4.1 ReentrantLock类
在Jav多线程中,可以使用synchronized类来实现线程之间的同步互斥,JDK1.5新增加了ReentrantLock类也能实现同样的功能,并且在扩展功能上也更加强大,比如具有嗅探锁定、多路分支通知等功能。
4.1.1 ReentrantLock的基本使用
ReentrantLock对象的调用lock()方法获取锁,调用unlock()方法释放锁。调用lock.lock()代码的线程就持有了“对象监视器”,其他线程只有等待锁被释放时再次争抢,效和使用synchronized关键字一样。
package p4;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyService1 {
private Lock lock=new ReentrantLock();
public void testMethods() {
try {
lock.lock();
for(int i=0;i<5;i++) {
System.out.println("ThreadName="+Thread.currentThread().getName()+" "+i);
}
}catch(Exception e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
4.1.2使用Condition来实现等待/通知
关键字synchronized与wait()和notify()/notifyAll()方法相结合可以实现等待/通知模式,类ReentrantLock也可以实现同样的功能,但需要借助condition对象。一个Lock对象里面可以创建多个condition实例,线程对象可以注册在指定的condition中,从而可以有选择性地进行线程通知,在调度线程上更加灵活。
synchronized就相当于整个Lock对象中只有一个单一的Condition对象,所有的线程都注册在它一个对象的身上。线程开始notifyAll()时,需要通知所有的WAITING对象,没有选择权,会出现相当大的效率问题。
必须在condition.await()方法前调用lock.lock()代码获得同步监视器,否则会抛出错误。
package p4;
public class Run2 {
public static void main(String[] args) {
MyService2 myService2=new MyService2();
ThreadA thread1=new ThreadA(myService2);
thread1.start();
ThreadB thread2=new ThreadB(myService2);
thread2.start();
}
}
package p4;
public class ThreadB extends Thread {
private MyService2 myService2;
public ThreadB(MyService2 myService2) {
super();
this.myService2 = myService2;
}
public void run() {
myService2.signal();
}
}
package p4;
public class ThreadA extends Thread {
private MyService2 myService2;
public ThreadA(MyService2 myService2) {
super();
this.myService2 = myService2;
}
public void run() {
myService2.await();
}
}
package p4;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyService2 {
private Lock lock=new ReentrantLock();
private Condition condition=lock.newCondition();
public void await() {
try {
lock.lock();
System.out.println("awit时间为"+System.currentTimeMillis());
condition.await();
}
catch(InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void signal() {
try {
lock.lock();
System.out.println("signal时间为"+System.currentTimeMillis());
condition.signalAll();;
}
catch(Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
4.1.3使用多个Condition实现通知部分线程
通过lock来创建两个condition对象,分别通过不同condition对象的await和signalall来控制线程同步。
package p4;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyService3 {
private Lock lock=new ReentrantLock();
private Condition conditionA=lock.newCondition();
private Condition conditionB=lock.newCondition();
public void awaitA() {
try {
lock.lock();
System.out.println("Thread "+Thread.currentThread().getName()+" begin awaitA时间为"+System.currentTimeMillis());
conditionA.await();
System.out.println("Thread "+Thread.currentThread().getName()+" end awaitA时间为"+System.currentTimeMillis());
}
catch(InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void signalA() {
try {
lock.lock();
System.out.println("Thread "+Thread.currentThread().getName()+" begin siginalA时间为"+System.currentTimeMillis());
conditionA.signalAll();
System.out.println("Thread "+Thread.currentThread().getName()+" end siginalA时间为"+System.currentTimeMillis());
}
catch(Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void awaitB() {
try {
lock.lock();
System.out.println("Thread "+Thread.currentThread().getName()+" begin awaitB时间为"+System.currentTimeMillis());
conditionB.await();
System.out.println("Thread "+Thread.currentThread().getName()+" end awaitB时间为"+System.currentTimeMillis());
}
catch(InterruptedException e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void signalB() {
try {
lock.lock();
System.out.println("Thread "+Thread.currentThread().getName()+" begin siginalB时间为"+System.currentTimeMillis());
conditionB.signalAll();
System.out.println("Thread "+Thread.currentThread().getName()+" end siginalB时间为"+System.currentTimeMillis());
}
catch(Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
线程执行awaitA()方法
package p4;
public class Thread21 extends Thread {
private MyService3 myService3;
public Thread21(MyService3 myService3) {
super();
this.myService3 = myService3;
}
public void run() {
myService3.awaitA();
}
}
线程执行awaitB()方法
package p4;
public class Thread22 extends Thread {
private MyService3 myService3;
public Thread22(MyService3 myService3) {
super();
this.myService3 = myService3;
}
public void run() {
myService3.awaitB();
}
}
主函数调用线程A的signalA方法来单独唤醒线程A
package p4;
public class Run3 {
public static void main(String[] args) {
MyService3 myService3=new MyService3();
Thread21 thread21=new Thread21(myService3);
thread21.setName("A");
thread21.start();
Thread22 thread22=new Thread22(myService3);
thread22.setName("B");
thread22.start();
myService3.signalA();
}
}
运行结果
4.1.4公平锁与非公平锁
锁Lock分为“公平锁”与“非公平锁”,公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配,即先来先得的FIFO先进先出顺序。而非公平锁就是一种获取锁的抢占机制,是随机获得锁的,和公平锁不一样的就是先来的不一定先得到锁,这个方式可能造成某些线程一直拿不到锁,结果就是不公平的了。
具体实现:
private ReentrantLock lock=new ReentrantLock(isFair)
isFair =true 为公平锁,isFair=false为非公平锁
公平锁的运行结果基本是呈有序的状态,非公平锁的运行结果基本上是乱序的。
4.1.5锁的一些方法
1)int getHoldCount ():查询当前线程保持此锁定的个数,也就是调用lock()方法的次数。
2)int getQueueLength():返回正等待获取此锁定的线程估计数。比如有5个线程,1个线程首先执行await()方法,name在调用getQueueLength()方法后返回值是4,说明有4个线程同时在等待lock的释放。
3)int getWaitQueueLength(Condition condition):作用是返回等待与此锁定相关的给定条件condition的线程估计数,比如有5个线程,每个线程都执行了同一个Condition对象的await()方法,则调用getWaitQueueLength(Condition condition)方法时返回值为5。
4)boolean hasQueueThread(Thread thread):查询指定线程是否正在等待获取此锁定
5)boolean hasQueueThreads():查询是否有线程正在等待获取此锁定
6)boolean hasWaiters(Condition condition):查询是否有线程正在等待与此锁定有关的condition条件
7)isFair():判断该锁是否为公平锁
8)isHeldByCurrentThread():查询当前线程是否保持此锁定
9)isLocked():查询此锁定是否由任意线程保持
10)lockInterruptibly():如果当前线程未被中断,则获取锁定,如果已经被中断则抛出异常。 lock.lock换为lock.lockInterruptibly
11)tryLock():调用时锁定未被另一个线程保持的情况下才获取该锁
4.2 使用ReentrantReadWriteLock类
读写锁可以加快运行效率,读写锁有两个锁,一个是读操作相关的锁,也称为共享锁;另一个是写操作相关的锁,也叫排他锁。多个读锁之间不互斥,读锁与写锁互斥,写锁与写锁互斥。在没有线程Thread进行写入操作时,进行读取操作的多个Thread都可以获取读锁,而进行写入操作的Thread只有获取写锁后才能进行写入操作。即多个Thread可以同时进行读取操作,只是同一时刻只允许一个Thread进行写入操作。
package p4;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class MyService4 {
private ReentrantReadWriteLock lock=new ReentrantReadWriteLock();
public void read() {
try {
lock.readLock().lock();
System.out.println("获取读锁 "+Thread.currentThread().getName()+" "+System.currentTimeMillis());
Thread.sleep(1000);
}catch(Exception e) {
e.printStackTrace();
}finally {
lock.readLock().unlock();
}
}
public void write() {
try {
lock.writeLock().lock();
System.out.println("获取写锁 "+Thread.currentThread().getName()+" "+System.currentTimeMillis());
Thread.sleep(1000);
}catch(Exception e) {
e.printStackTrace();
}finally {
lock.writeLock().unlock();
}
}
}
编写两个线程同时去读取结果如下,读取时间一致,说明读取不互斥。
编写两个线程一个写入数据一个读取数据结果如下,读写时间不一致,说明读写互斥。
编写两个线程都去写入数据结果如下,写入时间不一致说明写写互斥。