[Java] java.util.concurrent.locks

List<String> list = new ArrayList<String>();
...
private boolean threadA(){
	synchronized(list){
		list.add("Lock in A");
	}
}
...
private boolean threadB(){
	synchronized(list){
		list.add("Lock in B");
	}
}

Lock reentrantLock = new ReentrantLock();
List<String> list = new ArrayList<String>();

private boolean A(){
	try{
		reentrantLock.lock();
		list.add("Lock");
	}
	finally{
		reentrantLock.unlock();
	}
}

private boolean B(){
	try{
		reentrantLock.lock();
		list.add("Lock");
	}
	finally{
		reentrantLock.unlock();
	}
}

 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 {
	abstract void lock();
	..... 생략 
}

/**
 * Creates an instance of {@code ReentrantLock}.
 * This is equivalent to using {@code ReentrantLock(false)}.
 */
public ReentrantLock() {
	//비공정 방식으로 초기화 
    sync = new NonfairSync();
}

/**
 * Creates an instance of {@code ReentrantLock} with the
 * given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
	//boolean 방식에 따라 초기화 
    sync = fair ? new FairSync() : new 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))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1); //내부에서 tryAcquire를 호출합니다.
    }
    //대기중인 스레드가 있는지 검사하여 락을 획득할수 있는지를 돌려줍니다. nonfairTryAcquire에 관하여 아래 한번더 설명이 되어 있습니다.
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

/**
 * Sync object for fair locks
 */
static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {
        acquire(1); //내부에서 tryAcquire를 호출합니다.
    }

    /**
     * Fair version of tryAcquire.  Don't grant access unless
     * recursive call or no waiters or is first.
     */
     // NonFairSync와 거의 일치하지만 차이점은 hasQueuedPredecessors()라는 검사를 한다는 것입니다. 
     	그래서 해당 큐가 락을 획득 할 첫번째 스레드인지를 검사해줍니다. 
    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;
    }
}

public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}
/**
 * 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();
    // 현재 락을 얻은 스레드가 있는지 검사하고 없으면 true를 반환합니다.
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 락을 얻은 쓰레드가 자신일 경우 true를 반환합니다. 
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    // 그 이외에는 false를 반환합니다. 
    return false;
}

// 대기중인 큐가 있는지 검사합니다.
public final boolean hasQueuedThreads() {
    return sync.hasQueuedThreads();
}
//...sync내의 메서드 queue의 해드와 테일이 같은지를 판별해서 대기중 쓰레드의 존재 여부를 리턴해줍니다.
public final boolean hasQueuedThreads() {
    return head != tail;
}
// 조건에 맞는 대기중인 큐를 리턴해줍니다.
protected Collection<Thread> getWaitingThreads(Condition condition) {
if (condition == null)
    throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
    throw new IllegalArgumentException("not owner");
return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
}

protected final Collection<Thread> getWaitingThreads() {
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    ArrayList<Thread> list = new ArrayList<Thread>();
    for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
        if (w.waitStatus == Node.CONDITION) {
            Thread t = w.thread;
            if (t != null)
                list.add(t);
        }
    }
    return list;
}