Java多线程设计模式(4

 Java多线程设计模式(3)读写锁模式

2013-05-17 15:50:46

标签： java  多线程  读写锁模式

原创作品，允许转载，转载时请务必以超链接形式标明文章  原始出处 、作者信息和本声明。否则将追究法律责任。 http://computerdragon.blog.51cto.com/6235984/1202752

1 Read-Write Lock Pattern

Read-Write Lock Pattern是一种将对于共享资源的访问与修改操作分离，称为读写分离。即访问是reader，修改是write，用单独的线程来处理。可以允许多个reader，但是不允许同时多个写入或者在读的过程中有写入。

由于对于实例状态的读取，并不会破坏状态的完整性且状态也不会修改，可以允许多个线程同时访问操作。但是若在写入的过程中，会更改实例的状态，此时就需要对于写入做保护，防止其他线程来进行读操作和写操作。

在多个线程共享一个实例的时候，会有参考实例状态的线程即仅仅读取实例状态的Reader参与者，并且也会有改变实例的状态的线程即Writer参与者，此时就需要运用这种模式。

  这种模式在读取不会冲突下，允许多个Reader参与者同时reader，提高了性能。不用单纯的在每次读的时候利用Synchronized来使得只能允许一个线程读操作，而是利用了外部定义的逻辑锁来设置允许多个Reader同时操作。在读取的操作比写入的操作多的时候，也可以使用这个模式。

  在这个模式中，主要有四个参与者，分别为：

1 Reader参与者。Reader参与者会对SharedResource参与者进行read。

2 Writer参与者。Writer参与者会对SharedResource参与者进行write。

3 SharedResource参与者。这个是Reader参与者与Writer参与者共享的资源。里面包含了提供不会改变内部状态的操作read，与会改变内部状态的操作write。注意对于这个参与者，不需要在进行read与write的方法加上synchronized。

在对于SharedResource参与者进行read和write操作时候，利用Before/After Pattern实现。

    前置处理(获取锁定)

      try{

      实际操作

       }finally{

        后续处理(释放锁)}

利用finally可以保证无论发生什么情况，都会释放锁，也不能把前置处理放置在try中，如果放置在里面，则finally就一定会执行，当前置处理发生异常，就不应该进而执行finally。

  4 ReadWriteLock参与者。提供了对于SharedResource参与者进行read和write时需要的锁，就是用户自定义的锁机制。包括readLock和readUnLock锁，writeLock和writeUnLock，注意必须要对这些操作进行同步处理，放置多个线程同时调用这些方法，在每个方法中必须加上synchronized。

实例：

有多个读者和多个写者共同操作一本书，只允许同时多个读者读取书，只允许同时一个写者写这本书，不允许同时读者与写者同时操作这本书籍。

SharedResource参与者。

在每次读写操作之间和之后都要获取锁与释放锁，不需要synchronized

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

package  whut.readwritelock; public  class  Data {      private  final  char [] buffer;      private  final  ReadWriteLock lock= new  ReadWriteLock();                                                                                                                                                                                                                                                                                                           public  Data( int  size)      {          this .buffer= new  char [size];          for ( int  i= 0 ;i<buffer.length;i++)              buffer[i]= '*' ;      }                                                                                                                                                                                                                                                                                                           public  char [] read() throws  InterruptedException      {          lock.readLock();          try {              return  doRead();          } finally {              lock.readUnlock();          }      }                                                                                                                                                                                                                                                                                                           private  char [] doRead()      {          char [] newbuf= new  char [buffer.length];          for ( int  i= 0 ;i<buffer.length;i++)              newbuf[i]=buffer[i];          slowly();          return  newbuf;      }                                                                                                                                                                                                                                                                                                           public  void  write( char  c) throws  InterruptedException      {          lock.writeLock();          try {               doWrite(c);          } finally {              lock.writeUnlock();          }      }                                                                                                                                                                                                                                                                                                           private  void  doWrite( char  c)      {          for ( int  i= 0 ;i<buffer.length;i++)          {              buffer[i]=c;              slowly();              //这里的sleep并不会切换到别的线程              //这里就是体现了使用while的好处              //当该线程sleep时候，其余等待读取的还在wait中，而要写入的线程会判断它的状态，还没有释放锁          }      }                                                                                                                                                                                                                                                                                                           private  void  slowly()      {          try {              Thread.sleep( 50 );          } catch (InterruptedException e)          {                                                                                                                                                                                                                                                                                                                       }      }                                                                                                                                                                                                                                                                                                      }

读者线程Reader

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

package  whut.readwritelock; public  class  ReaderThread  extends  Thread{      private  final  Data data;      public  ReaderThread(Data data)      {          this .data=data;      }                                                                                                                                                                                                                                                                                                  public  void  run()      {          try {              while ( true )              {                  char [] readbuf=data.read();                  System.out.println(Thread.currentThread().getName()                          + " reads " +String.valueOf(readbuf));              }          } catch (InterruptedException e)          {          }      } }

写者线程Writer

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

package  whut.readwritelock; import  java.util.Random; public  class  WriterThread  extends  Thread{                                                                                                                                                                                                                                                                                          private  static  final  Random random= new  Random();      private  final  Data data;      private  final  String filler;      private  int  index= 0 ;                                                                                                                                                                                                                                                                                          public  WriterThread(Data data,String filler)      {          this .data=data;          this .filler=filler;      }                                                                                                                                                                                                                                                                                          public  void  run()      {          try {              while ( true )              {                  char  c=nextChar();                  data.write(c);                  Thread.sleep(random.nextInt( 1000 ));              }          } catch (InterruptedException e)          {                                                                                                                                                                                                                                                                                                      }      }                                                                                                                                                                                                                                                                                          private  char  nextChar()      {          char  c=filler.charAt(index);          index++;          if (index>=filler.length())              index= 0 ;          return  c;      } }

WriteReadLock类

 主要就是利用自定义锁机制来控制读写操作。设置读写时的警戒条件，利用Guarded Suspension Pattern来处理。

  设置有四个字段：

readingReaders表示实例当前被读取的线程数目。是readLock之后与readUnlock之间的数。作为写入操作的警戒条件之一。

  writingReaders表示实例当被写操作的线程数目，只能是0或者1，它是作为写入操作和读取操作的警戒条件。

waitingReaders表示多少个处于等待写入的线程数目。当ReaderThread比WriterThread多的时候，由于在要进行写入操作过程中，如果有读取操作，则会一直等待，但是读取操作没有设置为互斥，则他们会一个个的执行读操作，致使写入操作无法进行。设置这个字段状态目的就是为了使得ReaderThread在警戒条件判断中当waitingReaders大于0的时候，该ReaderThread能wait，能让出控制权给WriterThread。

preferWriter表示true为写优先，表示false为读优先。虽然读取能让出控制权给写入操作，可是当写入操作拥有了控制权后，则可能使得读取操作无法执行。此时就需要这个preferWriter字段，这个就是目的使得ReaderThread和WriterThread能够轮流执行的。

   当读操作完后，设置为true以使得写入操作有可能获得执行，不过写入操作必须在满足preferWriter为true以及有等待写入的操作下才能真正的写入。当写入操作完毕后，设置该字段为false使得读操作能够执行。

总结：

  读取操作等待的警戒条件是：当前写入线程大于0，或者preferWriter为true且有等待写入的线程

  写入操作等待的警戒条件是：当前写入线程大于0，或者当前读取线程大于0

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

package  whut.readwritelock; //关键部分 public  class  ReadWriteLock {      private  int  readingReaders= 0 ; //实际正在读取的线程数目      private  int  waitingWriters= 0 ; //正在等待写入的线程数目      private  int  writingWriters= 0 ; //实际正在写入的线程数目      private  boolean  preferWriter= true ; //写入优先的话，值为true                    //读取的时候获取锁      public  synchronized  void  readLock() throws  InterruptedException      {          //当有写入的时候，或者写入为优先级并且有等待的写入线程          while (writingWriters> 0 ||(preferWriter&&waitingWriters> 0 ))          {              wait();          }          readingReaders++;      }                    //读完毕后释放锁      public  synchronized  void  readUnlock() throws  InterruptedException      {          readingReaders--;          preferWriter= true ;          notifyAll();      }                    //写入的时候获取锁      public  synchronized  void  writeLock() throws  InterruptedException      {          waitingWriters++; //正在等待的写入的线程数目          try {              //有写入或者读入的时候              while (readingReaders> 0 ||writingWriters> 0 )              {                  wait();              }          } finally {              waitingWriters--; //被唤醒了，则就是进而真正写入          }          writingWriters++;      }                    //写入毕后释放锁      public  synchronized  void  writeUnlock() throws  InterruptedException      {          writingWriters--;          preferWriter= false ; //写入后马上更换优先级，让读者继续          notifyAll();      } }

测试类：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

package  whut.readwritelock; public  class  ReadWriteMain {      public  static  void  main(String[] args) {          // TODO Auto-generated method stub          Data data= new  Data( 10 );          //读取线程          new  ReaderThread(data).start();          new  ReaderThread(data).start();          new  ReaderThread(data).start();          new  ReaderThread(data).start();          new  ReaderThread(data).start();          new  ReaderThread(data).start();                      //写入线程          new  WriterThread(data, "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ).start();          new  WriterThread(data, "abcdefghijklmnopqrstuvwxyz" ).start();      } }

 Java多线程设计模式(4)线程池模式

2013-05-21 09:41:28

标签： java  线程池

原创作品，允许转载，转载时请务必以超链接形式标明文章  原始出处 、作者信息和本声明。否则将追究法律责任。 http://computerdragon.blog.51cto.com/6235984/1205324

前序：

   Thread-Per-Message Pattern,是一种对于每个命令或请求，都分配一个线程，由这个线程执行工作。它将“委托消息的一端”和“执行消息的一端”用两个不同的线程来实现。该线程模式主要包括三个部分：

   1，Request参与者(委托人)，也就是消息发送端或者命令请求端

   2，Host参与者，接受消息的请求，负责为每个消息分配一个工作线程。

   3，Worker参与者，具体执行Request参与者的任务的线程，由Host参与者来启动。

   由于常规调用一个方法后，必须等待该方法完全执行完毕后才能继续执行下一步操作，而利用线程后，就不必等待具体任务执行完毕，就可以马上返回继续执行下一步操作。

背景：

   由于在Thread-Per-Message Pattern中对于每一个请求都会生成启动一个线程，而线程的启动是很花费时间的工作，所以鉴于此，提出了Worker Thread，重复利用已经启动的线程。

线程池：

   Worker Thread，也称为工人线程或背景线程，不过一般都称为线程池。该模式主要在于，事先启动一定数目的工作线程。当没有请求工作的时候，所有的工人线程都会等待新的请求过来，一旦有工作到达，就马上从线程池中唤醒某个线程来执行任务，执行完毕后继续在线程池中等待任务池的工作请求的到达。

   任务池：主要是存储接受请求的集合，利用它可以缓冲接受到的请求，可以设置大小来表示同时能够接受最大请求数目。这个任务池主要是供线程池来访问。

   线程池：这个是工作线程所在的集合，可以通过设置它的大小来提供并发处理的工作量。对于线程池的大小，可以事先生成一定数目的线程，根据实际情况来动态增加或者减少线程数目。线程池的大小不是越大越好，线程的切换也会耗时的。

   存放池的数据结构，可以用数组也可以利用集合，在集合类中一般使用Vector，这个是线程安全的。

  Worker Thread的所有参与者：

   1，Client参与者，发送Request的参与者

   2，Channel参与者，负责缓存Request的请求，初始化启动线程，分配工作线程

   3，Worker参与者，具体执行Request的工作线程

   4，Request参与者

注意：将在Worker线程内部等待任务池非空的方式称为正向等待。

     将在Channel线程提供Worker线程来判断任务池非空的方式称为反向等待。

线程池实例1：

   利用同步方法来实现，使用数组来作为任务池的存放数据结构。在Channel有缓存请求方法和处理请求方法，利用生成者与消费者模式来处理存储请求，利用反向等待来判断任务池的非空状态。

Channel参与者：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

package  whut.threadpool; //用到了生产者与消费者模式 //生成线程池，接受客户端线程的请求，找到一个工作线程分配该客户端请求 public  class  Channel {      private  static  final  int  MAX_REQUEST =  100 ; // 并发数目，就是同时可以接受多少个客户端请求      //利用数组来存放请求，每次从数组末尾添加请求，从开头移除请求来处理      private  final  Request[] requestQueue; // 存储接受客户线程的数目      private  int  tail; //下一次存放Request的位置      private  int  head; //下一次获取Request的位置      private  int  count; // 当前request数量      private  final  WorkerThread[] threadPool; // 存储线程池中的工作线程      // 运用数组来存储      public  Channel( int  threads) {          this .requestQueue =  new  Request[MAX_REQUEST];          this .head =  0 ;          this .head =  0 ;          this .count =  0 ;          threadPool =  new  WorkerThread[threads];          // 启动工作线程          for  ( int  i =  0 ; i < threadPool.length; i++) {              threadPool[i] =  new  WorkerThread( "Worker-"  + i,  this );          }      }      public  void  startWorkers() {          for  ( int  i =  0 ; i < threadPool.length; i++) {              threadPool[i].start();          }      }      // 接受客户端请求线程      public  synchronized  void  putRequest(Request request) {          // 当Request的数量大于或等于同时接受的数目时候，要等待          while  (count >= requestQueue.length)              try  {                  wait();              }  catch  (InterruptedException e) {              }          requestQueue[tail] = request;          tail = (tail +  1 ) % requestQueue.length;          count++;          notifyAll();      }      // 处理客户端请求线程      public  synchronized  Request takeRequest() {          while  (count <=  0 )              try  {                  wait();              }  catch  (InterruptedException e) {              }          Request request = requestQueue[head];          head = (head +  1 ) % requestQueue.length;          count--;          notifyAll();          return  request;      } }

客户端请求线程

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

package  whut.threadpool; import  java.util.Random; //向Channel发送Request请求的 public  class  ClientThread  extends  Thread{      private  final  Channel channel;      private  static  final  Random random= new  Random();                                                                      public  ClientThread(String name,Channel channel)      {          super (name);          this .channel=channel;      }      public  void  run()      {          try {              for ( int  i= 0 ; true ;i++)              {                  Request request= new  Request(getName(),i);                  channel.putRequest(request);                  Thread.sleep(random.nextInt( 1000 ));              }          } catch (InterruptedException e)          {          }      } }

工作线程：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

package  whut.threadpool; //具体工作线程 public  class  WorkerThread  extends  Thread{                                                             private  final  Channel channel;      public  WorkerThread(String name,Channel channel)      {        super (name);        this .channel=channel;      }                                                             public  void  run()      {          while ( true )          {              Request request=channel.takeRequest();              request.execute();          }      } }

线程池实例2：

   利用同步块来处理，利用Vector来存储客户端请求。在Channel有缓存请求方法和处理请求方法，利用生成者与消费者模式来处理存储请求，利用正向等待来判断任务池的非空状态。

   这种实例，可以借鉴到网络ServerSocket处理用户请求的模式中，有很好的扩展性与实用性。

   利用Vector来存储，依旧是每次集合的最后一个位置添加请求，从开始位置移除请求来处理。

Channel参与者：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

package  whut.threadpool2; import  java.util.Vector; /*   * 这个主要的作用如下   * 0,缓冲客户请求线程(利用生产者与消费者模式)   * 1,存储客户端请求的线程   * 2,初始化启动一定数量的线程   * 3,主动来唤醒处于任务池中wait set的一些线程来执行任务   */ public  class  Channel {      public  final  static  int  THREAD_COUNT= 4 ;      public  static  void  main(String[] args) {        //定义两个集合，一个是存放客户端请求的，利用Vector，        //一个是存储线程的，就是线程池中的线程数目                                      //Vector是线程安全的，它实现了Collection和List        //Vector 类可以实现可增长的对象数组。与数组一样，        //它包含可以使用整数索引进行访问的组件。但Vector 的大小可以根据需要增大或缩小，        //以适应创建 Vector 后进行添加或移除项的操作。        //Collection中主要包括了list相关的集合以及set相关的集合,Queue相关的集合        //注意：Map不是Collection的子类，都是java.util.*下的同级包        Vector pool= new  Vector();        //工作线程，初始分配一定限额的数目        WorkerThread[] workers= new  WorkerThread[THREAD_COUNT];                                   //初始化启动工作线程        for ( int  i= 0 ;i<workers.length;i++)        {            workers[i]= new  WorkerThread(pool);            workers[i].start();        }                                    //接受新的任务，并且将其存储在Vector中        Object task= new  Object(); //模拟的任务实体类        //此处省略具体工作        //在网络编程中，这里就是利用ServerSocket来利用ServerSocket.accept接受一个Socket从而唤醒线程                                    //当有具体的请求达到        synchronized (pool)        {            pool.add(pool.size(), task);            pool.notifyAll(); //通知所有在pool wait set中等待的线程，唤醒一个线程进行处理        }        //注意上面这步骤添加任务池请求，以及通知线程，都可以放在工作线程内部实现        //只需要定义该方法为static，在方法体用同步块，且共享的线程池也是static即可                                    //下面这步，可以有可以没有根据实际情况        //取消等待的线程        for ( int  i= 0 ;i<workers.length;i++)        {            workers[i].interrupt();        }      } }

工作线程：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

package  whut.threadpool2; import  java.util.List; public  class  WorkerThread  extends  Thread {      private  List pool; //任务请求池      private  static  int  fileCompressed= 0 ; //所有实例共享的                            public  WorkerThread(List pool)      {            this .pool=pool;       }                            //利用静态synchronized来作为整个synchronized类方法，仅能同时一个操作该类的这个方法      private  static  synchronized  void  incrementFilesCompressed()      {          fileCompressed++;      }                            public  void  run()      {          //保证无限循环等待中          while ( true )          {              //共享互斥来访问pool变量              synchronized (pool)              {                  //利用多线程设计模式中的                  //Guarded Suspension Pattern,警戒条件为pool不为空，否则无限的等待中                  while (pool.isEmpty())                  {                      try {                          pool.wait(); //进入pool的wait set中等待着,释放了pool的锁                      } catch (InterruptedException e)                      {                      }                  }                  //当线程被唤醒，需要重新获取pool的锁，                  //再次继续执行synchronized代码块中其余的工作                  //当不为空的时候，继续再判断是否为空，如果不为空，则跳出循环                  //必须先从任务池中移除一个任务来执行，统一用从末尾添加，从开始处移除                                                    pool.remove( 0 ); //获取任务池中的任务，并且要进行转换              }              //下面是线程所要处理的具体工作          }      } }