淺談Java並發中ReentrantLock鎖應該怎麼用

package com.shockang.study.java.concurrent.lock;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();
    public static int i = 0;

    @Override
    public void run() {
        for (int j = 0; j < 10000000; j++) {
            lock.lock();
            lock.lock();
            try {
                i++;
            } finally {
                lock.unlock();
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockDemo tl = new ReentrantLockDemo();
        Thread t1 = new Thread(tl);
        Thread t2 = new Thread(tl);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

package com.shockang.study.java.concurrent.lock;

import java.util.concurrent.locks.ReentrantLock;

public class IntLock implements Runnable {
    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();
    int lock;

    /**
     * 控制加鎖順序，方便構造死鎖
     *
     * @param lock
     */
    public IntLock(int lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            if (lock == 1) {
                lock1.lockInterruptibly();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
                lock2.lockInterruptibly();
            } else {
                lock2.lockInterruptibly();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                }
                lock1.lockInterruptibly();
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock1.isHeldByCurrentThread())
                lock1.unlock();
            if (lock2.isHeldByCurrentThread())
                lock2.unlock();
            System.out.println(Thread.currentThread().getId() + ":線程退出");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        IntLock r1 = new IntLock(1);
        IntLock r2 = new IntLock(2);
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
        Thread.sleep(1000);
        //中斷其中一個線程
        t2.interrupt();
    }
}

package com.shockang.study.java.concurrent.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class TimeLock implements Runnable {
    public static ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        try {
            if (lock.tryLock(5, TimeUnit.SECONDS)) {
                Thread.sleep(6000);
            } else {
                System.out.println("get lock failed");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        TimeLock tl = new TimeLock();
        Thread t1 = new Thread(tl);
        Thread t2 = new Thread(tl);
        t1.start();
        t2.start();
    }
}

package com.shockang.study.java.concurrent.lock;

import java.util.concurrent.locks.ReentrantLock;

public class TryLock implements Runnable {
    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();
    int lock;

    public TryLock(int lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        if (lock == 1) {
            while (true) {
                if (lock1.tryLock()) {
                    try {
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                        }
                        if (lock2.tryLock()) {
                            try {
                                System.out.println(Thread.currentThread()
                                        .getId() + ":My Job done");
                                return;
                            } finally {
                                lock2.unlock();
                            }
                        }
                    } finally {
                        lock1.unlock();
                    }
                }
            }
        } else {
            while (true) {
                if (lock2.tryLock()) {
                    try {
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                        }
                        if (lock1.tryLock()) {
                            try {
                                System.out.println(Thread.currentThread()
                                        .getId() + ":My Job done");
                                return;
                            } finally {
                                lock1.unlock();
                            }
                        }
                    } finally {
                        lock2.unlock();
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TryLock r1 = new TryLock(1);
        TryLock r2 = new TryLock(2);
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
    }
}

/**
 * 使用給定的公平策略創建一個 ReentrantLock 的實例。
 *
 * @param fair 如果此鎖應使用公平排序策略為 true
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

package com.shockang.study.java.concurrent.lock;

import java.util.concurrent.locks.ReentrantLock;

public class FairLock implements Runnable {
    public static ReentrantLock fairLock = new ReentrantLock(true);

    @Override
    public void run() {
        while (true) {
            try {
                fairLock.lock();
                System.out.println(Thread.currentThread().getName() + " 獲得鎖");
            } finally {
                fairLock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        FairLock r1 = new FairLock();
        Thread t1 = new Thread(r1, "Thread_t1");
        Thread t2 = new Thread(r1, "Thread_t2");
        t1.start();
        t2.start();
    }
}

/**
 * 一種可重入互斥鎖，其基本行為和語義與使用同步方法和語句訪問的隱式監視鎖（即 synchronized）相同，但具有擴展功能。 
 * 
 * 可重入鎖屬於上次成功鎖定但尚未解鎖它的線程。
 * 
 * 當鎖不屬於另一個線程時，調用鎖的線程將返回，並成功獲取鎖。
 * 
 * 如果當前線程已經擁有鎖，則該方法將立即返回。這可以使用 isHeldByCurrentThread 和 getHoldCount 方法進行檢查。 
 * 
 * 此類的構造函數接受可選的公平性參數。
 * 
 * 當設置為 true 時，在競爭狀態下，鎖有利於向等待時間最長的線程授予訪問權限。否則，此鎖不保證任何特定的訪問順序。
 * 
 * 使用由多線程訪問的公平鎖的程序可能顯示較低的總吞吐量
 * 
 * （即，較慢；通常比使用默認設置的要慢得多，但是在獲得鎖和保證不饑餓的時間上有較小的差異。
 * 
 * 但是請註意，鎖的公平性並不能保證線程調度的公平性。
 * 
 * 因此，使用公平鎖的多個線程中的一個線程可以連續多次獲得公平鎖，而其他活動線程則沒有進行並且當前沒有持有該鎖。
 * 
 * 還要註意，untimed tryLock() 方法不支持公平性設置。
 * 
 * 如果鎖可用，即使其他線程正在等待，它也會成功。 
 * 
 * 建議的做法是總是在調用之後立即使用try塊鎖定，最典型的是在構建之前/之後，例如：
 * 
 * class X {
 *   private final ReentrantLock lock = new ReentrantLock();
 *   // ...
 *
 *   public void m() {
 *     lock.lock();  // block until condition holds
 *     try {
 *       // ... method body
 *     } finally {
 *       lock.unlock()
 *     }
 *   }
 * }}
 * 
 * 除瞭實現鎖接口之外，這個類還定義瞭許多公共和受保護的方法來檢查鎖的狀態。
 * 
 * 其中一些方法隻對 instrumentation 和 monitoring 有用。 
 * 
 * 此類的序列化與內置鎖的行為相同：反序列化的鎖處於未鎖定狀態，而與序列化時的狀態無關。 
 * 
 * 此鎖最多支持同一線程的2147483647個遞歸鎖。嘗試超過此限制會導致鎖定方法拋出錯誤。
 * 
 * @since 1.5
 * @author Doug Lea
 */
public class ReentrantLock implements Lock, java.io.Serializable