1. package com.kxg_05;
   
2. 
   
3. import java.util.concurrent.ExecutorService;
   
4. import java.util.concurrent.Executors;
   
5. 
   
6. /*
   
7. *
   
8. * 线程池：
   
9. *                 JDK5以后新增一个Execuors工厂类产生线程池
   
10. * 好处：
    
11. *                 线程池里面的每一个线程代码结束后，并不会死亡，而是再次回到线程池中称为空闲状态，等待下一个对象使用
    
12. *
    
13. * 实现线程池代码：
    
14. *                 1.创建一个线程池，指定控制几个线程
    
15. *                         public static ExecutorService newFixedThreadPool(int nThreads)
    
16. *                 2.线程池可以操作线程
    
17. *                         Runnable接口实现类和Callable接口实现类
    
18. *                 3.怎么把线程添加到线程池中
    
19. *                         由于线程池是ExecutorService类，调用以下方法添加
    
20. *                         <T> Future<T> submit(Callable<T> task)：添加Callable实现类
    
21. *                         Future<?> submit(Runnable task)：添加Runnable实现类
    
22. *                 4.结束线程
    
23. *                         void shutdown()
    
24. */
    
25. public class ExecutorsDemo {
    
26.         public static void main(String[] args) {
    
27.                 // public static ExecutorService newFixedThreadPool(int
    
28.                 // nThreads):创建一个指定容量的线程池
    
29.                 ExecutorService pool = Executors.newFixedThreadPool(2);
    
30. 
    
31.                 // 添加线程，Future<?> submit(Runnable task)
    
32.                 MyRunnable mr1 = new MyRunnable();
    
33.                 MyRunnable mr2 = new MyRunnable();
    
34.                 pool.submit(mr1);
    
35.                 pool.submit(mr2);
    
36. 
    
37.                 // 结束线程
    
38.                 pool.shutdown();
    
39.         }
    
40. }

复制代码

1. package com.kxg_05;
   
2. 
   
3. public class MyRunnable implements Runnable {
   
4. 
   
5.         @Override
   
6.         public void run() {
   
7.                 for (int i = 0; i < 100; i++) {
   
8.                         System.out.println(Thread.currentThread().getName() + ":" + i);
   
9.                 }
   
10.         }
    
11. }

复制代码

这个没讲吧