Java互斥同步 关于Synchronized关键字与ReentrantLock的使用和比较

synchronized关键字的四种使用方法

1. 同步一个代码块

        public void func1(){
//            同步代码块
            synchronized (this){
               //...
            }
        }

它只作用于同一个对象，如果调用两个对象上的同步代码块不会同步

对于以下线程，由于调用同一个对象，所以实现了同步。

/**
 * @Author 胡孟帆
 * @Date 2021-11-21 15:58
 * @Function
 **/
 @SpringBootTest
public class SynchronizedTests {
    @Test
    void contextLoads() {
    }
	public static void main(String[] args) {
        SynchronizedExample e1 = new SynchronizedExample();
        ExecutorService executorService = Executors.newCachedThreadPool();
//        同一个对象调用
        executorService.execute(() -> e1.func1());
        executorService.execute(() -> e1.func1());
    }
    public static class SynchronizedExample{
        public void func1(){
//            同步代码块
            synchronized (this){
                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.func1());
        executorService.execute(() -> e1.func1());
    }

由于运行比较快，所以这里改成循环100次，输出结果发现两个线程交叉执行。

2. 同步一个方法

//    同步一个方法
    public static class SynchronizedExample{
//        同步方法
        public synchronized void func1(){
            for (int i = 0;i < 100;i++){
                System.out.print(i + " ");
            }
        }
    }

它和同步代码块一样，作用于同一个对象，不同对象交叉执行。

3. 同步一个类

    public void func1(){
        synchronized (SynchronizedExample.class){
			for (int i = 0;i < 10;i++){
                System.out.print(i + " ");
            }
        }
    }

作用于整个类，也就是说不同对象也会同步

4. 同步一个静态方法

    public static class SynchronizedExample{
//        同步一个静态方法
        public synchronized void func1(){
            for (int i = 0;i < 10;i++){
                System.out.print(i + " ");
            }
        }
    }

作用于一整个类，和同步代码块一样，作用于同一个对象，不同对象交叉执行。

ReentrantLock

ReentrantLock 是 java.util.concurrent (J.U.C) 包中的锁。

/**
 * @Author 胡孟帆
 * @Date 2021-11-21 17:06
 * @Function
 **/
public class LockTests {

    public static void main(String[] args) {
        LockTests lockTests = new LockTests();
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> lockTests.func());
        executorService.execute(() -> lockTests.func());
    }

//    新建一个ReentrantLock对象
    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();
        }
    }
}

两者的比较

1、锁的实现

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

2、性能

新版本 Java 对 synchronized 进行了许多优化，比如自旋锁等，性能两者相当。

3、等待可中断

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

4、公平锁

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

5、锁绑定多个条件

一个 ReentrantLock 可以绑定多个 Condition 对象（鉴定完毕，大渣男）

6、使用选择

除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized，这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持，并且使用 synchronized 不用担心没有释放锁导致死锁问题，因为 JVM 会保存锁的释放