Synchronized与ReentrantLock的区别

Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现ReentrantLock。

synchronized用法

同步一个代码块

public void test() {
    synchronized (this) {
        //to do ...
    }
}

只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。
同步一个方法

public synchronized void test() {
    // to do ...
}

它和同步代码块一样，作用于同一个对象。
同步一个类

public void test() {
    synchronized (SynchronizedExample.class) {
        //  to do ...
    }
}

作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。例如:

    public void func2() {
        synchronized (SynchronizedExample.class) {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        }
    }
    
}
public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    SynchronizedExample e2 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func2());
    executorService.execute(() -> e2.func2());
    // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
}

同步一个静态方法

public synchronized static void fun() {
    // to do ...
}

ReentrantLock用法

ReentrantLock 是 java.util.concurrent（J.U.C）包中的锁。
基本用法

public class LockExample {

    private Lock lock = new ReentrantLock();

    public void func() {
        lock.lock();
        try {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
        } finally {
            lock.unlock(); // 确保释放锁，从而避免发生死锁。
        }
    }
    
    public static void main(String[] args) {
        LockExample lockExample = new LockExample();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> lockExample.func());
        executorService.execute(() -> lockExample.func());
    }
    
}

比较

1.锁的实现

synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的.

2.性能

新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同.

3.等待可中断

当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情.
ReentrantLock 可中断，而 synchronized 不行.

4.公平锁

公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁.
synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的.

5.锁绑定多个条件

一个 ReentrantLock 可以同时绑定多个 Condition 对象.