ReenTrantLock synchronized

怼烎@ 2021-07-25 23:07 390阅读 0赞

1.Synchronized的重入性  
（1）重进入  
1.定义：重进入是指任意线程在获取到锁之后，再次获取该锁而不会被该锁所阻塞。关联一个线程持有者+计数器，重入意味着锁操作的颗粒度为“线程”。（反之，不可重入锁的进入是单次的，代表锁状态的只有true和false）

2.需要解决两个问题：

线程再次获取锁：锁需要识别获取锁的现场是否为当前占据锁的线程，如果是，则再次成功获取；

锁的最终释放：线程重复n次获取锁，随后在第n次释放该锁后，其他线程能够获取该锁。要求对锁对于获取进行次数的自增，计数器对当前锁被重复获取的次数进行统计，当锁被释放的时候，计数器自减，当计数器值为0时，表示锁成功释放。

3.重入锁实现重入性：每个锁关联一个线程持有者和计数器，当计数器为0时表示该锁没有被任何线程持有，那么任何线程都可能获得该锁而调用相应的方法；当某一线程请求成功后，JVM会记下锁的持有线程，并且将计数器置为1；此时其它线程请求该锁，则必须等待；而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增；当线程退出同步代码块时，计数器会递减，如果计数器为0，则释放该锁

（2）synchronized可重入性  
同一线程在调用自己类中其他synchronized方法/块或调用父类的synchronized方法/块都不会阻碍该线程的执行，就是说同一线程对同一个对象锁是可重入的，而且同一个线程可以获取同一把锁多次，也就是可以多次重入。

1，第一种，同一个类中的synchronized方法互相调用

public class SyncDubbo1 \{  
   
    public synchronized void method1()\{  
        System.out.println("method1..");  
        method2();  
    \}  
    public synchronized void method2()\{  
        System.out.println("method2..");  
        method3();  
    \}  
    public synchronized void method3()\{  
        System.out.println("method3..");  
    \}  
      
    public static void main(String\[\] args) \{  
        final SyncDubbo1 sd = new SyncDubbo1();  
        Thread t1 = new Thread(new Runnable() \{  
            @Override  
            public void run() \{  
                sd.method1();  
            \}  
        \});  
        t1.start();  
    \}  
\}  
结果为

2，第二种，子类和父类之间的synchronized方法调用

public class SyncDubbo2 \{  
    static class Main \{  
        public int i = 10;  
        public synchronized void operationSup()\{  
            try \{  
                i--;  
                System.out.println("Main print i = " + i);  
                Thread.sleep(100);  
            \} catch (InterruptedException e) \{  
                e.printStackTrace();  
            \}  
        \}  
    \}      
    static class Sub extends Main \{  
        public synchronized void operationSub()\{  
            try \{  
                while(i > 0) \{  
                    i--;  
                    System.out.println ("Sub print i = " + i);  
                    Thread.sleep(100);          
                    this.operationSup();  
                \}  
            \} catch (InterruptedException e) \{  
                e.printStackTrace();  
            \}  
        \}  
    \}      
    public static void main(String\[\] args) \{          
        Thread t1 = new Thread(new Runnable() \{  
            @Override  
            public void run() \{  
                Sub sub = new Sub();  
                sub.operationSub();  
            \}  
        \});      
        t1.start();  
    \}          
\}  
结果为

（3）Synchronized的异常处理  
public class SyncException \{  
    private int i = 0;  
    public synchronized void operation()\{  
        while(true)\{  
            try \{  
                i++;  
                Thread.sleep(100);  
                System.out.println(Thread.currentThread().getName() + " , i = " + i);  
                if(i == 10)\{  
                    Integer.parseInt("a");  
                \}  
            \} catch (Exception e) \{  
                e.printStackTrace();  
            \}  
        \}  
    \}      
    public static void main(String\[\] args) \{  
          
        final SyncException se = new SyncException();  
        Thread t1 = new Thread(new Runnable() \{  
            @Override  
            public void run() \{  
                se.operation();  
            \}  
        \},"t1");  
        t1.start();  
    \}      
\}  
执行结果为

由于异常的出现，业务逻辑并没有正常地执行完毕就释放了锁，可能导致后续一连串的错误

所以在编写代码时，一定要考虑周全

第一种策略是出现了异常后允许继续执行，那么catch异常后记录日志并continue

另一种就是出现了异常之后不允许执行，那么catch后直接抛出运行时异常或者中断异常

2.ReentrantLock重入锁  
（1）概述  
java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象，它允许把锁定的实现作为 Java 类，而不是作为语言的特性来实现。这就为Lock 的多种实现留下了空间，各种实现可能有不同的调度算法、性能特性或者锁定语义。 ReentrantLock 类实现了 Lock ，它拥有与synchronized 相同的并发性和内存语义，但是添加了类似轮询锁、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。

用 ReentrantLock 保护代码块。

Lock lock = new ReentrantLock();  
lock.lock();  
try \{   
  // update object state  
\}  
finally \{  
  lock.unlock();   
\}

（2）ReenTrantLock可重入锁和synchronized的区别  
可重入性：

从名字上理解，ReenTrantLock的字面意思就是再进入的锁，其实synchronized关键字所使用的锁也是可重入的，两者关于这个的区别不大。两者都是同一个线程没进入一次，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。

锁的实现：

Synchronized是依赖于JVM实现的，而ReenTrantLock是JDK实现的，有什么区别，说白了就类似于操作系统来控制实现和用户自己敲代码实现的区别。前者的实现是比较难见到的，后者有直接的源码可供阅读。

性能的区别：

在Synchronized优化以前，synchronized的性能是比ReenTrantLock差很多的，但是自从Synchronized引入了偏向锁，轻量级锁（自旋锁）后，两者的性能就差不多了，在两种方法都可用的情况下，官方甚至建议使用synchronized，其实synchronized的优化我感觉就借鉴了ReenTrantLock中的CAS技术。都是试图在用户态就把加锁问题解决，避免进入内核态的线程阻塞。

功能区别：

便利性：很明显Synchronized的使用比较方便简洁，并且由编译器去保证锁的加锁和释放，而ReenTrantLock需要手工声明来加锁和释放锁，为了避免忘记手工释放锁造成死锁，所以最好在finally中声明释放锁。

锁的细粒度和灵活度：很明显ReenTrantLock优于Synchronized

ReenTrantLock独有的能力：

1.   ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获锁。

2.   ReenTrantLock提供了一个Condition（条件）类，用来实现分组唤醒需要唤醒的线程们，而不是像synchronized要么随机醒一个线程要么唤醒全部线程。

3.   ReenTrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。

具体应用可以参考这篇博文：重入锁：ReentrantLock 详解

什么情况下使用ReenTrantLock：

答案是，如果你需要实现ReenTrantLock的三个独有功能时。

（3）公平锁和非公平锁  
Synchronized只能是非公平锁

ReenTrantLock默认是非公平锁，但是可以通过构造方法传参true来创建公平锁

public class FairLock implements Runnable\{  
   public static ReentrantLock lock = new ReentrantLock(true);  
    @Override  
    public void run() \{  
        while (true) \{  
            try \{  
                lock.lock();  
                System.err.println(Thread.currentThread().getName() + "获取到了锁！");  
            \} finally \{  
                lock.unlock();  
            \}  
        \}  
    \}  
    public static void main(String\[\] args) throws InterruptedException \{  
        FairLock test = new FairLock();  
        Thread t1 = new Thread(test, "线程1");  
        Thread t2 = new Thread(test, "线程2");  
        t1.start();t2.start();  
    \}  
\}

图解公平锁和非公平锁

公平锁与非公平锁的一个重要区别就在于上图中的2、6、10那个步骤，对应源码如下：

分析以上代码，我们可以看到公平锁就是在获取锁之前会先判断等待队列是否为空或者自己是否位于队列头部，该条件通过才能继续获取锁。

在结合兔子喝水的图分析，非公平锁获取所得顺序基本决定在9、10、11这三个事件发生的先后顺序，

1、若在释放锁的时候总是没有新的兔子来打扰，则非公平锁等于公平锁；

2、若释放锁的时候，正好一个兔子来喝水，而此时位于队列头的兔子还没有被唤醒（因为线程上下文切换是需要不少开销的），此时后来的兔子则优先获得锁，成功打破公平，成为非公平锁；

其实对于非公平锁，只要线程进入了等待队列，队列里面依然是FIFO的原则，跟公平锁的顺序是一样的。因为公平锁与非公平锁的release()部分代码是共用AQS的代码。

上文说到的线程切换的开销，其实就是非公平锁效率高于公平锁的原因，因为非公平锁减少了线程挂起的几率，后来的线程有一定几率逃离被挂起的开销。

（4）ReentrantReadWriteLock读写锁  
ReentrantReadWriteLock的核心就是实现读写分离的锁。在高并发访问下，尤其是读多写少的情况下，性能远高于重入锁。

之前学synchronized、ReentrantLock时，我们知道，同一时间内，只能由一个线程进行访问被锁定的代码，那么读写锁则不同，其本质是分成两个锁，既读锁、写锁。在读锁下，多个线程可以并发地进行访问，但是在写锁的时候，只能一个一个地顺序访问

口诀：读读共享，写写互斥，读写互斥。