reentrantlock

可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试): 问题: Where am I going wrong? Even though my consumer Thread is not holding the lock, the program is not throwing IllegalMonitorStateException for any of the lock calls (unlock/await/signal). Update: private final ReentrantLock lock = new ReentrantLock(); private final Condition producers = lock.newCondition(); private final Condition consumers = lock.newCondition(); @Override public void run() { while (true) { try { //lock.lockInterruptibly(); try { while (sharedResource.isEmpty()) { printErr(name + " : Queue Empty .."); consumers.await(500,

阻塞队列中目前还剩下一个比较特殊的队列实现，相比较前面讲解过的队列，本文中要讲的LinkedBlockingDeque比较容易理解了，但是与之前讲解过的阻塞队列又有些不同，从命名上你应该能看出一些端倪，接下来就一起看看这个特殊的阻塞队列 前言 JDK版本号：1.8.0_171 LinkedBlockingDeque在结构上有别于之前讲解过的阻塞队列，它不是Queue而是Deque，中文翻译成双端队列，双端队列指可以从任意一端入队或者出队元素的队列，实现了在队列头和队列尾的高效插入和移除 LinkedBlockingDeque是链表实现的线程安全的无界的同时支持FIFO、LIFO的双端阻塞队列，可以回顾下之前的LinkedBlockingQueue阻塞队列特点，本质上是类似的，但是又有些不同： 内部是通过Node节点组成的链表来实现的，当然为了支持双端操作，结点结构不同 LinkedBlockingQueue通过两个ReentrantLock锁保护竞争资源，实现了多线程对竞争资源的互斥访问，入队和出队互不影响，可同时操作，然而LinkedBlockingDeque只设置了一个全局ReentrantLock锁，两个条件对象实现互斥访问，性能上要比LinkedBlockingQueue差一些 无界，默认链表长度为Integer.MAX_VALUE，本质上还是有界 阻塞队列

一、Lock 1. 概述 Lock是JDK 1.5以后将同步和锁封装成了对象。Lock是对之前synchronized的替代。 Lock接口的实现类：互斥锁ReentrantLock 。 2. synchronized与Lock区别 synchronized对于锁的操作是隐式的；Lock锁对象是显式的。 synchronized内只有一个锁。Lock可以有多个Conditoin。 3. 语法 Lock myLock = new ReentrantLock(); myLock.lock();//获取锁 try{ //do something }finally{ //释放锁。需要放在finally子句内，否则抛异常后，锁未被释放，其他线程则会永远被阻塞 myLock.unlock(); } 二、读写锁 1. 概述 为了提高性能，Java提供了读写锁，在读的地方使用读锁，在写的地方使用写锁，灵活控制，在一定程度上提高了程序的执行效率。 读写锁分为读锁和写锁。多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥。 Java中读写锁有个接口java.util.concurrent.locks.ReadWriteLock，也有具体的实现ReentrantReadWriteLock。 在实际开发中，最好在能用读写锁的情况下使用读写锁，而不要用普通锁，以求更好的性能。 2.

1、Lock 1）1.5版本之后出现，java.util.concurrent.locks.Lock 2） Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。 锁是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问。一次只能有一个线程获得锁，对共享资源的所有访问都需要首先获得锁。不过，某些锁可能允许对共享资源并发访问，如 ReadWriteLock 的读取锁。 3）一般使用的Lock替代synchronized的代码如下： private Lock l = new ReentrantLock(); l.lock(); try { // access the resource protected by this lock } finally { l.unlock(); } 4）和synchronized一样，也可以在线程之间进行通讯，如下代码： class Data { private int number = 0;// 共享变量 private Lock lock = new ReentrantLock(); // 一种互斥锁 private Condition c1 = lock.newCondition(); //

I have a LockManager that manages the locks of several threads. Sometimes the threads are bad boys, and I have to kill them and ask the LockManager to release all their locks. However, since I use ReentrantLock in java this is impossible, I can not unlock a lock owned by another thread. I am forced to use Locks (cannot use semaphores, it is point of the homework). Is there any Java Lock implementation that allows me to unlock locks owned by other threads? So far the options I considered are: re-implementing ReentrantLock in a way that allows me to do this Make some sort of mapping between

前言 多线程分类中写了21篇多线程的文章，21篇文章的内容很多，个人认为，学习，内容越多、越杂的知识，越需要进行深刻的总结，这样才能记忆深刻，将知识变成自己的。这篇文章主要是对多线程的问题进行总结的，因此罗列了40个多线程的问题。 这些多线程的问题，有些来源于各大网站、有些来源于自己的思考。可能有些问题网上有、可能有些问题对应的答案也有、也可能有些各位网友也都看过，但是本文写作的重心就是 所有的问题都会按照自己的理解回答一遍，不会去看网上的答案 ，因此可能有些问题讲的不对，能指正的希望大家不吝指教。 40个问题汇总 1、多线程有什么用？ 一个可能在很多人看来很扯淡的一个问题：我会用多线程就好了，还管它有什么用？在我看来，这个回答更扯淡。所谓"知其然知其所以然"，"会用"只是"知其然"，"为什么用"才是"知其所以然"，只有达到"知其然知其所以然"的程度才可以说是把一个知识点运用自如。OK，下面说说我对这个问题的看法： （1）发挥多核CPU的优势 随着工业的进步，现在的笔记本、台式机乃至商用的应用服务器至少也都是双核的，4核、8核甚至16核的也都不少见，如果是单线程的程序，那么在双核CPU上就浪费了50%，在4核CPU上就浪费了75%。 单核CPU上所谓的"多线程"那是假的多线程，同一时间处理器只会处理一段逻辑，只不过线程之间切换得比较快，看着像多个线程"同时"运行罢了

一、Lock接口 1. Java5之后，JDK新增了Lock接口，实现锁的功能，与synchronized关键字类似 2. 源码 public interface Lock { void lock(); //获取锁 void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time, TimeUnit unit) throws InterruptedException; void unlock(); // 释放锁 Condition newCondition(); } 二、ReentrantLock 1. 实现了Lock接口 2. 是synchronized的替代，ReentrantLock是Java语言层面实现的锁机制，synchronized是JVM层面实现的锁机制 3. 可重入锁：如果线程已经获取了锁，还能再获取一次，计数器加1；释放的时候，要释放两次，等计数器为0的时候，才真正释放 4. 公平锁：当一个线程释放锁之后，等待时间最长的线程会获得锁 5. 非公平锁：当一个线程释放锁之后，所有线程一起竞争锁，等待时间最长的线程不一定能获得锁 6. ReentrantLock默认的构造方法是非公平锁，但可以指定公平锁， pubic

公平锁/非公平锁（多线程执行顺序的维度） 概念理解 公平锁：加锁前先查看是否有排队等待的线程，有的话优先处理排在前面的线程， 先来先得 。 非公平所：线程加锁时 直接尝试获取锁 ，获取不到就自动到队尾等待。 例子 ReentrantLock 同时支持两种锁 // 创建一个非公平锁，默认是非公平锁 Lock nonFairLock = new ReentrantLock(); Lock nonFairLock = new ReentrantLock( false ); // 创建一个公平锁，构造传参true Lock fairLock = new ReentrantLock( true ); 适用场景 更多的是直接使用非公平锁：非公平锁比公平锁性能高5-10倍，因为公平锁需要在多核情况下维护一个队列，如果当前线程不是队列的第一个无法获取锁，增加了线程切换次数。 乐观锁/悲观锁（多线程操作共享数据的维度） 概念理解 悲观锁： 假设一定会发生并发冲突 ，通过阻塞其他所有线程来保证数据的完整性。 乐观锁： 假设不会发生并发冲突 ，直接不加锁去完成某项更新，如果冲突就返回失败。 例子 悲观锁： Synchronized 多线程同步，具有排他性，也会容易产生死锁。 乐观锁： CAS 机制，简单来说会有三个操作数，当前内存变量值V，变量预期值A，即将更新值B，当需要更新变量的时候

简述：reentrantLock是java当中提供的一个锁，他和synchronized关键字有所不同，这篇文章主要是从reentrantLock获取锁，然后释放锁，来分析整个底层源码的实现，并不介绍ReentrantLock的具体使用 我们最常使用的lock方式：创建一个非公平锁，并且添加锁操作 Lock lock = new ReentrantLock(); lock.lock(); public void lock() { sync.lock(); } 调用NonfairSync代码实现 final void lock() { if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); } sync继承自AbstractQueuedSynchronizer类，简称AQS, 其内部维护了一个int 类型的state变量，以及当前获取到锁的线程对象thread, 以上第一步是1、将AQS当中的state状态更改为1，假设现在有三个线程来访问，其中thread1成功将state状态改为1，另外两个线程thread2 和thread3 将执行acquire(1), 以下是AQS当中acquire方法的实现： public final void

AQS的功能可以分为独占和共享，ReentrantLock实现了独占功能。 ReentrantLock实现了Lock接口，加锁和解锁都需要显式写出，注意一定要在适当时候unlock。 ReentrantLock对比synchronized 和synchronized相比，ReentrantLock用起来会复杂一些。在基本的加锁和解锁上，两者是一样的，所以无特殊情况下，推荐使用synchronized。ReentrantLock的优势在于它更灵活、更强大，增加了轮训、超时、中断等高级功能。 公平锁和非公平锁 ReentrantLock的内部类Sync继承了AQS，分为公平锁FairSync和非公平锁NonfairSync。 公平锁：线程获取锁的顺序和调用lock的顺序一样，FIFO； 非公平锁：线程获取锁的顺序和调用lock的顺序无关，全凭运气。 ReentrantLock默认使用非公平锁是基于性能考虑，公平锁为了保证线程规规矩矩地排队，需要增加阻塞和唤醒的时间开销。如果直接插队获取非公平锁，跳过了对队列的处理，速度会更快。 尝试获取锁 获取锁成功分为两种情况，第一个if判断AQS的state是否等于0，表示锁没有人占有。接着，hasQueuedPredecessors判断队列是否有排在前面的线程在等待锁，没有的话调用compareAndSetState使用cas的方式修改state