Java并发包——线程同步和锁

Java并发包——线程同步和锁

摘要：本文主要学习了Java并发包里有关线程同步的类和锁的一些相关概念。

部分内容来自以下博客：

https://www.cnblogs.com/dolphin0520/p/3923167.html

https://blog.csdn.net/tyyj90/article/details/78236053

线程同步方式

对于线程安全我们前面使用了synchronized关键字，对于线程的协作我们使用Object.wait()和Object.notify()。在JDK1.5中java为我们提供了Lock来实现与它们相同的功能，并且性能优于它们，在JDK1.6时，JDK对synchronized做了优化，在性能上两种方式差距不大了。

synchronized的缺陷

synchronized修饰的代码块，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，如果没有释放则需要无限的等待下去。

获取锁的线程释放锁只会有两种情况：

1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有。

2）线程执行发生异常，此时JVM会让线程自动释放锁。

总结一下，也就是说Lock提供了比synchronized更多的功能。但是要注意以下几点：

1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问。

2）synchronized不需要手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用。而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

Lock

Lock接口位于java.util.concurrent.locks包中。

 public interface Lock {
     // 用来获取锁。如果锁已被其他线程获取，则进行等待。
     void lock();

     // 用来获取锁。允许在等待时由其它线程调用interrupt方法来中断等待而直接返回，这时不用获取锁，而会抛出一个InterruptedException。
     void lockInterruptibly() throws InterruptedException;

     // 用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false。
     boolean tryLock();

     // 用来尝试获取锁，如果拿到锁或者在等待期间内拿到了锁，则返回true。如果在某段时间之内获取失败，就返回false。
     boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

     // 释放锁。
     void unlock();

     // 获取Condition对象。
     Condition newCondition();
 }

lock方法

首先lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

通常使用Lock来进行同步的话，是以下面这种形式去使用的：

 Lock lock = ... ;
 lock.lock();
 try {
     // 处理任务
 } catch(Exception e) {

 } finally {
     lock.unlock();// 释放锁
 }

tryLock方法

tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

一般情况下通过tryLock来获取锁时是这样使用的：

 Lock lock = ... ;
 if (lock.tryLock()) {
     try {
         // 处理任务
     } catch (Exception e) {

     } finally {
         lock.unlock();// 释放锁
     }
 } else {
     // 获取失败处理其他事情
 }

lockInterruptibly方法

lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。

由于lockInterruptibly()的声明中抛出了异常，所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException。

一般的使用形式如下：

 public void method() throws InterruptedException {
     Lock lock = ... ;
     lock.lockInterruptibly();
     try {
         // 处理任务
     } finally {
         lock.unlock();
     }
 }

注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。因为本身在前面的文章中讲过单独调用interrupt()方法不能中断正在运行过程中的线程，只能中断阻塞过程中的线程。

因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。

而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。

ReentrantLock

ReentrantLock类实现了Lock接口，并且ReentrantLock提供了更多的方法。

 public class Demo {
     public static void main(String[] args) {
         DemoThread dt = new DemoThread();
         Thread t1 = new Thread(dt, "窗口1");
         Thread t2 = new Thread(dt, "窗口2");
         t1.start();
         t2.start();
     }
 }

 class DemoThread implements Runnable {
     private int ticket = 3;
     Lock lock = new ReentrantLock();

     @Override
     public void run() {
         while (ticket > 0) {
             try {
                 Thread.sleep(1);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }

             lock.lock();
             try {
                 if (ticket > 0) {
                     System.out.println(Thread.currentThread().getName() + " 进入卖票环节 ");
                     System.out.println(Thread.currentThread().getName() + " 售卖的车票编号为： " + ticket--);
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             } finally {
                 lock.unlock();
             }
         }
     }
 }

注意在声明Lock的时候，要注意不要声明为局部变量。

ReadWriteLock

ReadWriteLock也是一个接口，用来定义读写锁。

 public interface ReadWriteLock {
     Lock readLock();

     Lock writeLock();
 }

一个用来获取读锁，一个用来获取写锁。也就是说将文件的读写操作分开，分成两个锁来分配给线程，从而使得多个线程可以同时进行读操作。

ReentrantReadWriteLock

ReentrantReadWriteLock实现了ReadWriteLock接口，支持多个线程同时进行读操作。

 public class Demo {
     public static void main(String[] args) {
         DemoThread dt = new DemoThread();
         new Thread(() -> dt.showTicket(), "窗口1").start();
         new Thread(() -> dt.showTicket(), "窗口2").start();
         new Thread(() -> dt.showTicket(), "窗口3").start();
         new Thread(() -> dt.saleTicket(), "窗口4").start();
     }
 }

 class DemoThread {
     private int ticket = 3;
     ReadWriteLock lock = new ReentrantReadWriteLock();

     public void showTicket() {
         while (ticket > 0) {
             try {
                 Thread.sleep(1);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             lock.readLock().lock();
             try {
                 if (ticket > 0) {
                     System.out.println(Thread.currentThread().getName() + " 进入预售环节");
                     System.out.println(Thread.currentThread().getName() + " 预售的车票编号为： " + ticket);
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             } finally {
                 lock.readLock().unlock();
             }
         }
         System.out.println(Thread.currentThread().getName() + " 进入结束环节");
     }

     public void saleTicket() {
         while (ticket > 0) {
             try {
                 Thread.sleep(1);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             lock.writeLock().lock();
             try {
                 if (ticket > 0) {
                     System.out.println(Thread.currentThread().getName() + " 进入售票环节");
                     System.out.println(Thread.currentThread().getName() + " 售卖的车票编号为： " + ticket--);
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             } finally {
                 lock.writeLock().unlock();
             }
         }
         System.out.println(Thread.currentThread().getName() + " 进入结束环节");
     }
 }

运行结果如下：

 窗口2 进入预售环节
 窗口1 进入预售环节
 窗口1 预售的车票编号为： 3
 窗口2 预售的车票编号为： 3
 窗口3 进入预售环节
 窗口3 预售的车票编号为： 3
 窗口4 进入售票环节
 窗口4 售卖的车票编号为： 3
 窗口4 进入售票环节
 窗口4 售卖的车票编号为： 2
 窗口2 进入预售环节
 窗口3 进入预售环节
 窗口1 进入预售环节
 窗口1 预售的车票编号为： 1
 窗口2 预售的车票编号为： 1
 窗口3 预售的车票编号为： 1
 窗口4 进入售票环节
 窗口4 售卖的车票编号为： 1
 窗口4 进入结束环节
 窗口3 进入结束环节
 窗口2 进入结束环节
 窗口1 进入结束环节

从运行的结果来看，最多有三个线程在同时读，提高了读操作的效率。

如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。

如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

关于synchronized和Lock的比较

1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现。

2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生。而Lock在发生异常时，如果没有主动释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁。

3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断。

4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。

5）Lock可以提高多个线程进行读操作的效率。

6）synchronized的底层是一个基于CAS操作的等待队列，synchronized还实现了自旋锁，并针对不同的系统和硬件体系进行了优化，而Lock则完全依靠系统阻塞挂起等待线程。

7）在资源竞争不是很激烈的情况下，synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，synchronized的性能会下降几十倍，但是ReetrantLock的性能能维持常态

锁的分类

在读很多并发文章中，会提及各种各样锁如公平锁，乐观锁等等，这篇文章介绍各种锁的分类。介绍的内容如下：

 可重入锁
 独享锁/共享锁
 互斥锁/读写锁
 公平锁/非公平锁
 乐观锁/悲观锁
 分段锁
 偏向锁/轻量级锁/重量级锁
 自旋锁

上面是很多锁的名词，这些分类并不是全是指锁的状态，有的指锁的特性，有的指锁的设计，下面总结的内容是对每个锁的名词进行一定的解释。

可重入锁

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。

对于synchronized和ReentrantLock而言，都是可重入锁。

可重入锁的一个好处是可一定程度避免死锁，如果不是可重入锁的话，可能造成死锁。

独享锁/共享锁

独享锁是指该锁一次只能被一个线程所持有。共享锁是指该锁可被多个线程所持有。

对于synchronized和ReentrantLock而言，都是独享锁。

但是对于ReadWriteLock而言，其读锁是共享锁，其写锁是独享锁。读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。

独享锁与共享锁也是通过AQS来实现的，通过实现不同的方法，来实现独享或者共享。

互斥锁/读写锁

上面讲的独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。

互斥锁在Java中的具体实现就是ReentrantLock。读写锁在Java中的具体实现就是ReadWriteLock。

公平锁/非公平锁

公平锁是指多个线程按照申请锁的顺序来获取锁，非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序。

对于synchronized而言，是一种非公平锁。

对于ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。

乐观锁/悲观锁

乐观锁与悲观锁不是指具体的什么类型的锁，而是指看待并发同步的角度。

悲观锁认为对于同一个数据的并发操作，一定是会发生修改的，哪怕没有修改，也会认为修改。因此对于同一个数据的并发操作，悲观锁采取加锁的形式。悲观的认为，不加锁的并发操作一定会出问题。

乐观锁则认为对于同一个数据的并发操作，是不会发生修改的。在更新数据的时候，会采用尝试更新，不断重新的方式更新数据。乐观的认为，不加锁的并发操作是没有事情的。

悲观锁在Java中的使用，就是利用各种锁。

乐观锁在Java中的使用，是无锁编程，常常采用的是CAS算法，典型的例子就是原子类，通过CAS自旋实现原子操作的更新。

分段锁

分段锁其实是一种锁的设计，并不是具体的一种锁，对于ConcurrentHashMap而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。

分段锁的设计目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。

偏向锁/轻量级锁/重量级锁

这三种锁是指锁的状态，并且是针对Synchronized。在JDK5通过引入锁升级的机制来实现高效Synchronized。

这三种锁的状态是通过对象监视器在对象头中的字段来表明的。

偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。

轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。

重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。

自旋锁

在Java中，自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

了解AQS

什么是AQS

AQS是英文单词AbstractQueuedSynchronizer的缩写，翻译过来就是抽象的队列式的同步器，AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，如常用的ReentrantLock、Semaphore、CountDownLatch等等。

实现方式

AQS的主要使用方式是继承，子类通过继承同步器并实现它的抽象方法来管理同步状态。

原理

AQS维护了一个state用来代表资源共享状态 private volatile int state; ，AQS提供了三种操作state的方法： int getState(); 、 void setState(int newState); 、 boolean compareAndSetState(int expect, int update); 。

AQS通过内置的FIFO同步队列 static final class Node 来完成资源获取线程的排队工作，如果当前线程获取同步状态失败（锁）时，AQS则会将当前线程以及等待状态等信息构造成一个节点（Node）并将其加入同步队列，同时会阻塞当前线程，当同步状态释放时，则会把节点中的线程唤醒，使其再次尝试获取同步状态。

资源共享方式

AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）。

使用分析

不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。自定义同步器实现时主要实现以下几种方法：

isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。

tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。

tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。

tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。

tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。

再以CountDownLatch以例，任务分为N个子线程去执行，state也初始化为N（注意N要与线程个数一致）。这N个子线程是并行执行的，每个子线程执行完后countDown()一次，state会CAS减1。等到所有子线程都执行完后(即state=0)，会unpark()主调用线程，然后主调用线程就会从await()函数返回，继续后余动作。

一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如ReentrantReadWriteLock。