• 重入锁和读写锁

    一、重入锁和读写锁的引入

    在Java多线程中，我们知道可以使用synchronized关键字来实现线程间的同步互斥工作，那么其实还有一个更优秀的机制去完成这个“同步互斥”工作，它就是Lock对象，我们主要学习两种锁，重入锁和读写锁。它们具有比synchronized更为强大的功能，并且有嗅探锁定、多路分支等功能。

    二、重入锁（ReentrantLock）

    重入锁(ReentrantLock)是一个java.util.concurrent.locks包下实现了Lock接口的类，如下所示：

    1. public class ReentrantLock implements Lock{
    2.     ...
    3. }

    重入锁在需要进行同步的代码部分加上锁定，但不要忘记最后一定要释放锁定，不然会造成锁永远无法释放，其它线程永远进不来的结果。 

    2.1 线程t1释放锁，线程t2获得锁 

    1. import java.util.concurrent.locks.Lock;
    2. import java.util.concurrent.locks.ReentrantLock;
    3.  
    4. public class UseReentrantLock {
    5.  
    6.     private Lock lock = new ReentrantLock();
    7.  
    8.     public void method1() {
    9.         lock.lock();
    10.         try {
    11.             System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1..");
    12.             Thread.sleep(1000);
    13.             System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1..");
    14.         } catch (InterruptedException e) {
    15.             e.printStackTrace();
    16.         } finally {
    17.             lock.unlock();
    18.         }
    19.     }
    20.  
    21.     public void method2() {
    22.         lock.lock();
    23.         try {
    24.             System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method2..");
    25.             Thread.sleep(2000);
    26.             System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method2..");
    27.         } catch (InterruptedException e) {
    28.             e.printStackTrace();
    29.         } finally {
    30.             lock.unlock();
    31.         }
    32.     }
    33.  
    34.     public static void main(String[] args) {
    35.         final UseReentrantLock ur = new UseReentrantLock();
    36.  
    37.         Thread t1 = new Thread(new Runnable() {
    38.             @Override
    39.             public void run() {
    40.                 ur.method1();
    41.             }
    42.         }, "t1");
    43.  
    44.         Thread t2 = new Thread(new Runnable() {
    45.             @Override
    46.             public void run() {
    47.                 ur.method2();
    48.             }
    49.         }, "t2");
    50.  
    51.         t1.start();
    52.         t2.start();
    53.     }
    54. }

    执行上述代码，其输出结果为：

    1. 当前线程:t1进入method1..
    2. 当前线程:t1退出method1..
    3. 当前线程:t2进入method2..
    4. 当前线程:t2退出method2..

    线程t2在执行method2的时候由于线程t1释放锁了，所以线程t2可以获取到锁，method2方法正常运行。

    2.2 线程t1未释放锁，线程t2阻塞

    像下面这种情况由于线程t1未释放锁，线程t2一直处于阻塞状态：

    1. import java.util.concurrent.locks.Lock;
    2. import java.util.concurrent.locks.ReentrantLock;
    3.  
    4. public class UseReentrantLock {
    5.  
    6.     private Lock lock = new ReentrantLock();
    7.  
    8.     public void method1() {
    9.         lock.lock();
    10.         try {
    11.             System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1..");
    12.             Thread.sleep(1000);
    13.             System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1..");
    14.         } catch (InterruptedException e) {
    15.             e.printStackTrace();
    16.         } finally {
    17.             //lock.unlock();
    18.         }
    19.     }
    20.  
    21.     public void method2() {
    22.         lock.lock();
    23.         try {
    24.             System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method2..");
    25.             Thread.sleep(2000);
    26.             System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method2..");
    27.         } catch (InterruptedException e) {
    28.             e.printStackTrace();
    29.         } finally {
    30.             lock.unlock();
    31.         }
    32.     }
    33.  
    34.     public static void main(String[] args) {
    35.         final UseReentrantLock ur = new UseReentrantLock();
    36.  
    37.         Thread t1 = new Thread(new Runnable() {
    38.             @Override
    39.             public void run() {
    40.                 ur.method1();
    41.             }
    42.         }, "t1");
    43.  
    44.         Thread t2 = new Thread(new Runnable() {
    45.             @Override
    46.             public void run() {
    47.                 ur.method2();
    48.             }
    49.         }, "t2");
    50.  
    51.         t1.start();
    52.         t2.start();
    53.     }
    54. }

    执行上述代码，可以看到仅仅线程t1的执行结果进行了打印，线程t2由于未获得锁一直处于阻塞状态

    1. 当前线程:t1进入method1..
    2. 当前线程:t1退出method1..

    2.3 线程t1未释放锁，线程t1可以再次获得锁

    1. import java.util.concurrent.locks.Lock;
    2. import java.util.concurrent.locks.ReentrantLock;
    3.  
    4. public class UseReentrantLock {
    5.  
    6.     private Lock lock = new ReentrantLock();
    7.  
    8.     public void method1() {
    9.         lock.lock();
    10.         try {
    11.             System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1..");
    12.             Thread.sleep(1000);
    13.             System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1..");
    14.         } catch (InterruptedException e) {
    15.             e.printStackTrace();
    16.         } finally {
    17.  
    18.         }
    19.     }
    20.  
    21.     public void method2() {
    22.         lock.lock();
    23.         try {
    24.             System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method2..");
    25.             Thread.sleep(2000);
    26.             System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method2..");
    27.         } catch (InterruptedException e) {
    28.             e.printStackTrace();
    29.         } finally {
    30.             lock.unlock();
    31.         }
    32.     }
    33.  
    34.     public static void main(String[] args) {
    35.         final UseReentrantLock ur = new UseReentrantLock();
    36.  
    37.         Thread t1 = new Thread(new Runnable() {
    38.             @Override
    39.             public void run() {
    40.                 ur.method1();
    41.                 ur.method2();
    42.             }
    43.         }, "t1");
    44.  
    45.         t1.start();
    46.     }
    47. }

    执行上述代码，其输出结果为：

    1. 当前线程:t1进入method1..
    2. 当前线程:t1退出method1..
    3. 当前线程:t1进入method2..
    4. 当前线程:t1退出method2..

    可以看到线程t1在执行method1方法时虽然未释放锁，但是线程t1在执行method2时需要获得锁任然可以再次获得锁，即实现了锁重入的功能。

    三、锁与等待/通知

    还记得我们在使用synchronized的时候，如果需要多线程间进行协作工作则需要Object的wait()和notify()、notifyAlI()方法进行配合工作。那么同样，我们在使用Lock的时候，可以使用一个新的等待/通知的类，它就是Condition。这个Condition一定是针对具体某一把锁的。也就是在只有锁的基础之上才会产生Condition。

    1. import java.util.concurrent.locks.Condition;
    2. import java.util.concurrent.locks.Lock;
    3. import java.util.concurrent.locks.ReentrantLock;
    4.  
    5. public class UseCondition {
    6.  
    7.     private Lock lock = new ReentrantLock();
    8.     private Condition condition = lock.newCondition();
    9.  
    10.     public void method1() {
    11.         try {
    12.             lock.lock();
    13.             System.out.println("当前线程：" + Thread.currentThread().getName() + "进入..");
    14.             Thread.sleep(3000);
    15.             System.out.println("当前线程：" + Thread.currentThread().getName() + "释放锁..");
    16.             condition.await();    // Object wait
    17.             System.out.println("当前线程：" + Thread.currentThread().getName() + "继续执行...");
    18.         } catch (Exception e) {
    19.             e.printStackTrace();
    20.         } finally {
    21.             lock.unlock();
    22.         }
    23.     }
    24.  
    25.     public void method2() {
    26.         try {
    27.             lock.lock();
    28.             System.out.println("当前线程：" + Thread.currentThread().getName() + "进入..");
    29.             Thread.sleep(3000);
    30.             System.out.println("当前线程：" + Thread.currentThread().getName() + "发出唤醒..");
    31.             condition.signal();  //Object notify
    32.         } catch (Exception e) {
    33.             e.printStackTrace();
    34.         } finally {
    35.             lock.unlock();
    36.         }
    37.     }
    38.  
    39.     public static void main(String[] args) {
    40.  
    41.         final UseCondition uc = new UseCondition();
    42.         Thread t1 = new Thread(new Runnable() {
    43.             @Override
    44.             public void run() {
    45.                 uc.method1();
    46.             }
    47.         }, "t1");
    48.         Thread t2 = new Thread(new Runnable() {
    49.             @Override
    50.             public void run() {
    51.                 uc.method2();
    52.             }
    53.         }, "t2");
    54.  
    55.         t1.start();
    56.         t2.start();
    57.     }
    58. }

    执行上述代码，其输出结果：

    1. 当前线程：t1进入..
    2. 当前线程：t1释放锁..
    3. 当前线程：t2进入..
    4. 当前线程：t2发出唤醒..
    5. 当前线程：t1继续执行...

    此处需要特别注意的是t2线程的唤醒操作是不会释放锁的，必须在调用了lock.unlock()方法以后才能释放锁。

    四、多Condition

    我们可以通过一个Lock对象产生多个Condition进行多线程间的交互，非常的灵活。可以使得部分需要唤醒的线程唤醒，其他线程则继续等待通知。

    1. import java.util.concurrent.locks.Condition;
    2. import java.util.concurrent.locks.ReentrantLock;
    3.  
    4. public class UseManyCondition {
    5.  
    6. 	private ReentrantLock lock = new ReentrantLock();
    7. 	private Condition c1 = lock.newCondition();
    8. 	private Condition c2 = lock.newCondition();
    9. 	
    10. 	public void m1(){
    11. 		try {
    12. 			lock.lock();
    13. 			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m1等待..");
    14. 			c1.await();
    15. 			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m1继续..");
    16. 		} catch (Exception e) {
    17. 			e.printStackTrace();
    18. 		} finally {
    19. 			lock.unlock();
    20. 		}
    21. 	}
    22. 	
    23. 	public void m2(){
    24. 		try {
    25. 			lock.lock();
    26. 			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m2等待..");
    27. 			c1.await();
    28. 			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m2继续..");
    29. 		} catch (Exception e) {
    30. 			e.printStackTrace();
    31. 		} finally {
    32. 			lock.unlock();
    33. 		}
    34. 	}
    35. 	
    36. 	public void m3(){
    37. 		try {
    38. 			lock.lock();
    39. 			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m3等待..");
    40. 			c2.await();
    41. 			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m3继续..");
    42. 		} catch (Exception e) {
    43. 			e.printStackTrace();
    44. 		} finally {
    45. 			lock.unlock();
    46. 		}
    47. 	}
    48. 	
    49. 	public void m4(){
    50. 		try {
    51. 			lock.lock();
    52. 			System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
    53. 			c1.signalAll();
    54. 		} catch (Exception e) {
    55. 			e.printStackTrace();
    56. 		} finally {
    57. 			lock.unlock();
    58. 		}
    59. 	}
    60. 	
    61. 	public void m5(){
    62. 		try {
    63. 			lock.lock();
    64. 			System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
    65. 			c2.signal();
    66. 		} catch (Exception e) {
    67. 			e.printStackTrace();
    68. 		} finally {
    69. 			lock.unlock();
    70. 		}
    71. 	}
    72. 	
    73. 	public static void main(String[] args) {
    74. 		final UseManyCondition umc = new UseManyCondition();
    75. 		Thread t1 = new Thread(new Runnable() {
    76. 			@Override
    77. 			public void run() {
    78. 				umc.m1();
    79. 			}
    80. 		},"t1");
    81. 		Thread t2 = new Thread(new Runnable() {
    82. 			@Override
    83. 			public void run() {
    84. 				umc.m2();
    85. 			}
    86. 		},"t2");
    87. 		Thread t3 = new Thread(new Runnable() {
    88. 			@Override
    89. 			public void run() {
    90. 				umc.m3();
    91. 			}
    92. 		},"t3");
    93. 		Thread t4 = new Thread(new Runnable() {
    94. 			@Override
    95. 			public void run() {
    96. 				umc.m4();
    97. 			}
    98. 		},"t4");
    99. 		Thread t5 = new Thread(new Runnable() {
    100. 			@Override
    101. 			public void run() {
    102. 				umc.m5();
    103. 			}
    104. 		},"t5");
    105. 		
    106. 		t1.start();	// c1
    107. 		t2.start();	// c1
    108. 		t3.start();	// c2
    109.  
    110. 		try {
    111. 			Thread.sleep(2000);
    112. 		} catch (InterruptedException e) {
    113. 			e.printStackTrace();
    114. 		}
    115.  
    116. 		t4.start();	// c1
    117.  
    118.         try {
    119. 			Thread.sleep(2000);
    120. 		} catch (InterruptedException e) {
    121. 			e.printStackTrace();
    122. 		}
    123.  
    124. 		t5.start();	// c2
    125. 	}
    126. }

    执行上述代码，其输出结果：

    1. 当前线程：t1进入方法m1等待..
    2. 当前线程：t3进入方法m3等待..
    3. 当前线程：t2进入方法m2等待..
    4. 当前线程：t4唤醒..
    5. 当前线程：t1方法m1继续..
    6. 当前线程：t2方法m2继续..
    7. 当前线程：t5唤醒..
    8. 当前线程：t3方法m3继续..

    c1.signalAll()表示唤醒所有线程，c2.signal()表示随机唤醒一个线程

    五、Lock/Condition的其它用法

    公平锁与非公平锁：

    Lock lock = new ReentrantLock(boolean isFair);

    Lock用法：

    1. tryLock()：尝试获得锁，根据嗅探获得结果用true/false返回，不会产生锁等待
    2. tryLock(long timeout, TimeUnit unit)：在给定的时间内尝试获得锁,获得结果用truelfalse返回
    3. isFair()：是否是公平锁
    4. isLocked()：是否锁定
    5. getHoldCount()：查询当前线程保持此锁的个数，也就是调用lock()次数
    6. lockInterruptibly()：优先响应中断的锁
    7. getQueueLength()：返回正在等待获取此锁定的线程数
    8. getWaitQueueLength()：返回等待与锁定相关的给定条件Condition的线程数
    9. hasQueuedThread(Thread thread)：查询指定的线程是否正在等待此锁
    10. hasQueuedThreads()：查询是否有线程正在等待此锁
    11. hasWaiters()：查询是否有线程正在等待与此锁定有关的condition条件

    六、读写锁（ReentrantReadWriteLock）

    ReadWriteLock是 java.util.concurrent.locks 包下的一个接口，ReentrantReadWriteLock是java.util.concurrent.locks 包下的一个类，ReentrantReadWriteLock(读写锁)是ReadWriteLock的一个实现类。

    1. package java.util.concurrent.locks;
    2.  
    3. public interface ReadWriteLock {
    4.     ...
    5. }
    1. package java.util.concurrent.locks;
    2.  
    3. public class ReentrantReadWriteLock implements ReadWriteLock{
    4.     ...
    5. }

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

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

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

    6.1 读读共享

    1. import java.util.concurrent.locks.ReentrantReadWriteLock;
    2. import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
    3.  
    4. public class UseReentrantReadWriteLock {
    5.  
    6. 	private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    7. 	private ReadLock readLock = rwLock.readLock();
    8.  
    9. 	public void read(){
    10. 		try {
    11. 			readLock.lock();
    12. 			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
    13. 			Thread.sleep(3000);
    14. 			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
    15. 		} catch (Exception e) {
    16. 			e.printStackTrace();
    17. 		} finally {
    18. 			readLock.unlock();
    19. 		}
    20. 	}
    21. 	
    22. 	public static void main(String[] args) {
    23. 		
    24. 		final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();
    25. 		
    26. 		Thread t1 = new Thread(new Runnable() {
    27. 			@Override
    28. 			public void run() {
    29. 				urrw.read();
    30. 			}
    31. 		}, "t1");
    32. 		Thread t2 = new Thread(new Runnable() {
    33. 			@Override
    34. 			public void run() {
    35. 				urrw.read();
    36. 			}
    37. 		}, "t2");
    38.  
    39. 		//多个读操作的线程可以并发的去执行
    40. 		t1.start();
    41. 		t2.start();
    42. 	}
    43. }

    执行上述代码，其输出内容为：

    1. 当前线程:t2进入...
    2. 当前线程:t1进入...
    3. 当前线程:t1退出...
    4. 当前线程:t2退出...

    如果是进行读操作的话，多个线程可以并发的访问

    6.2 读写互斥

    1. import java.util.concurrent.locks.ReentrantReadWriteLock;
    2. import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
    3. import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
    4.  
    5. public class UseReentrantReadWriteLock {
    6.  
    7. 	private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    8. 	private ReadLock readLock = rwLock.readLock();
    9. 	private WriteLock writeLock = rwLock.writeLock();
    10.  
    11. 	public void read(){
    12. 		try {
    13. 			readLock.lock();
    14. 			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
    15. 			Thread.sleep(3000);
    16. 			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
    17. 		} catch (Exception e) {
    18. 			e.printStackTrace();
    19. 		} finally {
    20. 			readLock.unlock();
    21. 		}
    22. 	}
    23.  
    24. 	public void write(){
    25. 		try {
    26. 			writeLock.lock();
    27. 			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
    28. 			Thread.sleep(3000);
    29. 			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
    30. 		} catch (Exception e) {
    31. 			e.printStackTrace();
    32. 		} finally {
    33. 			writeLock.unlock();
    34. 		}
    35. 	}
    36. 	
    37. 	public static void main(String[] args) {
    38. 		
    39. 		final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();
    40. 		
    41. 		Thread t1 = new Thread(new Runnable() {
    42. 			@Override
    43. 			public void run() {
    44. 				urrw.read();
    45. 			}
    46. 		}, "t1");
    47. 		Thread t3 = new Thread(new Runnable() {
    48. 			@Override
    49. 			public void run() {
    50. 				urrw.write();
    51. 			}
    52. 		}, "t3");
    53.  
    54. 		//读写互斥
    55. 		t1.start();
    56. 		t3.start();
    57. 	}
    58. }

    执行上述代码，其输出结果为：

    1. 当前线程:t1进入...
    2. 当前线程:t1退出...
    3. 当前线程:t3进入...
    4. 当前线程:t3退出...

    可以看到只有当线程t1的读锁释放以后，线程t2才能获取到写锁

    6.3 写写互斥 

    1. import java.util.concurrent.locks.ReentrantReadWriteLock;
    2. import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
    3.  
    4. public class UseReentrantReadWriteLock {
    5.  
    6. 	private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    7. 	private WriteLock writeLock = rwLock.writeLock();
    8.  
    9. 	public void write(){
    10. 		try {
    11. 			writeLock.lock();
    12. 			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入...");
    13. 			Thread.sleep(3000);
    14. 			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出...");
    15. 		} catch (Exception e) {
    16. 			e.printStackTrace();
    17. 		} finally {
    18. 			writeLock.unlock();
    19. 		}
    20. 	}
    21. 	
    22. 	public static void main(String[] args) {
    23. 		
    24. 		final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();
    25.  
    26. 		Thread t3 = new Thread(new Runnable() {
    27. 			@Override
    28. 			public void run() {
    29. 				urrw.write();
    30. 			}
    31. 		}, "t3");
    32.  
    33. 		Thread t4 = new Thread(new Runnable() {
    34. 			@Override
    35. 			public void run() {
    36. 				urrw.write();
    37. 			}
    38. 		}, "t4");
    39.  
    40. 		// 写写互斥
    41. 		t3.start();
    42. 		t4.start();
    43. 	}
    44. }

    执行上述代码，其输出结果为：

    1. 当前线程:t3进入...
    2. 当前线程:t3退出...
    3. 当前线程:t4进入...
    4. 当前线程:t4退出...

    可以看到只有当线程t3的读锁释放以后，线程t4才能获取到读锁

    七、锁的优化

    1、避免死锁

    2、减小锁的持有时间

    3、减小锁的粒度

    4、锁的分离

    5、尽量使用无锁的操作，如原子操作(Atomic系列类)，锁升级优化

  • 相关阅读:
    SQL窗口函数
    MethodArgumentNotValidException 与 ConstraintViolationException
    flume系列之：基于zookeeper部署flume agent升级guava和curator版本
    oss 部署前端项目报错 Cannot find module ‘@/views/.....‘（require和import区别）
    旋转框/微调按钮的基类--QAbstractSpinBox 类
    核心内参: TDR原理及常见问题
    站在自动装配角度浅析Spring和SpringBoot的区别
    【网络编程】第三章 网络套接字（TCP协议程序+多进程+多线程+线程池）
    【Java数据类型】
    通过sls采集k8s集群上的服务日志
  • 原文地址：https://blog.csdn.net/y_bccl27/article/details/123884623