devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

多线程基础之设计模式Worker-Thread模式_worker thread

作者：从前慢现在也慢 | 2024-02-17 06:13:42

赞

踩

worker thread

一. Worker-Thread介绍

        我们可以使用 Thread-Per-Message 模式将 "发出工作请求的线程" 与 "执行工作请求的线程" 分开, 来提高程序的响应速度, 但是如果每次发出工作请求时都要创建执行工作的线程就太浪费了性能了, 这里介绍 Worker-Thread 模式, 可以事先启动执行工作的线程, 然后使用 Producer-Consumer 模式将表示工作内容的实例传递给工作线程, 这就是Worker-Thread模式

        Worker 的意思是工人劳动者, 在 Worker-Thread 模式中, 工人线程(WorkerTHread)会逐个取回工作并进行处理, 当所有工作完成后, 工人线程会等待新的工作到来, 该模式也被称为 Background Thread(背景线程模式), 如果从 "保存多个工人下线程的场所" 这一点来看, 这种模式也被称为 Thread Pool 模式

二. 示例程序

类名说明
Main测试程序类
ClientThread表示发出工作请求的线程的类
Request表示工作请求的类
Channel接收工作请求并将工作请求交给工人线程的类
WorkerThread表示工人线程的类

2.1 Main类

        Main 类会创建一个雇佣了五个工人线程的 Channel 的实例, 并将其共享给三个 ClientThread 的实例(Alice, Bobby, Chris)

  1. public class Main {
  2.     public static void main(String[] args) {
  3.         Channel channel = new Channel(5);
  4.         channel.startWorkers();
  5.         new ClientThread("alice", channel).start();
  6.         new ClientThread("bobby", channel).start();
  7.         new ClientThread("chris", channel).start();
  8.     }
  9. }

2.2 ClientThread类

        ClientThread 类的是发送工作请求类, 会创建 Request 实例, 并将该实例传递给 Channel 类的 putRequest() 方法

  1. public class ClientThread extends Thread {
  2.     private final Channel channel;
  3.     private static final Random R = new Random();
  4.     public ClientThread(String name, Channel channel) {
  5.         super(name);
  6.         this.channel = channel;
  7.     }
  8.  
  9.     @Override
  10.     public void run() {
  11.         try {
  12.             for (int i = 0; true; i++) {
  13.                 Request request = new Request(getName(), i);
  14.                 channel.putRequest(request);
  15.                 Thread.sleep(R.nextInt(1000));
  16.             }
  17.         } catch (InterruptedException e) {
  18.             //
  19.         }
  20.     }
  21. }

2.3 Request类

       Request 类是表示工作请求的类

  1. public class Request {
  2.     private final String name;
  3.     private final int num;
  4.     private static final Random R = new Random();
  5.  
  6.     public Request(String name, int num) {
  7.         this.name = name;
  8.         this.num = num;
  9.     }
  10.  
  11.     public void execute() {
  12.         System.out.println(Thread.currentThread().getName() + " executes " + this);
  13.         try {
  14.             Thread.sleep(R.nextInt(1000));
  15.         } catch (InterruptedException e) {
  16.             //
  17.         }
  18.     }
  19.  
  20.     @Override
  21.     public String toString() {
  22.         return "Request{" + "name='" + name + '\'' + ", num=" + num + '}';
  23.     }
  24. }

2.4 Channel类

        Channel 是负责传递工作请求以及保存工人线程的类, 为了传递请求, 在 Channel 类中定义 RequestQueue 字段, 该字段扮演保存队列的角色, putRequest() 方法用于将请求加入到队列中, takeRequest() 方法用于取出队列中的请求, 这里使用到了 Producer-Consumer 模式, 另外为了实现 putRequest() 方法, 这里还是用到了 Guarded Suspension 模式

        Channel 类中定义一个用于保存工人线程的 threadPool 字段, threadPool 是 WorkerThrea 的数组, Channel 类的构造函数会初始化 threadPool 字段并创建 WorkerThread 的线程实例

  1. public class Channel {
  2.     private static final int MAX_REQUEST = 100;
  3.     private final Request[] requestQueue;
  4.     private int tail;
  5.     private int head;
  6.     private int count;
  7.     private final WorkerThread[] workerThreadPool;
  8.  
  9.     public Channel(int threadCount) {
  10.         this.requestQueue = new Request[MAX_REQUEST];
  11.         this.head = 0;
  12.         this.tail = 0;
  13.         this.count = 0;
  14.         workerThreadPool = new WorkerThread[threadCount];
  15.         // 初始化工作线程
  16.         for (int i = 0; i < workerThreadPool.length; i++) {
  17.             workerThreadPool[i] = new WorkerThread(" Worker-" + i, this);
  18.         }
  19.     }
  20.  
  21.     public void startWorkers() {
  22.         for (int i = 0; i < workerThreadPool.length; i++) {
  23.             workerThreadPool[i].start();
  24.         }
  25.     }
  26.  
  27.     public synchronized void putRequest(Request request) {
  28.         while (count >= requestQueue.length) {
  29.             try {
  30.                 wait();
  31.             } catch (InterruptedException e) {
  32.                 //
  33.             }
  34.         }
  35.         requestQueue[tail] = request;
  36.         tail = (tail + 1) % requestQueue.length;
  37.         count++;
  38.         // 唤醒工作线程
  39.         notifyAll();
  40.     }
  41.  
  42.     public synchronized Request takeRequest() {
  43.         while (count <= 0) {
  44.             try {
  45.                 wait();
  46.             } catch (InterruptedException e) {
  47.                 //
  48.             }
  49.         }
  50.         Request request = requestQueue[head];
  51.         head = (head + 1) % requestQueue.length;
  52.         count--;
  53.         // 唤醒客户端生产
  54.         notifyAll();
  55.         return request;
  56.     }
  57. }

2.5 WorkerThread类        

        WorkerThread 是表示工人线程的类, 工人线程一旦启动后就会一直工作, 会反复执行 "获取一个新的 Request 的实例, 然后调用它的 execute() 方法进行处理

  1. public class WorkerThread extends Thread {
  2.     private final Channel channel;
  3.  
  4.     public WorkerThread(String name, Channel channel) {
  5.         super(name);
  6.         this.channel = channel;
  7.     }
  8.  
  9.     @Override
  10.     public void run() {
  11.         while (true) {
  12.             Request request = channel.takeRequest();
  13.             request.execute();
  14.         }
  15.     }
  16. }

2.5 运行实例

        从图中可以看出, Worker-0, 1, 2, 3, 4 这五个 WorkerThread 线程正在处理来自于 alice, bobby, chris这三个 ClientThread 的请求, 发送请求的 ClientThread 与处理请求的 WorkerThread 之间没有固定的对应关系, 工人线程不不在意是谁发送的请求, 它只处理接收到的请求              

  1.  Worker-4 executes Request{name='alice', num=0}
  2.  Worker-0 executes Request{name='bobby', num=0}
  3.  Worker-3 executes Request{name='chris', num=0}
  4.  Worker-1 executes Request{name='alice', num=1}
  5.  Worker-0 executes Request{name='alice', num=2}
  6.  Worker-2 executes Request{name='chris', num=1}
  7.  Worker-0 executes Request{name='bobby', num=1}
  8.  Worker-1 executes Request{name='alice', num=3}
  9.  Worker-4 executes Request{name='chris', num=2}
  10.  Worker-3 executes Request{name='bobby', num=2}
  11.  Worker-0 executes Request{name='bobby', num=3}
  12.  Worker-2 executes Request{name='bobby', num=4}
  13.  Worker-0 executes Request{name='alice', num=4}
  14.  Worker-1 executes Request{name='bobby', num=5}
  15.  Worker-3 executes Request{name='chris', num=3}

三. Worker-Thread模式中的登场的角色

3.1 Client(委托类)

        Client 创建表示工作请求的 Request 角色并将该角色传递给 Channel, 在示例程序中, 有 ClientThread 类扮演该角色

3.2 Channel(通信线路)

        Channel 接收来自于 Cilent 的 Request 请求, 并将其传递给 Worker 角色

3.3 Worker(工人)

        Worker 从 Channel 中获取 Request 角色, 并进行工作, 当一项工作完成后, 他会继续去获取另外的 Request

3.4 Request(请求)

        Request 表示工作实例, 保存了进行工作所必须的信息, 字段声明为final, 是线程安全的

3.5 模式类图

                        

四. java.util.concurrent包和Worker-Thread模式

        java.util.concurrent.ThreadPoolExecutor 类是管理工人线程的类, ThreadPoolExecutor 可以轻松的实现 Worker-Thread 模式, 这里使用 java.util.concurrent.Exectors 类中的静态方法改造上面的示例程序

        此时已经不在需要 WorkerThread 类,  因为已经使用juc包下的线程池替代了, 也不需要 Channel 类了, 因为线程池内部维护着一个 BlockingQueue (阻塞队列)

4.1 通过java.util.concurrent包改造Main类

        Main 类使用 Executors.newFixedThreadPool 方法创建了一个线程池, 该线程池保存了指定数量的线程, 是一个 ExecutorService 对象, 改造后 Main 类如下

  1. public class Main {
  2.     public static void main(String[] args) {
  3.         ExecutorService executorService = Executors.newFixedThreadPool(5);
  4.         try {
  5.             new ClientThread("alice", executorService).start();
  6.             new ClientThread("bobby", executorService).start();
  7.             new ClientThread("chris", executorService).start();
  8.             Thread.sleep(5000);
  9.         } catch (InterruptedException e) {
  10.             //
  11.         } finally {
  12.             executorService.shutdown();
  13.         }
  14.     }
  15. }

4.2 通过java.util.concurrent包改造ClientThread类        

  1. public class ClientThread extends Thread {
  2.     private final ExecutorService executorService;
  3.     private static final Random R = new Random();
  4.     public ClientThread(String name, ExecutorService executorService) {
  5.         super(name);
  6.         this.executorService = executorService;
  7.     }
  8.  
  9.     @Override
  10.     public void run() {
  11.         try {
  12.             for (int i = 0; true; i++) {
  13.                 Request request = new Request(getName(), i);
  14.                 executorService.execute(request);
  15.                 Thread.sleep(R.nextInt(1000));
  16.             }
  17.         } catch (InterruptedException e) {
  18.             //
  19.         }
  20.     }
  21. }

4.3 改造Request类      

        为了能够让 ExecutorService 类使用 Request 类, 下面的程序必须实现 Runnable 接口, 在 run() 方法中做实际的处理

  1. public class Request implements Runnable{
  2.     private final String name;
  3.     private final int num;
  4.     private static final Random R = new Random();
  5.  
  6.     public Request(String name, int num) {
  7.         this.name = name;
  8.         this.num = num;
  9.     }
  10.  
  11.     @Override
  12.     public String toString() {
  13.         return "Request{" + "name='" + name + '\'' + ", num=" + num + '}';
  14.     }
  15.  
  16.     @Override
  17.     public void run() {
  18.         System.out.println(Thread.currentThread().getName() + " executes " + this);
  19.         try {
  20.             Thread.sleep(R.nextInt(1000));
  21.         } catch (InterruptedException e) {
  22.             //
  23.         }
  24.     }
  25. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/100803
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号