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;

    /**
     * 控制加鎖順序，方便構(gòu)造死鎖
     *
     * @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);
        //中斷其中一個(gè)線程
        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();
    }
}

/**
 * 使用給定的公平策略創(chuàng)建一個(gè) ReentrantLock 的實(shí)例。
 *
 * @param fair 如果此鎖應(yīng)使用公平排序策略為 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();
    }
}

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