1. 
   
2. /*
   
3. * 线程池：
   
4. *
   
5. * 1.当使用继承Thread的方式实现线程，如果想反复的使用此线程，不能多次调用start()；
   
6. *   可以多次实例化此类的对象，然后再启动线程。
   
7. * 2.如果线程的启动，或者构造比较耗时，那么就大大的影响效率；
   
8. * 3.JDK5之后，提供了一个"线程池"，这个"线程池"可以缓存一些"线程对象"，
   
9. *   如果需要再次使用时，无需重复构造，直接从"池"中取出线程对象使用即可；
   
10. * 4.JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
    
11.                 public static ExecutorService newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
    
12.                 public static ExecutorService newFixedThreadPool(int nThreads)：创建一个可重用固定线程数的线程池
    
13.                 public static ExecutorService newSingleThreadExecutor()：创建一个使用单个 worker 线程的 Executor
    
14.          ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
    
15.                 Future<?> submit(Runnable task)
    
16.                 <T> Future<T> submit(Callable<T> task)
    
17. 
    
18. */
    
19. public class Demo {
    
20.         public static void main(String[] args) {
    
21.                 /*MyThread t1 = new MyThread();//需要5秒
    
22.                 t1.start();
    
23.                
    
24.                 System.out.println("主进程等待2秒......");
    
25.                 try {
    
26.                         Thread.sleep(1000 * 2);
    
27.                 } catch (InterruptedException e) {
    
28.                         e.printStackTrace();
    
29.                 }
    
30.                
    
31.                 System.out.println("再次启动MyThread");
    
32.                 t1 = new MyThread();//再次需要5秒
    
33.                 t1.start();*/
    
34.                
    
35.                 //获取一个"线程池"对象
    
36.                 ExecutorService service = Executors.newFixedThreadPool(2);
    
37.                 MyThread t3 = new MyThread();//需要5秒
    
38.                 //执行线程t3
    
39.                 service.submit(t3);
    
40.                
    
41.                 System.out.println("主进程休息2秒钟......");
    
42.                 try {
    
43.                         Thread.sleep(1000 * 2);
    
44.                 } catch (InterruptedException e) {
    
45.                         e.printStackTrace();
    
46.                 }
    
47.                 System.out.println("主进程再次启动线程......");
    
48.                 service.submit(t3);//无需再次构造
    
49.                
    
50.                 //将线程池停止
    
51.                 service.shutdown();
    
52.                
    
53.                
    
54.         }
    
55. }
    
56. package cn.itcast.demo05_线程池;
    
57. 
    
58. public class MyThread extends Thread{
    
59.         public MyThread(){
    
60.                 System.out.println("实例化一个我的对象，很耗时哟，需要5秒钟......");
    
61.                 for(int i = 0;i < 5 ; i++){
    
62.                         System.out.println(i + 1);
    
63.                         try {
    
64.                                 Thread.sleep(1000);
    
65.                         } catch (InterruptedException e) {
    
66.                                 e.printStackTrace();
    
67.                         }
    
68.                 }
    
69.         }
    
70.         @Override
    
71.         public void run() {
    
72.                 System.out.println("线程打印：run()......");
    
73.         }
    
74. }
    

复制代码

总结的不错啊

看起来好复杂，不过学到了，谢了