Java5.0多线程编程

[size=large]
Lock接口

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

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

//生成一个锁

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 来源：www.examda.com
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();

      }     

}

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

      }    

}

[/size]