zoukankan      html  css  js  c++  java

  • 使用Executors和ThreadPoolExecutor2

    线程池负责管理工作线程，包含一个等待执行的任务队列。线程池的任务队列是一个Runnable集合，工作线程负责从任务队列中取出并执行Runnable对象。

    java.util.concurrent.executors 提供了 java.util.concurrent.executor 接口的一个Java实现，可以创建线程池。下面是一个简单示例：

    首先创建一个Runable 类：

    WorkerThread.java

    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
    package com.journaldev.threadpool;
     
    public class WorkerThread implementsRunnable {
     
        privateString command;
     
        publicWorkerThread(String s){
            this.command=s;
        }
     
        @Override
        publicvoid run() {
            System.out.println(Thread.currentThread().getName()+" Start. Command = "+command);
            processCommand();
            System.out.println(Thread.currentThread().getName()+" End.");
        }
     
        privatevoid processCommand() {
            try{
                Thread.sleep(5000);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
     
        @Override
        publicString toString(){
            returnthis.command;
        }
    }

    下面是一个测试程序，从 Executors 框架中创建固定大小的线程池：

    SimpleThreadPool.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    package com.journaldev.threadpool;
     
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
     
    public class SimpleThreadPool {
     
        publicstatic void main(String[] args) {
            ExecutorService executor = Executors.newFixedThreadPool(5);
            for(int i = 0; i < 10; i++) {
                Runnable worker =new WorkerThread(""+ i);
                executor.execute(worker);
              }
            executor.shutdown();
            while(!executor.isTerminated()) {
            }
            System.out.println("Finished all threads");
        }
     
    }

    在上面的程序中，我们创建了包含5个工作线程的固定大小线程池。然后，我们向线程池提交10个任务。由于线程池的大小是5，因此首先会启动5个工作线程，其他任务将进行等待。一旦有任务结束，工作线程会从等待队列中挑选下一个任务并开始执行。

    以上程序的输出结果如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    pool-1-thread-2Start. Command = 1
    pool-1-thread-4Start. Command = 3
    pool-1-thread-1Start. Command = 0
    pool-1-thread-3Start. Command = 2
    pool-1-thread-5Start. Command = 4
    pool-1-thread-4End.
    pool-1-thread-5End.
    pool-1-thread-1End.
    pool-1-thread-3End.
    pool-1-thread-3Start. Command = 8
    pool-1-thread-2End.
    pool-1-thread-2Start. Command = 9
    pool-1-thread-1Start. Command = 7
    pool-1-thread-5Start. Command = 6
    pool-1-thread-4Start. Command = 5
    pool-1-thread-2End.
    pool-1-thread-4End.
    pool-1-thread-3End.
    pool-1-thread-5End.
    pool-1-thread-1End.
    Finished all threads

    从输出结果看，线程池中有五个名为“pool-1-thread-1”…“pool-1-thread-5”的工作线程负责执行提交的任务。

    Executors 类使用 ExecutorService  提供了一个 ThreadPoolExecutor 的简单实现，但 ThreadPoolExecutor 提供的功能远不止这些。我们可以指定创建 ThreadPoolExecutor 实例时活跃的线程数，并且可以限制线程池的大小，还可以创建自己的 RejectedExecutionHandler 实现来处理不适合放在工作队列里的任务。

    下面是一个 RejectedExecutionHandler 接口的自定义实现：

    RejectedExecutionHandlerImpl.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    package com.journaldev.threadpool;
     
    import java.util.concurrent.RejectedExecutionHandler;
    import java.util.concurrent.ThreadPoolExecutor;
     
    public class RejectedExecutionHandlerImpl implementsRejectedExecutionHandler {
     
        @Override
        publicvoid rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            System.out.println(r.toString() +" is rejected");
        }
     
    }

    ThreadPoolExecutor 提供了一些方法，可以查看执行状态、线程池大小、活动线程数和任务数。所以，我通过一个监视线程在固定间隔输出执行信息。

    MyMonitorThread.java

    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
    package com.journaldev.threadpool;
     
    import java.util.concurrent.ThreadPoolExecutor;
     
    public class MyMonitorThread implementsRunnable
    {
        privateThreadPoolExecutor executor;
     
        privateint seconds;
     
        privateboolean run=true;
     
        publicMyMonitorThread(ThreadPoolExecutor executor, intdelay)
        {
            this.executor = executor;
            this.seconds=delay;
        }
     
        publicvoid shutdown(){
            this.run=false;
        }
     
        @Override
        publicvoid run()
        {
            while(run){
                    System.out.println(
                        String.format("[monitor] [%d/%d] Active: %d, Completed: %d, Task: %d, isShutdown: %s, isTerminated: %s",
                            this.executor.getPoolSize(),
                            this.executor.getCorePoolSize(),
                            this.executor.getActiveCount(),
                            this.executor.getCompletedTaskCount(),
                            this.executor.getTaskCount(),
                            this.executor.isShutdown(),
                            this.executor.isTerminated()));
                    try{
                        Thread.sleep(seconds*1000);
                    }catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            }
     
        }
    }

    下面是使用 ThreadPoolExecutor 的线程池实现示例：

    WorkerPool.java

    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
    package com.journaldev.threadpool;
     
    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.Executors;
    import java.util.concurrent.ThreadFactory;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
     
    public class WorkerPool {
     
        publicstatic void main(String args[]) throws InterruptedException{
            //RejectedExecutionHandler implementation
            RejectedExecutionHandlerImpl rejectionHandler =new RejectedExecutionHandlerImpl();
            //Get the ThreadFactory implementation to use
            ThreadFactory threadFactory = Executors.defaultThreadFactory();
            //creating the ThreadPoolExecutor
            ThreadPoolExecutor executorPool =new ThreadPoolExecutor(2,4, 10, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(2), threadFactory, rejectionHandler);
            //start the monitoring thread
            MyMonitorThread monitor =new MyMonitorThread(executorPool,3);
            Thread monitorThread =new Thread(monitor);
            monitorThread.start();
            //submit work to the thread pool
            for(inti=0; i<10; i++){
                executorPool.execute(newWorkerThread("cmd"+i));
            }
     
            Thread.sleep(30000);
            //shut down the pool
            executorPool.shutdown();
            //shut down the monitor thread
            Thread.sleep(5000);
            monitor.shutdown();
     
        }
    }

    请注意：在初始化 ThreadPoolExecutor 时，初始线程池大小设为2、最大值设为4、工作队列大小设为2。所以，如果当前有4个任务正在运行而此时又有新任务提交，工作队列将只存储2个任务和其他任务将交由RejectedExecutionHandlerImpl 处理。

    程序执行的结果如下，确认了上面的结论：

    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
    pool-1-thread-1 Start. Command = cmd0
    pool-1-thread-4 Start. Command = cmd5
    cmd6 is rejected
    pool-1-thread-3 Start. Command = cmd4
    pool-1-thread-2 Start. Command = cmd1
    cmd7 is rejected
    cmd8 is rejected
    cmd9 is rejected
    [monitor] [0/2] Active: 4, Completed: 0, Task: 6, isShutdown:false, isTerminated:false
    [monitor] [4/2] Active: 4, Completed: 0, Task: 6, isShutdown:false, isTerminated:false
    pool-1-thread-4 End.
    pool-1-thread-1 End.
    pool-1-thread-2 End.
    pool-1-thread-3 End.
    pool-1-thread-1 Start. Command = cmd3
    pool-1-thread-4 Start. Command = cmd2
    [monitor] [4/2] Active: 2, Completed: 4, Task: 6, isShutdown:false, isTerminated:false
    [monitor] [4/2] Active: 2, Completed: 4, Task: 6, isShutdown:false, isTerminated:false
    pool-1-thread-1 End.
    pool-1-thread-4 End.
    [monitor] [4/2] Active: 0, Completed: 6, Task: 6, isShutdown:false, isTerminated:false
    [monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown:false, isTerminated:false
    [monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown:false, isTerminated:false
    [monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown:false, isTerminated:false
    [monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown:false, isTerminated:false
    [monitor] [2/2] Active: 0, Completed: 6, Task: 6, isShutdown:false, isTerminated:false
    [monitor] [0/2] Active: 0, Completed: 6, Task: 6, isShutdown:true, isTerminated:true
    [monitor] [0/2] Active: 0, Completed: 6, Task: 6, isShutdown:true, isTerminated:true

    请注意活跃线程、已完成线程和任务完成总数的变化。我们可以调用 shutdown() 结束所有已提交任务并终止线程池。

    如果希望延迟执行或定期运行任务，那么可以使用 ScheduledThreadPoolExecutor 类。
  • 相关阅读:
    [codevs]线段树练习5
    【Java学习笔记之十六】浅谈Java中的继承与多态
    【Java学习笔记之十五】Java中的static关键字解析
    【Java学习笔记之十四】Java中this用法小节
    【Java学习笔记之十三】初探Java面向对象的过程及代码实现
    【Java学习笔记之十二】Java8增强的工具类：Arrays的用法整理总结
    hdu2896 AC自动机
    hdu2222 AC自动机
    字符串匹配--AC自动机模板
    字符串匹配--（K）MP模板
  • 原文地址：https://www.cnblogs.com/kuyuyingzi/p/4266319.html
Copyright © 2011-2022 走看看