Lock是顶层接口,它的实现逻辑并未用到synchronized,而是利用了volatile的可见性。ReentrantLock对了Lock接口的实现主要依赖了Sync,而Sync继承了
AbstractQueuedSynchronizer(AQS)
ReentrantLock:
public class ReentrantLock implements Lock, java.io.Serializable { private static final long serialVersionUID = 7373984872572414699L; /** Synchronizer providing all implementation mechanics */ private final Sync sync; /** * Base of synchronization control for this lock. Subclassed * into fair and nonfair versions below. Uses AQS state to * represent the number of holds on the lock. */ abstract static class Sync extends AbstractQueuedSynchronizer { private static final long serialVersionUID = -5179523762034025860L; /** * Performs {@link Lock#lock}. The main reason for subclassing * is to allow fast path for nonfair version. */ abstract void lock(); /** * Performs non-fair tryLock. tryAcquire is * implemented in subclasses, but both need nonfair * try for trylock method. */ final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; } protected final boolean tryRelease(int releases) { int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; if (c == 0) { free = true; setExclusiveOwnerThread(null); } setState(c); return free; } protected final boolean isHeldExclusively() { // While we must in general read state before owner, // we don't need to do so to check if current thread is owner return getExclusiveOwnerThread() == Thread.currentThread(); } final ConditionObject newCondition() { return new ConditionObject(); } // Methods relayed from outer class final Thread getOwner() { return getState() == 0 ? null : getExclusiveOwnerThread(); } final int getHoldCount() { return isHeldExclusively() ? getState() : 0; } final boolean isLocked() { return getState() != 0; } /** * Reconstitutes this lock instance from a stream. * @param s the stream */ private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { s.defaultReadObject(); setState(0); // reset to unlocked state } } }
在AQS中,定义了一个volatile int state 变量作为共享资源。
/** * The synchronization state. */ private volatile int state;
如果线程获取此共享资源失败,则进入同步FIFO队列中等待;如果成功获取资源就执行临界区代码。执行完释放资源时,会通知同步队列中的等待线程来获取资源后出对并执行。
看其lock方法:
首先默认构造是非公平锁,所谓的公平锁就是先等待的线程先获得锁
public ReentrantLock() { sync = new NonfairSync(); }
NonfairSync:
/** * Sync object for non-fair locks */ static final class NonfairSync extends Sync { private static final long serialVersionUID = 7316153563782823691L; /** * Performs lock. Try immediate barge, backing up to normal * acquire on failure. */ final void lock() { if (compareAndSetState(0, 1)) //compareAndSetState(int expect, int update) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); } protected final boolean tryAcquire(int acquires) { return nonfairTryAcquire(acquires); } }
ReentrantLock:
public void lock() { sync.lock(); }
所以,默认执行的是NonfairSync中的lock()实现,利用Unsafe类的CAS,期望state值为0时将其值设为1,返回是否成功
protected final boolean compareAndSetState(int expect, int update) { // See below for intrinsics setup to support this return unsafe.compareAndSwapInt(this, stateOffset, expect, update); }
因此ReentrantLock的lock()方法只有在state为0时才能获得锁,并将state设为1。这样其他线程就无法获取锁,只能等待。
由于ReentrantLock是可重入锁,即在获得锁的情况下,可以再次获得锁。并且线程可以进入任何一个它已经拥有的锁所同步着的代码块。若在没有释放锁的情况下,
再次获得锁,则state加1,在释放资源时,state减1,因此Lock获取多少次锁就要释放多少次锁,直到state为0。
Conditon中的await()对应Object的wait(),Condition中的signal()对应Object的notify(),Condition中的signalAll()对应Object的notifyAll()
两个线程交替执行例子(同理生产者消费者也是这样交替执行):
package com.yang.spbo.other.lock; import java.util.concurrent.LinkedBlockingDeque; import java.util.concurrent.ThreadFactory; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; /** * A,B两个线程交替执行 * 〈功能详细描述〉 * * @author 17090889 * @see [相关类/方法](可选) * @since [产品/模块版本] (可选) */ public class ConditionService { private ReentrantLock lock = new ReentrantLock(); /** * 两个线程所以创建两个condition */ private Condition A = lock.newCondition(); private Condition B = lock.newCondition(); private int number = 1; private boolean flag = false; private void executeA() { while (number < 100) { try { lock.lock(); if (!flag) { System.out.println("A等待"); A.await(); } System.out.println("A " + number); number++; flag = false; System.out.println("B唤醒"); B.signal(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } } private void executeB() { while (number < 100) { try { lock.lock(); if (flag) { System.out.println("B等待"); B.await(); } System.out.println("B " + number); number++; flag = true; System.out.println("A唤醒"); A.signal(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } } } public static void main(String[] args) { final ConditionService cs = new ConditionService(); ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 5, 1, TimeUnit.MINUTES, new LinkedBlockingDeque<Runnable>(1000), new MyThreadFactory("conditionService")); executor.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()); cs.executeA(); } }); executor.execute(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()); cs.executeB(); } }); } static class MyThreadFactory implements ThreadFactory { /** * 线程名字前缀 */ private String namePrefix; private AtomicInteger id = new AtomicInteger(1); public MyThreadFactory(String namePrefix) { this.namePrefix = namePrefix; } @Override public Thread newThread(Runnable r) { String threadName = namePrefix + "-worker-" + id.getAndIncrement(); Thread thread; thread = new Thread(r, threadName); return thread; } } }
运行结果:
conditionService-worker-1
A等待
conditionService-worker-2
B 1
A唤醒
B等待
A 2
B唤醒
A等待
B 3
A唤醒
B等待
A 4
B唤醒
A等待
B 5
A唤醒
B等待
A 6
ReentrantLock实现死锁:
/** * ReentrantLock实现死锁 * 〈功能详细描述〉 * * @author 17090889 * @see [相关类/方法](可选) * @since [产品/模块版本] (可选) */ public class DeadLockTest { private static ReentrantLock lock1 = new ReentrantLock(); private static ReentrantLock lock2 = new ReentrantLock(); public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { lock1.lock(); try { Thread.sleep(1000); lock2.lock(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock1.unlock(); } } }).start(); new Thread(new Runnable() { @Override public void run() { lock2.lock(); try { Thread.sleep(1000); lock1.lock(); } catch (InterruptedException e) { e.printStackTrace(); } finally { lock2.unlock(); } } }).start(); } }
7996 Main
3960 Jps
8396 Launcher
5568 Launcher
1204
8212 Bootstrap
396 ProfilerServer
=============================
"Thread-1":
waiting for ownable synchronizer 0x00000007d5e6f5c0, (a java.util.concurrent.l
ocks.ReentrantLock$NonfairSync),
which is held by "Thread-0"
"Thread-0":
waiting for ownable synchronizer 0x00000007d5e6f5f0, (a java.util.concurrent.l
ocks.ReentrantLock$NonfairSync),
which is held by "Thread-1"
Java stack information for the threads listed above:
===================================================
"Thread-1":
at sun.misc.Unsafe.park(Native Method)
- parking to wait for <0x00000007d5e6f5c0> (a java.util.concurrent.lock
s.ReentrantLock$NonfairSync)
at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
errupt(AbstractQueuedSynchronizer.java:834)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
bstractQueuedSynchronizer.java:867)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
tQueuedSynchronizer.java:1197)
at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLo
ck.java:214)
at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:290)
at deadLock.DeadLockTest$2.run(DeadLockTest.java:38)
at java.lang.Thread.run(Thread.java:745)
"Thread-0":
at sun.misc.Unsafe.park(Native Method)
- parking to wait for <0x00000007d5e6f5f0> (a java.util.concurrent.lock
s.ReentrantLock$NonfairSync)
at java.util.concurrent.locks.LockSupport.park(LockSupport.java:186)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInt
errupt(AbstractQueuedSynchronizer.java:834)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(A
bstractQueuedSynchronizer.java:867)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(Abstrac
tQueuedSynchronizer.java:1197)
synchronized实现死锁:
/** * synchronized实现死锁 * 〈功能详细描述〉 * * @author 17090889 * @see [相关类/方法](可选) * @since [产品/模块版本] (可选) */ public class DeadLockTest2 { private static Object obj1 = new Object(); private static Object obj2 = new Object(); public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { synchronized (obj1) { System.out.println("thead1 get lock1"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (obj2) { System.out.println("thead1 get lock2"); } System.out.println("thread1 end"); } } }, "thead1").start(); new Thread(new Runnable() { @Override public void run() { synchronized (obj2) { System.out.println("thead2 get lock2"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (obj1) { System.out.println("thead2 get lock1"); } System.out.println("thread2 end"); } } }, "thead2").start(); } }
=============================
"thead2":
waiting to lock monitor 0x000000000b15a7c8 (object 0x00000007d5e6f290, a java.
lang.Object),
which is held by "thead1"
"thead1":
waiting to lock monitor 0x000000000b1593d8 (object 0x00000007d5e6f2a0, a java.
lang.Object),
which is held by "thead2"
Java stack information for the threads listed above:
===================================================
"thead2":
at deadLock.DeadLockTest2$2.run(DeadLockTest2.java:44)
- waiting to lock <0x00000007d5e6f290> (a java.lang.Object)
- locked <0x00000007d5e6f2a0> (a java.lang.Object)
at java.lang.Thread.run(Thread.java:745)
"thead1":
at deadLock.DeadLockTest2$1.run(DeadLockTest2.java:27)
- waiting to lock <0x00000007d5e6f2a0> (a java.lang.Object)
- locked <0x00000007d5e6f290> (a java.lang.Object)
at java.lang.Thread.run(Thread.java:745)