去故就新Java线程新同步机制

1、可重入锁ReentrantLock，相当于synchronized块，为临界区提供互斥访问机制。

(1) 相关的接口

创建一个可重入锁

 
 
 
    
  
  
  
  1. Lock lock = new ReentrantLock();
    2.

请求锁,如果锁被当前另一个线程持有，则阻塞。

 
 
 
    
  
  
  
  1. void lock(); 
    2.

释放锁

 
 
 
    
  
  
  
  1. void unlock();
    2.

非阻塞型lock()

 
 
 
    
  
  
  
  1. boolean tryLock();
    2.


(2) 使用基本结构

 
 
 
    
  
  
  
  1. locker.lock();
    2. 
  
  
  
  2. try{
    3. 
  
  
  
  3. //code here to access the cirtical section
    4. 
  
  
  
  4. }finally{
    5. 
  
  
  
  5. locker.unlock();
    6. 
  
  
  
  6. }
    7.

这种结构保证在任何时刻只有一个线程能够进入临界区，如果一个线程锁住了锁对象，其他任何线程在调用lock时，都会被阻塞，直到第一个线程释放锁对象。而且无论try块是否抛出异常，都会执行finally block，解锁locker。

(3) 锁的可重入性

锁是可重入的，线程能够重复地获取它已经拥有的锁。锁对象维护一个持有计数(hold count)来追踪对lock方法的嵌套调用。线程在每次调用lock后都要调用unlock来释放锁。由于这个特性，被一个锁保护的代码可以调用另一个使用相同锁的方法。

(4) 示例代码：

 
 
 
    
  
  
  
  1. import java.util.concurrent.locks.Lock;
    2. 
  
  
  
  2. import java.util.concurrent.locks.ReentrantLock;
    3. 
  
  
  
  3. 
  
  
  
  4. class WorkerOne extends Thread{
    5. 
  
  
  
  5.     private Lock locker;
    6. 
  
  
  
  6.     public WorkerOne (Lock locker){
    7. 
  
  
  
  7.         this.locker = locker;
    8. 
  
  
  
  8.     }
    9. 
  
  
  
  9.     
    10. 
  
  
  
  10.     public void run(){
    11. 
  
  
  
  11.         locker.lock();
    12. 
  
  
  
  12.         try{
    13. 
  
  
  
  13. System.out.println(Thread.currentThread().getName()+":step into critical section");
    14. 
  
  
  
  14.         }finally{
    15. 
  
  
  
  15.             locker.unlock();    
    16. 
  
  
  
  16.         }
    17. 
  
  
  
  17.     }
    18. 
  
  
  
  18. }
    19. 
  
  
  
  19. 
  
  
  
  20. class WorkerTwo extends Thread{
    21. 
  
  
  
  21.     private Lock locker;
    22. 
  
  
  
  22.     public WorkerTwo (Lock locker){
    23. 
  
  
  
  23.         this.locker = locker;
    24. 
  
  
  
  24.     }
    25. 
  
  
  
  25.     
    26. 
  
  
  
  26.     public void sayHello(){
    27. 
  
  
  
  27.         locker.lock();
    28. 
  
  
  
  28.         try{    System.out.println(Thread.currentThread().getName()+":call sayHello()");
    29. 
  
  
  
  29.             Thread.sleep(1000);
    30. 
  
  
  
  30.         } catch (InterruptedException e) {
    31. 
  
  
  
  31.             e.printStackTrace();
    32. 
  
  
  
  32.         }finally{
    33. 
  
  
  
  33.             locker.unlock();
    34. 
  
  
  
  34.         }
    35. 
  
  
  
  35.     }
    36. 
  
  
  
  36.     
    37. 
  
  
  
  37.     public void run(){
    38. 
  
  
  
  38.         locker.lock();  
    39. 
  
  
  
  39.         try{        System.out.println(Thread.currentThread().getName()+":setp into critical section");
    40. 
  
  
  
  40.                         //测试锁的可重入性 
    41. 
  
  
  
  41.             sayHello();
    42. 
  
  
  
  42.         }finally{
    43. 
  
  
  
  43.             locker.unlock();    
    44. 
  
  
  
  44.         }
    45. 
  
  
  
  45.     }
    46. 
  
  
  
  46. }
    47. 
  
  
  
  47. 
  
  
  
  48. public class Test5 {
    49. 
  
  
  
  49.     public static void main(String[] args) {
    50. 
  
  
  
  50.         Lock locker = new ReentrantLock();
    51. 
  
  
  
  51.         WorkerOne wo= new WorkerOne(locker);
    52. 
  
  
  
  52.         wo.setName("WorkerOne");
    53. 
  
  
  
  53.         WorkerTwo wt = new WorkerTwo(locker);
    54. 
  
  
  
  54.         wt.setName("WorkerTwo");
    55. 
  
  
  
  55.         
    56. 
  
  
  
  56.         wt.start();
    57. 
  
  
  
  57.         wo.start(); 
    58. 
  
  
  
  58.     }
    59. 
  
  
  
  59. }
    60.

输出：

WorkerTwo:setp into critical section
WorkerTwo:call sayHello()
WorkerOne:step into critical section

2、条件对象Condition,相当于wait-notify机制，提供一种线程间的等待通知机制,condition中的等待-通知方法是await(),signal(),signalAll(),也需要在互斥环境下被调用。

(1) 相关的接口

创建Condition对象,Condition对象是跟Lock关联在一起的。

 
 
 
    
  
  
  
  1. Lock locker = new ReentrantLock();
    2. 
  
  
  
  2. Condition cond = locker.newCondition();
    3.

把此线程放到条件的等待集中。

 
 
 
    
  
  
  
  1. void await();
    2.

解除此条件的等待集中所有线程的阻塞状态。

 
 
 
    
  
  
  
  1. void signalAll();
    2.

在此条件的等待集中随机选择一个线程，解除其阻塞状态。

 
 
 
    
  
  
  
  1. void signal();
    2.

(2) 使用的基本结构：

 
 
 
    
  
  
  
  1. //初始时ok_to_proceed为false.
    2. 
  
  
  
  2. locker.lock()
    3. 
  
  
  
  3. try{
    4. 
  
  
  
  4.      while(!ok_to_proceed){
    5. 
  
  
  
  5. //进入等待此条件集中,被阻塞,它维持状态直到另一个线程调用同一个条件上的。
    6. 
  
  
  
  6. //signalAll/signal方法时为止。
    7. 
  
  
  
  7.        cond.await();
    8. 
  
  
  
  8.      }
    9. 
  
  
  
  9. }finally{
    10. 
  
  
  
  10. cker.unlock();
    11. 
  
  
  
  11. }
    12. 
 
 
 


 
 
 
    
  
  
  
  1. locker.lock();
    2. 
  
  
  
  2.    try{
    3. 
  
  
  
  3.       //调用将解除所有等待此条件下的线程的阻塞状态。当线程从等待集中被移走时，它们将再次成为可运行的，调度器将再次激活它们    
    4. 
  
  
  
  4.       //此时，它们将试图重新进入对象。一旦锁可获得，它们中的某个线程将从await调用返回，从而获得锁并从它被阻塞的地方继续执行。
    5. 
  
  
  
  5.       ok_to_proceed = true;
    6. 
  
  
  
  6.       cond.signalAll() or cond.signal();
    7. 
  
  
  
  7.    }finally{
    8. 
  
  
  
  8.        locker.unlock();
    9. 
  
  
  
  9.    }
    10.

ok_to_proceed也是为了防止wait-notify出现的问题，即再wait之间，notify()已经给出通知，此时wait只会一直等待下去,这样就保证了signal()线程的通知被await()线程接收到。

(3) 测试代码：

 
 
 
    
  
  
  
  1. import java.util.concurrent.locks.Condition;
    2. 
  
  
  
  2. import java.util.concurrent.locks.Lock;
    3. 
  
  
  
  3. import java.util.concurrent.locks.ReentrantLock;
    4. 
  
  
  
  4. class GlobalV{
    5. 
  
  
  
  5.     public final static Lock locker = new ReentrantLock();
    6. 
  
  
  
  6.     public final static Condition cond = locker.newCondition();
    7. 
  
  
  
  7.     public static boolean to_proceed = false;
    8. 
  
  
  
  8. }
    9. 
  
  
  
  9. 
  
  
  
  10. class Response extends Thread{
    11. 
  
  
  
  11.     public void run(){
    12. 
  
  
  
  12.         while(true){
    13. 
  
  
  
  13.             GlobalV.locker.lock();
    14. 
  
  
  
  14.             try{
    15. 
  
  
  
  15.                 while(!GlobalV.to_proceed){
    16. 
  
  
  
  16.                     GlobalV.cond.await();
    17. 
  
  
  
  17.                 }
    18. 
  
  
  
  18. System.out.println("Response:finish a job");
    19. 
  
  
  
  19.                 GlobalV.to_proceed = false;
    20. 
  
  
  
  20.                 
    21. 
  
  
  
  21.             }catch(Exception e){
    22. 
  
  
  
  22.                 e.printStackTrace();
    23. 
  
  
  
  23.             }finally{
    24. 
  
  
  
  24.                 GlobalV.locker.unlock();
    25. 
  
  
  
  25.             }   
    26. 
  
  
  
  26.         }
    27. 
  
  
  
  27.     }
    28. 
  
  
  
  28. }
    29. 
  
  
  
  29. 
  
  
  
  30. class Request extends Thread{
    31. 
  
  
  
  31.     public void run(){
    32. 
  
  
  
  32.         while(true){
    33. 
  
  
  
  33.             GlobalV.locker.lock();  
    34. 
  
  
  
  34.             try{
    35. 
  
  
  
  35.                 GlobalV.to_proceed = true;
    36. 
  
  
  
  36.                 GlobalV.cond.signalAll();
    37. 
  
  
  
  37.                 System.out.println("Request:send a job to Response");   
    38. 
  
  
  
  38.             }finally{
    39. 
  
  
  
  39.                 GlobalV.locker.unlock();
    40. 
  
  
  
  40.             }
    41. 
  
  
  
  41.             try {
    42. 
  
  
  
  42.                 Thread.sleep(2000);
    43. 
  
  
  
  43.             } catch (InterruptedException e) {
    44. 
  
  
  
  44.                 e.printStackTrace();
    45. 
  
  
  
  45.             }
    46. 
  
  
  
  46.         }
    47. 
  
  
  
  47.     }
    48. 
  
  
  
  48. }
    49. 
  
  
  
  49. 
  
  
  
  50. public class Test6 {
    51. 
  
  
  
  51.     public static void main(String[] args) {
    52. 
  
  
  
  52.         Request req = new Request();
    53. 
  
  
  
  53.         Response res = new Response();
    54. 
  
  
  
  54.         req.start();
    55. 
  
  
  
  55.         res.start();
    56. 
  
  
  
  56.     }
    57. 
  
  
  
  57. }
    58.

输出：

Request:send a job to Response
Response:finish a job
Request:send a job to Response
Response:finish a job
Request:send a job to Response
Response:finish a job
Request:send a job to Response
Response:finish a job

#p#

3、读写锁ReentrantReadWriteLock,适用于"读多写少"的多线程应用场景，"读-写"互斥，"写-写"互斥，而读-读可以共享同读锁，即一个线程获取读锁，其它线程可直接进入读，不会被阻塞。

(1) 相关接口

创建读写锁对象

 
 
 
    
  
  
  
  1. ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    2.

获取读锁

 
 
 
    
  
  
  
  1. Lock readLock = rwLock.readLock();
    2.

获取写锁

 
 
 
    
  
  
  
  1. Lock writeLock = rwLock.writeLock();
    2.

(2).读写锁使用基本结构

 
 
 
    
  
  
  
  1. //对所有的读操作添加读锁
    2. 
  
  
  
  2. readLock.lock();
    3. 
  
  
  
  3. try{
    4. 
  
  
  
  4. //code to read
    5. 
  
  
  
  5. }finally{
    6. 
  
  
  
  6. readLock.unlock();
    7. 
  
  
  
  7. } 
    8. 
 
 
 
 
 
 
    
  
  
  
  1. //对所有的写操作添加写锁
    2. 
  
  
  
  2.   writeLock.lock(); 
    3. 
  
  
  
  3.    try{ 
    4. 
  
  
  
  4. //code to write 
    5. 
  
  
  
  5.    }finally{ 
    6. 
  
  
  
  6.     writeLock.unlock(); 
    7. 
  
  
  
  7.    } 
    8.

(3) 测试代码：

 
 
 
    
  
  
  
  1. import java.util.concurrent.locks.Lock;
    2. 
  
  
  
  2. import java.util.concurrent.locks.ReentrantReadWriteLock;
    3. 
  
  
  
  3. class Reader extends Thread {
    4. 
  
  
  
  4.     private Lock readLock = null;
    5. 
  
  
  
  5.     public Reader(Lock readLock) {
    6. 
  
  
  
  6.         this.readLock = readLock;
    7. 
  
  
  
  7.     }
    8. 
  
  
  
  8. 
  
  
  
  9.     public void run() {
    10. 
  
  
  
  10.         while (true) {
    11. 
  
  
  
  11.             readLock.lock();
    12. 
  
  
  
  12.             try {
    13. 
  
  
  
  13. System.out.println(Thread.currentThread().getName()
    14. 
  
  
  
  14.                         + ":read action for 1 seconds-"+ReadWriteLock.testVal);
    15. 
  
  
  
  15.             } finally {
    16. 
  
  
  
  16.                 readLock.unlock();
    17. 
  
  
  
  17.             }
    18. 
  
  
  
  18.             try {
    19. 
  
  
  
  19.                 Thread.sleep(1000);
    20. 
  
  
  
  20.             } catch (InterruptedException e) {
    21. 
  
  
  
  21.                 e.printStackTrace();
    22. 
  
  
  
  22.             }
    23. 
  
  
  
  23.         }
    24. 
  
  
  
  24.     }
    25. 
  
  
  
  25. }
    26. 
  
  
  
  26. 
  
  
  
  27. class Writer extends Thread {
    28. 
  
  
  
  28.     private Lock writeLock = null;
    29. 
  
  
  
  29.     public Writer(Lock writeLock) {
    30. 
  
  
  
  30.         this.writeLock = writeLock;
    31. 
  
  
  
  31.     }
    32. 
  
  
  
  32.     public void run() {
    33. 
  
  
  
  33.         while (true) {
    34. 
  
  
  
  34.             writeLock.lock();
    35. 
  
  
  
  35.             try {
    36. 
  
  
  
  36. System.out.println(Thread.currentThread().getName()
    37. 
  
  
  
  37.                         + ":write action for 2 seconds");
    38. 
  
  
  
  38. if(ReadWriteLock.testVal.equals("1111"))
    39. 
  
  
  
  39.                     ReadWriteLock.testVal = "2222";
    40. 
  
  
  
  40.                 else
    41. 
  
  
  
  41.                     ReadWriteLock.testVal = "1111";
    42. 
  
  
  
  42.             } finally {
    43. 
  
  
  
  43.                 writeLock.unlock();
    44. 
  
  
  
  44.             }
    45. 
  
  
  
  45.             try {
    46. 
  
  
  
  46.                 Thread.sleep(2000);
    47. 
  
  
  
  47.             } catch (InterruptedException e) {
    48. 
  
  
  
  48.                 e.printStackTrace();
    49. 
  
  
  
  49.             }
    50. 
  
  
  
  50.         }
    51. 
  
  
  
  51.     }
    52. 
  
  
  
  52. }
    53. 
  
  
  
  53. 
  
  
  
  54. public class ReadWriteLock {
    55. 
  
  
  
  55.     public static String  testVal = "Initiation";
    56. 
  
  
  
  56.     public static void main(String[] args) {
    57. 
  
  
  
  57.         ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    58. 
  
  
  
  58.         Lock readLock = lock.readLock();
    59. 
  
  
  
  59.         Lock writeLock = lock.writeLock();
    60. 
  
  
  
  60.         Reader reader1 = new Reader(readLock);
    61. 
  
  
  
  61.         reader1.setName("reader1");
    62. 
  
  
  
  62.         Reader reader2 = new Reader(readLock);
    63. 
  
  
  
  63.         reader2.setName("reader2");
    64. 
  
  
  
  64.         Reader reader3 = new Reader(readLock);
    65. 
  
  
  
  65.         reader3.setName("reader3");
    66. 
  
  
  
  66.         Reader reader4 = new Reader(readLock);
    67. 
  
  
  
  67.         reader4.setName("reader4");
    68. 
  
  
  
  68.         Writer writer = new Writer(writeLock);
    69. 
  
  
  
  69.         writer.setName("writer1");
    70. 
  
  
  
  70.         reader1.start();
    71. 
  
  
  
  71.         reader2.start();
    72. 
  
  
  
  72.         reader3.start();
    73. 
  
  
  
  73.         reader4.start();
    74. 
  
  
  
  74.         writer.start();
    75. 
  
  
  
  75.     }
    76. 
  
  
  
  76. }
    77.

输出：

reader1:read action for 1 seconds-Initiation
reader3:read action for 1 seconds-Initiation
writer1:write action for 2 seconds
reader2:read action for 1 seconds-1111
reader4:read action for 1 seconds-1111
reader3:read action for 1 seconds-1111
reader1:read action for 1 seconds-1111
reader4:read action for 1 seconds-1111
reader2:read action for 1 seconds-1111
writer1:write action for 2 seconds
reader4:read action for 1 seconds-2222
reader1:read action for 1 seconds-2222
reader3:read action for 1 seconds-2222
reader2:read action for 1 seconds-2222

4、总结

Lock接口替代synchronized

Lock接口可以比sychronized提供更广泛的锁定操作，可以提供多把不同的锁，且锁之间互不干涉。

Lock接口提供lock()与unlock()方法，使用明确调用来完成同步的，OO思想好于前者。

Lock可以自由操控同步范围(scope)。

Lock接口支持nested lock(嵌套锁定)，并提供了丰富的api。

Lock接口提供了tryLock()方法，支持尝试取得某个object lock。

分享标题：去故就新Java线程新同步机制
浏览路径：http://www.shufengxianlan.com/qtweb/news24/366074.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

品牌网站建设知识

分类信息网

成都搬家公司　　 　成都名片印刷　　 　商城网站　　 　迷你发光字　　 　达州主机托管　　 　四川服务器托管　　 　广汉锦华橡塑　　 　成都小程序开发　　 　重庆水土机房托管　　 　化妆品企业网站建设方案　　 　路面机械及配件　　 　普能电气　　 　达州网站建设　　 　广安网站建设　　 　四川网站建设　　 　德阳机房托管　　 　航龙航空　　 　温江网站设计　　 　成都网站建设　　 　成都响应式网站建设