每天一例多线程[day21]-----ReentrantReadWriteLock

 

ReentrantReadWriteLock，读写锁，核心就是实现读写分离的锁，在高并发访问下，尤其是读多写少的场景下，性能要远远高于重入锁。之前的ReentrantLock和Synchronized在同一时间内只能有一个线程访问被锁定的代码，那么读写锁则不同，其本质时分成两个锁，读锁+写锁，在读锁下，多个线程可以并发地访问；但是在写锁的时候只能一个一个顺序访问。

总结：读读共享，读写互斥，写写互斥。

 

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 t2 = new Thread(new Runnable() {

48. @Override

49. public void run() {

50. urrw.read();

51. }

52. }, "t2");

53. Thread t3 = new Thread(new Runnable() {

54. @Override

55. public void run() {

56. urrw.write();

57. }

58. }, "t3");

59. Thread t4 = new Thread(new Runnable() {

60. @Override

61. public void run() {

62. urrw.write();

63. }

64. }, "t4");

65.  

66. //读读共享

67. // t1.start();//R

68. // t2.start();//R

69.  

70. //读写互斥

71. // t1.start(); // R

72. // t3.start(); // W

73.  

74. //写写互斥

75. t3.start();//W

76. t4.start();//W

77.  
78.  
79.  
80.  
81.  
82.  
83.  
84.  

85. }

86. }

分析：在两个线程一起访问的是一个被读锁锁定的方法时，可以一起进入读取数据，相当于数据是共享的。但是如果一个访问的是读锁锁定的方法，一个访问的是写锁锁定的方法，则相当于访问的是同一把锁，只能等一个访问完释放后，另外一个线程才能继续访问，写写亦然。