Lock lock = new ReentrantLock(); //這里可以是自己實(shí)現(xiàn)Lock接口的實(shí)現(xiàn)類，也可以是jdk提供的同步組件
lock.lock();//一般不將鎖的獲取放在try語句塊中，因?yàn)槿绻l(fā)生異常，在拋出異常的同時(shí)，也會導(dǎo)致鎖的無故釋放
try {
}finally {
    lock.unlock(); //放在finally代碼塊中，保證鎖一定會被釋放
}

public interface Lock {

    /**
     * 獲取鎖，調(diào)用該方法的線程會獲取鎖，當(dāng)獲取到鎖之后會從該方法但會
     */
    void lock();

    /**
     * 可響應(yīng)中斷。即在獲取鎖的過程中可以中斷當(dāng)前線程
     */
    void lockInterruptibly() throws InterruptedException;

    /**
     * 嘗試非阻塞的獲取鎖，調(diào)用該方法之后會立即返回，如果獲取到鎖就返回true否則返回false
     */
    boolean tryLock();

    /**
     * 超時(shí)的獲取鎖，下面的三種情況會返回
     * ①當(dāng)前線程在超時(shí)時(shí)間內(nèi)獲取到了鎖
     * ②當(dāng)前線程在超時(shí)時(shí)間內(nèi)被中斷
     * ③超時(shí)時(shí)間結(jié)束，返回false
     */
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    /**
     * 釋放鎖
     */
    void unlock();

    /**
     * 獲取等待通知組件，該組件和當(dāng)前鎖綁定，當(dāng)前線程只有獲取到了鎖才能調(diào)用組件的wait方法，調(diào)用該方法之后會釋放鎖
     */
    Condition newCondition();
}

import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
 public class TestCR {
     Lock lock = new ReentrantLock();
     
     void m1(){
         try{
             lock.lock(); // 加鎖
             for(int i = 0; i < 4; i++){
                 TimeUnit.SECONDS.sleep(1);
                 System.out.println("m1() method " + i);
             }
             m2(); //在釋放鎖之前，調(diào)用m2方法
         }catch(InterruptedException e){
             e.printStackTrace();
         }finally{
             lock.unlock(); // 解鎖
         }
     }
     
     void m2(){
         lock.lock();
         System.out.println("m2() method");
         lock.unlock();
     }
     
     public static void main(String[] args) {
         final TestCR t = new TestCR();
         new Thread(new Runnable() {
             @Override
             public void run() {
                 t.m1();
             }
         }).start();
 
         new Thread(new Runnable() {
             @Override
             public void run() {
                 t.m2();
             }
         }).start();
     }
 }

abstract static class Sync extends AbstractQueuedSynchronizer {
    /**
     * 創(chuàng)建非公平鎖的方法
     */
    abstract void lock();

    /**
     * 執(zhí)行非公平的tryLock。 tryAcquire實(shí)現(xiàn)于
     * 子類，但兩者都需要tryf方法的非公平嘗試。
     */
    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();//獲取當(dāng)前線程
        int c = getState(); //獲取當(dāng)前同步狀態(tài)的值
        if (c == 0) { //如果當(dāng)前的同步狀態(tài)還沒有被任何線程獲取
            if (compareAndSetState(0, acquires)) { //就更新同步狀態(tài)的值，因?yàn)橐呀?jīng)有線程獲取到同步裝填
                setExclusiveOwnerThread(current);//設(shè)置同步狀態(tài)的線程擁有者為當(dāng)前獲取的線程
                return true;
            }
        }
        else if (current == getExclusiveOwnerThread()) {//增加再次獲取同步狀態(tài)的處理邏輯
            int nextc = c + acquires; //如果再次嘗試獲取同步狀態(tài)的線程就是當(dāng)前已經(jīng)占有同步狀態(tài)的線程,那么就更新同步狀態(tài)的值(進(jìn)行增加操作)
            if (nextc < 0) // 對同步狀態(tài)的值進(jìn)行非法判斷
                throw new Error("Maximum lock count exceeded");
            setState(nextc); //更新state的值
            return true;
        }
        return false;
    }

    /**
     * 釋放同步狀態(tài)的處理邏輯
     */
    protected final boolean tryRelease(int releases) {
        int c = getState() - releases; //對同一線程而言，就是減去相應(yīng)的獲取次數(shù)
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false; //返回值
        if (c == 0) { //只有該線程將獲取的次數(shù)全部釋放之后，才會返回true，并且將當(dāng)前同步狀態(tài)的持有者設(shè)置為null
            free = true;
            setExclusiveOwnerThread(null);
        }
        setState(c); //更新state
        return free;
    }

        /**
         * 判斷當(dāng)前同步狀態(tài)的持有者線程
         */
    protected final boolean isHeldExclusively() {
        return getExclusiveOwnerThread() == Thread.currentThread();
    }

    final ConditionObject newCondition() {
        return new ConditionObject();
    }

        /**
         * 返回當(dāng)前持有者線程
         */
    final Thread getOwner() {
        return getState() == 0 ? null : getExclusiveOwnerThread();
    }

        /**
         * 返回持有同步狀態(tài)的線程獲取次數(shù)
         */
    final int getHoldCount() {
        return isHeldExclusively() ? getState() : 0;
    }

        /**
         * 判斷當(dāng)前是否有線程獲取到同步狀態(tài)(根據(jù)state值進(jìn)行判斷)
         */
    final boolean isLocked() {
        return getState() != 0;
    }

    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
    }
}

//非公平鎖實(shí)現(xiàn)
static final class NonfairSync extends Sync {

    /**
     * 以CAS方式原子的更新state的值
     */
    final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

    /**
     * 非公平鎖的實(shí)現(xiàn)是直接調(diào)用Sync的nonfairTryAcquire方法
     */
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

static final class FairSync extends Sync {

    final void lock() {
        acquire(1); //調(diào)用AQS的模板方法實(shí)現(xiàn)鎖的獲取
    }

    /**
     * 公平鎖的處理邏輯
     */
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread(); //獲取當(dāng)前線程
        int c = getState(); //獲取當(dāng)前同步狀態(tài)的值
        if (c == 0) { //當(dāng)前同步狀態(tài)沒有被任何線程獲取的時(shí)候
            if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) { //這個(gè)點(diǎn)的主要處理邏輯就是：hasQueuedPredecessors判斷當(dāng)前線程所在的結(jié)點(diǎn)是否含有前驅(qū)結(jié)點(diǎn),　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 如果返回值為true表示有前驅(qū)結(jié)點(diǎn)，那么當(dāng)前線程需要等待前驅(qū)結(jié)點(diǎn)中的線程獲取并釋放鎖之后才能獲取鎖，保證了FIFO
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        else if (current == getExclusiveOwnerThread()) { //支持重入的邏輯，和非公平鎖的實(shí)現(xiàn)原理相同
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }
}
//hasQueuedPredecessors的處理邏輯
public final boolean hasQueuedPredecessors() {
    // 簡單而言，就是判斷當(dāng)前線程是否有前驅(qū)結(jié)點(diǎn)
    // 當(dāng)前結(jié)點(diǎn)含有前驅(qū)結(jié)點(diǎn)時(shí)候返回true；當(dāng)前結(jié)點(diǎn)為頭結(jié)點(diǎn)揮著隊(duì)列為空的時(shí)候返回false
    Node t = tail; // Read fields in reverse initialization order
    Node h = head;
    Node s;
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import org.junit.Test;

public class TestReentrantLock {
    /**
     * ReentrantLock的構(gòu)造方法
     * public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();}
     */
    private Lock fairLock = new ReentrantLock2(true);
    private Lock unFairLock = new ReentrantLock2(false);

    @Test
    public void testFair() throws InterruptedException {
        testLock(fairLock); //測試公平鎖
    }

    @Test
    public void testUnFair() throws InterruptedException {
        testLock(unFairLock); //測試非公平鎖
    }

    private void testLock(Lock lock) throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Job(lock)) {
                public String toString() {
                        return getName();
                }
            };
            thread.setName(i+"");
            thread.start();
        }
        Thread.sleep(12000);
    }

    private static class Job extends Thread {
        private Lock lock;
        public Job(Lock lock) {
            this.lock = lock;
        }
        @Override
        public void run() {
            //兩次打印當(dāng)前線程和等待隊(duì)列中的Threads
            for (int i = 0; i < 2; i++) {
                lock.lock(); //獲取鎖
                try {
                    Thread.sleep(1000);
                    System.out.println("當(dāng)前線程=>" + Thread.currentThread().getName() + " " +
                            "等待隊(duì)列中的線程=>" + ((ReentrantLock2)lock).getQueuedThreads());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock(); //釋放鎖
                }
            }
        }

    }

    private static class ReentrantLock2 extends ReentrantLock {
        public ReentrantLock2(boolean fair) {
            super(fair);
        }
        public Collection<Thread> getQueuedThreads() { //逆序打印等待隊(duì)列中的線程
            List<Thread> list = new ArrayList<Thread>(super.getQueuedThreads());
            Collections.reverse(list);
            return list;
        }
    }


}

package cn.source.sync;

public class TestSync01 {
    private static int count = 0;
    private Object object = new Object();

    public void testSyn1() {
        //同步代碼塊（這里面是鎖臨界資源，即括號中的對象）
        synchronized (object) {
            System.out.println(Thread.currentThread().getName()
                +" count =" + count++);
        }
    }

    public void testSyn2() {
        //鎖當(dāng)前對象（相當(dāng)于普通同步方法）
        synchronized (this) {
            System.out.println(Thread.currentThread().getName()
                    +" count =" + count++);
        }
    }

    //普通同步方法：鎖當(dāng)前對象
    public synchronized void testSyn3() {
        System.out.println(Thread.currentThread().getName()
                +" count =" + count++);
    }

    //靜態(tài)同步方法，鎖的是當(dāng)前類型的類對象（即TestSync01.class）
    public static synchronized void testSyn4() {
        System.out.println(Thread.currentThread().getName()
                +" count =" + count++);
    }

    //下面的這種方式也是鎖當(dāng)前類型的類對象
    public static void testSyn5() {
        synchronized (TestSync01.class) {
            System.out.println(Thread.currentThread().getName()
                    +" count =" + count ++);
        }
    }
}