import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.ReentrantLock; /** * @author admin * @date 2018/1/16 12:16 * ReentrantLock 可重入锁: * 1、启动两个线程,线程A获取锁,然后执行;同时线程B进来后,一直阻塞,直到线程A释放锁之后,线程B才接着执行 */ public class ReentrantLockTest { ReentrantLock lock = new ReentrantLock(); public void reentrantLockRun1(String threadName) { System.out.println(threadName + "进入"); lock.lock(); System.out.println(threadName + "方法被锁"); try { System.out.println(threadName + "方法执行"); TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); System.out.println(threadName + "锁被释放"); } } public static void main(String[] args) { ReentrantLockTest rltest = new ReentrantLockTest(); Thread thread = new Thread() { public void run() { rltest.reentrantLockRun1("线程A"); } }; thread.start(); Thread thread2 = new Thread() { public void run() { rltest.reentrantLockRun1("线程B"); } }; thread2.start(); } } 运行结果: 线程A进入 线程A方法被锁 线程A方法执行 线程B进入 线程A锁被释放 线程B方法被锁 线程B方法执行 线程B锁被释放
import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.ReentrantLock; /** * @author admin * @date 2018/1/16 12:16 * ReentrantLock 可重入锁: * 1、启动两个线程,线程A获取锁,然后执行,不释放锁,接着线程A再调用reentrantLockRun2,不需要阻塞,接着执行,最后释放锁;说明同一个线程对ReentrantLock可重复获取 * 2、线程B在这个过程中一直阻塞,等到线程A把所有的锁释放完之后,再获取锁,执行方法,最后释放锁 */ public class ReentrantLockTest2 { ReentrantLock lock = new ReentrantLock(); public ReentrantLock reentrantLockRun1(String threadName) { System.out.println(threadName + "进入"); lock.lock(); System.out.println(threadName + "方法被锁"); try { System.out.println(threadName + "方法执行"); TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } return lock; } public ReentrantLock reentrantLockRun2(String threadName) { System.out.println(threadName + "进入"); lock.lock(); System.out.println(threadName + "方法被锁"); try { System.out.println(threadName + "方法执行"); TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } return lock; } public static void main(String[] args) { ReentrantLockTest2 rltest = new ReentrantLockTest2(); Thread thread = new Thread() { public void run() { ReentrantLock lock1 = rltest.reentrantLockRun1("线程A"); ReentrantLock lock2 = rltest.reentrantLockRun2("线程A2"); lock1.unlock(); System.out.println("线程A释放锁"); lock2.unlock(); System.out.println("线程A2释放锁"); } }; thread.start(); Thread thread2 = new Thread() { public void run() { ReentrantLock lock = rltest.reentrantLockRun1("线程B"); lock.unlock(); System.out.println("线程B释放锁"); } }; thread2.start(); } } 运行结果: 线程A进入 线程A方法被锁 线程A方法执行 线程B进入 线程A2进入 线程A2方法被锁 线程A2方法执行 线程A释放锁 线程A2释放锁 线程B方法被锁 线程B方法执行 线程B释放锁
根据源码发现:维护了这个可见性变量state ;同一个线程对可重入锁体现用state标记作累加,int nextc = c + acquires;
private volatile int state;
public void lock() {
sync.lock();
}
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
// 判断是不是第一次获取锁,如果是操作state=1;否则判断是不是同一个线程如果是state+1,如果不是同一个线程直接返回false
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
// 大概就是用一个链表来维护等待线程
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}