java 高并发 ReentrantLock -- 可重入的锁

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/uptake/article/details/83762409
ReentrantLock -- 可重入的锁
可重入锁指在同一个线程中,可以重入的锁。当然,当这个线程获得锁后,其他线程将等待这个锁被释放后,才可以获得这个锁。
构造器:ReentrantLock(boolean fair): 布尔值用来表示,创建的这个锁是公平的锁,还是自由竞争的锁。所谓公平的锁,是指,各个希望获得所得线程获得锁的顺序是按到达的顺序获得,还是自由竞争获得。
通常的使用方法:
ReentrantLock lock = new ReentrantLock(); // not a fair lock
lock.lock();

try {

// synchronized do something

} finally {
lock.unlock();
}
一个典型的例子:先测试可重入锁的重入特性,然后创建3个线程,每个线程启动后,尝试获取锁,获取锁后对共享数据 + 1,然后显示chula

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();
}
}
}
}

程序运行结果:
Tue Jan 24 13:41:45 CST 2006 Thread[main,5,main] get lock.
Tue Jan 24 13:41:46 CST 2006 Thread[main,5,main] get lock.
Tue Jan 24 13:41:46 CST 2006 Thread[main,5,main] get lock.
Tue Jan 24 13:41:46 CST 2006 Thread[Thread-0,5,main] accesses the data 100
Tue Jan 24 13:41:46 CST 2006 Thread[Thread-1,5,main] accesses the data 101
Tue Jan 24 13:41:47 CST 2006 Thread[Thread-2,5,main] accesses the data 102
Tue Jan 24 13:41:47 CST 2006 Thread[Thread-2,5,main] accesses the data 103
Tue Jan 24 13:41:48 CST 2006 Thread[Thread-2,5,main] accesses the data 104
Tue Jan 24 13:41:48 CST 2006 Thread[Thread-0,5,main] accesses the data 105
Tue Jan 24 13:41:49 CST 2006 Thread[Thread-0,5,main] accesses the data 106
Tue Jan 24 13:41:49 CST 2006 Thread[Thread-0,5,main] accesses the data 107
Tue Jan 24 13:41:50 CST 2006 Thread[Thread-0,5,main] accesses the data 108
Tue Jan 24 13:41:50 CST 2006 Thread[Thread-1,5,main] accesses the data 109
Tue Jan 24 13:41:51 CST 2006 Thread[Thread-1,5,main] accesses the data 110

前三行表示main线程,重入3次获得该锁。
第四行表示Thread-0线程,先获得锁,使共享数据+1,然后显示信息,然后释放锁。
第五行表示Thread-1线程,获得锁,使共享数据+1,然后显示信息,然后释放锁。

由程序输出的信息可以知道,各线程获得锁的顺序,是自由竞争的结果。
如果将 lock = new ReentrantLock(); 改为:lock = new ReentrantLock(true);
将看到如下的结果:
Tue Jan 24 13:47:29 CST 2006 Thread[main,5,main] get lock.
Tue Jan 24 13:47:30 CST 2006 Thread[main,5,main] get lock.
Tue Jan 24 13:47:30 CST 2006 Thread[main,5,main] get lock.
Tue Jan 24 13:47:30 CST 2006 Thread[Thread-0,5,main] accesses the data 100
Tue Jan 24 13:47:30 CST 2006 Thread[Thread-1,5,main] accesses the data 101
Tue Jan 24 13:47:31 CST 2006 Thread[Thread-2,5,main] accesses the data 102
Tue Jan 24 13:47:31 CST 2006 Thread[Thread-0,5,main] accesses the data 103
Tue Jan 24 13:47:32 CST 2006 Thread[Thread-1,5,main] accesses the data 104
Tue Jan 24 13:47:32 CST 2006 Thread[Thread-2,5,main] accesses the data 105
Tue Jan 24 13:47:33 CST 2006 Thread[Thread-0,5,main] accesses the data 106
Tue Jan 24 13:47:33 CST 2006 Thread[Thread-1,5,main] accesses the data 107
Tue Jan 24 13:47:34 CST 2006 Thread[Thread-2,5,main] accesses the data 108
Tue Jan 24 13:47:34 CST 2006 Thread[Thread-0,5,main] accesses the data 109
Tue Jan 24 13:47:35 CST 2006 Thread[Thread-1,5,main] accesses the data 110
可以看到各线程获得锁的顺序,是按线程获得锁的顺序。
(注: new Thread(new workerThread()).start(); 并不是表示线程启动的顺序,就是线程获得锁的顺序)java 高并发 ReentrantLock -- 可重入的锁
展开阅读全文

没有更多推荐了,返回首页