`
doris1bruce
  • 浏览: 4689 次
  • 性别: Icon_minigender_1
  • 来自: 北京
最近访客 更多访客>>
社区版块
存档分类
最新评论

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

阅读更多

前序:

   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);//获取任务池中的任务,并且要进行转换
            }
            //下面是线程所要处理的具体工作
        }
    }
}
分享到:
评论

相关推荐

    Java多线程设计模式_清晰完整PDF版 Java多线程设计模式源代码

    Java多线程设计模式是Java开发中的重要领域,它涉及到如何在并发环境下高效、安全地管理资源和控制程序执行流程。本资料集包含了清晰完整的PDF版书籍和源代码,为学习和理解Java多线程设计模式提供了丰富的素材。 ...

    java多线程设计模式详解(PDF及源码).zip

    Java多线程设计模式是Java开发中的重要领域,它涉及到如何高效、安全地利用系统资源进行并发处理。在这个主题中,我们将深入探讨单线程、生产者与消费者模型以及Java中实现多线程的各种方法。 首先,单线程是程序...

    java多线程设计模式详解.pdf

    标题“java多线程设计模式详解.pdf”中提到的知识点是关于Java多线程编程中设计模式的应用。Java多线程是并发编程的重要组成部分,设计模式则是软件工程中用于解决特定问题的最佳实践。将两者结合起来,意味着此文件...

    java多线程设计模式_java_设计模式_多线程_多线程课题_

    Java多线程设计模式是Java开发中的核心概念,它涉及到如何高效、安全地在多个执行线程之间共享资源和协调任务。设计模式是解决特定问题的成熟方案,它们是编程经验的结晶,可以帮助开发者在面临多线程挑战时快速找到...

    java多线程设计模式详解(PDF及源码)

    本资源“java多线程设计模式详解”涵盖了这一主题的深入探讨,包括PDF文档和源码示例。 多线程设计模式是程序员在开发高效、稳定且可维护的多线程应用程序时遵循的一系列最佳实践。以下是一些常见的Java多线程设计...

    Java多线程设计模式(带源码)

    Java多线程设计模式是Java开发中的重要领域,它涉及到并发编程、系统性能优化以及程序的稳定性。在Java中,多线程允许程序同时执行多个任务,极大地提升了程序的执行效率。本资源提供了详细的Java多线程设计模式的...

    Java多线程设计模式源代码

    总之,这份Java多线程设计模式源代码涵盖了从基本的线程创建到复杂的线程同步、通信和线程池管理,以及各种线程安全的类和设计模式的实战应用。通过学习和分析这些源码,开发者能够更好地理解和掌握Java多线程编程,...

    java多线程设计模式源码

    Java多线程设计模式是构建高并发、高性能应用的关键技术之一。这些模式通过优化资源利用、提高程序可读性和可维护性,使并发编程更加高效和安全。以下将详细讲解标题和描述中涉及的一些核心知识点: 1. **线程池...

    java多线程设计模式详解

    Java多线程设计模式是Java编程中不可或缺的一部分,它涉及到如何在并发环境下高效、安全地组织代码执行。本文将深入探讨几种常见的Java多线程设计模式,并提供源码实例进行详细解析。 一、生产者消费者模式 生产者...

    java多线程设计模式

    Java多线程设计模式是Java开发中不可或缺的一部分,它涉及到如何在并发环境下高效、安全地组织程序执行。本文将深入探讨Java多线程设计模式及其应用,帮助开发者理解和掌握这一重要技术。 首先,理解Java多线程的...

    JAVA设计模式与JAVA多线程设计模式详解

    在Java编程领域,设计模式和多线程设计模式是开发者必备的技能。设计模式是一种在特定情境下解决软件设计问题的通用、可复用的解决方案,而多线程设计模式则是处理并发问题的关键。本文将深入探讨这两种重要的概念,...

    Java多线程设计模式上传文件

    综上所述,Java多线程和设计模式的结合使得文件上传任务能够高效、安全地执行。通过合理的设计和实现,我们可以创建一个可扩展、易维护的文件上传系统,满足各种复杂的需求。具体到项目中的源代码,应该包含了对上述...

    java 多线程编程实战指南(核心 + 设计模式 完整版)

    《Java多线程编程实战指南》这本书深入浅出地讲解了Java多线程的核心概念和实战技巧,分为核心篇和设计模式篇,旨在帮助开发者掌握并应用多线程技术。 1. **线程基础** - **线程的创建**:Java提供了两种创建线程...

    java 多线程设计模式 进程详解

    《JAVA多线程设计模式》PDF 下载 《Java线程 高清晰中文第二版》中文第二版(PDF) 前言 第一章 线程简介 Java术语 线程概述 为什么要使用线程? 总结 第二章 Java线程API 通过Thread类创建线程 使用Runable接口...

Global site tag (gtag.js) - Google Analytics