devbox
黑客灵魂
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java中的Lock详解_java lock锁

作者：黑客灵魂 | 2024-08-10 01:14:10

赞

踩

java lock锁

一、简介

java.util.concurrent.locks.Lock 是一个类似于synchronized 块的线程同步机制。但是 Lock比 synchronized 块更加灵活。Lock是个接口，有个实现类是ReentrantLock。

二、Lock和syncronized的区别

  • synchronized是Java语言的关键字。Lock是一个接口。
  • synchronized不需要用户去手动释放锁，发生异常或者线程结束时自动释放锁;Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。
  • lock可以配置公平策略,实现线程按照先后顺序获取锁。
  • 提供了trylock方法 可以试图获取锁，获取到或获取不到时，返回不同的返回值 让程序可以灵活处理。
  • lock()和unlock()可以在不同的方法中执行,可以实现同一个线程在上一个方法中lock()在后续的其他方法中unlock(),比syncronized灵活的多。

三、Lock接口抽象方法 

void lock()：获取锁，如果锁不可用，则出于线程调度的目的，当前线程将被禁用，并且在获取锁之前处于休眠状态。

  1. Lock lock = ...;
  2. lock.lock();
  3. try{
  4.     //处理任务
  5. }catch(Exception ex){
  6.      
  7. }finally{
  8.     lock.unlock();   //释放锁
  9. }

boolean tryLock()：如果锁可用立即返回true，如果锁不可用立即返回false；
boolean tryLock(long time, TimeUnit unit) throws InterruptedException：如果锁可用，则此方法立即返回true。 如果该锁不可用，则当前线程将出于线程调度目的而被禁用并处于休眠状态，直到发生以下三种情况之一为止：①当前线程获取到该锁；②当前线程被其他线程中断，并且支持中断获取锁；③经过指定的等待时间如果获得了锁，则返回true，没获取到锁返回false。

  1. Lock lock = ...;
  2. if(lock.tryLock()) {
  3.      try{
  4.          //处理任务
  5.      }catch(Exception ex){
  6.          
  7.      }finally{
  8.          lock.unlock();   //释放锁
  9.      } 
  10. }else {
  11.     //如果不能获取锁，则直接做其他事情
  12. }

void unlock()：释放锁。释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

四、ReentrantLock

重入锁也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。避免死锁问题的,synchronized也可重入。

4.1、synchronized重入测试

  1. public class ReentrantDemo {
  2.     public synchronized  void method1() {
  3.         System.out.println("synchronized method1");
  4.         method2();
  5.     }
  6.     public synchronized void method2() {
  7.         System.out.println("synchronized method2");
  8.     }
  9.     public static void main(String[] args) {
  10.         ReentrantDemo reentrantDemo = new ReentrantDemo();
  11.         reentrantDemo.method1();
  12.     }
  13. }

 在这里插入图片描述

 4.2、ReentrantLock重入测试 

  1. public class ReentrantDemo implements Runnable {
  2.     Lock lock = new ReentrantLock();
  3.     @Override
  4.     public void run() {
  5.         set();
  6.     }
  7.     public void set() {
  8.         try {
  9.             lock.lock();
  10.             System.out.println("set 方法");
  11.             get();
  12.         } catch (Exception e) {
  13.             e.printStackTrace();
  14.         } finally {
  15.             lock.unlock();// 必须在finally中释放
  16.         }
  17.     }
  18.  
  19.     public void get() {
  20.  
  21.         try {
  22.             lock.lock();
  23.             System.out.println("get 方法");
  24.         } catch (Exception e) {
  25.             e.printStackTrace();
  26.         } finally {
  27.             lock.unlock();
  28.         }
  29.     }
  30.     public static void main(String[] args) {
  31.         ReentrantDemo reentrantDemo = new ReentrantDemo();
  32.         new Thread(reentrantDemo).start();
  33.     }
  34. }

测试结果：同一个线程，首先在set方法中获取锁，然后调用get方法，get方法中重复获取同一个锁。两个方法都执行成功。

 在这里插入图片描述

 五、ReentrantReadWriteLock（读写锁） 

读写锁，可以分别获取读锁或写锁。也就是说将数据的读写操作分开，分成2个锁来分配给线程，从而使得多个线程可以同时进行读操作。读锁使用共享模式；写锁使用独占模式；读锁可以在没有写锁的时候被多个线程同时持有，写锁是独占的。当有读锁时，写锁就不能获得；而当有写锁时，除了获得写锁的这个线程可以获得读锁外，其他线程不能获得读锁

writeLock()：获取写锁。
readLock()：获取读锁。
执行三个线程进行读写操作，并设置一个屏障，线程依次准备就绪后未获取锁之前都在等待，当第三个线程执行 cyclicBarrier.await();后屏障解除，三个线程同时执行。
 

  1. public class WriteAndReadLockTest {
  2.     private static ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
  3.     private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10,
  4.             60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
  5.     private static CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
  6.     private static int i = 100;
  7.     public static void main(String[] args) {
  8.         threadPoolExecutor.execute(()->{
  9.             read(Thread.currentThread());
  10.         });
  11.         threadPoolExecutor.execute(()->{
  12.             write(Thread.currentThread());
  13.         });
  14.         threadPoolExecutor.execute(()->{
  15.             read(Thread.currentThread());
  16.         });
  17.         threadPoolExecutor.shutdown();
  18.     }
  19.  
  20.     private static void read(Thread thread) {
  21.         try {
  22.             cyclicBarrier.await();
  23.         } catch (InterruptedException e) {
  24.             e.printStackTrace();
  25.         } catch (BrokenBarrierException e) {
  26.             e.printStackTrace();
  27.         }
  28.         reentrantReadWriteLock.readLock().lock();
  29.         try {
  30.             System.out.println("读线程 "+ thread.getName() + " 开始执行, i=" + i);
  31.             Thread.sleep(1000);
  32.             System.out.println(thread.getName() +" is over!");
  33.         } catch (InterruptedException e) {
  34.             e.printStackTrace();
  35.         } finally {
  36.             reentrantReadWriteLock.readLock().unlock();
  37.  
  38.         }
  39.     }
  40.     private static void write(Thread thread) {
  41.         try {
  42.             cyclicBarrier.await();
  43.         } catch (InterruptedException e) {
  44.             e.printStackTrace();
  45.         } catch (BrokenBarrierException e) {
  46.             e.printStackTrace();
  47.         }
  48.         reentrantReadWriteLock.writeLock().lock();
  49.         try {
  50.             i++;
  51.             System.out.println("写线程 "+ thread.getName() + " is doing, i=" + i);
  52.             System.out.println(thread.getName() +" is over!");
  53.         } finally {
  54.             reentrantReadWriteLock.writeLock().unlock();
  55.         }
  56.     }
  57. }

执行结果：线程1先获取到了读锁，因为读锁时可以共享的，所有线程3也可以获取到读锁，线程1、3读操作完成后将读锁释放后，线程2才能获取到写锁并开始执行写操作。

 在这里插入图片描述

 六、公平锁与非公平锁 

公平锁：就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己
非公平锁：比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁那种方式

6.1、如何实现 

ReentrantLock：模式是非公平锁。也可通过构造方法创建公平锁；

  1. public ReentrantLock() {
  2. 	sync = new NonfairSync();
  3. }
  4. public ReentrantLock(boolean fair) {
  5.     sync = fair ? new FairSync() : new NonfairSync();
  6. }

​​​​​​​ReentrantReadWriteLock：默认是非公平锁，也可以通过构造方法创建公平锁；

  1. public ReentrantReadWriteLock() {
  2. 	this(false);
  3. }
  4. public ReentrantReadWriteLock(boolean fair) {
  5.     sync = fair ? new FairSync() : new NonfairSync();
  6.     readerLock = new ReadLock(this);
  7.     writerLock = new WriteLock(this);
  8. }

6.2、优缺点

非公平锁性能高于公平锁性能。首先，在恢复一个被挂起的线程与该线程真正运行之间存在着严重的延迟。而且，非公平锁能更充分的利用cpu的时间片，尽量的减少cpu空闲的状态时间。

七、Condition的使用

当满足一定条件时，调用Condition的await()方法使当前线程进入休眠状态进行等待。调用Condition的signalAll()方法唤醒因await()进入休眠的线程。

Lock锁实现同步时需要使用者手动控制锁的获取和释放，其灵活性使得可以实现更复杂的多线程同步和更高的性能，但同时，使用者一定要在获取锁后及时捕获代码运行过程中的异常并在finally代码块中释放锁。

使用Lock锁及其同步条件来实现一个生产者-消费者模型：

  1. public class MessageStorageByLock {  
  2.     private int maxSize;  
  3.     private List<String> messages;  
  4.   
  5.     private final ReentrantLock lock;  
  6.     private final Condition conditionWrite;//声明两个锁条件  
  7.     private final Condition conditionRead;  
  8.     public MessageStorageByLock(int maxSize) {  
  9.         this.maxSize = maxSize;  
  10.         messages = new LinkedList<String>();  
  11.         lock = new ReentrantLock(true);//true修改锁的公平性，为true时，使用lifo队列来顺序获得锁  
  12.         conditionWrite = lock.newCondition();//调用newCondition()方法，即new ConditionObject();  
  13.         conditionRead = lock.newCondition();  
  14.   
  15.     }  
  16.     public void set(String message){  
  17.         //使用锁实现同步，获取所得操作，当锁被其他线程占用时，当前线程将进入休眠  
  18.         lock.lock();  
  19.         try{  
  20.             while(messages.size() == maxSize){  
  21.                     System.out.print("the message buffer is full now,start into wait()\n");  
  22.                     conditionWrite.await();//满足条件时，线程休眠并释放锁。当调用 signalAll()时。线程唤醒并重新获得锁  
  23.             }  
  24.             Thread.sleep(100);  
  25.             messages.add(message);  
  26.             System.out.print("add message:"+message+" success\n");  
  27.             conditionRead.signalAll();//唤醒因conditionRead.await()休眠的线程  
  28.         }catch (InterruptedException e){  
  29.             e.printStackTrace();  
  30.         }finally {  
  31.             lock.unlock();  
  32.         }  
  33.     }  
  34.     public String get(){  
  35.         String message = null;  
  36.         lock.lock();  
  37.         try{  
  38.             while(messages.size() == 0){  
  39.                 conditionRead.await();  
  40.                 System.out.print("the message buffer is empty now,start into wait()\n");  
  41.             }  
  42.             Thread.sleep(100);  
  43.             message = ((LinkedList<String>)messages).poll();  
  44.             System.out.print("get message:"+message+" success\n");  
  45.             conditionWrite.signalAll();  
  46.         }catch (InterruptedException e){  
  47.             e.printStackTrace();  
  48.         }finally {  
  49.             lock.unlock();  
  50.         }  
  51.         return message;  
  52.     }  
  53. }
Modifier and TypeMethod and Description
void

lock()

获得锁

voidlockInterruptibly()

获取锁定，除非当前线程是 interrupted 。

ConditionnewCondition()

返回一个新Condition绑定到该实例Lock实例。

booleantryLock()

只有在调用时才可以获得锁。

booleantryLock(long time, TimeUnit unit)

如果在给定的等待时间内是空闲的，并且当前的线程尚未得到 interrupted，则获取该锁。

void

unlock();

释放锁

  1. package java.util.concurrent.locks;
  2. import java.util.concurrent.TimeUnit;
  3.  
  4. public interface Lock {
  5.     void lock();
  6.  
  7.     void lockInterruptibly() throws InterruptedException;
  8.  
  9.     boolean tryLock();
  10.  
  11.     boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
  12.  
  13.     void unlock();
  14.  
  15.     Condition newCondition();
  16. }

 

  1. package java.util.concurrent.locks;
  2. import java.util.concurrent.TimeUnit;
  3. import java.util.Date;
  4.  
  5. public interface Condition {
  6.  
  7.     void await() throws InterruptedException;
  8.  
  9.     void awaitUninterruptibly();
  10.  
  11.     long awaitNanos(long nanosTimeout) throws InterruptedException;
  12.  
  13.     boolean await(long time, TimeUnit unit) throws InterruptedException;
  14.  
  15.     boolean awaitUntil(Date deadline) throws InterruptedException;
  16.  
  17.     void signal();
  18.  
  19.     void signalAll();
  20. }

 

八、代码举例

8.1、Demo1（先演示一下锁的可重入性）

  1. package com.szh.lock;
  2.  
  3. /**
  4.  * 演示锁的可重入性
  5.  */
  6. public class Test01 {
  7.  
  8.     public synchronized void metthod1() {
  9.         System.out.println("同步方法1");
  10.         //线程执行 metthod1() 方法,默认 this 作为锁对象,
  11.         //在 metthod1() 方法中调用了 method2() 方法,注意当前线程还是持有 this 锁对象的
  12.         //method2() 同步方法默认的锁对象也是 this 对象, 要执行 method2() 必须先获得 this 锁对象,
  13.         //当前 this 对象被当前线程持有,可以 再次获得 this 对象, 这就是锁的可重入性.
  14.         //假设锁不可重入的话,可能会造成死锁
  15.         method2();
  16.     }
  17.  
  18.     public synchronized void method2() {
  19.         System.out.println("同步方法2");
  20.         method3();
  21.     }
  22.  
  23.     public synchronized void method3() {
  24.         System.out.println("同步方法3");
  25.     }
  26.  
  27.     public static void main(String[] args) {
  28.         Test01 obj=new Test01();
  29.  
  30.         new Thread(new Runnable() {
  31.             @Override
  32.             public void run() {
  33.                 obj.metthod1();
  34.             }
  35.         }).start();
  36.     }
  37. }

8.2、Demo2（ReentrantLock的基本使用）

  1. package com.szh.lock;
  2.  
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  5.  
  6. /**
  7.  * ReentrantLock 的基本使用
  8.  */
  9. public class Test02 {
  10.  
  11.     //定义一个显示锁
  12.     static Lock lock=new ReentrantLock();
  13.  
  14.     public static void method() {
  15.         //先获得锁
  16.         lock.lock();
  17.         //for循环此时就是同步代码块
  18.         for (int i = 0; i < 3; i++) {
  19.             System.out.println(Thread.currentThread().getName() + " ---> " + i);
  20.         }
  21.         //释放锁
  22.         lock.unlock();
  23.     }
  24.  
  25.     public static void main(String[] args) {
  26.         Runnable r=new Runnable() {
  27.             @Override
  28.             public void run() {
  29.                 method();
  30.             }
  31.         };
  32.         //启动三个线程
  33.         new Thread(r).start();
  34.         new Thread(r).start();
  35.         new Thread(r).start();
  36.     }
  37. }

 

8.3、Demo3（使用Lock锁同步不同方法中的代码块）

  1. package com.szh.lock;
  2.  
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  5.  
  6. /**
  7.  * 使用 Lock 锁同步不同方法中的同步代码块
  8.  */
  9. public class Test03 {
  10.     //定义锁对象
  11.     static Lock lock=new ReentrantLock();
  12.  
  13.     public static void method1() {
  14.         //经常在 try 代码块中获得 Lock 锁, 在 finally 子句中释放锁
  15.         try {
  16.             lock.lock(); //获得锁
  17.             System.out.println(Thread.currentThread().getName() + " ---method1--- " + System.currentTimeMillis());
  18.             Thread.sleep(1000);
  19.             System.out.println(Thread.currentThread().getName() + " ---method1--- " + System.currentTimeMillis());
  20.         } catch (InterruptedException e) {
  21.             e.printStackTrace();
  22.         }finally {
  23.             lock.unlock(); //释放锁
  24.         }
  25.     }
  26.  
  27.     public static void method2() {
  28.         //经常在 try 代码块中获得 Lock 锁, 在 finally 子句中释放锁
  29.         try {
  30.             lock.lock(); //获得锁
  31.             System.out.println(Thread.currentThread().getName() + " ---method2--- " + System.currentTimeMillis());
  32.             Thread.sleep(1000);
  33.             System.out.println(Thread.currentThread().getName() + " ---method2--- " + System.currentTimeMillis());
  34.         } catch (InterruptedException e) {
  35.             e.printStackTrace();
  36.         }finally {
  37.             lock.unlock(); //释放锁
  38.         }
  39.     }
  40.  
  41.     public static void main(String[] args) {
  42.  
  43.         Runnable r1=new Runnable() {
  44.             @Override
  45.             public void run() {
  46.                 method1();
  47.             }
  48.         };
  49.  
  50.         Runnable r2=new Runnable() {
  51.             @Override
  52.             public void run() {
  53.                 method2();
  54.             }
  55.         };
  56.  
  57.         new Thread(r1).start();
  58.         new Thread(r1).start();
  59.  
  60.         new Thread(r2).start();
  61.         new Thread(r2).start();
  62.     }
  63. }

 

8.4、Demo4（ReentrantLock锁的可重入性） 

  1. package com.szh.lock;
  2.  
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  5.  
  6. /**
  7.  * ReentrantLock 锁的可重入性
  8.  */
  9. public class Test04 {
  10.  
  11.     static class SubThread extends Thread {
  12.         //定义锁对象
  13.         private static Lock lock=new ReentrantLock();
  14.  
  15.         //定义变量
  16.         private static int num=0;
  17.  
  18.         @Override
  19.         public void run() {
  20.             for (int i = 0; i < 10000; i++) {
  21.                 try {
  22.                     //可重入锁指可以反复获得该锁
  23.                     lock.lock();
  24.                     lock.lock();
  25.                     num++;
  26.                 }finally {
  27.                     lock.unlock();
  28.                     lock.unlock();
  29.                 }
  30.             }
  31.         }
  32.     }
  33.  
  34.     public static void main(String[] args) throws InterruptedException {
  35.  
  36.         SubThread t1=new SubThread();
  37.         SubThread t2=new SubThread();
  38.  
  39.         t1.start();
  40.         t2.start();
  41.  
  42.         t1.join();
  43.         t2.join();
  44.  
  45.         System.out.println(SubThread.num);
  46.     }
  47. }

 

8.5、Demo5（ReentrantLock的lockInterruptibly()方法）

  1. package com.szh.lock;
  2.  
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  5.  
  6. /**
  7.  * lockInterruptibly()方法
  8.  *  如果当前线程未被中断则获得锁,
  9.  *  如果当前线程被中断则出现异常.
  10.  */
  11. public class Test05 {
  12.  
  13.     static class Service {
  14.         private Lock lock=new ReentrantLock(); //定义锁对象
  15.         public void serviceMethod() {
  16.             try {
  17.                 //lock.lock();  获得锁, 即使调用了线程的 interrupt() 方法, 也没有真正的中断线程
  18.                 //如果线程被中断了, 不会获得锁, 会产生异常
  19.                 lock.lockInterruptibly();
  20.                 System.out.println(Thread.currentThread().getName() + " --- begin lock");
  21.                 //执行一段耗时的操作
  22.                 for (int i = 0; i < Integer.MAX_VALUE; i++) {
  23.                     new StringBuilder();
  24.                 }
  25.                 System.out.println(Thread.currentThread().getName() + " --- end lock");
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             } finally {
  29.                 System.out.println(Thread.currentThread().getName() + " === 释放锁");
  30.                 lock.unlock(); //释放锁
  31.             }
  32.         }
  33.     }
  34.  
  35.     public static void main(String[] args) throws InterruptedException {
  36.         Service s=new Service();
  37.  
  38.         Runnable r=new Runnable() {
  39.             @Override
  40.             public void run() {
  41.                 s.serviceMethod();
  42.             }
  43.         };
  44.  
  45.         Thread t1=new Thread(r);
  46.         t1.start();
  47.         Thread.sleep(50);
  48.  
  49.         Thread t2=new Thread(r);
  50.         t2.start();
  51.         Thread.sleep(50);
  52.  
  53.         t2.interrupt(); //中断 t2 线程
  54.     }
  55. }

 

 8.6、Demo6（lockInterruptibly()方法可以避免死锁） 

  1. package com.szh.lock;
  2.  
  3. import java.util.concurrent.locks.ReentrantLock;
  4.  
  5. /**
  6.  * 通过 ReentrantLock 锁的 lockInterruptibly() 方法避免死锁的产生
  7.  */
  8. public class Test06 {
  9.  
  10.     static class MyLock implements Runnable {
  11.  
  12.         //创建两个ReentrantLock等锁对象
  13.         private static ReentrantLock lock1=new ReentrantLock();
  14.         private static ReentrantLock lock2=new ReentrantLock();
  15.  
  16.         int lockNum; //定义整数变量,决定使用哪个锁,偶数用lock1,奇数用lock2
  17.  
  18.         public MyLock(int lockNum) {
  19.             this.lockNum=lockNum;
  20.         }
  21.  
  22.         @Override
  23.         public void run() {
  24.             try {
  25.                 if (lockNum % 2 == 1) { //奇数, 先锁 1, 再锁 2
  26.                     lock1.lockInterruptibly();
  27.                     System.out.println(Thread.currentThread().getName() + "获得锁1，还需要获得锁2");
  28.                     Thread.sleep(1000);
  29.                     lock2.lockInterruptibly();
  30.                     System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2");
  31.                 }else { //偶数, 先锁 2, 再锁 1
  32.                     lock2.lockInterruptibly();
  33.                     System.out.println(Thread.currentThread().getName() + "获得了锁2，还需要获得锁1");
  34.                     Thread.sleep(1000);
  35.                     lock1.lockInterruptibly();
  36.                     System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2");
  37.                 }
  38.             }catch (InterruptedException e) {
  39.                 e.printStackTrace();
  40.             }finally {
  41.                 if (lock1.isHeldByCurrentThread()) { //判断当前线程是否持有该锁
  42.                     lock1.unlock();
  43.                 }
  44.                 if (lock2.isHeldByCurrentThread()) {
  45.                     lock2.unlock();
  46.                 }
  47.                 System.out.println(Thread.currentThread().getName() + "线程退出");
  48.             }
  49.         }
  50.     }
  51.  
  52.     public static void main(String[] args) throws InterruptedException {
  53.         MyLock myLock1=new MyLock(11);
  54.         MyLock myLock2=new MyLock(22);
  55.  
  56.         Thread t1=new Thread(myLock1);
  57.         Thread t2=new Thread(myLock2);
  58.         t1.start();
  59.         t2.start();
  60.  
  61.         //在 main 线程, 等待 3000 ms, 如果还有线程没有结束就中断该线程
  62.         Thread.sleep(1000 * 3);
  63.         //可以中断任何一个线程来解决死锁, t2 线程会放弃对锁 1 的申请, 同时释放锁 2, t1 线程会完成它的任务
  64.         if (t2.isAlive()) {
  65.             t2.interrupt();
  66.         }
  67.     }
  68. }

 8.7、Demo7（ReentrantLock的tryLock(long time, TimeUnit unit)方法） 

  1. package com.szh.lock;
  2.  
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.locks.ReentrantLock;
  5.  
  6. /**
  7.  * tryLock(long time, TimeUnit unit) 的作用在给定等待时长内,
  8.  * 锁没有被另外的线程持有, 并且当前线程也没有被中断, 则获得该锁.
  9.  * 通过该方法可以实现锁对象的限时等待.
  10.  */
  11. public class Test07 {
  12.  
  13.     static class TimeLock implements Runnable {
  14.         private static ReentrantLock lock=new ReentrantLock(); //定义锁对象
  15.  
  16.         @Override
  17.         public void run() {
  18.             try {
  19.                 //假设 t1 线程先持有锁, 完成任务需要 4 秒钟,
  20.                 //这个时候 t2 线程尝试获得锁, t2 线程在 3 秒内还没有获得锁的话, 那么它就不再等了，直接放弃
  21.                 if (lock.tryLock(3, TimeUnit.SECONDS)) {
  22.                     System.out.println(Thread.currentThread().getName() + "获得锁，执行耗时任务");
  23.                     Thread.sleep(1000 * 4);
  24.                     /*
  25.                         假设 t1 线程先持有锁, 完成任务需要 2 秒钟
  26.                         这个时候t2 线程尝试获得锁, t2 线程会一直尝试
  27.                         在它约定尝试的 3 秒内可以获得锁对象
  28.                      */
  29.                     //Thread.sleep(1000 * 2);
  30.                 }else {
  31.                     System.out.println(Thread.currentThread().getName() + "没有获得锁");
  32.                 }
  33.             } catch (InterruptedException e) {
  34.                 e.printStackTrace();
  35.             } finally {
  36.                 if (lock.isHeldByCurrentThread()) {
  37.                     lock.unlock();
  38.                 }
  39.             }
  40.         }
  41.     }
  42.  
  43.     public static void main(String[] args) {
  44.         TimeLock timeLock=new TimeLock();
  45.  
  46.         Thread t1=new Thread(timeLock);
  47.         Thread t2=new Thread(timeLock);
  48.  
  49.         t1.setName("t1");
  50.         t2.setName("t2");
  51.  
  52.         t1.start();
  53.         t2.start();
  54.     }
  55. }

 8.8、Demo8（ReentrantLock的tryLock()方法）

  1. package com.szh.lock;
  2.  
  3. import java.util.concurrent.locks.ReentrantLock;
  4.  
  5. /**
  6.  * tryLock() 当锁对象没有被其他线程持有的情况下, 才会获得该锁定
  7.  */
  8. public class Test08 {
  9.  
  10.     static class Service {
  11.         private ReentrantLock lock=new ReentrantLock();
  12.  
  13.         public void serviceMethod() {
  14.             try {
  15.                 if (lock.tryLock()) {
  16.                     System.out.println(Thread.currentThread().getName() + "获得锁定");
  17.                     Thread.sleep(1000 * 3); //模拟执行任务的时长
  18.                 }else {
  19.                     System.out.println(Thread.currentThread().getName() + "没有获得锁定");
  20.                 }
  21.             }catch (InterruptedException e) {
  22.                 e.printStackTrace();
  23.             }finally {
  24.                 if (lock.isHeldByCurrentThread()) {
  25.                     lock.unlock();
  26.                 }
  27.             }
  28.         }
  29.     }
  30.  
  31.     public static void main(String[] args) throws InterruptedException {
  32.         Service service=new Service();
  33.  
  34.         Runnable r=new Runnable() {
  35.             @Override
  36.             public void run() {
  37.                 service.serviceMethod();
  38.             }
  39.         };
  40.  
  41.         Thread t1=new Thread(r);
  42.         t1.start();
  43.         Thread.sleep(100);
  44.         Thread t2=new Thread(r);
  45.         t2.start();
  46.     }
  47. }

8.9、Demo9（tryLock()方法可以避免死锁）

  1. package com.szh.lock;
  2.  
  3. import java.util.concurrent.locks.ReentrantLock;
  4.  
  5. /**
  6.  * 使用 tryLock() 可以避免死锁
  7.  */
  8. public class Test09 {
  9.  
  10.     static class MyLock implements Runnable {
  11.  
  12.         private static ReentrantLock lock1=new ReentrantLock();
  13.         private static ReentrantLock lock2=new ReentrantLock();
  14.  
  15.         private int lockNum;
  16.  
  17.         public MyLock(int lockNum) {
  18.             this.lockNum=lockNum;
  19.         }
  20.  
  21.         @Override
  22.         public void run() {
  23.             if (lockNum % 2 == 0) { //偶数先锁 1, 再锁 2
  24.                 while (true) {
  25.                     try {
  26.                         if (lock1.tryLock()) {
  27.                             System.out.println(Thread.currentThread().getName() + "获得了锁1，还想获得锁2");
  28.                             Thread.sleep(50);
  29.                             try {
  30.                                 if (lock2.tryLock()) {
  31.                                     System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2，完成任务了");
  32.                                     return;
  33.                                 }
  34.                             } finally {
  35.                                 if (lock2.isHeldByCurrentThread()) {
  36.                                     lock2.unlock();
  37.                                 }
  38.                             }
  39.                         }
  40.                     } catch (InterruptedException e) {
  41.                         e.printStackTrace();
  42.                     } finally {
  43.                         if (lock1.isHeldByCurrentThread()) {
  44.                             lock1.unlock();
  45.                         }
  46.                     }
  47.                 }
  48.             }else { //奇数就先锁 2, 再锁 1
  49.                 while (true) {
  50.                     try {
  51.                         if (lock2.tryLock()) {
  52.                             System.out.println(Thread.currentThread().getName() + "获得了锁2，还想获得锁1");
  53.                             Thread.sleep(50);
  54.                             try {
  55.                                 if (lock1.tryLock()) {
  56.                                     System.out.println(Thread.currentThread().getName() + "同时获得了锁1与锁2，完成任务了");
  57.                                     return;
  58.                                 }
  59.                             } finally {
  60.                                 if (lock1.isHeldByCurrentThread()) {
  61.                                     lock1.unlock();
  62.                                 }
  63.                             }
  64.                         }
  65.                     } catch (InterruptedException e) {
  66.                         e.printStackTrace();
  67.                     } finally {
  68.                         if (lock2.isHeldByCurrentThread()) {
  69.                             lock2.unlock();
  70.                         }
  71.                     }
  72.                 }
  73.             }
  74.         }
  75.     }
  76.  
  77.     public static void main(String[] args) {
  78.         MyLock lock1=new MyLock(11);
  79.         MyLock lock2=new MyLock(22);
  80.  
  81.         Thread t1=new Thread(lock1);
  82.         Thread t2=new Thread(lock2);
  83.  
  84.         t1.start();
  85.         t2.start();
  86.         //运行后, 使用 tryLock() 尝试获得锁, 不会傻傻的等待, 通过循环不停的再次尝试, 如果等待的时间足够长, 线程总是会获得想要的资源
  87.     }
  88. }

 

 转：Java中的Lock详解_向上的狼的博客-CSDN博客_java lock

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号