第4章 Lock的使用
标签： Java多线程编程
《Java多线程编程核心技术》 个人笔记
第4章 Lock的使用
使用ReentrantLock类
使用ReentrantLock实现同步测试1使用Condition实现等待通知错误用法与解决正确使用Condition实现等待通知使用多个Condition实现通知部分线程错误用法使用多个Condition实现通知部分线程正确用法实现生产者消费者模式一对一交替打印实现生产者消费者模式多对多交替打印公平锁与非公平锁方法getHoldCountgetQueueLength和getWaitQueueLength的测试方法hasQueueThreadhasQueueThreads和hasWaiters的测试方法isFairisHeldByCurrentThread和isLocked的测试方法lockInterruptiblytryLock和tryLocklong timeout TimeUnit unit的测试方法awaitUninterruptibly的使用方法awaitUntil的使用使用Condition实现顺序执行 使用ReentrantReadWriteLock类
类ReentrantReadWriteLock的使用读读共享类ReentrantReadWriteLock的使用写写互斥类ReentrantReadWriteLock的使用读写互斥类ReentrantReadWriteLock的使用写读互斥
本章着重掌握以下2个知识点： 1. ReentrantLock类的使用 2. ReentrantReadWriteLock类的使用
使用ReentrantLock类
在Java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在JDK1.5中新增加了ReentrantLock类也能达到同样的效果，并且在扩展功能上也更加强大，比如具有嗅探锁定、多路分支通知功能。
使用ReentrantLock实现同步：测试1
public class MyService {
private Lock lock =
new ReentrantLock();
public void testMethod() {
lock.lock();
for (
int i =
0; i <
5; i++) {
System.out.println(
"ThreadName=" + Thread.currentThread().getName()
+ (
" " + (i +
1)));
}
lock.unlock();
}
}
public class MyThread extends Thread {
private MyService service;
public MyThread(MyService service) {
super();
this.service = service;
}
@Override
public void run() {
service.testMethod();
}
}
public class Run {
public static void main(String[] args) {
MyService service =
new MyService();
MyThread a1 =
new MyThread(service);
MyThread a2 =
new MyThread(service);
MyThread a3 =
new MyThread(service);
MyThread a4 =
new MyThread(service);
MyThread a5 =
new MyThread(service);
a1.start();
a2.start();
a3.start();
a4.start();
a5.start();
}
}
ThreadName=Thread-
0 1
ThreadName=Thread-
0 2
ThreadName=Thread-
0 3
ThreadName=Thread-
0 4
ThreadName=Thread-
0 5
ThreadName=Thread-
1 1
ThreadName=Thread-
1 2
ThreadName=Thread-
1 3
ThreadName=Thread-
1 4
ThreadName=Thread-
1 5
ThreadName=Thread-
2 1
ThreadName=Thread-
2 2
ThreadName=Thread-
2 3
ThreadName=Thread-
2 4
ThreadName=Thread-
2 5
ThreadName=Thread-
3 1
ThreadName=Thread-
3 2
ThreadName=Thread-
3 3
ThreadName=Thread-
3 4
ThreadName=Thread-
3 5
ThreadName=Thread-
4 1
ThreadName=Thread-
4 2
ThreadName=Thread-
4 3
ThreadName=Thread-
4 4
ThreadName=Thread-
4 5
使用Condition实现等待/通知：错误用法与解决
Condition类是JDK5中才出现的技术，使用它有更好的灵活性，比如可以实现多路通知功能，也就是在一个Lock对象里可以创建多个Condition（即对象监视器）实例，线程对象可以注册在指定的Condition中，从而可以有选择性地进行线程通知，在调度线程上更加灵活。
调用Condition对象的await()方法之前必须先调用lock.lock()获得同步监视器
调用Condition对象的await()，是执行当前任务的线程进入等待WAITING状态
正确使用Condition实现等待/通知
Object类中的wait()方法相当于Condition类中的await()方法Object类中的wait(long timeout)方法相当于Condition类中的await(long time, TimeUnit unit)方法Object类中的notify()方法相当于Condition类中的signal()方法Object类中的notifyAll()相当于Condition类中的signalAll()方法
使用多个Condition实现通知部分线程：错误用法
如果想单独唤醒部分线程，就有必要使用多个Condition对象了，也就是Condition对象可以唤醒部分指定线程，有助于提升程序运行效率。可以先对线程进行分组，然后唤醒指定组中的线程
使用多个Condition实现通知部分线程：正确用法
public class MyService {
private Lock lock =
new ReentrantLock();
public Condition conditionA = lock.newCondition();
public Condition conditionB = lock.newCondition();
public void awaitA() {
try {
lock.lock();
System.out.println(
"begin awaitA时间为 " + System.currentTimeMillis()
+
" ThreadName=" + Thread.currentThread().getName());
conditionA.await();
System.out.println(
" end awaitA时间为 " + System.currentTimeMillis()
+
" ThreadName=" + Thread.currentThread().getName());
}
catch (InterruptedException e) {
e.printStackTrace();
}
finally {
lock.unlock();
}
}
public void awaitB() {
try {
lock.lock();
System.out.println(
"begin awaitB时间为" + System.currentTimeMillis()
+
" ThreadName=" + Thread.currentThread().getName());
conditionB.await();
System.out.println(
" end awaitB时间为" + System.currentTimeMillis()
+
" ThreadName=" + Thread.currentThread().getName());
}
catch (InterruptedException e) {
e.printStackTrace();
}
finally {
lock.unlock();
}
}
public void signalAll_A() {
try {
lock.lock();
System.out.println(
" signalAll_A时间为" + System.currentTimeMillis()
+
" ThreadName=" + Thread.currentThread().getName());
conditionA.signalAll();
}
finally {
lock.unlock();
}
}
public void signalAll_B() {
try {
lock.lock();
System.out.println(
" signalAll_B时间为" + System.currentTimeMillis()
+
" ThreadName=" + Thread.currentThread().getName());
conditionB.signalAll();
}
finally {
lock.unlock();
}
}
}
public class ThreadA extends Thread {
private MyService service;
public ThreadA(MyService service) {
super();
this.service = service;
}
@Override
public void run() {
service.awaitA();
}
}
public class ThreadB extends Thread {
private MyService service;
public ThreadB(MyService service) {
super();
this.service = service;
}
@Override
public void run() {
service.awaitB();
}
}
public static void main(String[] args)
throws InterruptedException {
MyService service =
new MyService();
ThreadA a =
new ThreadA(service);
a.setName(
"A");
a.start();
ThreadB b =
new ThreadB(service);
b.setName(
"B");
b.start();
Thread.sleep(
6000);
service.signalAll_A();
}
}
begin awaitA时间为
1493952464356 ThreadName=A
begin awaitB时间为
1493952464357 ThreadName=B
signalAll_A时间为
1493952470356 ThreadName=main
end awaitA时间为
1493952470356 ThreadName=A
实现生产者/消费者模式：一对一交替打印
实现生产者/消费者模式：多对多交替打印
public class MyService {
private ReentrantLock lock =
new ReentrantLock();
private Condition condition = lock.newCondition();
private boolean hasValue =
false;
public void set() {
try {
lock.lock();
while (hasValue ==
true) {
System.out.println(
"有可能**连续");
condition.await();
}
System.out.println(
"打印**");
hasValue =
true;
condition.signalAll();
}
catch (InterruptedException e) {
e.printStackTrace();
}
finally {
lock.unlock();
}
}
public void get() {
try {
lock.lock();
while (hasValue ==
false) {
System.out.println(
"有可能--连续");
condition.await();
}
System.out.println(
"打印--");
hasValue =
false;
condition.signalAll();
}
catch (InterruptedException e) {
e.printStackTrace();
}
finally {
lock.unlock();
}
}
}
public class MyThreadA extends Thread {
private MyService myService;
public MyThreadA(MyService myService) {
super();
this.myService = myService;
}
@Override
public void run() {
for (
int i =
0; i < Integer.MAX_VALUE; i++) {
myService.set();
}
}
}
public class MyThreadB extends Thread {
private MyService myService;
public MyThreadB(MyService myService) {
super();
this.myService = myService;
}
@Override
public void run() {
for (
int i =
0; i < Integer.MAX_VALUE; i++) {
myService.get();
}
}
}
public class Run {
public static void main(String[] args)
throws InterruptedException {
MyService service =
new MyService();
MyThreadA[] threadA =
new MyThreadA[
10];
MyThreadB[] threadB =
new MyThreadB[
10];
for (
int i =
0; i <
10; i++) {
threadA[i] =
new MyThreadA(service);
threadB[i] =
new MyThreadB(service);
threadA[i].start();
threadB[i].start();
}
}
}
打印**
有可能**连续
打印--
有可能--连续
有可能--连续
有可能--连续
有可能--连续
有可能--连续
有可能--连续
打印**
有可能**连续
有可能**连续
有可能**连续
有可能**连续
有可能**连续
打印--
有可能--连续
有可能--连续
打印**
有可能**连续
…………
公平锁与非公平锁
锁Lock分为“公平锁”和“非公平锁”公平锁：线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序非公平锁：是一种获取锁的抢占机制，是随机获得锁的，这个方式可能造成某些线程一直获取不到锁，结果就是不公平了
public class Service {
private ReentrantLock
lock;
public Service(boolean isFair) {
super();
lock =
new ReentrantLock(isFair);
}
public void serviceMethod() {
try {
lock.
lock();
System.
out.println(
"ThreadName=" + Thread.currentThread().getName()
+
"获得锁定");
}
finally {
lock.unlock();
}
}
}
公平锁的特点：获取锁的顺序基本上呈有序的状态（但是貌似我看不出有序）非公平锁是乱序的
方法getHoldCount()、getQueueLength()和getWaitQueueLength()的测试
getHoldCount()查询当前线程保持此锁定的个数，也就是调用lock()方法的次数getQueueLength()返回正等待获取此锁定的线程估计数getWaitQueueLength()返回与此锁定相关的给定条件Condition的线程估计数
方法hasQueueThread()、hasQueueThreads()和hasWaiters()的测试
hasQueueThread()查询指定的线程是否正在等待获取此锁定hasQueueThreads()查询是否有线程正在等待获取此锁定hasWaiters()查询是否有线程正在等待与此锁定有关的condition条件
方法isFair()、isHeldByCurrentThread()和isLocked()的测试
isFair()判断是不是公平锁，默认情况下ReentrantLock类使用的是非公平锁isHeldByCurrentThread()方法查询当前线程是否保持此锁定isLocked()查询此锁定是否由任意线程保持
方法lockInterruptibly(),tryLock()和tryLock(long timeout, TimeUnit unit)的测试
lockInterruptibly()的作用是：如果当前线程未被中断，则获取锁定，如果已经被中断则出现异常tryLock()的作用是：仅在调用时锁定未被另一个线程保持的情况下，才获取该锁定tryLock(long timeout, TimeUnit unit)的作用是：如果锁定在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁定
方法awaitUninterruptibly()的使用
方法awaitUntil()的使用
使用Condition实现顺序执行
使用ReentrantReadWriteLock类
类ReentrantLock具有完全互斥排他的效果，即同一时间只有一个线程在执行ReentrantLock.lock()方法后面的任务。这样做虽然保证了实例变量的线程安全性，但效率却是非常低下的。所以在JDK中提供了一种读写锁ReentrantReadWriteLock类，使用它可以加速运行效率，在某些不需要操作实例变量的方法中，完全可以使用读写锁ReentrantReadWriteLock来提升该方法的代码运行速度。读写锁表示也有两个锁，一个读操作相关的锁，也称共享锁；另一个是写操作相关的锁，也叫排他锁。也就是多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。在没有线程Thread进行写入操作时，进行读取操作的多个线程都可以获取读锁，而进行写入操作的线程只有在获取写锁之后才能进行写入操作。即多个线程可以同时进行读取操作，但同一时刻只允许一个线程进行写操作
类ReentrantReadWriteLock的使用：读读共享
public class Service {
private ReentrantReadWriteLock lock =
new ReentrantReadWriteLock();
public void read() {
try {
try {
lock.readLock().lock();
System.out.println(
"获得读锁" + Thread.currentThread().getName()
+
" " + System.currentTimeMillis());
Thread.sleep(
10000);
}
finally {
lock.readLock().unlock();
}
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class ThreadA extends Thread {
private Service service;
public ThreadA(Service service) {
super();
this.service = service;
}
@Override
public void run() {
service.read();
}
}
public class ThreadB extends Thread {
private Service service;
public ThreadB(Service service) {
super();
this.service = service;
}
@Override
public void run() {
service.read();
}
}
public class Run {
public static void main(String[] args) {
Service service =
new Service();
ThreadA a =
new ThreadA(service);
a.setName(
"A");
ThreadB b =
new ThreadB(service);
b.setName(
"B");
a.start();
b.start();
}
}
类ReentrantReadWriteLock的使用：写写互斥
public class Service {
private ReentrantReadWriteLock
lock =
new ReentrantReadWriteLock();
public void write() {
try {
try {
lock.writeLock().
lock();
System.
out.println(
"获得写锁" + Thread.currentThread().getName()
+
" " + System.currentTimeMillis());
Thread.sleep(
10000);
}
finally {
lock.writeLock().unlock();
}
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
类ReentrantReadWriteLock的使用：读写互斥
public class Service {
private ReentrantReadWriteLock
lock =
new ReentrantReadWriteLock();
public void read() {
try {
try {
lock.readLock().
lock();
System.
out.println(
"获得读锁" + Thread.currentThread().getName()
+
" " + System.currentTimeMillis());
Thread.sleep(
10000);
}
finally {
lock.readLock().unlock();
}
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
public void write() {
try {
try {
lock.writeLock().
lock();
System.
out.println(
"获得写锁" + Thread.currentThread().getName()
+
" " + System.currentTimeMillis());
Thread.sleep(
10000);
}
finally {
lock.writeLock().unlock();
}
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
类ReentrantReadWriteLock的使用：写读互斥
