博客分类：
线程池的作用:
线程池作用就是限制系统中执行线程的数量。
根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程 排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程 池中有等待的工作线程，就可以开始运行了；否则进入等待队列。
为什么要用线程池:
- 减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务
- 可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)
线程池类
1. package
2.
3. import
4.
5. /**
6. * @project LocationGateway
7. * @author sunnylocus
8. * @verson 1.0.0
9. * @date Aug 2, 2008
10. * @jdk 1.4.2
11. */
12. public class ThreadPool extends
13. private boolean isClosed = false ; //线程池是否关闭
14. private LinkedList workQueue; //工作队列
15. private static int threadPoolID = 1 ; //线程池的id
16. public ThreadPool( int poolSize) { //poolSize 表示线程池中的工作线程的数量
17.
18. super (threadPoolID + "" ); //指定ThreadGroup的名称
19. true ); //继承到的方法，设置是否守护线程池
20. new LinkedList(); //创建工作队列
21. for ( int i = 0
22. new WorkThread(i).start(); //创建并启动工作线程,线程池数量是多少就创建多少个工作线程
23. }
24. }
25.
26. /** 向工作队列中加入一个新任务,由工作线程去执行该任务*/
27. public synchronized void
28. if
29. throw new
30. }
31. if (task != null
32. //向队列中加入一个任务
33. //唤醒一个正在getTask()方法中待任务的工作线程
34. }
35. }
36.
37. /** 从工作队列中取出一个任务,工作线程会调用此方法*/
38. private synchronized Runnable getTask( int threadid) throws
39. while (workQueue.size() == 0
40. if (isClosed) return null
41. "工作线程" +threadid+ "等待任务..."
42. //如果工作队列中没有任务,就等待任务
43. }
44. "工作线程" +threadid+ "开始执行任务..."
45. return (Runnable) workQueue.removeFirst(); //反回队列中第一个元素,并从队列中删除
46. }
47.
48. /** 关闭线程池 */
49. public synchronized void
50. if
51. //等待工作线程执行完毕
52. true
53. //清空工作队列
54. //中断线程池中的所有的工作线程,此方法继承自ThreadGroup类
55. }
56. }
57.
58. /** 等待工作线程把所有任务执行完毕*/
59. public void
60. synchronized ( this
61. true
62. //唤醒所有还在getTask()方法中等待任务的工作线程
63. }
64. new Thread[activeCount()]; //activeCount() 返回该线程组中活动线程的估计值。
65. int count = enumerate(threads); //enumerate()方法继承自ThreadGroup类，根据活动线程的估计值获得线程组中当前所有活动的工作线程
66. for ( int i = 0 ; i < count; i++) { //等待所有工作线程结束
67. try
68. //等待工作线程结束
69. catch
70. ex.printStackTrace();
71. }
72. }
73. }
74.
75. /**
76. * 内部类,工作线程,负责从工作队列中取出任务,并执行
77. * @author sunnylocus
78. */
79. private class WorkThread extends
80. private int
81. public WorkThread( int
82. //父类构造方法,将线程加入到当前ThreadPool线程组中
83. super (ThreadPool. this ,id+ ""
84. this
85. }
86. public void
87. while (! isInterrupted()) { //isInterrupted()方法继承自Thread类，判断线程是否被中断
88. null
89. try
90. //取出任务
91. catch
92. ex.printStackTrace();
93. }
94. //如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程
95. if (task == null ) return
96.
97. try
98. //运行任务
99. catch
100. t.printStackTrace();
101. }
102. // end while
103. // end run
104. // end workThread
105. }
2.测试类
1. package
2.
3. import
4.
5. public class
6.
7. public static void main(String[] args) throws
8. new ThreadPool( 3 ); //创建一个有个3工作线程的线程池
9. 500 ); //休眠500毫秒,以便让线程池中的工作线程全部运行
10. //运行任务
11. for ( int i = 0 ; i <= 5 ; i++) { //创建6个任务
12. threadPool.execute(createTask(i));
13. }
14. //等待所有任务执行完毕
15. //关闭线程池
16.
17. }
18.
19. private static Runnable createTask( final int
20. return new
21. public void
22. // System.out.println("Task" + taskID + "开始");
23. "Hello world"
24. // System.out.println("Task" + taskID + "结束");
25. }
26. };
27. }
28. }
结果:
1. 0
2. 1
3. 2
4.
5. 0
6. Hello world
7. 0
8.
9. 1
10. Hello world
11. 1
12.
13. 2
14. Hello world
15. 2
16.
17. 0
18. Hello world
19. 0
20.
21. 1
22. Hello world
23. 1
24.
25. 2
26. Hello world
27. 2
