开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> 深入显出一篇能懂Java锁机制，Synchronized和ReentrantLock -> 正文阅读

[Java知识库]深入显出一篇能懂Java锁机制，Synchronized和ReentrantLock

一、synchronized关键字特性

二、synchronized应用：双重校验锁实现单例模式

三、显式锁：Lock和ReentrantLock

1、Lock接口

2、ReentrantLock

四、锁的公平性

五、synchronized和ReentrantLock的区别?

本篇内容共 2303?字，5234字符，阅读需要 6分钟。?

在Java中，多线程并发的应用场景下，同步性和安全性在设计中尤为重要，这也是面试当中时常提及的问题。在项目中，如果有使用多线程的经历，通常会应用到Java中的锁来保证线程安全和数据的一致性。

到目前，Java中的锁机制可以说很全面且强大了。同步、共享、互斥等功能的实现，我们有了许多选择，包括实现共享对象访问的机制：synchronized和volatile，还有提供高级特性的ReentrantLock机制。

这篇文章就简单记录一下synchronized?和?ReentrantLock?的原理应用和区别，在以后的使用选择中有着更加明确的依据。

一、synchronized关键字特性

sychronized关键字保证多个线程之间访问资源的同步性，被它修饰的方法或者代码块在任意时刻只能有一个线程执行。

synchronized关键字是原生语法层面的互斥，在JVM层面实现，是一种重量级锁，因为在互斥状态下，没有获取到锁的线程会被挂起阻塞，而挂起线程和恢复线程的操作都需要系统转入内核态中完成。

在JDK1.6官方对synchronized在JVM层面进行大量的优化，引入了自旋锁、偏向锁、适应性自旋锁、锁消除、锁粗化、轻量级锁等技术来减少锁操作的开销。

另外，上面提到的使用synchronized修饰方法和代码块，主要有三种情况：

修饰实例方法，作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁。
修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁。
修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码块前要获得给定对象的锁。

二、synchronized应用：双重校验锁实现单例模式

以下实现的单例模式是线程安全的，使用synchronized关键字将类对象加锁。

/**
 * 双重校验锁实现单例模式（线程安全）
 * @author Charzous
 * @date 2021-07-03 下午 06:56
 *
 */
public class singleton {
    private static volatile singleton singletonInstance;

    private singleton(){

    }

    public static singleton getSingletonInstance(){
//        先判断对象是否已经实例过，没有实例化过才进入加锁代码块
        if (singletonInstance==null){
//            类对象加锁
            synchronized (singleton.class){
                if (singletonInstance==null){
                    singletonInstance=new singleton();
                }
            }
        }
        return singletonInstance;
    }
}

其中，volatile关键字是必要的，因为?JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。

在多线程的情况下，volatile关键字保证了可见性，禁止 JVM 的指令重排，保证在多线程环境下也能正常运行?。

三、显式锁：Lock和ReentrantLock

1、Lock接口

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

?在JDK1.5，开始提供Lock接口，从上面的源码可以发现，与synchronized这种内部加锁机制不同，Lock提供了无条件、定时的、可轮询、可中断的锁操作，加锁和解锁的操作都是显式进行的。

2、ReentrantLock

ReentrantLock是JDK1.5提供的互斥锁API。它实现了Lock接口，提供了跟synchronized相同的互斥和内存可见。

ReentrantLock支持Lock接口定义的所有获取锁的模式，因此对于处理不可用的锁提供了更多的灵活性。ReentrantLock锁机制的本质跟内部锁十分相似，它的优势就体现在：

ReenTrantLock的实现是一种自旋锁，通过循环调用CAS操作来实现加锁。它的性能比较好也是因为避免了使线程进入内核态的阻塞状态。
简化了代码，更好地与异常处理机制相结合，某些情况下，提供了更好的性能。

当然，使用ReentrantLock的时候，需要知道它的特性以及带来的问题。

上面说到，Lock的加锁和解锁都是显式操作，因此这种锁比内部锁更加复杂，锁必须在finally块中释放。另外，如果在加锁的代码块之外抛出了异常，锁将永远不会被释放。这些问题都是需要警惕的，出现错误很难找出程序的发生点。

class X {
     ReentrantLock lock = new ReentrantLock();
     // ...
     public void m() {
     assert !lock.isHeldByCurrentThread();
     lock.lock();
         try {
             // ... method body
         } finally {
             lock.unlock();
         }
     }
}

四、锁的公平性

ReentrantLock的构造函数中提供了两种锁的选择：非公平锁（默认）和公平锁。

部分源码如下：

    /**
     * Sync object for fair locks
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

    /**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

?公平锁则是保证线程按照先来先服务的请求顺序，如果锁已经被其他线程占有，或者已经存在线程在等待锁了，新请求线程会加入等待队列；而非公平锁则是允许抢占的方式，线程只有在锁被占用时才会等待，一旦可以获得锁，不会让给等待队列中的其他线程。

在实际场景中，非公平锁的性能明显高于公平锁。