public class SynchronizedObject {
    // 必须将共享资源设置为私有(不能被外部直接访问),否则synchronize方法将失去意义
    private Resource resource;
    // 所有的synchronize方法共享同一个锁,锁定的其实是这个对象本身
    synchronized void f() {/*访问resource*/}
    synchronized void g() {/*访问resource*/}
}

synchronized (syncObject) {
    // 对于一个syncObject,同一时间只有一个线程能进入这段代码
}

package java.util.concurrent.locks;
public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

// 获取锁
lock.lock();
try {

    ......
} finally {
    // 释放锁
    lock.unlock();  
}

void lockInterruptibly() throws InterruptedException;

boolean tryLock();

boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

public class ReentrantLock implements Lock, java.io.Serializable {
    abstract static class Sync extends AbstractQueuedSynchronizer {
        // 关键方法,非公平地试着获取锁
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            // 当前锁是空闲的
            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;
            }
            return false;
        }
    }
    static final class NonfairSync extends Sync {...}
    static final class FairSync extends Sync {
        // 关键方法,公平地获取锁
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                // 判断同步队列中是否线程比当前线程更早地请求获取锁,
                // 如果有则返回false,即要等待前驱线程获取并释放锁之后才能获取锁
                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 ReentrantLock() {
        sync = new NonfairSync();
    }
    // -- 通过构造函数决定锁是不是公平的
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
}

public interface ReadWriteLock {
    // 获得读锁
    Lock readLock();
    // 获得写锁
    Lock writeLock();
}

public class ReentrantReadWriteLock
        implements ReadWriteLock, java.io.Serializable {
}