java基础－－Java 5.0多线程编程（3）

Lock 接口

ReentrantLock 是 Lock 的具体类， Lock 提供了以下一些方法：

• lock(): 请求锁定，如果锁已被别的线程锁定，调用此方法的线程被阻断进入等待状态。
• tryLock() ：如果锁没被别的线程锁定，进入锁定状态，并返回 true 。若锁已被锁定，返回 false ，不进入等待状态。此方法还可带时间参数，如果锁在方法执行时已被锁定，线程将继续等待规定的时间，若还不行才返回 false 。
• unlock() ：取消锁定，需要注意的是 Lock 不会自动取消，编程时必须手动解锁。

代码：

// 生成一个锁 Lock lock = new ReentrantLock(); public void accessProtectedResource() {   lock.lock(); // 取得锁定   try {     // 对共享资源进行操作   } finally {     // 一定记着把锁取消掉，锁本身是不会自动解锁的     lock.unlock();   } }

ReadWriteLock 接口

   为了提高效率有些共享资源允许同时进行多个读的操作，但只允许一个写的操作，比如一个文件，只要其内容不变可以让多个线程同时读，不必做排他的锁定，排他的锁定只有在写的时候需要，以保证别的线程不会看到数据不完整的文件。 ReadWriteLock 可满足这种需要。 ReadWriteLock 内置两个 Lock ，一个是读的 Lock ，一个是写的 Lock 。多个线程可同时得到读的 Lock ，但只有一个线程能得到写的 Lock ，而且写的 Lock 被锁定后，任何线程都不能得到 Lock 。 ReadWriteLock 提供的方法有：

• readLock(): 返回一个读的 lock
• writeLock(): 返回一个写的 lock, 此 lock 是排他的。

ReadWriteLock 的例子：

public class FileOperator{       // 初始化一个 ReadWriteLock       ReadWriteLock lock = new ReentrantReadWriteLock(); public String read() {       // 得到 readLock 并锁定             Lock readLock = lock.readLock();              readLock.lock();             try {                   // 做读的工作                   return "Read something";             } finally {                  readLock.unlock();             }       }       public void write(String content) {       // 得到 writeLock 并锁定             Lock writeLock = lock.writeLock();             writeLock.lock();             try {                   // 做读的工作             } finally {                  writeLock.unlock();             }       } }

 

   需要注意的是 ReadWriteLock 提供了一个高效的锁定机理，但最终程序的运行效率是和程序的设计息息相关的，比如说如果读的线程和写的线程同时在等待，要考虑是先发放读的 lock 还是先发放写的 lock 。如果写发生的频率不高，而且快，可以考虑先给写的 lock 。还要考虑的问题是如果一个写正在等待读完成，此时一个新的读进来，是否要给这个新的读发锁，如果发了，可能导致写的线程等很久。等等此类问题在编程时都要给予充分的考虑。

Condition 接口：

   有时候线程取得 lock 后需要在一定条件下才能做某些工作，比如说经典的 Producer 和 Consumer 问题， Consumer 必须在篮子里有苹果的时候才能吃苹果，否则它必须暂时放弃对篮子的锁定，等到 Producer 往篮子里放了苹果后再去拿来吃。而 Producer 必须等到篮子空了才能往里放苹果，否则它也需要暂时解锁等 Consumer 把苹果吃了才能往篮子里放苹果。在 Java 5.0 以前，这种功能是由 Object 类的 wait(), notify() 和 notifyAll() 等方法实现的，在 5.0 里面，这些功能集中到了 Condition 这个接口来实现， Condition 提供以下方法：

• await() ：使调用此方法的线程放弃锁定，进入睡眠直到被打断或被唤醒。
• signal(): 唤醒一个等待的线程
• signalAll() ：唤醒所有等待的线程

Condition 的例子：

public class Basket {      Lock lock = new ReentrantLock(); // 产生 Condition 对象      Condition produced = lock.newCondition();      Condition consumed = lock.newCondition();      boolean available = false;            public void produce() throws InterruptedException {            lock.lock();            try {                  if(available){                     consumed.await(); // 放弃 lock 进入睡眠                    }                  /* 生产苹果 */                  System.out.println("Apple produced.");                  available = true;                  produced.signal(); // 发信号唤醒等待这个 Condition 的线程            } finally {                  lock.unlock();            }      }           public void consume() throws InterruptedException {            lock.lock();            try {                  if(!available){                        produced.await();// 放弃 lock 进入睡眠                    }                  /* 吃苹果 */                  System.out.println("Apple consumed.");                  available = false;                  consumed.signal();// 发信号唤醒等待这个 Condition 的线程            } finally {                  lock.unlock();            }      }      }

ConditionTester:

public class ConditionTester {             public static void main(String[] args) throws InterruptedException{ final Basket basket = new Basket(); // 定义一个 producer             Runnable producer = new Runnable() {                   public void run() {                         try {                               basket.produce();                          } catch (InterruptedException ex) {                               ex.printStackTrace();                         }                   } }; // 定义一个 consumer             Runnable consumer = new Runnable() {                   public void run() {                         try {                               basket.consume();                         } catch (InterruptedException ex) {                               ex.printStackTrace();                         }                   } }; // 各产生 10 个 consumer 和 producer             ExecutorService service = Executors.newCachedThreadPool();             for(int i=0; i < 10; i++)                   service.submit(consumer);             Thread.sleep(2000);             for(int i=0; i<10; i++)                   service.submit(producer);             service.shutdown();       }      }

5: Synchronizer：同步装置

   Java 5.0 里新加了 4 个协调线程间进程的同步装置，它们分别是 Semaphore, CountDownLatch, CyclicBarrier 和 Exchanger.

Semaphore:

   用来管理一个资源池的工具， Semaphore 可以看成是个通行证，线程要想从资源池拿到资源必须先拿到通行证， Semaphore 提供的通行证数量和资源池的大小一致。如果线程暂时拿不到通行证，线程就会被阻断进入等待状态。以下是一个例子：

public class Pool {        ArrayList pool = null;       Semaphore pass = null;       public Pool(int size){             // 初始化资源池             pool = new ArrayList();             for(int i=0; i                   pool.add("Resource "+i);             }              //Semaphore 的大小和资源池的大小一致             pass = new Semaphore(size);       }       public String get() throws InterruptedException{             // 获取通行证 , 只有得到通行证后才能得到资源             pass.acquire();             return getResource();       }       public void put(String resource){             // 归还通行证，并归还资源             pass.release();             releaseResource(resource);       }      private synchronized String getResource() {             String result = pool.get(0);             pool.remove(0);             System.out.println("Give out "+result);             return result;       }       private synchronized void releaseResource(String resource) {             System.out.println("return "+resource);             pool.add(resource);       } }

SemaphoreTest:

public class SemaphoreTest {       public static void main(String[] args){             final Pool aPool = new Pool(2);             Runnable worker = new Runnable() {                   public void run() {                         String resource = null;                          try {                               // 取得 resource                               resource = aPool.get();                         } catch (InterruptedException ex) {                               ex.printStackTrace();                         }                         // 用 resource 做工作                         System.out.println("I worked on "+resource);                         // 归还 resource                         aPool.put(resource);                   }             };             ExecutorService service = Executors.newCachedThreadPool();             for(int i=0; i<20; i++){                   service.submit(worker);             }             service.shutdown();       }     }