java多线程编程核心技术（学习笔记四 ）

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

编写两个线程同时去读取结果如下，读取时间一致，说明读取不互斥。

编写两个线程一个写入数据一个读取数据结果如下，读写时间不一致，说明读写互斥。

编写两个线程都去写入数据结果如下，写入时间不一致说明写写互斥。