JAVA的并发编程（二）：Synchronized的重入性、重入锁，读写锁

本文主要是介绍JAVA的并发编程（二）：Synchronized的重入性、重入锁，读写锁，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1.Synchronized的重入性

（1）重进入

（2）synchronized可重入性

（3）Synchronized的异常处理

2.ReentrantLock重入锁

（1）概述

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

（3）公平锁和非公平锁

（4）ReentrantReadWriteLock读写锁

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() {@Overridepublic 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() {@Overridepublic 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() {@Overridepublic 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);@Overridepublic 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();}
}