关闭

Java多线程之ThreadPool

2369人阅读 评论(0) 收藏 举报

这里演示了普通线程池以及带有返回值的线程池的使用方式

  1. package com.jadyer.thread.pool;  
  2.   
  3. import java.util.Random;  
  4. import java.util.concurrent.Callable;  
  5. import java.util.concurrent.CompletionService;  
  6. import java.util.concurrent.ExecutionException;  
  7. import java.util.concurrent.ExecutorCompletionService;  
  8. import java.util.concurrent.ExecutorService;  
  9. import java.util.concurrent.Executors;  
  10. import java.util.concurrent.Future;  
  11. import java.util.concurrent.TimeUnit;  
  12.   
  13. /** 
  14.  * ThreadPool Test 
  15.  * @see ================================================================================================ 
  16.  * @see 线程与进程的区别 
  17.  * @see 1)多个进程的内部数据和状态是完全独立的,而多线程则会共享一块内存空间和一组系统资源,有可能互相影响 
  18.  * @see 2)线程本身的数据通常只有寄存器数据,以及一个程序执行时使用的堆栈。所以线程的切换比进程切换的负担要小 
  19.  * @see ================================================================================================ 
  20.  * @see 线程的启动方式和消亡 
  21.  * @see 1)以Thread.start()启动时,JVM会以线程的方式运行它。start()首先会为线程的执行准备系统资源,然后才去调用run方法 
  22.  * @see 2)以Thread.run()启动时,JVM会以普通方法运行它。此时就不会存在线程所特有的交替执行的效果 
  23.  * @see 3)一个线程类的两个对象,同时以start()方式运行时,JVM仍会把它们当作两个线程类来执行 
  24.  * @see 4)终止线程时,绝对不能使用stop()方法,而应该让run()自然结束 
  25.  * @see ================================================================================================ 
  26.  * @author 宏宇 
  27.  * @create Feb 29, 2012 1:13:43 AM 
  28.  */  
  29. public class ThreadPoolTest {  
  30.     public static void main(String[] args) {  
  31.         new ThreadPoolTest().threadPoolTest();  
  32.         new ThreadPoolTest().threadPoolScheduledTest();  
  33.         new ThreadPoolTest().threadPoolCallbaleAndFutureSignTest();  
  34.         new ThreadPoolTest().threadPoolCallbaleAndFutureMoreTest();  
  35.     }  
  36.       
  37.     /** 
  38.      * 创建线程池的几种方式 
  39.      * @see Executors.newFixedThreadPool(3);     //创建固定大小的线程池 
  40.      * @see Executors.newCachedThreadPool();     //创建缓存线程池。它会根据实际请求的线程数量动态创建线程 
  41.      * @see Executors.newSingleThreadExecutor(); //创建单个线程池。它可以实现线程死掉后重新启动的效果,但实际启动的是"替补线程" 
  42.      */  
  43.     public void threadPoolTest(){  
  44.         //newSingleThreadExecutor()的好处就是,若池中的线程死了,它会把一个"替补的线程"扶上位,即它会保证池中始终有一个线程存在   
  45.         ExecutorService threadPool = Executors.newSingleThreadExecutor();  
  46.         for(int i=1; i<=10; i++) {  
  47.             final int task = i;  
  48.             threadPool.execute(new MyThread(task)); //注意execute()的返回值是void   
  49.         }  
  50.         System.out.println("all of 10 tasks have committed......");  
  51.           
  52.         //线程池中的任务均执行完毕后,关闭线程池   
  53.         threadPool.shutdown();  
  54.     }  
  55.       
  56.     /** 
  57.      * 线程池启动定时器 
  58.      * @see Executors.newScheduledThreadPool(3).schedule();            //创建并执行在给定延迟后启用的一次性操作 
  59.      * @see Executors.newScheduledThreadPool(3).scheduleAtFixedRate(); //首次启动后,以固定的频率自动执行操作 
  60.      * @see scheduleAtFixedRate()支持间隔重复任务的定时方式,但不直接支持绝对定时方式,我们需要转换为相对时间的方式,来执行 
  61.      */  
  62.     public void threadPoolScheduledTest(){  
  63.         //10秒后自动执行一次   
  64.         //Executors.newScheduledThreadPool(3).schedule(new MyScheduledThread(), 10, TimeUnit.SECONDS);   
  65.         //6秒后首次执行,之后每2秒均自动执行一次   
  66.         Executors.newScheduledThreadPool(3).scheduleAtFixedRate(new MyScheduledThread(), 62, TimeUnit.SECONDS);  
  67.     }  
  68.       
  69.     /** 
  70.      * 线程池返回一个任务的值 
  71.      * @see 注意:这里需使用java.util.concurrent.ExecutorService.submit()来提交,它会返回Future对象 
  72.      * @see 注意:Future取得的结果类型,与Callable返回的结果类型,必须一致。我们这里是通过泛型来实现的 
  73.      */  
  74.     public void threadPoolCallbaleAndFutureSignTest(){  
  75.         ExecutorService threadPool =  Executors.newSingleThreadExecutor();  
  76.         Future<String> future = threadPool.submit(  
  77.             new Callable<String>() {  
  78.                 @Override  
  79.                 public String call() throws Exception {  
  80.                     Thread.sleep(2000);  
  81.                     return "张起灵";  
  82.                 };  
  83.             }  
  84.         );  
  85.         System.out.println("等待结果");  
  86.         try {  
  87.             System.out.println("拿到结果:" + future.get()); //future.get(4, TimeUnit.SECONDS)   
  88.         } catch (InterruptedException e) {  
  89.             e.printStackTrace();  
  90.         } catch (ExecutionException e) {  
  91.             e.printStackTrace();  
  92.         }  
  93.     }  
  94.       
  95.     /** 
  96.      * 线程池返回多个任务的值 
  97.      * @see java.util.concurrent.CompletionService用于提交一组Callable任务 
  98.      * @see CompletionService.take()会返回已完成的一个Callable任务所对应的Future对象 
  99.      * @see 这就好比同时种植了几块菜地,然后等待收菜。收菜时,哪块菜熟了,就先去收哪块菜地的菜 
  100.      */  
  101.     public void threadPoolCallbaleAndFutureMoreTest(){  
  102.         ExecutorService threadPool =  Executors.newFixedThreadPool(5);  
  103.         CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(threadPool);  
  104.         for(int i=1; i<=5; i++){  
  105.             final int taskCode = i;  
  106.             completionService.submit(  
  107.                 new Callable<Integer>(){  
  108.                     @Override  
  109.                     public Integer call() throws Exception {  
  110.                         Thread.sleep(new Random().nextInt(5000));  
  111.                         return taskCode;  
  112.                     }  
  113.                 }  
  114.             );  
  115.         }  
  116.         for(int i=0; i<5; i++){  
  117.             try {  
  118.                 System.out.println(completionService.take().get());  
  119.             } catch (InterruptedException e) {  
  120.                 e.printStackTrace();  
  121.             } catch (ExecutionException e) {  
  122.                 e.printStackTrace();  
  123.             }  
  124.         }  
  125.     }  
  126. }  
  127.   
  128.   
  129. class MyThread implements Runnable{  
  130.     private Integer task;  
  131.     public MyThread(Integer task){  
  132.         this.task = task;  
  133.     }  
  134.     @Override  
  135.     public void run() {  
  136.         //这里不需要写成j,因为它和threadPoolTest()里面的for()循环中的i并不是同一个方法中的变量,故其不会冲突   
  137.         for(int i=1; i<=10; i++) {  
  138.             try {  
  139.                 Thread.sleep(20);  
  140.             } catch (InterruptedException e) {  
  141.                 e.printStackTrace();  
  142.             }  
  143.             System.out.println(Thread.currentThread().getName() + " is looping of " + i + " for  task of " + task);  
  144.         }  
  145.     }  
  146. }  
  147.   
  148.   
  149. class MyScheduledThread implements Runnable{  
  150.     @Override  
  151.     public void run() {  
  152.         System.out.println("bombing......");  
  153.     }  
  154. }  
2
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:269186次
    • 积分:4812
    • 等级:
    • 排名:第5946名
    • 原创:201篇
    • 转载:19篇
    • 译文:2篇
    • 评论:33条
    文章分类
    最新评论