Thread之ReentrantLock

重入锁ReentrantLock是Lock接口的实现，ReentrantReadWriteLock是ReadWriteLock的实现。重入锁ReentrantLock的作用是，实现同一线程对同一把锁的重复加锁。重入锁分为公平锁和非公平锁，公平锁获取锁采用FIFO原则，不会出现“饥饿”线程，但会降低效率，相反，非公平锁的持有线程在释放锁之后，会大概率地再次持有锁，因而减少了线程切换的成本，提高了效率，增大了吞吐量。

模型：

lock.lock();
try {
    //工作逻辑
} finally {
lock.unlock();
}

测试实例

实例中ReentrantLock2扩展了ReentrantLock，增加了获取同步线程的方法，采用逆序的方法将线程逆向排序。在测试线程中打印了持有锁的线程和同步线程的名称。

package reentrantlock;

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

import org.junit.Test;

public class FairAndUnfairLock {
    private static Lock fairLock = new ReentrantLock2(true);
    private static Lock unfairLock = new ReentrantLock2(false);

     @Test
    public void fair() {
         System.out.println("公平锁测试：");
        testLock(fairLock);
    }

    @Test
    public void unfair() {
        System.out.println("非公平锁测试：");
        testLock(unfairLock);
    }

    public void testLock(Lock lock) {
        Thread[] threads = new Thread[5];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(new Job(lock), "Job-" + i);
            threads[i].start();
        }
        for (int i = 0; i < threads.length; i++) {
            try {
                threads[i].join();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    private static class Job implements Runnable {
        private Lock lock;

        public Job(Lock lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            printThreads(((ReentrantLock2) lock).getQueuedThreads());
            printThreads(((ReentrantLock2) lock).getQueuedThreads());
        }

        private void printThreads(Collection<Thread> queuedThreads) {
            lock.lock();
            try {
                System.out.print("Lock by [ " + Thread.currentThread().getName() + " ], Waiting by [ ");
                for (Thread thread : queuedThreads) {
                    System.out.print(thread.getName() + " ");
                }
                System.out.println("]");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();

            }
        }

    }

    private static class ReentrantLock2 extends ReentrantLock {
        public ReentrantLock2(boolean fair) {
            super(fair);
        }

        public Collection<Thread> getQueuedThreads() {
            ArrayList<Thread> threadList = new ArrayList<Thread>(super.getQueuedThreads());
            Collections.reverse(threadList);
            return threadList;
        }
    }
}

测试结果

从测试结果可知，持有非公平锁的线程一般连续获得锁两次，公平锁的线程按照线程在同步队列中的顺序以此获得锁。

非公平锁测试：
Lock by [ Job-0 ], Waiting by [ ]
Lock by [ Job-0 ], Waiting by [ Job-1 Job-2 Job-3 Job-4 ]
Lock by [ Job-1 ], Waiting by [ ]
Lock by [ Job-1 ], Waiting by [ Job-2 Job-3 Job-4 ]
Lock by [ Job-2 ], Waiting by [ Job-1 ]
Lock by [ Job-3 ], Waiting by [ Job-1 Job-2 ]
Lock by [ Job-3 ], Waiting by [ Job-4 Job-2 ]
Lock by [ Job-4 ], Waiting by [ Job-1 Job-2 Job-3 ]
Lock by [ Job-4 ], Waiting by [ Job-2 ]
Lock by [ Job-2 ], Waiting by [ Job-4 ]
公平锁测试：
Lock by [ Job-0 ], Waiting by [ ]
Lock by [ Job-1 ], Waiting by [ ]
Lock by [ Job-2 ], Waiting by [ Job-1 ]
Lock by [ Job-3 ], Waiting by [ Job-1 Job-2 ]
Lock by [ Job-4 ], Waiting by [ Job-1 Job-2 Job-3 ]
Lock by [ Job-0 ], Waiting by [ Job-2 Job-3 Job-4 ]
Lock by [ Job-1 ], Waiting by [ Job-2 Job-3 Job-4 Job-0 ]
Lock by [ Job-2 ], Waiting by [ Job-3 Job-4 Job-0 Job-1 ]
Lock by [ Job-3 ], Waiting by [ Job-4 Job-0 Job-1 Job-2 ]
Lock by [ Job-4 ], Waiting by [ Job-0 Job-1 Job-2 Job-3 ]