java多线程总结五：线程池的原理及实现

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）来完成了

[java] view plain copy print?

  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. }

package mine.util.thread;

import java.util.LinkedList;
import java.util.List;

/**
 * 线程池类，线程管理器：创建线程，执行任务，销毁线程，获取线程基本信息
 */
public final class ThreadPool {
	// 线程池中默认线程的个数为5
	private static int worker_num = 5;
	// 工作线程
	private WorkThread[] workThrads;
	// 未处理的任务
	private static volatile int finished_task = 0;
	// 任务队列，作为一个缓冲,List线程不安全
	private List<Runnable> taskQueue = new LinkedList<Runnable>();
	private static ThreadPool threadPool;

	// 创建具有默认线程个数的线程池
	private ThreadPool() {
		this(5);
	}

	// 创建线程池,worker_num为线程池中工作线程的个数
	private ThreadPool(int worker_num) {
		ThreadPool.worker_num = worker_num;
		workThrads = new WorkThread[worker_num];
		for (int i = 0; i < worker_num; i++) {
			workThrads[i] = new WorkThread();
			workThrads[i].start();// 开启线程池中的线程
		}
	}

	// 单态模式，获得一个默认线程个数的线程池
	public static ThreadPool getThreadPool() {
		return getThreadPool(ThreadPool.worker_num);
	}

	// 单态模式，获得一个指定线程个数的线程池,worker_num(>0)为线程池中工作线程的个数
	// worker_num<=0创建默认的工作线程个数
	public static ThreadPool getThreadPool(int worker_num1) {
		if (worker_num1 <= 0)
			worker_num1 = ThreadPool.worker_num;
		if (threadPool == null)
			threadPool = new ThreadPool(worker_num1);
		return threadPool;
	}

	// 执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定
	public void execute(Runnable task) {
		synchronized (taskQueue) {
			taskQueue.add(task);
			taskQueue.notify();
		}
	}

	// 批量执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定
	public void execute(Runnable[] task) {
		synchronized (taskQueue) {
			for (Runnable t : task)
				taskQueue.add(t);
			taskQueue.notify();
		}
	}

	// 批量执行任务,其实只是把任务加入任务队列，什么时候执行有线程池管理器觉定
	public void execute(List<Runnable> task) {
		synchronized (taskQueue) {
			for (Runnable t : task)
				taskQueue.add(t);
			taskQueue.notify();
		}
	}

	// 销毁线程池,该方法保证在所有任务都完成的情况下才销毁所有线程，否则等待任务完成才销毁
	public void destroy() {
		while (!taskQueue.isEmpty()) {// 如果还有任务没执行完成，就先睡会吧
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		// 工作线程停止工作，且置为null
		for (int i = 0; i < worker_num; i++) {
			workThrads[i].stopWorker();
			workThrads[i] = null;
		}
		threadPool=null;
		taskQueue.clear();// 清空任务队列
	}

	// 返回工作线程的个数
	public int getWorkThreadNumber() {
		return worker_num;
	}

	// 返回已完成任务的个数,这里的已完成是只出了任务队列的任务个数，可能该任务并没有实际执行完成
	public int getFinishedTasknumber() {
		return finished_task;
	}

	// 返回任务队列的长度，即还没处理的任务个数
	public int getWaitTasknumber() {
		return taskQueue.size();
	}

	// 覆盖toString方法，返回线程池信息：工作线程个数和已完成任务个数
	@Override
	public String toString() {
		return "WorkThread number:" + worker_num + "  finished task number:"
				+ finished_task + "  wait task number:" + getWaitTasknumber();
	}

	/**
	 * 内部类，工作线程
	 */
	private class WorkThread extends Thread {
		// 该工作线程是否有效，用于结束该工作线程
		private boolean isRunning = true;

		/*
		 * 关键所在啊，如果任务队列不空，则取出任务执行，若任务队列空，则等待
		 */
		@Override
		public void run() {
			Runnable r = null;
			while (isRunning) {// 注意，若线程无效则自然结束run方法，该线程就没用了
				synchronized (taskQueue) {
					while (isRunning && taskQueue.isEmpty()) {// 队列为空
						try {
							taskQueue.wait(20);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
					if (!taskQueue.isEmpty())
						r = taskQueue.remove(0);// 取出任务
				}
				if (r != null) {
					r.run();// 执行任务
				}
				finished_task++;
				r = null;
			}
		}

		// 停止工作，让该线程自然执行完run方法，自然结束
		public void stopWorker() {
			isRunning = false;
		}
	}
}

测试代码：

[java] view plain copy print?

  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. }

package mine.util.thread;

//测试线程池
public class TestThreadPool {
	public static void main(String[] args) {
		// 创建3个线程的线程池
		ThreadPool t = ThreadPool.getThreadPool(3);
		t.execute(new Runnable[] { new Task(), new Task(), new Task() });
		t.execute(new Runnable[] { new Task(), new Task(), new Task() });
		System.out.println(t);
		t.destroy();// 所有线程都执行完成才destory
		System.out.println(t);
	}

	// 任务类
	static class Task implements Runnable {
		private static volatile int i = 1;

		@Override
		public void run() {// 执行任务
			System.out.println("任务 " + (i++) + " 完成");
		}
	}
}

运行结果：

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提供的线程池更加强大，相信理解线程池的工作原理，看类库中的线程池就不会感到陌生了。

其他具体内容查看jdk帮助或看jdk源代码吧。。。

参考文章：http://hi.baidu.com/obullxl/blog/item/ee50ad1ba8e8ff1f8718bf66.html

时间： 2024-12-07 13:12:57

java多线程总结五：线程池的原理及实现的相关文章

Java多线程-新特性-线程池

Sun在Java5中,对Java线程的类库做了大量的扩展,其中线程池就是Java5的新特征之一,除了线程池之外,还有很多多线程相关的内容,为多线程的编程带来了极大便利.为了编写高效稳定可靠的多线程程序,线程部分的新增内容显得尤为重要. 有关Java5线程新特征的内容全部在java.util.concurrent下面,里面包含数目众多的接口和类,熟悉这部分API特征是一项艰难的学习过程.目前有关这方面的资料和书籍都少之又少,大部分介绍线程方面书籍还停留在java5之前的知识层面上. 在Java5之

Java多线程系列--“JUC线程池”03之 线程池原理(二)

线程池示例 在分析线程池之前,先看一个简单的线程池示例. import java.util.concurrent.Executors; import java.util.concurrent.ExecutorService; public class ThreadPoolDemo1 { public static void main(String[] args) { // 创建一个可重用固定线程数的线程池 ExecutorService pool = Executors.newFixedThre

Java多线程系列--“JUC线程池”05之 线程池原理(四)

拒绝策略介绍 线程池的拒绝策略,是指当任务添加到线程池中被拒绝,而采取的处理措施.当任务添加到线程池中之所以被拒绝,可能是由于:第一,线程池异常关闭.第二,任务数量超过线程池的最大限制. 线程池共包括4种拒绝策略,它们分别是:AbortPolicy, CallerRunsPolicy, DiscardOldestPolicy和DiscardPolicy. AbortPolicy -- 当任务添加到线程池中被拒绝时,它将抛出 RejectedExecutionException 异常. Calle

Java多线程系列--“JUC线程池”02之 线程池原理(一)

ThreadPoolExecutor简介 ThreadPoolExecutor是线程池类.对于线程池,可以通俗的将它理解为"存放一定数量线程的一个线程集合.线程池允许同时运行的线程数量就是线程池的容量:当添加到线程池中的线程超过它的容量时,会有一部分线程阻塞等待.线程池会通过相应的调度策略和拒绝策略,对添加到线程池中的线程进行管理." ThreadPoolExecutor数据结构 ThreadPoolExecutor的数据结构如下图所示: 各个数据在ThreadPoolExecutor

Java多线程系列--“JUC线程池”04之 线程池原理(三)

本章介绍线程池的生命周期. 线程有5种状态:新建状态,就绪状态,运行状态,阻塞状态,死亡状态.线程池也有5种状态:然而,线程池不同于线程,线程池的5种状态是:Running, SHUTDOWN, STOP, TIDYING, TERMINATED. 线程池状态定义代码如下: /** * The main pool control state, ctl, is an atomic integer packing * two conceptual fields * workerCount, indi

Java多线程系列 JUC线程池07 线程池原理解析(六)

 关闭“线程池” shutdown()的源码如下: public void shutdown() { final ReentrantLock mainLock = this.mainLock; // 获取锁 mainLock.lock(); try { // 检查终止线程池的“线程”是否有权限. checkShutdownAccess(); // 设置线程池的状态为关闭状态. advanceRunState(SHUTDOWN); // 中断线程池中空闲的线程. interruptIdleWork

Java多线程系列--“JUC线程池”06之 Callable和Future

概要 本章介绍线程池中的Callable和Future.Callable 和 Future 简介示例和源码分析(基于JDK1.7.0_40) 转载请注明出处:http://www.cnblogs.com/skywang12345/p/3544116.html Callable 和 Future 简介 Callable 和 Future 是比较有趣的一对组合.当我们需要获取线程的执行结果时,就需要用到它们.Callable用于产生结果,Future用于获取结果. 1. Callable Calla

Java多线程系列--“JUC线程池”01之 线程池架构

概要 前面分别介绍了"Java多线程基础"."JUC原子类"和"JUC锁".本章介绍JUC的最后一部分的内容——线程池.内容包括:线程池架构图线程池示例 转载请注明出处:http://www.cnblogs.com/skywang12345/p/3509903.html 线程池架构图 线程池的架构图如下: 1. Executor 它是"执行者"接口,它是来执行任务的.准确的说,Executor提供了execute()接口来执行

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

前序: Thread-Per-Message Pattern,是一种对于每个命令或请求,都分配一个线程,由这个线程执行工作.它将“委托消息的一端”和“执行消息的一端”用两个不同的线程来实现.该线程模式主要包括三个部分: 1,Request参与者(委托人),也就是消息发送端或者命令请求端 2,Host参与者,接受消息的请求,负责为每个消息分配一个工作线程. 3,Worker参与者,具体执行Request参与者的任务的线程,由Host参与者来启动. 由于常规调用一个方法后,必须等待该方法完全执行完毕

Java多线程——Executors和线程池

线程池的概念与Executors类的应用 1.创建固定大小的线程池 package java_thread; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class ThreadPoolTest { /** * @param args */ public static void mai