java 多线程 作用域_Java多线程并发编程(互斥锁Reentrant Lock)

Java 中的锁通常分为两种：

通过关键字 synchronized 获取的锁，我们称为同步锁，上一篇有介绍到：Java 多线程并发编程 Synchronized 关键字。

java.util.concurrent(JUC)包里的锁，如通过继承接口 Lock 而实现的 ReentrantLock(互斥锁)，继承 ReadWriteLock 实现的 ReentrantReadWriteLock(读写锁)。

本篇主要介绍 ReentrantLock(互斥锁)。

ReentrantLock(互斥锁)

ReentrantLock 互斥锁，在同一时间只能被一个线程所占有，在被持有后并未释放之前，其他线程若想获得该锁只能等待或放弃。

ReentrantLock 互斥锁是可重入锁，即某一线程可多次获得该锁。

公平锁 and 非公平锁

public ReentrantLock() {

sync = new NonfairSync();

}

public ReentrantLock(boolean fair) {

sync = fair ? new FairSync() : new NonfairSync();

}

由 ReentrantLock 的构造函数可见，在实例化 ReentrantLock 的时候我们可以选择实例化一个公平锁或非公平锁，而默认会构造一个非公平锁。

公平锁与非公平锁区别在于竞争锁时的有序与否。公平锁可确保有序性(FIFO 队列)，非公平锁不能确保有序性(即使也有 FIFO 队列)。

然而，公平是要付出代价的，公平锁比非公平锁要耗性能，所以在非必须确保公平的条件下，一般使用非公平锁可提高吞吐率。所以 ReentrantLock 默认的构造函数也是“不公平”的。

一般使用

DEMO1：

public class Test {

private static class Counter {

private ReentrantLock mReentrantLock = new ReentrantLock();

public void count() {

mReentrantLock.lock();

try {

for (int i = 0; i < 6; i++) {

System.out.println(Thread.currentThread().getName() + "， i = " + i);

}

} finally {

// 必须在 finally 释放锁

mReentrantLock.unlock();

}

}

}

private static class MyThread extends Thread {

private Counter mCounter;

public MyThread(Counter counter) {

mCounter = counter;

}

@Override

public void run() {

super.run();

mCounter.count();

}

}

public static void main(String[] var0) {

Counter counter = new Counter();

// 注：myThread1 和 myThread2 是调用同一个对象 counter

MyThread myThread1 = new MyThread(counter);

MyThread myThread2 = new MyThread(counter);

myThread1.start();

myThread2.start();

}

}

DEMO1 输出：

Thread-0， i = 0

Thread-0， i = 1

Thread-0， i = 2

Thread-0， i = 3

Thread-0， i = 4

Thread-0， i = 5

Thread-1， i = 0

Thread-1， i = 1

Thread-1， i = 2

Thread-1， i = 3

Thread-1， i = 4

Thread-1， i = 5

DEMO1 仅使用了 ReentrantLock 的 lock 和 unlock 来提现一般锁的特性，确保线程的有序执行。此种场景 synchronized 也适用。

锁的作用域

DEMO2：

public class Test {

private static class Counter {

private ReentrantLock mReentrantLock = new ReentrantLock();

public void count() {

for (int i = 0; i < 6; i++) {

mReentrantLock.lock();

// 模拟耗时，突出线程是否阻塞

try{

Thread.sleep(100);

System.out.println(Thread.currentThread().getName() + "， i = " + i);

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

// 必须在 finally 释放锁

mReentrantLock.unlock();

}

}

}

public void doOtherThing(){

for (int i = 0; i < 6; i++) {

// 模拟耗时，突出线程是否阻塞

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);

}

}

}

public static void main(String[] var0) {

final Counter counter = new Counter();

new Thread(new Runnable() {

@Override

public void run() {

counter.count();

}

}).start();

new Thread(new Runnable() {

@Override

public void run() {

counter.doOtherThing();

}

}).start();

}

}

DEMO2 输出：

Thread-0， i = 0

Thread-1 doOtherThing， i = 0

Thread-0， i = 1

Thread-1 doOtherThing， i = 1

Thread-0， i = 2

Thread-1 doOtherThing， i = 2

Thread-0， i = 3

Thread-1 doOtherThing， i = 3

Thread-0， i = 4

Thread-1 doOtherThing， i = 4

Thread-0， i = 5

Thread-1 doOtherThing， i = 5

DEMO3:

public class Test {

private static class Counter {

private ReentrantLock mReentrantLock = new ReentrantLock();

public void count() {

for (int i = 0; i < 6; i++) {

mReentrantLock.lock();

// 模拟耗时，突出线程是否阻塞

try{

Thread.sleep(100);

System.out.println(Thread.currentThread().getName() + "， i = " + i);

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

// 必须在 finally 释放锁

mReentrantLock.unlock();

}

}

}

public void doOtherThing(){

mReentrantLock.lock();

try{

for (int i = 0; i < 6; i++) {

// 模拟耗时，突出线程是否阻塞

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);

}

}finally {

mReentrantLock.unlock();

}

}

}

public static void main(String[] var0) {

final Counter counter = new Counter();

new Thread(new Runnable() {

@Override

public void run() {

counter.count();

}

}).start();

new Thread(new Runnable() {

@Override

public void run() {

counter.doOtherThing();

}

}).start();

}

}

DEMO3 输出：

Thread-0， i = 0

Thread-0， i = 1

Thread-0， i = 2

Thread-0， i = 3

Thread-0， i = 4

Thread-0， i = 5

Thread-1 doOtherThing， i = 0

Thread-1 doOtherThing， i = 1

Thread-1 doOtherThing， i = 2

Thread-1 doOtherThing， i = 3

Thread-1 doOtherThing， i = 4

Thread-1 doOtherThing， i = 5

结合 DEMO2 和 DEMO3 输出可见，锁的作用域在于 mReentrantLock，因为所来自于 mReentrantLock。

可终止等待

DEMO4：

public class Test {

static final int TIMEOUT = 300;

private static class Counter {

private ReentrantLock mReentrantLock = new ReentrantLock();

public void count() {

try{

//lock() 不可中断

mReentrantLock.lock();

// 模拟耗时，突出线程是否阻塞

for (int i = 0; i < 6; i++) {

long startTime = System.currentTimeMillis();

while (true) {

if (System.currentTimeMillis() - startTime > 100)

break;

}

System.out.println(Thread.currentThread().getName() + "， i = " + i);

}

} finally {

// 必须在 finally 释放锁

mReentrantLock.unlock();

}

}

public void doOtherThing(){

try{

//lockInterruptibly() 可中断，若线程没有中断，则获取锁

mReentrantLock.lockInterruptibly();

for (int i = 0; i < 6; i++) {

// 模拟耗时，突出线程是否阻塞

long startTime = System.currentTimeMillis();

while (true) {

if (System.currentTimeMillis() - startTime > 100)

break;

}

System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);

}

} catch (InterruptedException e) {

System.out.println(Thread.currentThread().getName() + " 中断 ");

}finally {

// 若当前线程持有锁，则释放

if(mReentrantLock.isHeldByCurrentThread()){

mReentrantLock.unlock();

}

}

}

}

public static void main(String[] var0) {

final Counter counter = new Counter();

new Thread(new Runnable() {

@Override

public void run() {

counter.count();

}

}).start();

Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

counter.doOtherThing();

}

});

thread2.start();

long start = System.currentTimeMillis();

while (true){

if (System.currentTimeMillis() - start > TIMEOUT) {

// 若线程还在运行，尝试中断

if(thread2.isAlive()){

System.out.println(" 不等了，尝试中断 ");

thread2.interrupt();

}

break;

}

}

}

}

DEMO4 输出：

Thread-0， i = 0

Thread-0， i = 1

Thread-0， i = 2

不等了，尝试中断

Thread-1 中断

Thread-0， i = 3

Thread-0， i = 4

Thread-0， i = 5

线程 thread2 等待 300ms 后 timeout，中断等待成功。

若把 TIMEOUT 改成 3000ms，输出结果：(正常运行)

Thread-0， i = 0

Thread-0， i = 1

Thread-0， i = 2

Thread-0， i = 3

Thread-0， i = 4

Thread-0， i = 5

Thread-1 doOtherThing， i = 0

Thread-1 doOtherThing， i = 1

Thread-1 doOtherThing， i = 2

Thread-1 doOtherThing， i = 3

Thread-1 doOtherThing， i = 4

Thread-1 doOtherThing， i = 5

定时锁

DEMO5：

public class Test {

static final int TIMEOUT = 3000;

private static class Counter {

private ReentrantLock mReentrantLock = new ReentrantLock();

public void count() {

try{

//lock() 不可中断

mReentrantLock.lock();

// 模拟耗时，突出线程是否阻塞

for (int i = 0; i < 6; i++) {

long startTime = System.currentTimeMillis();

while (true) {

if (System.currentTimeMillis() - startTime > 100)

break;

}

System.out.println(Thread.currentThread().getName() + "， i = " + i);

}

} finally {

// 必须在 finally 释放锁

mReentrantLock.unlock();

}

}

public void doOtherThing(){

try{

//tryLock(long timeout, TimeUnit unit) 尝试获得锁

boolean isLock = mReentrantLock.tryLock(300, TimeUnit.MILLISECONDS);

System.out.println(Thread.currentThread().getName() + " isLock:" + isLock);

if(isLock){

for (int i = 0; i < 6; i++) {

// 模拟耗时，突出线程是否阻塞

long startTime = System.currentTimeMillis();

while (true) {

if (System.currentTimeMillis() - startTime > 100)

break;

}

System.out.println(Thread.currentThread().getName() + " doOtherThing， i = " + i);

}

}else{

System.out.println(Thread.currentThread().getName() + " timeout");

}

} catch (InterruptedException e) {

System.out.println(Thread.currentThread().getName() + " 中断 ");

}finally {

// 若当前线程持有锁，则释放

if(mReentrantLock.isHeldByCurrentThread()){

mReentrantLock.unlock();

}

}

}

}

public static void main(String[] var0) {

final Counter counter = new Counter();

new Thread(new Runnable() {

@Override

public void run() {

counter.count();

}

}).start();

Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

counter.doOtherThing();

}

});

thread2.start();

}

}

DEMO5 输出：

Thread-0， i = 0

Thread-0， i = 1

Thread-0， i = 2

Thread-1 isLock:false

Thread-1 timeout

Thread-0， i = 3

Thread-0， i = 4

Thread-0， i = 5

tryLock() 尝试获得锁，tryLock(long timeout, TimeUnit unit) 在给定的 timeout 时间内尝试获得锁，若超时，则不带锁往下走，所以必须加以判断。

ReentrantLock or synchronized

ReentrantLock 、synchronized 之间如何选择？

ReentrantLock 在性能上 比 synchronized 更胜一筹。

ReentrantLock 需格外小心，因为需要显式释放锁，lock() 后记得 unlock()，而且必须在 finally 里面，否则容易造成死锁。

synchronized 隐式自动释放锁，使用方便。

ReentrantLock 扩展性好，可中断锁，定时锁，自由控制。

synchronized 一但进入阻塞等待，则无法中断等待。