JAVA并发框架ReentrantLock与Condition

     同步代码与同步代码块可以实现多线程的同步，JAVA并发框架提供另外了一个框架，它也能实现多线程的同步，即是Lock和Condition，Condition和Lock是配合在一起使用，从字面意思上看，Condition是条件锁，有了锁，为什么要引用条件锁呢？原因有两个：

     1.对一个共享资源有读和写的能力，如果读线程或写线程获取了Lock的权力，即有能力进入，但是如果里面没有内容，读也没有用，如果空间已满了，写也写不了，所有还得有条件去判断一下，是不是线程要等待了；

     2.提供一种多线程之间的通信机制，类似wait()和nofity()的原理。

     看一个例子，就会明白了，还是实现上次的那个生产者和消费者的例子。

     我们假设有一个篮子，最多可以放10个苹果，有多个人可以放苹果，也有多个人可以拿走苹果。

public   class  Apple {

         private  String  appName  ;

         public    Apple(String  appName  ){

                this  . appName  = appName  ;

       }

       

         public  String ToString(){

                return   this  . appName  ;

       }

}

public   class  Bascket {

       List  bascket =  new  ArrayList(10);

       

       Lock  lock  =  new  ReentrantLock();

         //条件锁与Lock是相关的

       Condition  noEmptity  = lock  .newCondition();

       Condition  isFull  =  lock .newCondition();

       

         public   void  put(Apple  app )  throws  InterruptedException{

                //获取锁

                lock .lock();

                try  {

                  if  ( bascket  .size()>=10){

                         //等待

                         isFull .await();

                 }

                  bascket .add(  app );

                  //唤醒其它等待线程

                  noEmptity  .signalAll();

              }

                finally  {

                       lock .unlock();

              }

       }

       

         public  Apple take()  throws  InterruptedException{

                lock .lock();

              Apple  apple ;

                try  {

                       if  ( bascket  .size()<=0){

                             noEmptity  .await();

                     }

                       apple =  bascket .remove(0);

                       isFull .signalAll();

              }

                finally  {

                       lock .unlock();

              }

                return   apple  ;

       }

}

//生产者

public   class  Producer  implements  Runnable{

         private  Bascket  bascket  ;

         private  String  name  ;

         public  Producer(Bascket  bascket  ,String  name  ){

                this  . bascket  = bascket  ;

                this  . name  = name  ;

       }

         public   void  run(){

              

                while  ( true  ){

                       try  {

                           System.  out  .println(  name +  "produce.."  );

                             bascket .put(  new  Apple( "name"  +( int  )Math.random()*1000));

                     }  catch  (InterruptedException  e  ) {

                             //  TODO  Auto-generated catch block

                             e .printStackTrace();

                     }

                       try  {

                           Thread. sleep(1000);

                     }  catch  (InterruptedException  e  ) {

                             //  TODO  Auto-generated catch block

                             e .printStackTrace();

                     }

                     

              }

              

       }

}

public   class  TestDemo {

         public   static  void  main(String  args []){

              Bascket  bascket =  new  Bascket();

              Consumer  c1 =  new  Consumer( bascket  , "c1"  );

              

              Producer  p1 =  new  Producer( bascket  , "p1"  );

              Producer  p2 =  new  Producer( bascket  , "p2"  );

              

                //线程池管理

              ExecutorService  service  = Executors. newCachedThreadPool();

                service .execute(  c1 );

                service .execute(  p1 );

                service .execute(  p2 );

       }

}

具体Lock的实现机制将会在源代码中加以分析。

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/30024515/viewspace-1429096/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/30024515/viewspace-1429096/