1、线程池简介:
    多线程技术主要解决处理器单元内多个线程执行的问题,它可以显著减少处理器单元的闲置时间,增加处理器单元的吞吐能力。    
    假设一个服务器完成一项任务所需时间为:T1 创建线程时间,T2 在线程中执行任务的时间,T3 销毁线程时间。

如果:T1 + T3 远大于 T2,则可以采用线程池,以提高服务器性能。
                一个线程池包括以下四个基本组成部分:
                1、线程池管理器(ThreadPool):用于创建并管理线程池,包括 创建线程池,销毁线程池,添加新任务;
                2、工作线程(PoolWorker):线程池中线程,在没有任务时处于等待状态,可以循环的执行任务;
                3、任务接口(Task):每个任务必须实现的接口,以供工作线程调度任务的执行,它主要规定了任务的入口,任务执行完后的收尾工作,任务的执行状态等;
                4、任务队列(taskQueue):用于存放没有处理的任务。提供一种缓冲机制。
                
    线程池技术正是关注如何缩短或调整T1,T3时间的技术,从而提高服务器程序性能的。它把T1,T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段,这样在服务器程序处理客户请求时,不会有T1,T3的开销了。
    线程池不仅调整T1,T3产生的时间段,而且它还显著减少了创建线程的数目,看一个例子:
    假设一个服务器一天要处理50000个请求,并且每个请求需要一个单独的线程完成。在线程池中,线程数一般是固定的,所以产生线程总数不会超过线程池中线程的数目,而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间,从而提高效率。

代码实现中并没有实现任务接口,而是把Runnable对象加入到线程池管理器(ThreadPool),然后剩下的事情就由线程池管理器(ThreadPool)来完成了

  1. package mine.util.thread;
  2. import java.util.LinkedList;
  3. import java.util.List;
  4. /**
  5. * 线程池类,线程管理器:创建线程,执行任务,销毁线程,获取线程基本信息
  6. */
  7. public final class ThreadPool {
  8. // 线程池中默认线程的个数为5
  9. private static int worker_num = 5;
  10. // 工作线程
  11. private WorkThread[] workThrads;
  12. // 未处理的任务
  13. private static volatile int finished_task = 0;
  14. // 任务队列,作为一个缓冲,List线程不安全
  15. private List<Runnable> taskQueue = new LinkedList<Runnable>();
  16. private static ThreadPool threadPool;
  17. // 创建具有默认线程个数的线程池
  18. private ThreadPool() {
  19. this(5);
  20. }
  21. // 创建线程池,worker_num为线程池中工作线程的个数
  22. private ThreadPool(int worker_num) {
  23. ThreadPool.worker_num = worker_num;
  24. workThrads = new WorkThread[worker_num];
  25. for (int i = 0; i < worker_num; i++) {
  26. workThrads[i] = new WorkThread();
  27. workThrads[i].start();// 开启线程池中的线程
  28. }
  29. }
  30. // 单态模式,获得一个默认线程个数的线程池
  31. public static ThreadPool getThreadPool() {
  32. return getThreadPool(ThreadPool.worker_num);
  33. }
  34. // 单态模式,获得一个指定线程个数的线程池,worker_num(>0)为线程池中工作线程的个数
  35. // worker_num<=0创建默认的工作线程个数
  36. public static ThreadPool getThreadPool(int worker_num1) {
  37. if (worker_num1 <= 0)
  38. worker_num1 = ThreadPool.worker_num;
  39. if (threadPool == null)
  40. threadPool = new ThreadPool(worker_num1);
  41. return threadPool;
  42. }
  43. // 执行任务,其实只是把任务加入任务队列,什么时候执行有线程池管理器觉定
  44. public void execute(Runnable task) {
  45. synchronized (taskQueue) {
  46. taskQueue.add(task);
  47. taskQueue.notify();
  48. }
  49. }
  50. // 批量执行任务,其实只是把任务加入任务队列,什么时候执行有线程池管理器觉定
  51. public void execute(Runnable[] task) {
  52. synchronized (taskQueue) {
  53. for (Runnable t : task)
  54. taskQueue.add(t);
  55. taskQueue.notify();
  56. }
  57. }
  58. // 批量执行任务,其实只是把任务加入任务队列,什么时候执行有线程池管理器觉定
  59. public void execute(List<Runnable> task) {
  60. synchronized (taskQueue) {
  61. for (Runnable t : task)
  62. taskQueue.add(t);
  63. taskQueue.notify();
  64. }
  65. }
  66. // 销毁线程池,该方法保证在所有任务都完成的情况下才销毁所有线程,否则等待任务完成才销毁
  67. public void destroy() {
  68. while (!taskQueue.isEmpty()) {// 如果还有任务没执行完成,就先睡会吧
  69. try {
  70. Thread.sleep(10);
  71. } catch (InterruptedException e) {
  72. e.printStackTrace();
  73. }
  74. }
  75. // 工作线程停止工作,且置为null
  76. for (int i = 0; i < worker_num; i++) {
  77. workThrads[i].stopWorker();
  78. workThrads[i] = null;
  79. }
  80. threadPool=null;
  81. taskQueue.clear();// 清空任务队列
  82. }
  83. // 返回工作线程的个数
  84. public int getWorkThreadNumber() {
  85. return worker_num;
  86. }
  87. // 返回已完成任务的个数,这里的已完成是只出了任务队列的任务个数,可能该任务并没有实际执行完成
  88. public int getFinishedTasknumber() {
  89. return finished_task;
  90. }
  91. // 返回任务队列的长度,即还没处理的任务个数
  92. public int getWaitTasknumber() {
  93. return taskQueue.size();
  94. }
  95. // 覆盖toString方法,返回线程池信息:工作线程个数和已完成任务个数
  96. @Override
  97. public String toString() {
  98. return "WorkThread number:" + worker_num + "  finished task number:"
  99. + finished_task + "  wait task number:" + getWaitTasknumber();
  100. }
  101. /**
  102. * 内部类,工作线程
  103. */
  104. private class WorkThread extends Thread {
  105. // 该工作线程是否有效,用于结束该工作线程
  106. private boolean isRunning = true;
  107. /*
  108. * 关键所在啊,如果任务队列不空,则取出任务执行,若任务队列空,则等待
  109. */
  110. @Override
  111. public void run() {
  112. Runnable r = null;
  113. while (isRunning) {// 注意,若线程无效则自然结束run方法,该线程就没用了
  114. synchronized (taskQueue) {
  115. while (isRunning && taskQueue.isEmpty()) {// 队列为空
  116. try {
  117. taskQueue.wait(20);
  118. } catch (InterruptedException e) {
  119. e.printStackTrace();
  120. }
  121. }
  122. if (!taskQueue.isEmpty())
  123. r = taskQueue.remove(0);// 取出任务
  124. }
  125. if (r != null) {
  126. r.run();// 执行任务
  127. }
  128. finished_task++;
  129. r = null;
  130. }
  131. }
  132. // 停止工作,让该线程自然执行完run方法,自然结束
  133. public void stopWorker() {
  134. isRunning = false;
  135. }
  136. }
  137. }

测试代码:

  1. package mine.util.thread;
  2. //测试线程池
  3. public class TestThreadPool {
  4. public static void main(String[] args) {
  5. // 创建3个线程的线程池
  6. ThreadPool t = ThreadPool.getThreadPool(3);
  7. t.execute(new Runnable[] { new Task(), new Task(), new Task() });
  8. t.execute(new Runnable[] { new Task(), new Task(), new Task() });
  9. System.out.println(t);
  10. t.destroy();// 所有线程都执行完成才destory
  11. System.out.println(t);
  12. }
  13. // 任务类
  14. static class Task implements Runnable {
  15. private static volatile int i = 1;
  16. @Override
  17. public void run() {// 执行任务
  18. System.out.println("任务 " + (i++) + " 完成");
  19. }
  20. }
  21. }

运行结果:

WorkThread number:3  finished task number:0  wait task number:6
任务 1 完成
任务 2 完成
任务 3 完成
任务 4 完成
任务 5 完成
任务 6 完成
WorkThread number:3  finished task number:6  wait task number:0

分析:由于并没有任务接口,传入的可以是自定义的任何任务,所以线程池并不能准确的判断该任务是否真正的已经完成(真正完成该任务是这个任务的run方法执行完毕),只能知道该任务已经出了任务队列,正在执行或者已经完成。

2、Java类库中提供的线程池简介:

     Java提供的线程池更加强大,相信理解线程池的工作原理,看类库中的线程池就不会感到陌生了。

在Java5之后,并 发线程这块发生了根本的变化,最重要的莫过于新的启动、调度、管理线程的一大堆API了。在Java5以后,通过Executor来启动线程比用 Thread的start()更好。在新特征中,可以很容易控制线程的启动、执行和关闭过程,还可以很容易使用线程池的特性。

  一、创建任务

  任务就是一个实现了Runnable接口的类。

  创建的时候实run方法即可。

  二、执行任务

  通过java.util.concurrent.ExecutorService接口对象来执行任务,该接口对象通过工具类java.util.concurrent.Executors的静态方法来创建。

  Executors此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。

   ExecutorService提供了管理终止的方法,以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。 可以关闭 ExecutorService,这将导致其停止接受新任务。关闭后,执行程序将最后终止,这时没有任务在执行,也没有任务在等待执行,并且无法提交新任 务。

  executorService.execute(new TestRunnable());

  1、创建ExecutorService

  通过工具类java.util.concurrent.Executors的静态方法来创建。

  Executors此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。

  比如,创建一个ExecutorService的实例,ExecutorService实际上是一个线程池的管理工具:

  ExecutorService executorService = Executors.newCachedThreadPool();

  ExecutorService executorService = Executors.newFixedThreadPool(3);

  ExecutorService executorService = Executors.newSingleThreadExecutor();

  2、将任务添加到线程去执行

  当将一个任务添加到线程池中的时候,线程池会为每个任务创建一个线程,该线程会在之后的某个时刻自动执行。

  三、关闭执行服务对象

  executorService.shutdown();

  四、综合实例

package concurrent;

import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors;

public class TestCachedThreadPool { 
        public static void main(String[] args) { 
//                ExecutorService executorService = Executors.newCachedThreadPool(); 
                ExecutorService executorService = Executors.newFixedThreadPool(5); //         ExecutorService executorService = Executors.newSingleThreadExecutor();

for (int i = 0; i < 5; i++) { 
                        executorService.execute(new TestRunnable()); 
                        System.out.println("************* a" + i + " *************"); 
                } 
                executorService.shutdown(); 
        } 
}

class TestRunnable implements Runnable { 
        public void run() { 
                System.out.println(Thread.currentThread().getName() + "线程被调用了。"); 
                while (true) { 
                        try { 
                                Thread.sleep(5000); 
                               System.out.println(Thread.currentThread().getName()); 
                        } catch (InterruptedException e) { 
                                e.printStackTrace(); 
                        } 
                } 
        } 
}

  运行结果:

************* a0 ************* 
************* a1 ************* 
pool-1-thread-2线程被调用了。 
************* a2 ************* 
pool-1-thread-3线程被调用了。 
pool-1-thread-1线程被调用了。 
************* a3 ************* 
************* a4 ************* 
pool-1-thread-4线程被调用了。 
pool-1-thread-5线程被调用了。 
pool-1-thread-2 
pool-1-thread-1 
pool-1-thread-3 
pool-1-thread-5 
pool-1-thread-4 
pool-1-thread-2 
pool-1-thread-1 
pool-1-thread-3 
pool-1-thread-5 
pool-1-thread-4

 五、获取任务的执行的返回值

  在Java5之 后,任务分两类:一类是实现了Runnable接口的类,一类是实现了Callable接口的类。两者都可以被ExecutorService执行,但是 Runnable任务没有返回值,而Callable任务有返回值。并且Callable的call()方法只能通过ExecutorService的 submit(Callable<T> task) 方法来执行,并且返回一个 <T> Future<T>,是表示任务等待完成的 Future.

  public interface Callable<V>返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法。

  Callable 接口类似于 Runnable,两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果,并且无法抛出经过检查的异常。

  Executors 类包含一些从其他普通形式转换成 Callable 类的实用方法。

  Callable中的call()方法类似Runnable的run()方法,就是前者有返回值,后者没有。

  当将一个Callable的对象传递给ExecutorService的submit方法,则该call方法自动在一个线程上执行,并且会返回执行结果Future对象。

  同样,将Runnable的对象传递给ExecutorService的submit方法,则该run方法自动在一个线程上执行,并且会返回执行结果Future对象,但是在该Future对象上调用get方法,将返回null.

  遗憾的是,在JavaAPI文档中,这块介绍的很糊涂,估计是翻译人员还没搞清楚的缘故吧。或者说是注释不到位。下面看个例子:

import java.util.ArrayList; 
import java.util.List; 
import java.util.concurrent.*;

public class CallableDemo { 
        public static void main(String[] args) { 
                ExecutorService executorService = Executors.newCachedThreadPool(); 
                List<Future<String>> resultList = new ArrayList<Future<String>>();

//创建10个任务并执行 
                for (int i = 0; i < 10; i++) { 
                        //使用ExecutorService执行Callable类型的任务,并将结果保存在future变量中 
                        Future<String> future = executorService.submit(new TaskWithResult(i)); 
                        //将任务执行结果存储到List中 
                        resultList.add(future); 
                }

//遍历任务的结果 
                for (Future<String> fs : resultList) { 
                        try { 
                                System.out.println(fs.get());     //打印各个线程(任务)执行的结果 
                        } catch (InterruptedException e) { 
                                e.printStackTrace(); 
                        } catch (ExecutionException e) { 
                                e.printStackTrace(); 
                        } finally { 
                                //启动一次顺序关闭,执行以前提交的任务,但不接受新任务。如果已经关闭,则调用没有其他作用。 
                                executorService.shutdown(); 
                        } 
                } 
        } 
}

class TaskWithResult implements Callable<String> { 
        private int id;

public TaskWithResult(int id) { 
                this.id = id; 
        }

public String call() throws Exception { 
                System.out.println("call()方法被自动调用,干活!!!             " + Thread.currentThread().getName()); 
                //一个模拟耗时的操作 
                for (int i = 999999; i > 0; i--) ; 
                return "call()方法被自动调用,任务的结果是:" + id + "    " + Thread.currentThread().getName(); 
        } 
}

  运行结果:

call()方法被自动调用,干活!!!             pool-1-thread-1 
call()方法被自动调用,干活!!!             pool-1-thread-3 
call()方法被自动调用,干活!!!             pool-1-thread-4 
call()方法被自动调用,干活!!!             pool-1-thread-6 
call()方法被自动调用,干活!!!             pool-1-thread-2 
call()方法被自动调用,干活!!!             pool-1-thread-5 
call()方法被自动调用,任务的结果是:0    pool-1-thread-1 
call()方法被自动调用,任务的结果是:1    pool-1-thread-2 
call()方法被自动调用,干活!!!             pool-1-thread-2 
call()方法被自动调用,干活!!!             pool-1-thread-6 
call()方法被自动调用,干活!!!             pool-1-thread-4 
call()方法被自动调用,任务的结果是:2    pool-1-thread-3 
call()方法被自动调用,干活!!!             pool-1-thread-3 
call()方法被自动调用,任务的结果是:3    pool-1-thread-4 
call()方法被自动调用,任务的结果是:4    pool-1-thread-5 
call()方法被自动调用,任务的结果是:5    pool-1-thread-6 
call()方法被自动调用,任务的结果是:6    pool-1-thread-2 
call()方法被自动调用,任务的结果是:7    pool-1-thread-6 
call()方法被自动调用,任务的结果是:8    pool-1-thread-4 
call()方法被自动调用,任务的结果是:9    pool-1-thread-3

Process finished with exit code 0

一个 ExecutorService,它使用可能的几个池线程之一执行每个提交的任务,通常使用 Executors 工厂方法配置。

线程池可以解决两个不 同问题:由于减少了每个任务调用的开销,它们通常可以在执行大量异步任务时提供增强的性能,并且还可以提供绑定和管理资源(包括执行集合任务时使用的线 程)的方法。每个 ThreadPoolExecutor 还维护着一些基本的统计数据,如完成的任务数。

为了便于跨大量上下文 使用,此类提供了很多可调整的参数和扩展挂钩。但是,强烈建议程序员使用较为方便的 Executors 工厂方法Executors.newCachedThreadPool()(无界线程池,可以进行自动线程回收)、 Executors.newFixedThreadPool(int)(固定大小线程池)和 Executors.newSingleThreadExecutor()(单个后台线程),它们均为大多数使用场景预定义了设置。

    1. 用法示例
    2. 下面给出了一个网络服务的简单结构,这里线程池中的线程作为传入的请求。它使用了预先配置的 Executors.newFixedThreadPool(int) 工厂方法:
    3. class NetworkService implements Runnable {
    4. private final ServerSocket serverSocket;
    5. private final ExecutorService pool;
    6. public NetworkService(int port, int poolSize)
    7. throws IOException {
    8. serverSocket = new ServerSocket(port);
    9. pool = Executors.newFixedThreadPool(poolSize);
    10. }
    11. public void run() { // run the service
    12. try {
    13. for (;;) {
    14. pool.execute(new Handler(serverSocket.accept()));
    15. }
    16. } catch (IOException ex) {
    17. pool.shutdown();
    18. }
    19. }
    20. }
    21. class Handler implements Runnable {
    22. private final Socket socket;
    23. Handler(Socket socket) { this.socket = socket; }
    24. public void run() {
    25. // read and service request on socket
    26. }
    27. }
    28. 下列方法分两个阶段关闭 ExecutorService。第一阶段调用 shutdown 拒绝传入任务,然后调用 shutdownNow(如有必要)取消所有遗留的任务:
    29. void shutdownAndAwaitTermination(ExecutorService pool) {
    30. pool.shutdown(); // Disable new tasks from being submitted
    31. try {
    32. // Wait a while for existing tasks to terminate
    33. if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
    34. pool.shutdownNow(); // Cancel currently executing tasks
    35. // Wait a while for tasks to respond to being cancelled
    36. if (!pool.awaitTermination(60, TimeUnit.SECONDS))
    37. System.err.println("Pool did not terminate");
    38. }
    39. } catch (InterruptedException ie) {
    40. // (Re-)Cancel if current thread also interrupted
    41. pool.shutdownNow();
    42. // Preserve interrupt status
    43. Thread.currentThread().interrupt();
    44. }
    45. }
    46. 内存一致性效果:线程中向 ExecutorService 提交 Runnable 或 Callable 任务之前的操作 happen-before 由该任务所提取的所有操作,后者依次 happen-before 通过 Future.get() 获取的结果。

java中线程池的几种实现方式的更多相关文章

  1. Java 中线程池的 7 种创建方式!

    在 Java 语言中,并发编程都是通过创建线程池来实现的,而线程池的创建方式也有很多种,每种线程池的创建方式都对应了不同的使用场景,总体来说线程池的创建可以分为以下两类: 通过 ThreadPoolE ...

  2. Java中线程池的实现原理

    知识点总结 ---------------------------------------------------------------------------------------------- ...

  3. Java中线程池,你真的会用吗?

    在<深入源码分析Java线程池的实现原理>这篇文章中,我们介绍过了Java中线程池的常见用法以及基本原理. 在文中有这样一段描述: 可以通过Executors静态工厂构建线程池,但一般不建 ...

  4. 沉淀再出发:java中线程池解析

    沉淀再出发:java中线程池解析 一.前言 在多线程执行的环境之中,如果线程执行的时间短但是启动的线程又非常多,线程运转的时间基本上浪费在了创建和销毁上面,因此有没有一种方式能够让一个线程执行完自己的 ...

  5. Java中线程池,你真的会用吗?ExecutorService ThreadPoolExcutor

    原文:https://www.hollischuang.com/archives/2888 在<深入源码分析Java线程池的实现原理>这篇文章中,我们介绍过了Java中线程池的常见用法以及 ...

  6. Java中线程池的学习

    线程池的基本思想还是一种对象池的思想,开辟一块内存空间,里面存放了众多(未死亡)的线程,池中线程执行调度由池管理器来处理.当有线程任务时,从池中取一个,执行完成后线程对象归池,这样可以避免反复创建线程 ...

  7. Java中线程池的实现原理-求职必备

    jdk1.5引入Executor线程池框架,通过它把任务的提交和执行进行解耦,只需要定义好任务,然后提交给线程池,而不用关心该任务是如何执行.被哪个线程执行,以及什么时候执行. 初始化线程池(4种) ...

  8. java中线程同步的几种方法

    1.使用synchronized关键字 由于java的每个对象都有一个内置锁,当用此关键字修饰方法时, 内置锁会保护整个方法.在调用该方法前,需要获得内置锁,否则就处于阻塞状态. 注: synchro ...

  9. java中线程池创建的几种方式

    java中创建线程池的方式一般有两种: 通过Executors工厂方法创建 通过new ThreadPoolExecutor(int corePoolSize, int maximumPoolSize ...

随机推荐

  1. NSNotificationCenter 注意

    成对出现 意思很简单,NSNotificationCenter消息的接受线程是基于发送消息的线程的.也就是同步的,因此,有时候,你发送的消息可能不在主线程,而大家都知道操作UI必须在主线程,不然会出现 ...

  2. event对象的理解

    0.给对象绑定事件准确的说是给对象事件绑定事件函数 1.event:事件对象,当一个事件发生的时候,和当前这个对象发生的事件有关的信息都会被i临时保存到event对象中 2.event对象必须在一个事 ...

  3. k8s容器挂载配置文件

    1.新建ConfigMap apiVersion: v1 kind: ConfigMap metadata: name: test-conf namespace: default labels: na ...

  4. Mouse Touch Stylus

    Mouse操作: preview mouse down, StylusDevice:null mouse down,StylusDevice:null preview mouse up, Stylus ...

  5. (最短路 dijkstra)昂贵的聘礼 -- poj -- 1062

    链接: http://poj.org/problem?id=1062 昂贵的聘礼 Time Limit: 1000MS   Memory Limit: 10000K Total Submissions ...

  6. 西邮Linux兴趣小组2014级免试挑战题

    原文链接:西邮Linux兴趣小组2014级免试挑战题 又到了小组纳新的季节^_^,时间过的真快! 想起去年这会儿自己做免试题的时候根本找不着北@_@  有幸今年能够在这里和大家分享免试挑战题,也正如我 ...

  7. Linux下的ICMP反弹后门:PRISM

    搜索的时候无意中看见的这款基于ping的ICMP后门.于是到作者的github上看看,居然是阴文的,为了过级,只能强忍着看了,学生狗伤不起.还好比较简单易懂,正如简介说的一样:“PRISM is an ...

  8. hdu 5039 线段树+dfs序

    http://acm.hdu.edu.cn/showproblem.php?pid=5039 给定一棵树,边权为0/1.m个操作支持翻转一条边的权值或者询问树上有多少条路径的边权和为奇数. 用树形df ...

  9. node API assert

    1.assert.throws(block, [error], [message]): assert.throws( function(){ throw new Error('wrong'); }, ...

  10. WC Java 实现

    项目 github 地址 一. 实现情况 基本要求 c 统计文件字符数 (实现) w 统计文件词数 (实现) l 统计文件行数(实现) 扩展功能 s 递归处理目录下符合条件得文件(实现) a 返回文件 ...