使用ReentrantLock

最新推荐文章于 2024-05-04 06:45:00 发布

yueloveme

最新推荐文章于 2024-05-04 06:45:00 发布

阅读量396

点赞数

分类专栏： JAVA 文章标签： ReentrantLock

本文链接：https://blog.csdn.net/yueloveme/article/details/86424422

版权

JAVA 专栏收录该内容

110 篇文章 0 订阅

订阅专栏

大家推荐个靠谱的公众号程序员探索之路，公众号内点击网赚获取彩蛋,大家一起加油，这个公众号已经接入图灵

1.基本使用：
static int i = 1;
   public static void main(String[] args) {
       ReentrantLock reentrantLock = new ReentrantLock();
       for (int m = 0; m < 10;m++){
           new Thread(new Runnable() {
               @Override
               public void run() {
                   try {
                       reentrantLock.lock();
                       System.out.println(Thread.currentThread().getName()+" i = "+i);
                       i = i + 1;
                   } catch (Exception e) {
                       e.printStackTrace();
                   } finally {
                       reentrantLock.unlock();
                   }
               }
           }).start();
       }
   }
结果：
Thread-0 i = 1
Thread-1 i = 2
Thread-2 i = 3
Thread-3 i = 4
Thread-4 i = 5
Thread-5 i = 6
Thread-8 i = 7
Thread-6 i = 8
Thread-7 i = 9
Thread-9 i = 10

注意：ReentrantLock持有的锁是需要手动去unlock()的，所以一般是在finally中进行unlock

2.Condition 作用：condition.await()/condition.signal()/condition.signalAll()和await/notify/notifyAll作用类似
Condition更灵活一个ReentrantLock 实例可以new出来很多个Condition 一个Condition实例只能唤醒它await的线程

public static void main(String[] args) {
       ReentrantLock reentrantLock = new ReentrantLock();
       Condition condition = reentrantLock.newCondition();
       for (int m = 0; m < 10;m++){
           new Thread(new Runnable() {
               @Override
               public void run() {
                   try {
                       reentrantLock.lock();
                       System.out.println(Thread.currentThread().getName()+"等待中...");
                       condition.await();
                       System.out.println(Thread.currentThread().getName()+"等待结束");
                   } catch (Exception e) {
                       e.printStackTrace();
                   } finally {
                       reentrantLock.unlock();
                   }
               }
           }).start();
       }
       //睡一会让上面所有的线程都进入等待状态
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       reentrantLock.lock();
       condition.signal();
       reentrantLock.unlock();
   }

condition.signal();是唤醒该condition queue中的第一个线程
public final void signal() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
doSignal(first);
}
/** First node of condition queue. */
private transient Node firstWaiter;

3.公平锁/非公平锁：非公平锁不是按照线程排队顺序来获取锁的，也就是随机获取，有可能导致有的线程一致获取不到锁
ReentrantLock 的构造函数可以来指定公平/非公平锁默认是非公平
ReentrantLock reentrantLock = new ReentrantLock(); //非公平
ReentrantLock reentrantLock = new ReentrantLock(false); //非公平
ReentrantLock reentrantLock = new ReentrantLock(true); //公平

//非公平示例
public static void main(String[] args) {
       ReentrantLock reentrantLock = new ReentrantLock();
       for (int m = 0; m < 10;m++){
           new Thread(new Runnable() {
               @Override
               public void run() {
                   try {
                       System.out.println(Thread.currentThread().getName()+"start run....");
                       reentrantLock.lock();
                       System.out.println(Thread.currentThread().getName()+"获取了锁");
                   } catch (Exception e) {
                       e.printStackTrace();
                   } finally {
                       reentrantLock.unlock();
                   }
               }
           }).start();
       }
   }
Thread-2start run....
Thread-1start run....
Thread-0start run....
Thread-5start run....
Thread-3start run....
Thread-8start run....
Thread-4start run....
Thread-9start run....
Thread-7start run....
Thread-6start run....
Thread-2获取了锁
Thread-0获取了锁
Thread-1获取了锁
Thread-5获取了锁
Thread-3获取了锁
Thread-8获取了锁
Thread-4获取了锁
Thread-9获取了锁
Thread-7获取了锁
Thread-6获取了锁

//公平示例
.......
ReentrantLock reentrantLock = new ReentrantLock(true);
.......
Thread-1start run....
Thread-1获取了锁
Thread-7start run....
Thread-0start run....
Thread-2start run....
Thread-6start run....
Thread-3start run....
Thread-7获取了锁
Thread-4start run....
Thread-5start run....
Thread-8start run....
Thread-9start run....
Thread-0获取了锁
Thread-2获取了锁
Thread-6获取了锁
Thread-3获取了锁
Thread-4获取了锁
Thread-5获取了锁
Thread-8获取了锁
Thread-9获取了锁

4.getHoldCount() 获取当前线程调用lock的次数也证明了ReentrantLock 是可重入锁
   static final ReentrantLock reentrantLock = new ReentrantLock(true);
   public static void main(String[] args) {
           new Thread(new Runnable() {
               @Override
               public void run() {
                   try {
                       reentrantLock.lock();
                       System.out.println("reentrantLock的调用次数:"+reentrantLock.getHoldCount());
                       sout();
                   } catch (Exception e) {
                       e.printStackTrace();
                   } finally {
                       reentrantLock.unlock();
                   }
               }
           }).start();
   }

   public static void sout(){
       try {
           reentrantLock.lock();
           System.out.println("我是sout方法,reentrantLock的调用次数"+reentrantLock.getHoldCount());
       } finally {
           reentrantLock.unlock();
       }
   }
reentrantLock的调用次数:1
我是sout方法,reentrantLock的调用次数2

5.isFair() 获取是否是公平锁

6.getQueueLength() 获取等待锁的线程数---注意这个数可能不准确线程在获取后有可能获取到锁了
示例：
   static final ReentrantLock reentrantLock = new ReentrantLock(true);
   public static void main(String[] args) {
       for (int m = 0; m < 10;m++){
           new Thread(new Runnable() {
               @Override
               public void run() {
                   try {
                       reentrantLock.lock();
                   } catch (Exception e) {
                       e.printStackTrace();
                   } finally {
                       //注意我这里故意没有释放锁正常写代码时不要这样
//                       reentrantLock.unlock();
                   }
               }
           }).start();
       }
       //让上面所有的线程有足够的时间启动
       try {
           Thread.sleep(100);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("等待:"+reentrantLock.getQueueLength());
   }
结果：等待:9

7.hasQueuedThreads() 是否有线程正在等待锁

8.hasQueuedThread(Thread实例) 判断Thread是否在等待
示例：
static final ReentrantLock reentrantLock = new ReentrantLock(true);
   public static void main(String[] args) {
       Thread[] ts = new Thread[10];
       for (int m = 0; m < 10;m++){
           ts[m] = new Thread(new Runnable() {
               @Override
               public void run() {
                   try {
                       reentrantLock.lock();
                   } catch (Exception e) {
                       e.printStackTrace();
                   } finally {
                       //注意我这里故意没有释放锁正常写代码时不要这样
//                       reentrantLock.unlock();
                   }
               }
           });
           ts[m].start();
       }
       //让上面所有的线程有足够的时间启动
       try {
           Thread.sleep(100);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println(ts[0].getName()+"是否在等待"+reentrantLock.hasQueuedThread(ts[0]));
       System.out.println(ts[1].getName()+"是否在等待"+reentrantLock.hasQueuedThread(ts[1]));
   }
结果：
Thread-0是否在等待true
Thread-1是否在等待false

9.isHeldByCurrentThread()/isLocked() 当前线程是否持有锁/是否有任意线程持有锁
示例：
   static final ReentrantLock reentrantLock = new ReentrantLock(true);
   public static void main(String[] args) {
       new Thread(new Runnable() {
           @Override
           public void run() {
               try {
                   reentrantLock.lock();
                   System.out.println(Thread.currentThread().getName() + "持有锁");
                   System.out.println(Thread.currentThread().getName() + "是否持有锁" + reentrantLock.isHeldByCurrentThread());
                   System.out.println("是否有任意线程持有锁" + reentrantLock.isLocked());
               } catch (Exception e) {
                   e.printStackTrace();
               } finally {
                   //注意我这里故意没有释放锁正常写代码时不要这样
//                       reentrantLock.unlock();
               }
           }
       }).start();
       try {
           Thread.sleep(100);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       //开启另外一个线程查询
       new Thread(new Runnable() {
           @Override
           public void run() {
               System.out.println(Thread.currentThread().getName() + "是否持有锁" + reentrantLock.isHeldByCurrentThread());
               System.out.println("是否有任意线程持有锁" + reentrantLock.isLocked());
           }
       }).start();
   }
结果：
Thread-0持有锁
Thread-0是否持有锁true
是否有任意线程持有锁true
Disconnected from the target VM, address: '127.0.0.1:55741', transport: 'socket'
Thread-1是否持有锁false
是否有任意线程持有锁true

10.尝试（指定时间内）获取锁：tryLock/tryLock(*, TimeUnit.*)
static int i = 1;
   public static void main(String[] args) {
       ReentrantLock reentrantLock = new ReentrantLock();
       for (int m = 0; m < 10;m++){
           new Thread(new Runnable() {
               @Override
               public void run() {
                   try {
                       if (reentrantLock.tryLock(2, TimeUnit.SECONDS)){
                           System.out.println(Thread.currentThread().getName()+" i = "+i);
                           i = i + 1;
                       }else {
                           System.out.println(Thread.currentThread().getName()+"获取锁失败");
                       }
                   } catch (Exception e) {
                       e.printStackTrace();
                   } finally {
//注意我这里没有释放锁
//                       reentrantLock.unlock();
                   }
               }
           }).start();
       }
   }
Thread-1 i = 1
Thread-8获取锁失败
Thread-4获取锁失败
Thread-3获取锁失败
Thread-2获取锁失败
Thread-0获取锁失败
Thread-5获取锁失败
Thread-9获取锁失败
Thread-6获取锁失败
Thread-7获取锁失败

11.getWaitQueueLength(Condition condition)
类似getQueueLength()，不过此方法的前提是condition。比如5个线程，每个线程都执行了同一个condition的await()方法，那么方法调用的返回值是5，
因为5个线程都在等待获得锁

12.hasWaiters(Condition condition)
查询是否有线程正在等待与此锁有关的condition条件。比如5个线程，每个线程都执行了同一个condition的await()方法，那么方法调用的返回值是true，
因为它们都在等待condition

13.lockInterruptibly()
如果当前线程未被中断，则获取锁

14.getWaitingThreads(Condition condition)
返回一个collection，它包含可能正在等待与此锁相关给定条件的那些线程，因为构造结果的时候实际线程可能动态变化，因此返回的collection只是尽力的估计值

15.synchronized和ReentrantLock的对比
1、synchronized是关键字，是语法层面的实现，因此synchronized获取锁以及释放锁都是jvm帮助完成的；
ReentrantLock是类层面的实现，因此锁的获取以及锁的释放都需要自己去操作。特别再次提醒，ReentrantLock在lock()完了，一定要手动unlock()

2、synchronized简单，同时意味着不灵活，而ReentrantLock的锁机制给用户的使用提供了极大的灵活性。
这点在1.7版本的Hashtable和ConcurrentHashMap中体现得淋漓尽致。synchronized一锁就锁整个Hash表，而ConcurrentHashMap则利用ReentrantLock实现了锁分离，
锁的只是segment而不是整个Hash表

3、synchronized是不公平锁，而ReentrantLock可以指定锁是公平的还是非公平的

4、synchronized实现等待/通知机制通知的线程是随机的，ReentrantLock实现等待/通知机制可以有选择性地通知

5、和synchronized相比，ReentrantLock提供了多种方法用于锁信息的获取，比如可以知道lock是否被当前线程获取、lock被同一个线程调用了几次、
lock是否被任意线程获取等等
总结起来，我认为如果只需要锁定简单的方法、简单的代码块，那么考虑使用synchronized，复杂的多线程处理场景下可以考虑使用ReentrantLock。
最重要的时具体场景具体分析

yueloveme

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
使用ReentrantLock

大家推荐个靠谱的公众号程序员探索之路，公众号内点击网赚获取彩蛋,大家一起加油，这个公众号已经接入图灵1.基本使用：static int i = 1; public static void main(String[] args) { ReentrantLock reentrantLock = new ReentrantLock(); for (in...
复制链接

扫一扫

专栏目录