java多线程 ReentrantLock

本章对ReentrantLock包进行基本介绍，这一章主要对ReentrantLock进行概括性的介绍，内容包括：
ReentrantLock介绍
ReentrantLock函数列表
ReentrantLock示例
在后面的两章，会分别介绍ReentrantLock的两个子类(公平锁和非公平锁)的实现原理。
转载请注明出处：http://www.cnblogs.com/skywang12345/p/3496101.html

 

ReentrantLock介绍

ReentrantLock是一个可重入的互斥锁，又被称为“独占锁”。

顾名思义，ReentrantLock锁在同一个时间点只能被一个线程锁持有；而可重入的意思是，ReentrantLock锁，可以被单个线程多次获取。
ReentrantLock分为“公平锁”和“非公平锁”。它们的区别体现在获取锁的机制上是否公平。“锁”是为了保护竞争资源，防止多个线程同时操作线程而出错，ReentrantLock在同一个时间点只能被一个线程获取(当某线程获取到“锁”时，其它线程就必须等待)；ReentraantLock是通过一个FIFO的等待队列来管理获取该锁所有线程的。在“公平锁”的机制下，线程依次排队获取锁；而“非公平锁”在锁是可获取状态时，不管自己是不是在队列的开头都会获取锁。

 

ReentrantLock函数列表

// 创建一个 ReentrantLock ，默认是“非公平锁”。
ReentrantLock()
// 创建策略是fair的 ReentrantLock。fair为true表示是公平锁，fair为false表示是非公平锁。
ReentrantLock(boolean fair)

// 查询当前线程保持此锁的次数。
int getHoldCount()
// 返回目前拥有此锁的线程，如果此锁不被任何线程拥有，则返回 null。
protected Thread getOwner()
// 返回一个 collection，它包含可能正等待获取此锁的线程。
protected Collection<Thread> getQueuedThreads()
// 返回正等待获取此锁的线程估计数。
int getQueueLength()
// 返回一个 collection，它包含可能正在等待与此锁相关给定条件的那些线程。
protected Collection<Thread> getWaitingThreads(Condition condition)
// 返回等待与此锁相关的给定条件的线程估计数。
int getWaitQueueLength(Condition condition)
// 查询给定线程是否正在等待获取此锁。
boolean hasQueuedThread(Thread thread)
// 查询是否有些线程正在等待获取此锁。
boolean hasQueuedThreads()
// 查询是否有些线程正在等待与此锁有关的给定条件。
boolean hasWaiters(Condition condition)
// 如果是“公平锁”返回true，否则返回false。
boolean isFair()
// 查询当前线程是否保持此锁。
boolean isHeldByCurrentThread()
// 查询此锁是否由任意线程保持。
boolean isLocked()
// 获取锁。
void lock()
// 如果当前线程未被中断，则获取锁。
void lockInterruptibly()
// 返回用来与此 Lock 实例一起使用的 Condition 实例。
Condition newCondition()
// 仅在调用时锁未被另一个线程保持的情况下，才获取该锁。
boolean tryLock()
// 如果锁在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁。
boolean tryLock(long timeout, TimeUnit unit)
// 试图释放此锁。
void unlock()

可重入锁指在同一个线程中，可以重入的锁。当然，当这个线程获得锁后，其他线程将等待这个锁被释放后，才可以获得这个锁。

构造器：ReentrantLock(boolean fair): 布尔值用来表示，创建的这个锁是公平的锁，还是自由竞争的锁。所谓公平的锁，是指，各个希望获得所得线程获得锁的顺序是按到达的顺序获得，还是自由竞争获得。

通常的使用方法：

 

ReentrantLock lock = new ReentrantLock(); // not a fair lock
lock.lock();

try {

    // synchronized do something

} finally {
    lock.unlock();
}

 

一个典型的例子：先测试可重入锁的重入特性，然后创建3个线程，每个线程启动后，尝试获取锁，获取锁后对共享数据 + 1，然后显示chula

package base2;

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

public class TestLock {
    private ReentrantLock lock = null;
    // 用于线程同步访问的共享数据
    public int data = 100;

    public TestLock() {
        // 创建一个自由竞争的可重入锁
        lock = new ReentrantLock();
    }

    public static void main(String[] args) {

        TestLock tester = new TestLock();

        // 测试可重入，函数testReentry() 同一线程中,可重复获取锁,执行获取锁后，显示信息的功能
        tester.testReentry();
        // 能执行到这里而不阻塞，表示锁可重入
        tester.testReentry();
        // 再次重入
        tester.testReentry();

        // 释放重入测试的锁，要按重入的数量解锁，否则其他线程无法获取该锁。
        tester.getLock().unlock();
        tester.getLock().unlock();
        tester.getLock().unlock();

        // 启动3个线程测试在锁保护下的共享数据data的访问
        tester.test();
    }

    public ReentrantLock getLock() {
        return lock;
    }

    public void test() {
        new Thread(new workerThread(this)).start();
        new Thread(new workerThread(this)).start();
        new Thread(new workerThread(this)).start();
    }

    public void testReentry() {
        lock.lock();

        Calendar now = Calendar.getInstance();

        System.out.println(now.getTime() + " " + Thread.currentThread()
                + " get lock.");
    }

    // 线程调用的方法
    public void testRun() throws Exception {
        // 加锁
        lock.lock();

        Calendar now = Calendar.getInstance();
        try {
            // 获取锁后显示 当前时间 当前调用线程 共享数据的值（并使共享数据 + 1）
            System.out.println(now.getTime() + " " + Thread.currentThread()
                    + " accesses the data " + data++);

            // 模拟其他处理，这里假设休眠一下
            Thread.sleep(500);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }
    }
}

// 工作线程，调用TestServer.testRun
class workerThread implements Runnable {

    private TestLock tester = null;

    public workerThread(TestLock testLock) {
        this.tester = testLock;
    }

    public void run() {
        // 循环调用，尝试加锁，并对共享数据+1，然后显示出来
        while (true) {
            try {
                // 调用tester.testRun()
                tester.testRun();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}