Java多线程设计模式(4

转载 2013年12月05日 14:38:05
 Java多线程设计模式(3)读写锁模式
2013-05-17 15:50:46
原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。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();
      }