Java中的ReentrantLock

Java中的ReentrantLock基本功能与synchronized代码块相当，但是提供了一些高级特性。

首先来看一下ReentrantLock的基本使用：

public class LockTest {

    ReentrantLock mLock = new ReentrantLock();

    int num = 0;

    Runnable mRunnableOne = new Runnable() {
        @Override
        public void run() {
            mLock.lock();
            System.out.println("ThreadOne: start");
            try {
                for (int m = 0; m < Integer.MAX_VALUE; m++) {
                    num++;
                }
                System.out.println("ThreadOne: over");
            } finally {
                mLock.unlock();
            }
        }
    };

    Runnable mRunnableTwo = new Runnable() {
        @Override
        public void run() {
            mLock.lock();
            System.out.println(num);
            mLock.unlock();
        }
    };

    public static void main(String[] args) {
        LockTest test = new LockTest();
        Thread a = new Thread(test.mRunnableOne);
        Thread b = new Thread(test.mRunnableTwo);

        a.start();
        b.start();
    }
}

在这段程序中，我们定义了两个Runnable，第一个线程获得锁，循环将变量num值+1，第二个线程尝试获得锁，并打印num的值。
运行这段程序，会输出：

ThreadOne: start
ThreadOne: over
2147483647

可以看到线程2一开始无法获得锁，需等待线程1执行完毕后，才可打印num的数值。

下面来看看ReentrantLock的一些特性。
1.ReentrantLock允许同一个线程多次调用lock接口获取锁，每调用一次计数便加一。因此在释放锁的时候必须调用相应多次数unlock才能释放锁：

package study.threadtest;

import java.util.concurrent.locks.ReentrantLock;

public class LockTest {
    ......

    Runnable mRunnableOne = new Runnable() {
        @Override
        public void run() {
            mLock.lock();
            mLock.lock();
            System.out.println("ThreadOne: start");
            try {
                for (int m = 0; m < Integer.MAX_VALUE; m++) {
                    num++;
                }
                System.out.println("ThreadOne: over");
            } finally {
                mLock.unlock();
            }
        }
    };
    ......

}

我们对线程一做一下修改，多调用一次lock接口。程序运行后输出：

ThreadOne: start
ThreadOne: over

可见由于调用unlock次数不够，线程2并不能获取到锁，因此无法输出打印。

2.synchronized在获取不到锁的时候会一直阻塞，直到这个线程获取到锁才继续执行。由上面的例子可以看到ReentrantLock的lock接口也是这样的，旦ReentrantLock同时还提供了一个tryLock接口，它允许线程尝试获取锁，如果无法获得锁，就执行其他的逻辑，而不是一直阻塞等待。

public class LockTest {

    ReentrantLock mLock = new ReentrantLock();

    int num = 0;

    Runnable mRunnableOne = new Runnable() {
        @Override
        public void run() {
            mLock.lock();
            System.out.println("ThreadOne: start");
            try {
                for (int m = 0; m < Integer.MAX_VALUE; m++) {
                    num++;
                }
                System.out.println("ThreadOne: over");
            } finally {
                mLock.unlock();
            }
        }
    };

    Runnable mRunnableTwo = new Runnable() {
        @Override
        public void run() {
            if (mLock.tryLock()) {
                System.out.println(num);
                mLock.unlock();
            } else {
                System.out.println("ThreadTwo: Do something else");
            }
        }
    };

    public static void main(String[] args) {
        LockTest test = new LockTest();
        Thread a = new Thread(test.mRunnableOne);
        Thread b = new Thread(test.mRunnableTwo);

        a.start();
        b.start();
    }
}

我们在线程2中使用tryLock尝试获取锁，如果不能获取，则执行else中的逻辑。运行代码可以看到输出：

ThreadOne: start
ThreadTwo: Do something else
ThreadOne: over