java 中的lock 先关的类路径：
Lock 是个接口，源码：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package java.util.concurrent.locks;
import java.util.concurrent.TimeUnit;
public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long var1, TimeUnit var3) throws InterruptedException;
void unlock();
Condition newCondition();
}使用lock 要具体使用lock 的实例类
ReentrantLock
ReentrantReadWriteLock
ReentrantLock 代码：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package java.util.concurrent.locks;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.Collection;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject;
public class ReentrantLock implements Lock, Serializable {
private static final long serialVersionUID = 7373984872572414699L;
private final ReentrantLock.Sync sync;
public ReentrantLock() {
this.sync = new ReentrantLock.NonfairSync();
}
public ReentrantLock(boolean var1) {
this.sync = (ReentrantLock.Sync)(var1 ? new ReentrantLock.FairSync() : new ReentrantLock.NonfairSync());
}
public void lock() {
this.sync.lock();
}
public void lockInterruptibly() throws InterruptedException {
this.sync.acquireInterruptibly(1);
}
public boolean tryLock() {
return this.sync.nonfairTryAcquire(1);
}
public boolean tryLock(long var1, TimeUnit var3) throws InterruptedException {
return this.sync.tryAcquireNanos(1, var3.toNanos(var1));
}
public void unlock() {
this.sync.release(1);
}
public Condition newCondition() {
return this.sync.newCondition();
}
public int getHoldCount() {
return this.sync.getHoldCount();
}
public boolean isHeldByCurrentThread() {
return this.sync.isHeldExclusively();
}
public boolean isLocked() {
return this.sync.isLocked();
}
public final boolean isFair() {
return this.sync instanceof ReentrantLock.FairSync;
}
protected Thread getOwner() {
return this.sync.getOwner();
}
public final boolean hasQueuedThreads() {
return this.sync.hasQueuedThreads();
}
public final boolean hasQueuedThread(Thread var1) {
return this.sync.isQueued(var1);
}
public final int getQueueLength() {
return this.sync.getQueueLength();
}
protected Collection<Thread> getQueuedThreads() {
return this.sync.getQueuedThreads();
}
public boolean hasWaiters(Condition var1) {
if (var1 == null) {
throw new NullPointerException();
} else if (!(var1 instanceof ConditionObject)) {
throw new IllegalArgumentException("not owner");
} else {
return this.sync.hasWaiters((ConditionObject)var1);
}
}
public int getWaitQueueLength(Condition var1) {
if (var1 == null) {
throw new NullPointerException();
} else if (!(var1 instanceof ConditionObject)) {
throw new IllegalArgumentException("not owner");
} else {
return this.sync.getWaitQueueLength((ConditionObject)var1);
}
}
protected Collection<Thread> getWaitingThreads(Condition var1) {
if (var1 == null) {
throw new NullPointerException();
} else if (!(var1 instanceof ConditionObject)) {
throw new IllegalArgumentException("not owner");
} else {
return this.sync.getWaitingThreads((ConditionObject)var1);
}
}
public String toString() {
Thread var1 = this.sync.getOwner();
return super.toString() + (var1 == null ? "[Unlocked]" : "[Locked by thread " + var1.getName() + "]");
}
static final class FairSync extends ReentrantLock.Sync {
private static final long serialVersionUID = -3000897897090466540L;
FairSync() {
}
final void lock() {
this.acquire(1);
}
protected final boolean tryAcquire(int var1) {
Thread var2 = Thread.currentThread();
int var3 = this.getState();
if (var3 == 0) {
if (!this.hasQueuedPredecessors() && this.compareAndSetState(0, var1)) {
this.setExclusiveOwnerThread(var2);
return true;
}
} else if (var2 == this.getExclusiveOwnerThread()) {
int var4 = var3 + var1;
if (var4 < 0) {
throw new Error("Maximum lock count exceeded");
}
this.setState(var4);
return true;
}
return false;
}
}
static final class NonfairSync extends ReentrantLock.Sync {
private static final long serialVersionUID = 7316153563782823691L;
NonfairSync() {
}
final void lock() {
if (this.compareAndSetState(0, 1)) {
this.setExclusiveOwnerThread(Thread.currentThread());
} else {
this.acquire(1);
}
}
protected final boolean tryAcquire(int var1) {
return this.nonfairTryAcquire(var1);
}
}
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
Sync() {
}
abstract void lock();
final boolean nonfairTryAcquire(int var1) {
Thread var2 = Thread.currentThread();
int var3 = this.getState();
if (var3 == 0) {
if (this.compareAndSetState(0, var1)) {
this.setExclusiveOwnerThread(var2);
return true;
}
} else if (var2 == this.getExclusiveOwnerThread()) {
int var4 = var3 + var1;
if (var4 < 0) {
throw new Error("Maximum lock count exceeded");
}
this.setState(var4);
return true;
}
return false;
}
protected final boolean tryRelease(int var1) {
int var2 = this.getState() - var1;
if (Thread.currentThread() != this.getExclusiveOwnerThread()) {
throw new IllegalMonitorStateException();
} else {
boolean var3 = false;
if (var2 == 0) {
var3 = true;
this.setExclusiveOwnerThread((Thread)null);
}
this.setState(var2);
return var3;
}
}
protected final boolean isHeldExclusively() {
return this.getExclusiveOwnerThread() == Thread.currentThread();
}
final ConditionObject newCondition() {
return new ConditionObject(this);
}
final Thread getOwner() {
return this.getState() == 0 ? null : this.getExclusiveOwnerThread();
}
final int getHoldCount() {
return this.isHeldExclusively() ? this.getState() : 0;
}
final boolean isLocked() {
return this.getState() != 0;
}
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
var1.defaultReadObject();
this.setState(0);
}
}
}
ReentrantReadWriteLock ->ReadWriteLock
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package java.util.concurrent.locks;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.util.Collection;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject;
import sun.misc.Unsafe;
public class ReentrantReadWriteLock implements ReadWriteLock, Serializable {
private static final long serialVersionUID = -6992448646407690164L;
private final ReentrantReadWriteLock.ReadLock readerLock;
private final ReentrantReadWriteLock.WriteLock writerLock;
final ReentrantReadWriteLock.Sync sync;
private static final Unsafe UNSAFE;
private static final long TID_OFFSET;
public ReentrantReadWriteLock() {
this(false);
}
public ReentrantReadWriteLock(boolean var1) {
this.sync = (ReentrantReadWriteLock.Sync)(var1 ? new ReentrantReadWriteLock.FairSync() : new ReentrantReadWriteLock.NonfairSync());
this.readerLock = new ReentrantReadWriteLock.ReadLock(this);
this.writerLock = new ReentrantReadWriteLock.WriteLock(this);
}
public ReentrantReadWriteLock.WriteLock writeLock() {
return this.writerLock;
}
public ReentrantReadWriteLock.ReadLock readLock() {
return this.readerLock;
}
public final boolean isFair() {
return this.sync instanceof ReentrantReadWriteLock.FairSync;
}
protected Thread getOwner() {
return this.sync.getOwner();
}
public int getReadLockCount() {
return this.sync.getReadLockCount();
}
public boolean isWriteLocked() {
return this.sync.isWriteLocked();
}
public boolean isWriteLockedByCurrentThread() {
return this.sync.isHeldExclusively();
}
public int getWriteHoldCount() {
return this.sync.getWriteHoldCount();
}
public int getReadHoldCount() {
return this.sync.getReadHoldCount();
}
protected Collection<Thread> getQueuedWriterThreads() {
return this.sync.getExclusiveQueuedThreads();
}
protected Collection<Thread> getQueuedReaderThreads() {
return this.sync.getSharedQueuedThreads();
}
public final boolean hasQueuedThreads() {
return this.sync.hasQueuedThreads();
}
public final boolean hasQueuedThread(Thread var1) {
return this.sync.isQueued(var1);
}
public final int getQueueLength() {
return this.sync.getQueueLength();
}
protected Collection<Thread> getQueuedThreads() {
return this.sync.getQueuedThreads();
}
public boolean hasWaiters(Condition var1) {
if (var1 == null) {
throw new NullPointerException();
} else if (!(var1 instanceof ConditionObject)) {
throw new IllegalArgumentException("not owner");
} else {
return this.sync.hasWaiters((ConditionObject)var1);
}
}
public int getWaitQueueLength(Condition var1) {
if (var1 == null) {
throw new NullPointerException();
} else if (!(var1 instanceof ConditionObject)) {
throw new IllegalArgumentException("not owner");
} else {
return this.sync.getWaitQueueLength((ConditionObject)var1);
}
}
protected Collection<Thread> getWaitingThreads(Condition var1) {
if (var1 == null) {
throw new NullPointerException();
} else if (!(var1 instanceof ConditionObject)) {
throw new IllegalArgumentException("not owner");
} else {
return this.sync.getWaitingThreads((ConditionObject)var1);
}
}
public String toString() {
int var1 = this.sync.getCount();
int var2 = ReentrantReadWriteLock.Sync.exclusiveCount(var1);
int var3 = ReentrantReadWriteLock.Sync.sharedCount(var1);
return super.toString() + "[Write locks = " + var2 + ", Read locks = " + var3 + "]";
}
static final long getThreadId(Thread var0) {
return UNSAFE.getLongVolatile(var0, TID_OFFSET);
}
static {
try {
UNSAFE = Unsafe.getUnsafe();
Class var0 = Thread.class;
TID_OFFSET = UNSAFE.objectFieldOffset(var0.getDeclaredField("tid"));
} catch (Exception var1) {
throw new Error(var1);
}
}
static final class FairSync extends ReentrantReadWriteLock.Sync {
private static final long serialVersionUID = -2274990926593161451L;
FairSync() {
}
final boolean writerShouldBlock() {
return this.hasQueuedPredecessors();
}
final boolean readerShouldBlock() {
return this.hasQueuedPredecessors();
}
}
static final class NonfairSync extends ReentrantReadWriteLock.Sync {
private static final long serialVersionUID = -8159625535654395037L;
NonfairSync() {
}
final boolean writerShouldBlock() {
return false;
}
final boolean readerShouldBlock() {
return this.apparentlyFirstQueuedIsExclusive();
}
}
public static class ReadLock implements Lock, Serializable {
private static final long serialVersionUID = -5992448646407690164L;
private final ReentrantReadWriteLock.Sync sync;
protected ReadLock(ReentrantReadWriteLock var1) {
this.sync = var1.sync;
}
public void lock() {
this.sync.acquireShared(1);
}
public void lockInterruptibly() throws InterruptedException {
this.sync.acquireSharedInterruptibly(1);
}
public boolean tryLock() {
return this.sync.tryReadLock();
}
public boolean tryLock(long var1, TimeUnit var3) throws InterruptedException {
return this.sync.tryAcquireSharedNanos(1, var3.toNanos(var1));
}
public void unlock() {
this.sync.releaseShared(1);
}
public Condition newCondition() {
throw new UnsupportedOperationException();
}
public String toString() {
int var1 = this.sync.getReadLockCount();
return super.toString() + "[Read locks = " + var1 + "]";
}
}
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 6317671515068378041L;
static final int SHARED_SHIFT = 16;
static final int SHARED_UNIT = 65536;
static final int MAX_COUNT = 65535;
static final int EXCLUSIVE_MASK = 65535;
private transient ReentrantReadWriteLock.Sync.ThreadLocalHoldCounter readHolds = new ReentrantReadWriteLock.Sync.ThreadLocalHoldCounter();
private transient ReentrantReadWriteLock.Sync.HoldCounter cachedHoldCounter;
private transient Thread firstReader = null;
private transient int firstReaderHoldCount;
static int sharedCount(int var0) {
return var0 >>> 16;
}
static int exclusiveCount(int var0) {
return var0 & '\uffff';
}
Sync() {
this.setState(this.getState());
}
abstract boolean readerShouldBlock();
abstract boolean writerShouldBlock();
protected final boolean tryRelease(int var1) {
if (!this.isHeldExclusively()) {
throw new IllegalMonitorStateException();
} else {
int var2 = this.getState() - var1;
boolean var3 = exclusiveCount(var2) == 0;
if (var3) {
this.setExclusiveOwnerThread((Thread)null);
}
this.setState(var2);
return var3;
}
}
protected final boolean tryAcquire(int var1) {
Thread var2 = Thread.currentThread();
int var3 = this.getState();
int var4 = exclusiveCount(var3);
if (var3 != 0) {
if (var4 != 0 && var2 == this.getExclusiveOwnerThread()) {
if (var4 + exclusiveCount(var1) > 65535) {
throw new Error("Maximum lock count exceeded");
} else {
this.setState(var3 + var1);
return true;
}
} else {
return false;
}
} else if (!this.writerShouldBlock() && this.compareAndSetState(var3, var3 + var1)) {
this.setExclusiveOwnerThread(var2);
return true;
} else {
return false;
}
}
protected final boolean tryReleaseShared(int var1) {
Thread var2 = Thread.currentThread();
int var4;
if (this.firstReader == var2) {
if (this.firstReaderHoldCount == 1) {
this.firstReader = null;
} else {
--this.firstReaderHoldCount;
}
} else {
ReentrantReadWriteLock.Sync.HoldCounter var3 = this.cachedHoldCounter;
if (var3 == null || var3.tid != ReentrantReadWriteLock.getThreadId(var2)) {
var3 = (ReentrantReadWriteLock.Sync.HoldCounter)this.readHolds.get();
}
var4 = var3.count;
if (var4 <= 1) {
this.readHolds.remove();
if (var4 <= 0) {
throw this.unmatchedUnlockException();
}
}
--var3.count;
}
int var5;
do {
var5 = this.getState();
var4 = var5 - 65536;
} while(!this.compareAndSetState(var5, var4));
return var4 == 0;
}
private IllegalMonitorStateException unmatchedUnlockException() {
return new IllegalMonitorStateException("attempt to unlock read lock, not locked by current thread");
}
protected final int tryAcquireShared(int var1) {
Thread var2 = Thread.currentThread();
int var3 = this.getState();
if (exclusiveCount(var3) != 0 && this.getExclusiveOwnerThread() != var2) {
return -1;
} else {
int var4 = sharedCount(var3);
if (!this.readerShouldBlock() && var4 < 65535 && this.compareAndSetState(var3, var3 + 65536)) {
if (var4 == 0) {
this.firstReader = var2;
this.firstReaderHoldCount = 1;
} else if (this.firstReader == var2) {
++this.firstReaderHoldCount;
} else {
ReentrantReadWriteLock.Sync.HoldCounter var5 = this.cachedHoldCounter;
if (var5 != null && var5.tid == ReentrantReadWriteLock.getThreadId(var2)) {
if (var5.count == 0) {
this.readHolds.set(var5);
}
} else {
this.cachedHoldCounter = var5 = (ReentrantReadWriteLock.Sync.HoldCounter)this.readHolds.get();
}
++var5.count;
}
return 1;
} else {
return this.fullTryAcquireShared(var2);
}
}
}
final int fullTryAcquireShared(Thread var1) {
ReentrantReadWriteLock.Sync.HoldCounter var2 = null;
int var3;
do {
var3 = this.getState();
if (exclusiveCount(var3) != 0) {
if (this.getExclusiveOwnerThread() != var1) {
return -1;
}
} else if (this.readerShouldBlock() && this.firstReader != var1) {
if (var2 == null) {
var2 = this.cachedHoldCounter;
if (var2 == null || var2.tid != ReentrantReadWriteLock.getThreadId(var1)) {
var2 = (ReentrantReadWriteLock.Sync.HoldCounter)this.readHolds.get();
if (var2.count == 0) {
this.readHolds.remove();
}
}
}
if (var2.count == 0) {
return -1;
}
}
if (sharedCount(var3) == 65535) {
throw new Error("Maximum lock count exceeded");
}
} while(!this.compareAndSetState(var3, var3 + 65536));
if (sharedCount(var3) == 0) {
this.firstReader = var1;
this.firstReaderHoldCount = 1;
} else if (this.firstReader == var1) {
++this.firstReaderHoldCount;
} else {
if (var2 == null) {
var2 = this.cachedHoldCounter;
}
if (var2 != null && var2.tid == ReentrantReadWriteLock.getThreadId(var1)) {
if (var2.count == 0) {
this.readHolds.set(var2);
}
} else {
var2 = (ReentrantReadWriteLock.Sync.HoldCounter)this.readHolds.get();
}
++var2.count;
this.cachedHoldCounter = var2;
}
return 1;
}
final boolean tryWriteLock() {
Thread var1 = Thread.currentThread();
int var2 = this.getState();
if (var2 != 0) {
int var3 = exclusiveCount(var2);
if (var3 == 0 || var1 != this.getExclusiveOwnerThread()) {
return false;
}
if (var3 == 65535) {
throw new Error("Maximum lock count exceeded");
}
}
if (!this.compareAndSetState(var2, var2 + 1)) {
return false;
} else {
this.setExclusiveOwnerThread(var1);
return true;
}
}
final boolean tryReadLock() {
Thread var1 = Thread.currentThread();
int var2;
int var3;
do {
var2 = this.getState();
if (exclusiveCount(var2) != 0 && this.getExclusiveOwnerThread() != var1) {
return false;
}
var3 = sharedCount(var2);
if (var3 == 65535) {
throw new Error("Maximum lock count exceeded");
}
} while(!this.compareAndSetState(var2, var2 + 65536));
if (var3 == 0) {
this.firstReader = var1;
this.firstReaderHoldCount = 1;
} else if (this.firstReader == var1) {
++this.firstReaderHoldCount;
} else {
ReentrantReadWriteLock.Sync.HoldCounter var4 = this.cachedHoldCounter;
if (var4 != null && var4.tid == ReentrantReadWriteLock.getThreadId(var1)) {
if (var4.count == 0) {
this.readHolds.set(var4);
}
} else {
this.cachedHoldCounter = var4 = (ReentrantReadWriteLock.Sync.HoldCounter)this.readHolds.get();
}
++var4.count;
}
return true;
}
protected final boolean isHeldExclusively() {
return this.getExclusiveOwnerThread() == Thread.currentThread();
}
final ConditionObject newCondition() {
return new ConditionObject(this);
}
final Thread getOwner() {
return exclusiveCount(this.getState()) == 0 ? null : this.getExclusiveOwnerThread();
}
final int getReadLockCount() {
return sharedCount(this.getState());
}
final boolean isWriteLocked() {
return exclusiveCount(this.getState()) != 0;
}
final int getWriteHoldCount() {
return this.isHeldExclusively() ? exclusiveCount(this.getState()) : 0;
}
final int getReadHoldCount() {
if (this.getReadLockCount() == 0) {
return 0;
} else {
Thread var1 = Thread.currentThread();
if (this.firstReader == var1) {
return this.firstReaderHoldCount;
} else {
ReentrantReadWriteLock.Sync.HoldCounter var2 = this.cachedHoldCounter;
if (var2 != null && var2.tid == ReentrantReadWriteLock.getThreadId(var1)) {
return var2.count;
} else {
int var3 = ((ReentrantReadWriteLock.Sync.HoldCounter)this.readHolds.get()).count;
if (var3 == 0) {
this.readHolds.remove();
}
return var3;
}
}
}
}
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
var1.defaultReadObject();
this.readHolds = new ReentrantReadWriteLock.Sync.ThreadLocalHoldCounter();
this.setState(0);
}
final int getCount() {
return this.getState();
}
static final class HoldCounter {
int count = 0;
final long tid = ReentrantReadWriteLock.getThreadId(Thread.currentThread());
HoldCounter() {
}
}
static final class ThreadLocalHoldCounter extends ThreadLocal<ReentrantReadWriteLock.Sync.HoldCounter> {
ThreadLocalHoldCounter() {
}
public ReentrantReadWriteLock.Sync.HoldCounter initialValue() {
return new ReentrantReadWriteLock.Sync.HoldCounter();
}
}
}
public static class WriteLock implements Lock, Serializable {
private static final long serialVersionUID = -4992448646407690164L;
private final ReentrantReadWriteLock.Sync sync;
protected WriteLock(ReentrantReadWriteLock var1) {
this.sync = var1.sync;
}
public void lock() {
this.sync.acquire(1);
}
public void lockInterruptibly() throws InterruptedException {
this.sync.acquireInterruptibly(1);
}
public boolean tryLock() {
return this.sync.tryWriteLock();
}
public boolean tryLock(long var1, TimeUnit var3) throws InterruptedException {
return this.sync.tryAcquireNanos(1, var3.toNanos(var1));
}
public void unlock() {
this.sync.release(1);
}
public Condition newCondition() {
return this.sync.newCondition();
}
public String toString() {
Thread var1 = this.sync.getOwner();
return super.toString() + (var1 == null ? "[Unlocked]" : "[Locked by thread " + var1.getName() + "]");
}
public boolean isHeldByCurrentThread() {
return this.sync.isHeldExclusively();
}
public int getHoldCount() {
return this.sync.getWriteHoldCount();
}
}
}
ReadWriteLock 接口代码：
package java.util.concurrent.locks;
public interface ReadWriteLock {
Lock readLock();
Lock writeLock();
}上面的锁中的同步操作都是调用this.compareAndSetState方法，这个方法是cas 操作。this 是类abstract static class Sync extends AbstractQueuedSynchronizer
看下AbstractQueuedSynchronizer 源码：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package java.util.concurrent.locks;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import sun.misc.Unsafe;
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements Serializable {
private static final long serialVersionUID = 7373984972572414691L;
private transient volatile AbstractQueuedSynchronizer.Node head;
private transient volatile AbstractQueuedSynchronizer.Node tail;
private volatile int state;
static final long spinForTimeoutThreshold = 1000L;
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long stateOffset;
private static final long headOffset;
private static final long tailOffset;
private static final long waitStatusOffset;
private static final long nextOffset;
protected AbstractQueuedSynchronizer() {
}
protected final int getState() {
return this.state;
}
protected final void setState(int var1) {
this.state = var1;
}
protected final boolean compareAndSetState(int var1, int var2) {
return unsafe.compareAndSwapInt(this, stateOffset, var1, var2);
}
private AbstractQueuedSynchronizer.Node enq(AbstractQueuedSynchronizer.Node var1) {
while(true) {
AbstractQueuedSynchronizer.Node var2 = this.tail;
if (var2 == null) {
if (this.compareAndSetHead(new AbstractQueuedSynchronizer.Node())) {
this.tail = this.head;
}
} else {
var1.prev = var2;
if (this.compareAndSetTail(var2, var1)) {
var2.next = var1;
return var2;
}
}
}
}
private AbstractQueuedSynchronizer.Node addWaiter(AbstractQueuedSynchronizer.Node var1) {
AbstractQueuedSynchronizer.Node var2 = new AbstractQueuedSynchronizer.Node(Thread.currentThread(), var1);
AbstractQueuedSynchronizer.Node var3 = this.tail;
if (var3 != null) {
var2.prev = var3;
if (this.compareAndSetTail(var3, var2)) {
var3.next = var2;
return var2;
}
}
this.enq(var2);
return var2;
}
private void setHead(AbstractQueuedSynchronizer.Node var1) {
this.head = var1;
var1.thread = null;
var1.prev = null;
}
private void unparkSuccessor(AbstractQueuedSynchronizer.Node var1) {
int var2 = var1.waitStatus;
if (var2 < 0) {
compareAndSetWaitStatus(var1, var2, 0);
}
AbstractQueuedSynchronizer.Node var3 = var1.next;
if (var3 == null || var3.waitStatus > 0) {
var3 = null;
for(AbstractQueuedSynchronizer.Node var4 = this.tail; var4 != null && var4 != var1; var4 = var4.prev) {
if (var4.waitStatus <= 0) {
var3 = var4;
}
}
}
if (var3 != null) {
LockSupport.unpark(var3.thread);
}
}
private void doReleaseShared() {
while(true) {
AbstractQueuedSynchronizer.Node var1 = this.head;
if (var1 != null && var1 != this.tail) {
int var2 = var1.waitStatus;
if (var2 == -1) {
if (!compareAndSetWaitStatus(var1, -1, 0)) {
continue;
}
this.unparkSuccessor(var1);
} else if (var2 == 0 && !compareAndSetWaitStatus(var1, 0, -3)) {
continue;
}
}
if (var1 == this.head) {
return;
}
}
}
private void setHeadAndPropagate(AbstractQueuedSynchronizer.Node var1, int var2) {
AbstractQueuedSynchronizer.Node var3 = this.head;
this.setHead(var1);
if (var2 <= 0 && var3 != null && var3.waitStatus >= 0) {
var3 = this.head;
if (this.head != null && var3.waitStatus >= 0) {
return;
}
}
AbstractQueuedSynchronizer.Node var4 = var1.next;
if (var4 == null || var4.isShared()) {
this.doReleaseShared();
}
}
private void cancelAcquire(AbstractQueuedSynchronizer.Node var1) {
if (var1 != null) {
var1.thread = null;
AbstractQueuedSynchronizer.Node var2;
for(var2 = var1.prev; var2.waitStatus > 0; var1.prev = var2 = var2.prev) {
;
}
AbstractQueuedSynchronizer.Node var3 = var2.next;
var1.waitStatus = 1;
if (var1 == this.tail && this.compareAndSetTail(var1, var2)) {
compareAndSetNext(var2, var3, (AbstractQueuedSynchronizer.Node)null);
} else {
label37: {
if (var2 != this.head) {
int var4 = var2.waitStatus;
if ((var2.waitStatus == -1 || var4 <= 0 && compareAndSetWaitStatus(var2, var4, -1)) && var2.thread != null) {
AbstractQueuedSynchronizer.Node var5 = var1.next;
if (var5 != null && var5.waitStatus <= 0) {
compareAndSetNext(var2, var3, var5);
}
break label37;
}
}
this.unparkSuccessor(var1);
}
var1.next = var1;
}
}
}
private static boolean shouldParkAfterFailedAcquire(AbstractQueuedSynchronizer.Node var0, AbstractQueuedSynchronizer.Node var1) {
int var2 = var0.waitStatus;
if (var2 == -1) {
return true;
} else {
if (var2 > 0) {
do {
var1.prev = var0 = var0.prev;
} while(var0.waitStatus > 0);
var0.next = var1;
} else {
compareAndSetWaitStatus(var0, var2, -1);
}
return false;
}
}
static void selfInterrupt() {
Thread.currentThread().interrupt();
}
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
final boolean acquireQueued(AbstractQueuedSynchronizer.Node var1, int var2) {
boolean var3 = true;
try {
boolean var4 = false;
while(true) {
AbstractQueuedSynchronizer.Node var5 = var1.predecessor();
if (var5 == this.head && this.tryAcquire(var2)) {
this.setHead(var1);
var5.next = null;
var3 = false;
boolean var6 = var4;
return var6;
}
if (shouldParkAfterFailedAcquire(var5, var1) && this.parkAndCheckInterrupt()) {
var4 = true;
}
}
} finally {
if (var3) {
this.cancelAcquire(var1);
}
}
}
private void doAcquireInterruptibly(int var1) throws InterruptedException {
AbstractQueuedSynchronizer.Node var2 = this.addWaiter(AbstractQueuedSynchronizer.Node.EXCLUSIVE);
boolean var3 = true;
try {
AbstractQueuedSynchronizer.Node var4;
do {
var4 = var2.predecessor();
if (var4 == this.head && this.tryAcquire(var1)) {
this.setHead(var2);
var4.next = null;
var3 = false;
return;
}
} while(!shouldParkAfterFailedAcquire(var4, var2) || !this.parkAndCheckInterrupt());
throw new InterruptedException();
} finally {
if (var3) {
this.cancelAcquire(var2);
}
}
}
private boolean doAcquireNanos(int var1, long var2) throws InterruptedException {
if (var2 <= 0L) {
return false;
} else {
long var4 = System.nanoTime() + var2;
AbstractQueuedSynchronizer.Node var6 = this.addWaiter(AbstractQueuedSynchronizer.Node.EXCLUSIVE);
boolean var7 = true;
try {
do {
AbstractQueuedSynchronizer.Node var8 = var6.predecessor();
boolean var9;
if (var8 == this.head && this.tryAcquire(var1)) {
this.setHead(var6);
var8.next = null;
var7 = false;
var9 = true;
return var9;
}
var2 = var4 - System.nanoTime();
if (var2 <= 0L) {
var9 = false;
return var9;
}
if (shouldParkAfterFailedAcquire(var8, var6) && var2 > 1000L) {
LockSupport.parkNanos(this, var2);
}
} while(!Thread.interrupted());
throw new InterruptedException();
} finally {
if (var7) {
this.cancelAcquire(var6);
}
}
}
}
private void doAcquireShared(int var1) {
AbstractQueuedSynchronizer.Node var2 = this.addWaiter(AbstractQueuedSynchronizer.Node.SHARED);
boolean var3 = true;
try {
boolean var4 = false;
while(true) {
AbstractQueuedSynchronizer.Node var5 = var2.predecessor();
if (var5 == this.head) {
int var6 = this.tryAcquireShared(var1);
if (var6 >= 0) {
this.setHeadAndPropagate(var2, var6);
var5.next = null;
if (var4) {
selfInterrupt();
}
var3 = false;
return;
}
}
if (shouldParkAfterFailedAcquire(var5, var2) && this.parkAndCheckInterrupt()) {
var4 = true;
}
}
} finally {
if (var3) {
this.cancelAcquire(var2);
}
}
}
private void doAcquireSharedInterruptibly(int var1) throws InterruptedException {
AbstractQueuedSynchronizer.Node var2 = this.addWaiter(AbstractQueuedSynchronizer.Node.SHARED);
boolean var3 = true;
try {
AbstractQueuedSynchronizer.Node var4;
do {
var4 = var2.predecessor();
if (var4 == this.head) {
int var5 = this.tryAcquireShared(var1);
if (var5 >= 0) {
this.setHeadAndPropagate(var2, var5);
var4.next = null;
var3 = false;
return;
}
}
} while(!shouldParkAfterFailedAcquire(var4, var2) || !this.parkAndCheckInterrupt());
throw new InterruptedException();
} finally {
if (var3) {
this.cancelAcquire(var2);
}
}
}
private boolean doAcquireSharedNanos(int var1, long var2) throws InterruptedException {
if (var2 <= 0L) {
return false;
} else {
long var4 = System.nanoTime() + var2;
AbstractQueuedSynchronizer.Node var6 = this.addWaiter(AbstractQueuedSynchronizer.Node.SHARED);
boolean var7 = true;
while(true) {
boolean var14;
try {
AbstractQueuedSynchronizer.Node var8 = var6.predecessor();
if (var8 == this.head) {
int var9 = this.tryAcquireShared(var1);
if (var9 >= 0) {
this.setHeadAndPropagate(var6, var9);
var8.next = null;
var7 = false;
boolean var10 = true;
return var10;
}
}
var2 = var4 - System.nanoTime();
if (var2 > 0L) {
if (shouldParkAfterFailedAcquire(var8, var6) && var2 > 1000L) {
LockSupport.parkNanos(this, var2);
}
if (Thread.interrupted()) {
throw new InterruptedException();
}
continue;
}
var14 = false;
} finally {
if (var7) {
this.cancelAcquire(var6);
}
}
return var14;
}
}
}
protected boolean tryAcquire(int var1) {
throw new UnsupportedOperationException();
}
protected boolean tryRelease(int var1) {
throw new UnsupportedOperationException();
}
protected int tryAcquireShared(int var1) {
throw new UnsupportedOperationException();
}
protected boolean tryReleaseShared(int var1) {
throw new UnsupportedOperationException();
}
protected boolean isHeldExclusively() {
throw new UnsupportedOperationException();
}
public final void acquire(int var1) {
if (!this.tryAcquire(var1) && this.acquireQueued(this.addWaiter(AbstractQueuedSynchronizer.Node.EXCLUSIVE), var1)) {
selfInterrupt();
}
}
public final void acquireInterruptibly(int var1) throws InterruptedException {
if (Thread.interrupted()) {
throw new InterruptedException();
} else {
if (!this.tryAcquire(var1)) {
this.doAcquireInterruptibly(var1);
}
}
}
public final boolean tryAcquireNanos(int var1, long var2) throws InterruptedException {
if (Thread.interrupted()) {
throw new InterruptedException();
} else {
return this.tryAcquire(var1) || this.doAcquireNanos(var1, var2);
}
}
public final boolean release(int var1) {
if (this.tryRelease(var1)) {
AbstractQueuedSynchronizer.Node var2 = this.head;
if (var2 != null && var2.waitStatus != 0) {
this.unparkSuccessor(var2);
}
return true;
} else {
return false;
}
}
public final void acquireShared(int var1) {
if (this.tryAcquireShared(var1) < 0) {
this.doAcquireShared(var1);
}
}
public final void acquireSharedInterruptibly(int var1) throws InterruptedException {
if (Thread.interrupted()) {
throw new InterruptedException();
} else {
if (this.tryAcquireShared(var1) < 0) {
this.doAcquireSharedInterruptibly(var1);
}
}
}
public final boolean tryAcquireSharedNanos(int var1, long var2) throws InterruptedException {
if (Thread.interrupted()) {
throw new InterruptedException();
} else {
return this.tryAcquireShared(var1) >= 0 || this.doAcquireSharedNanos(var1, var2);
}
}
public final boolean releaseShared(int var1) {
if (this.tryReleaseShared(var1)) {
this.doReleaseShared();
return true;
} else {
return false;
}
}
public final boolean hasQueuedThreads() {
return this.head != this.tail;
}
public final boolean hasContended() {
return this.head != null;
}
public final Thread getFirstQueuedThread() {
return this.head == this.tail ? null : this.fullGetFirstQueuedThread();
}
private Thread fullGetFirstQueuedThread() {
AbstractQueuedSynchronizer.Node var1 = this.head;
AbstractQueuedSynchronizer.Node var2;
Thread var3;
if (this.head != null) {
var2 = var1.next;
if (var1.next != null && var2.prev == this.head) {
var3 = var2.thread;
if (var2.thread != null) {
return var3;
}
}
}
var1 = this.head;
if (this.head != null) {
var2 = var1.next;
if (var1.next != null && var2.prev == this.head) {
var3 = var2.thread;
if (var2.thread != null) {
return var3;
}
}
}
AbstractQueuedSynchronizer.Node var4 = this.tail;
Thread var5;
for(var5 = null; var4 != null && var4 != this.head; var4 = var4.prev) {
Thread var6 = var4.thread;
if (var6 != null) {
var5 = var6;
}
}
return var5;
}
public final boolean isQueued(Thread var1) {
if (var1 == null) {
throw new NullPointerException();
} else {
for(AbstractQueuedSynchronizer.Node var2 = this.tail; var2 != null; var2 = var2.prev) {
if (var2.thread == var1) {
return true;
}
}
return false;
}
}
final boolean apparentlyFirstQueuedIsExclusive() {
AbstractQueuedSynchronizer.Node var1 = this.head;
boolean var10000;
if (this.head != null) {
AbstractQueuedSynchronizer.Node var2 = var1.next;
if (var1.next != null && !var2.isShared() && var2.thread != null) {
var10000 = true;
return var10000;
}
}
var10000 = false;
return var10000;
}
public final boolean hasQueuedPredecessors() {
AbstractQueuedSynchronizer.Node var1 = this.tail;
AbstractQueuedSynchronizer.Node var2 = this.head;
boolean var10000;
if (var2 != var1) {
AbstractQueuedSynchronizer.Node var3 = var2.next;
if (var2.next == null || var3.thread != Thread.currentThread()) {
var10000 = true;
return var10000;
}
}
var10000 = false;
return var10000;
}
public final int getQueueLength() {
int var1 = 0;
for(AbstractQueuedSynchronizer.Node var2 = this.tail; var2 != null; var2 = var2.prev) {
if (var2.thread != null) {
++var1;
}
}
return var1;
}
public final Collection<Thread> getQueuedThreads() {
ArrayList var1 = new ArrayList();
for(AbstractQueuedSynchronizer.Node var2 = this.tail; var2 != null; var2 = var2.prev) {
Thread var3 = var2.thread;
if (var3 != null) {
var1.add(var3);
}
}
return var1;
}
public final Collection<Thread> getExclusiveQueuedThreads() {
ArrayList var1 = new ArrayList();
for(AbstractQueuedSynchronizer.Node var2 = this.tail; var2 != null; var2 = var2.prev) {
if (!var2.isShared()) {
Thread var3 = var2.thread;
if (var3 != null) {
var1.add(var3);
}
}
}
return var1;
}
public final Collection<Thread> getSharedQueuedThreads() {
ArrayList var1 = new ArrayList();
for(AbstractQueuedSynchronizer.Node var2 = this.tail; var2 != null; var2 = var2.prev) {
if (var2.isShared()) {
Thread var3 = var2.thread;
if (var3 != null) {
var1.add(var3);
}
}
}
return var1;
}
public String toString() {
int var1 = this.getState();
String var2 = this.hasQueuedThreads() ? "non" : "";
return super.toString() + "[State = " + var1 + ", " + var2 + "empty queue]";
}
final boolean isOnSyncQueue(AbstractQueuedSynchronizer.Node var1) {
if (var1.waitStatus != -2 && var1.prev != null) {
return var1.next != null ? true : this.findNodeFromTail(var1);
} else {
return false;
}
}
private boolean findNodeFromTail(AbstractQueuedSynchronizer.Node var1) {
for(AbstractQueuedSynchronizer.Node var2 = this.tail; var2 != var1; var2 = var2.prev) {
if (var2 == null) {
return false;
}
}
return true;
}
final boolean transferForSignal(AbstractQueuedSynchronizer.Node var1) {
if (!compareAndSetWaitStatus(var1, -2, 0)) {
return false;
} else {
AbstractQueuedSynchronizer.Node var2 = this.enq(var1);
int var3 = var2.waitStatus;
if (var3 > 0 || !compareAndSetWaitStatus(var2, var3, -1)) {
LockSupport.unpark(var1.thread);
}
return true;
}
}
final boolean transferAfterCancelledWait(AbstractQueuedSynchronizer.Node var1) {
if (compareAndSetWaitStatus(var1, -2, 0)) {
this.enq(var1);
return true;
} else {
while(!this.isOnSyncQueue(var1)) {
Thread.yield();
}
return false;
}
}
final int fullyRelease(AbstractQueuedSynchronizer.Node var1) {
boolean var2 = true;
int var4;
try {
int var3 = this.getState();
if (!this.release(var3)) {
throw new IllegalMonitorStateException();
}
var2 = false;
var4 = var3;
} finally {
if (var2) {
var1.waitStatus = 1;
}
}
return var4;
}
public final boolean owns(AbstractQueuedSynchronizer.ConditionObject var1) {
return var1.isOwnedBy(this);
}
public final boolean hasWaiters(AbstractQueuedSynchronizer.ConditionObject var1) {
if (!this.owns(var1)) {
throw new IllegalArgumentException("Not owner");
} else {
return var1.hasWaiters();
}
}
public final int getWaitQueueLength(AbstractQueuedSynchronizer.ConditionObject var1) {
if (!this.owns(var1)) {
throw new IllegalArgumentException("Not owner");
} else {
return var1.getWaitQueueLength();
}
}
public final Collection<Thread> getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject var1) {
if (!this.owns(var1)) {
throw new IllegalArgumentException("Not owner");
} else {
return var1.getWaitingThreads();
}
}
private final boolean compareAndSetHead(AbstractQueuedSynchronizer.Node var1) {
return unsafe.compareAndSwapObject(this, headOffset, (Object)null, var1);
}
private final boolean compareAndSetTail(AbstractQueuedSynchronizer.Node var1, AbstractQueuedSynchronizer.Node var2) {
return unsafe.compareAndSwapObject(this, tailOffset, var1, var2);
}
private static final boolean compareAndSetWaitStatus(AbstractQueuedSynchronizer.Node var0, int var1, int var2) {
return unsafe.compareAndSwapInt(var0, waitStatusOffset, var1, var2);
}
private static final boolean compareAndSetNext(AbstractQueuedSynchronizer.Node var0, AbstractQueuedSynchronizer.Node var1, AbstractQueuedSynchronizer.Node var2) {
return unsafe.compareAndSwapObject(var0, nextOffset, var1, var2);
}
static {
try {
stateOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer.class.getDeclaredField("state"));
headOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer.class.getDeclaredField("head"));
tailOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
waitStatusOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer.Node.class.getDeclaredField("waitStatus"));
nextOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer.Node.class.getDeclaredField("next"));
} catch (Exception var1) {
throw new Error(var1);
}
}
public class ConditionObject implements Condition, Serializable {
private static final long serialVersionUID = 1173984872572414699L;
private transient AbstractQueuedSynchronizer.Node firstWaiter;
private transient AbstractQueuedSynchronizer.Node lastWaiter;
private static final int REINTERRUPT = 1;
private static final int THROW_IE = -1;
public ConditionObject() {
}
private AbstractQueuedSynchronizer.Node addConditionWaiter() {
AbstractQueuedSynchronizer.Node var1 = this.lastWaiter;
if (var1 != null && var1.waitStatus != -2) {
this.unlinkCancelledWaiters();
var1 = this.lastWaiter;
}
AbstractQueuedSynchronizer.Node var2 = new AbstractQueuedSynchronizer.Node(Thread.currentThread(), -2);
if (var1 == null) {
this.firstWaiter = var2;
} else {
var1.nextWaiter = var2;
}
this.lastWaiter = var2;
return var2;
}
private void doSignal(AbstractQueuedSynchronizer.Node var1) {
while(true) {
if ((this.firstWaiter = var1.nextWaiter) == null) {
this.lastWaiter = null;
}
var1.nextWaiter = null;
if (!AbstractQueuedSynchronizer.this.transferForSignal(var1)) {
var1 = this.firstWaiter;
if (this.firstWaiter != null) {
continue;
}
}
return;
}
}
private void doSignalAll(AbstractQueuedSynchronizer.Node var1) {
this.lastWaiter = this.firstWaiter = null;
AbstractQueuedSynchronizer.Node var2;
do {
var2 = var1.nextWaiter;
var1.nextWaiter = null;
AbstractQueuedSynchronizer.this.transferForSignal(var1);
var1 = var2;
} while(var2 != null);
}
private void unlinkCancelledWaiters() {
AbstractQueuedSynchronizer.Node var1 = this.firstWaiter;
AbstractQueuedSynchronizer.Node var3;
for(AbstractQueuedSynchronizer.Node var2 = null; var1 != null; var1 = var3) {
var3 = var1.nextWaiter;
if (var1.waitStatus != -2) {
var1.nextWaiter = null;
if (var2 == null) {
this.firstWaiter = var3;
} else {
var2.nextWaiter = var3;
}
if (var3 == null) {
this.lastWaiter = var2;
}
} else {
var2 = var1;
}
}
}
public final void signal() {
if (!AbstractQueuedSynchronizer.this.isHeldExclusively()) {
throw new IllegalMonitorStateException();
} else {
AbstractQueuedSynchronizer.Node var1 = this.firstWaiter;
if (var1 != null) {
this.doSignal(var1);
}
}
}
public final void signalAll() {
if (!AbstractQueuedSynchronizer.this.isHeldExclusively()) {
throw new IllegalMonitorStateException();
} else {
AbstractQueuedSynchronizer.Node var1 = this.firstWaiter;
if (var1 != null) {
this.doSignalAll(var1);
}
}
}
public final void awaitUninterruptibly() {
AbstractQueuedSynchronizer.Node var1 = this.addConditionWaiter();
int var2 = AbstractQueuedSynchronizer.this.fullyRelease(var1);
boolean var3 = false;
while(!AbstractQueuedSynchronizer.this.isOnSyncQueue(var1)) {
LockSupport.park(this);
if (Thread.interrupted()) {
var3 = true;
}
}
if (AbstractQueuedSynchronizer.this.acquireQueued(var1, var2) || var3) {
AbstractQueuedSynchronizer.selfInterrupt();
}
}
private int checkInterruptWhileWaiting(AbstractQueuedSynchronizer.Node var1) {
return Thread.interrupted() ? (AbstractQueuedSynchronizer.this.transferAfterCancelledWait(var1) ? -1 : 1) : 0;
}
private void reportInterruptAfterWait(int var1) throws InterruptedException {
if (var1 == -1) {
throw new InterruptedException();
} else {
if (var1 == 1) {
AbstractQueuedSynchronizer.selfInterrupt();
}
}
}
public final void await() throws InterruptedException {
if (Thread.interrupted()) {
throw new InterruptedException();
} else {
AbstractQueuedSynchronizer.Node var1 = this.addConditionWaiter();
int var2 = AbstractQueuedSynchronizer.this.fullyRelease(var1);
int var3 = 0;
while(!AbstractQueuedSynchronizer.this.isOnSyncQueue(var1)) {
LockSupport.park(this);
if ((var3 = this.checkInterruptWhileWaiting(var1)) != 0) {
break;
}
}
if (AbstractQueuedSynchronizer.this.acquireQueued(var1, var2) && var3 != -1) {
var3 = 1;
}
if (var1.nextWaiter != null) {
this.unlinkCancelledWaiters();
}
if (var3 != 0) {
this.reportInterruptAfterWait(var3);
}
}
}
public final long awaitNanos(long var1) throws InterruptedException {
if (Thread.interrupted()) {
throw new InterruptedException();
} else {
AbstractQueuedSynchronizer.Node var3 = this.addConditionWaiter();
int var4 = AbstractQueuedSynchronizer.this.fullyRelease(var3);
long var5 = System.nanoTime() + var1;
int var7;
for(var7 = 0; !AbstractQueuedSynchronizer.this.isOnSyncQueue(var3); var1 = var5 - System.nanoTime()) {
if (var1 <= 0L) {
AbstractQueuedSynchronizer.this.transferAfterCancelledWait(var3);
break;
}
if (var1 >= 1000L) {
LockSupport.parkNanos(this, var1);
}
if ((var7 = this.checkInterruptWhileWaiting(var3)) != 0) {
break;
}
}
if (AbstractQueuedSynchronizer.this.acquireQueued(var3, var4) && var7 != -1) {
var7 = 1;
}
if (var3.nextWaiter != null) {
this.unlinkCancelledWaiters();
}
if (var7 != 0) {
this.reportInterruptAfterWait(var7);
}
return var5 - System.nanoTime();
}
}
public final boolean awaitUntil(Date var1) throws InterruptedException {
long var2 = var1.getTime();
if (Thread.interrupted()) {
throw new InterruptedException();
} else {
AbstractQueuedSynchronizer.Node var4 = this.addConditionWaiter();
int var5 = AbstractQueuedSynchronizer.this.fullyRelease(var4);
boolean var6 = false;
int var7 = 0;
while(!AbstractQueuedSynchronizer.this.isOnSyncQueue(var4)) {
if (System.currentTimeMillis() > var2) {
var6 = AbstractQueuedSynchronizer.this.transferAfterCancelledWait(var4);
break;
}
LockSupport.parkUntil(this, var2);
if ((var7 = this.checkInterruptWhileWaiting(var4)) != 0) {
break;
}
}
if (AbstractQueuedSynchronizer.this.acquireQueued(var4, var5) && var7 != -1) {
var7 = 1;
}
if (var4.nextWaiter != null) {
this.unlinkCancelledWaiters();
}
if (var7 != 0) {
this.reportInterruptAfterWait(var7);
}
return !var6;
}
}
public final boolean await(long var1, TimeUnit var3) throws InterruptedException {
long var4 = var3.toNanos(var1);
if (Thread.interrupted()) {
throw new InterruptedException();
} else {
AbstractQueuedSynchronizer.Node var6 = this.addConditionWaiter();
int var7 = AbstractQueuedSynchronizer.this.fullyRelease(var6);
long var8 = System.nanoTime() + var4;
boolean var10 = false;
int var11;
for(var11 = 0; !AbstractQueuedSynchronizer.this.isOnSyncQueue(var6); var4 = var8 - System.nanoTime()) {
if (var4 <= 0L) {
var10 = AbstractQueuedSynchronizer.this.transferAfterCancelledWait(var6);
break;
}
if (var4 >= 1000L) {
LockSupport.parkNanos(this, var4);
}
if ((var11 = this.checkInterruptWhileWaiting(var6)) != 0) {
break;
}
}
if (AbstractQueuedSynchronizer.this.acquireQueued(var6, var7) && var11 != -1) {
var11 = 1;
}
if (var6.nextWaiter != null) {
this.unlinkCancelledWaiters();
}
if (var11 != 0) {
this.reportInterruptAfterWait(var11);
}
return !var10;
}
}
final boolean isOwnedBy(AbstractQueuedSynchronizer var1) {
return var1 == AbstractQueuedSynchronizer.this;
}
protected final boolean hasWaiters() {
if (!AbstractQueuedSynchronizer.this.isHeldExclusively()) {
throw new IllegalMonitorStateException();
} else {
for(AbstractQueuedSynchronizer.Node var1 = this.firstWaiter; var1 != null; var1 = var1.nextWaiter) {
if (var1.waitStatus == -2) {
return true;
}
}
return false;
}
}
protected final int getWaitQueueLength() {
if (!AbstractQueuedSynchronizer.this.isHeldExclusively()) {
throw new IllegalMonitorStateException();
} else {
int var1 = 0;
for(AbstractQueuedSynchronizer.Node var2 = this.firstWaiter; var2 != null; var2 = var2.nextWaiter) {
if (var2.waitStatus == -2) {
++var1;
}
}
return var1;
}
}
protected final Collection<Thread> getWaitingThreads() {
if (!AbstractQueuedSynchronizer.this.isHeldExclusively()) {
throw new IllegalMonitorStateException();
} else {
ArrayList var1 = new ArrayList();
for(AbstractQueuedSynchronizer.Node var2 = this.firstWaiter; var2 != null; var2 = var2.nextWaiter) {
if (var2.waitStatus == -2) {
Thread var3 = var2.thread;
if (var3 != null) {
var1.add(var3);
}
}
}
return var1;
}
}
}
static final class Node {
static final AbstractQueuedSynchronizer.Node SHARED = new AbstractQueuedSynchronizer.Node();
static final AbstractQueuedSynchronizer.Node EXCLUSIVE = null;
static final int CANCELLED = 1;
static final int SIGNAL = -1;
static final int CONDITION = -2;
static final int PROPAGATE = -3;
volatile int waitStatus;
volatile AbstractQueuedSynchronizer.Node prev;
volatile AbstractQueuedSynchronizer.Node next;
volatile Thread thread;
AbstractQueuedSynchronizer.Node nextWaiter;
final boolean isShared() {
return this.nextWaiter == SHARED;
}
final AbstractQueuedSynchronizer.Node predecessor() throws NullPointerException {
AbstractQueuedSynchronizer.Node var1 = this.prev;
if (var1 == null) {
throw new NullPointerException();
} else {
return var1;
}
}
Node() {
}
Node(Thread var1, AbstractQueuedSynchronizer.Node var2) {
this.nextWaiter = var2;
this.thread = var1;
}
Node(Thread var1, int var2) {
this.waitStatus = var2;
this.thread = var1;
}
}
}cas :
protected final boolean compareAndSetState(int var1, int var2) {
return unsafe.compareAndSwapInt(this, stateOffset, var1, var2);
}看下unsafe类，这个类是在sun.misc包下面：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package sun.misc;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.security.ProtectionDomain;
import sun.reflect.CallerSensitive;
import sun.reflect.Reflection;
public final class Unsafe {
private static final Unsafe theUnsafe;
public static final int INVALID_FIELD_OFFSET = -1;
public static final int ARRAY_BOOLEAN_BASE_OFFSET;
public static final int ARRAY_BYTE_BASE_OFFSET;
public static final int ARRAY_SHORT_BASE_OFFSET;
public static final int ARRAY_CHAR_BASE_OFFSET;
public static final int ARRAY_INT_BASE_OFFSET;
public static final int ARRAY_LONG_BASE_OFFSET;
public static final int ARRAY_FLOAT_BASE_OFFSET;
public static final int ARRAY_DOUBLE_BASE_OFFSET;
public static final int ARRAY_OBJECT_BASE_OFFSET;
public static final int ARRAY_BOOLEAN_INDEX_SCALE;
public static final int ARRAY_BYTE_INDEX_SCALE;
public static final int ARRAY_SHORT_INDEX_SCALE;
public static final int ARRAY_CHAR_INDEX_SCALE;
public static final int ARRAY_INT_INDEX_SCALE;
public static final int ARRAY_LONG_INDEX_SCALE;
public static final int ARRAY_FLOAT_INDEX_SCALE;
public static final int ARRAY_DOUBLE_INDEX_SCALE;
public static final int ARRAY_OBJECT_INDEX_SCALE;
public static final int ADDRESS_SIZE;
private static native void registerNatives();
private Unsafe() {
}
@CallerSensitive
public static Unsafe getUnsafe() {
Class var0 = Reflection.getCallerClass();
if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
throw new SecurityException("Unsafe");
} else {
return theUnsafe;
}
}
public native int getInt(Object var1, long var2);
public native void putInt(Object var1, long var2, int var4);
public native Object getObject(Object var1, long var2);
public native void putObject(Object var1, long var2, Object var4);
public native boolean getBoolean(Object var1, long var2);
public native void putBoolean(Object var1, long var2, boolean var4);
public native byte getByte(Object var1, long var2);
public native void putByte(Object var1, long var2, byte var4);
public native short getShort(Object var1, long var2);
public native void putShort(Object var1, long var2, short var4);
public native char getChar(Object var1, long var2);
public native void putChar(Object var1, long var2, char var4);
public native long getLong(Object var1, long var2);
public native void putLong(Object var1, long var2, long var4);
public native float getFloat(Object var1, long var2);
public native void putFloat(Object var1, long var2, float var4);
public native double getDouble(Object var1, long var2);
public native void putDouble(Object var1, long var2, double var4);
/** @deprecated */
@Deprecated
public int getInt(Object var1, int var2) {
return this.getInt(var1, (long)var2);
}
/** @deprecated */
@Deprecated
public void putInt(Object var1, int var2, int var3) {
this.putInt(var1, (long)var2, var3);
}
/** @deprecated */
@Deprecated
public Object getObject(Object var1, int var2) {
return this.getObject(var1, (long)var2);
}
/** @deprecated */
@Deprecated
public void putObject(Object var1, int var2, Object var3) {
this.putObject(var1, (long)var2, var3);
}
/** @deprecated */
@Deprecated
public boolean getBoolean(Object var1, int var2) {
return this.getBoolean(var1, (long)var2);
}
/** @deprecated */
@Deprecated
public void putBoolean(Object var1, int var2, boolean var3) {
this.putBoolean(var1, (long)var2, var3);
}
/** @deprecated */
@Deprecated
public byte getByte(Object var1, int var2) {
return this.getByte(var1, (long)var2);
}
/** @deprecated */
@Deprecated
public void putByte(Object var1, int var2, byte var3) {
this.putByte(var1, (long)var2, var3);
}
/** @deprecated */
@Deprecated
public short getShort(Object var1, int var2) {
return this.getShort(var1, (long)var2);
}
/** @deprecated */
@Deprecated
public void putShort(Object var1, int var2, short var3) {
this.putShort(var1, (long)var2, var3);
}
/** @deprecated */
@Deprecated
public char getChar(Object var1, int var2) {
return this.getChar(var1, (long)var2);
}
/** @deprecated */
@Deprecated
public void putChar(Object var1, int var2, char var3) {
this.putChar(var1, (long)var2, var3);
}
/** @deprecated */
@Deprecated
public long getLong(Object var1, int var2) {
return this.getLong(var1, (long)var2);
}
/** @deprecated */
@Deprecated
public void putLong(Object var1, int var2, long var3) {
this.putLong(var1, (long)var2, var3);
}
/** @deprecated */
@Deprecated
public float getFloat(Object var1, int var2) {
return this.getFloat(var1, (long)var2);
}
/** @deprecated */
@Deprecated
public void putFloat(Object var1, int var2, float var3) {
this.putFloat(var1, (long)var2, var3);
}
/** @deprecated */
@Deprecated
public double getDouble(Object var1, int var2) {
return this.getDouble(var1, (long)var2);
}
/** @deprecated */
@Deprecated
public void putDouble(Object var1, int var2, double var3) {
this.putDouble(var1, (long)var2, var3);
}
public native byte getByte(long var1);
public native void putByte(long var1, byte var3);
public native short getShort(long var1);
public native void putShort(long var1, short var3);
public native char getChar(long var1);
public native void putChar(long var1, char var3);
public native int getInt(long var1);
public native void putInt(long var1, int var3);
public native long getLong(long var1);
public native void putLong(long var1, long var3);
public native float getFloat(long var1);
public native void putFloat(long var1, float var3);
public native double getDouble(long var1);
public native void putDouble(long var1, double var3);
public native long getAddress(long var1);
public native void putAddress(long var1, long var3);
public native long allocateMemory(long var1);
public native long reallocateMemory(long var1, long var3);
public native void setMemory(Object var1, long var2, long var4, byte var6);
public void setMemory(long var1, long var3, byte var5) {
this.setMemory((Object)null, var1, var3, var5);
}
public native void copyMemory(Object var1, long var2, Object var4, long var5, long var7);
public void copyMemory(long var1, long var3, long var5) {
this.copyMemory((Object)null, var1, (Object)null, var3, var5);
}
public native void freeMemory(long var1);
/** @deprecated */
@Deprecated
public int fieldOffset(Field var1) {
return Modifier.isStatic(var1.getModifiers()) ? (int)this.staticFieldOffset(var1) : (int)this.objectFieldOffset(var1);
}
/** @deprecated */
@Deprecated
public Object staticFieldBase(Class<?> var1) {
Field[] var2 = var1.getDeclaredFields();
for(int var3 = 0; var3 < var2.length; ++var3) {
if (Modifier.isStatic(var2[var3].getModifiers())) {
return this.staticFieldBase(var2[var3]);
}
}
return null;
}
public native long staticFieldOffset(Field var1);
public native long objectFieldOffset(Field var1);
public native Object staticFieldBase(Field var1);
public native boolean shouldBeInitialized(Class<?> var1);
public native void ensureClassInitialized(Class<?> var1);
public native int arrayBaseOffset(Class<?> var1);
public native int arrayIndexScale(Class<?> var1);
public native int addressSize();
public native int pageSize();
public native Class<?> defineClass(String var1, byte[] var2, int var3, int var4, ClassLoader var5, ProtectionDomain var6);
public native Class<?> defineAnonymousClass(Class<?> var1, byte[] var2, Object[] var3);
public native Object allocateInstance(Class<?> var1) throws InstantiationException;
/** @deprecated */
@Deprecated
public native void monitorEnter(Object var1);
/** @deprecated */
@Deprecated
public native void monitorExit(Object var1);
/** @deprecated */
@Deprecated
public native boolean tryMonitorEnter(Object var1);
public native void throwException(Throwable var1);
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
public native Object getObjectVolatile(Object var1, long var2);
public native void putObjectVolatile(Object var1, long var2, Object var4);
public native int getIntVolatile(Object var1, long var2);
public native void putIntVolatile(Object var1, long var2, int var4);
public native boolean getBooleanVolatile(Object var1, long var2);
public native void putBooleanVolatile(Object var1, long var2, boolean var4);
public native byte getByteVolatile(Object var1, long var2);
public native void putByteVolatile(Object var1, long var2, byte var4);
public native short getShortVolatile(Object var1, long var2);
public native void putShortVolatile(Object var1, long var2, short var4);
public native char getCharVolatile(Object var1, long var2);
public native void putCharVolatile(Object var1, long var2, char var4);
public native long getLongVolatile(Object var1, long var2);
public native void putLongVolatile(Object var1, long var2, long var4);
public native float getFloatVolatile(Object var1, long var2);
public native void putFloatVolatile(Object var1, long var2, float var4);
public native double getDoubleVolatile(Object var1, long var2);
public native void putDoubleVolatile(Object var1, long var2, double var4);
public native void putOrderedObject(Object var1, long var2, Object var4);
public native void putOrderedInt(Object var1, long var2, int var4);
public native void putOrderedLong(Object var1, long var2, long var4);
public native void unpark(Object var1);
public native void park(boolean var1, long var2);
public native int getLoadAverage(double[] var1, int var2);
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
public final long getAndAddLong(Object var1, long var2, long var4) {
long var6;
do {
var6 = this.getLongVolatile(var1, var2);
} while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));
return var6;
}
public final int getAndSetInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var4));
return var5;
}
public final long getAndSetLong(Object var1, long var2, long var4) {
long var6;
do {
var6 = this.getLongVolatile(var1, var2);
} while(!this.compareAndSwapLong(var1, var2, var6, var4));
return var6;
}
public final Object getAndSetObject(Object var1, long var2, Object var4) {
Object var5;
do {
var5 = this.getObjectVolatile(var1, var2);
} while(!this.compareAndSwapObject(var1, var2, var5, var4));
return var5;
}
public native void loadFence();
public native void storeFence();
public native void fullFence();
private static void throwIllegalAccessError() {
throw new IllegalAccessError();
}
static {
registerNatives();
Reflection.registerMethodsToFilter(Unsafe.class, new String[]{"getUnsafe"});
theUnsafe = new Unsafe();
ARRAY_BOOLEAN_BASE_OFFSET = theUnsafe.arrayBaseOffset(boolean[].class);
ARRAY_BYTE_BASE_OFFSET = theUnsafe.arrayBaseOffset(byte[].class);
ARRAY_SHORT_BASE_OFFSET = theUnsafe.arrayBaseOffset(short[].class);
ARRAY_CHAR_BASE_OFFSET = theUnsafe.arrayBaseOffset(char[].class);
ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset(int[].class);
ARRAY_LONG_BASE_OFFSET = theUnsafe.arrayBaseOffset(long[].class);
ARRAY_FLOAT_BASE_OFFSET = theUnsafe.arrayBaseOffset(float[].class);
ARRAY_DOUBLE_BASE_OFFSET = theUnsafe.arrayBaseOffset(double[].class);
ARRAY_OBJECT_BASE_OFFSET = theUnsafe.arrayBaseOffset(Object[].class);
ARRAY_BOOLEAN_INDEX_SCALE = theUnsafe.arrayIndexScale(boolean[].class);
ARRAY_BYTE_INDEX_SCALE = theUnsafe.arrayIndexScale(byte[].class);
ARRAY_SHORT_INDEX_SCALE = theUnsafe.arrayIndexScale(short[].class);
ARRAY_CHAR_INDEX_SCALE = theUnsafe.arrayIndexScale(char[].class);
ARRAY_INT_INDEX_SCALE = theUnsafe.arrayIndexScale(int[].class);
ARRAY_LONG_INDEX_SCALE = theUnsafe.arrayIndexScale(long[].class);
ARRAY_FLOAT_INDEX_SCALE = theUnsafe.arrayIndexScale(float[].class);
ARRAY_DOUBLE_INDEX_SCALE = theUnsafe.arrayIndexScale(double[].class);
ARRAY_OBJECT_INDEX_SCALE = theUnsafe.arrayIndexScale(Object[].class);
ADDRESS_SIZE = theUnsafe.addressSize();
}
}看到 unsafe 直接调用native c 接口方法。
但是在sun.misc 下面也有Lock 方法：
源码代码：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package sun.misc;
public class Lock {
private boolean locked = false;
public Lock() {
}
public final synchronized void lock() throws InterruptedException {
while(this.locked) {
this.wait();
}
this.locked = true;
}
public final synchronized void unlock() {
this.locked = false;
this.notifyAll();
}
}不过实现不是cas，而是synchronized.