线程池

 1 package concurrency;
 2 
 3 import java.util.concurrent.BlockingQueue;
 4 import java.util.concurrent.Callable;
 5 import java.util.concurrent.ExecutionException;
 6 import java.util.concurrent.Future;
 7 import java.util.concurrent.LinkedBlockingQueue;
 8 import java.util.concurrent.ThreadPoolExecutor;
 9 import java.util.concurrent.TimeUnit;
10 
11 public class ThreadPoolTest {
12     //定义任务队列
13     private static BlockingQueue<Runnable> workQueue =new LinkedBlockingQueue<Runnable>();
14     //创建线程池
15     private static ThreadPoolExecutor executor =
16             new ThreadPoolExecutor(10, 25, 1000000, TimeUnit.NANOSECONDS, workQueue);
17 //ThreadPoolExecutor 实现了ExecutorService接口，所以executor也是一个ExecutorService
18     //    private static ExecutorService executor =
19 //            new ThreadPoolExecutor(10, 25, 1000000, TimeUnit.NANOSECONDS, workQueue);
20     public static void main(String[] args) throws InterruptedException, ExecutionException {
21         //execute()方法用于提交不需要返回值的任务
22         executor.execute(new ThreadPoolJob());
23         
24         //submit 方法用于提交需要返回值的任务
25         executor.submit(new ThreadPoolJob());//可以提交Runnable类型的job
26         
27         Future<String> future = executor.submit(new ThreadPoolCalJob());//也可以提交Callable类型的job
28         String result = future.get();//Future.get()会一直阻塞到job完成并返回结果
29         
30         System.out.println("result=" + result);
31 
32         System.out.println("zuse ing");
33         System.out.println(Runtime.getRuntime().availableProcessors());
34         executor.shutdown();//将线程池状态设置为shutdown，并中断所有没有正在执行任务的线程
35         //List<Runnable> jobs = executor.shutdownNow();//将线程池的状态设置为stoped，并尝试停止所有正在执行或者暂停任务的线程，并返回等待执行任务的列表
36     }
37     
38 }
39 class ThreadPoolJob implements Runnable{
40 
41     @Override
42     public void run() {
43         System.out.println("i am a runnable..");
44     }
45     
46 }
47 
48 class ThreadPoolCalJob implements Callable<String>{
49 
50     @Override
51     public String call() throws Exception {
52         System.out.println("submit a callable");
53         Thread.sleep(3000);
54         return "ThreadPoolCalJob return a callable";
55     }
56     
57 }

 1 package concurrency;
 2 
 3 import java.util.concurrent.ExecutorService;
 4 import java.util.concurrent.Executors;
 5 
 6 public class ExecutorTest {
 7     public static void main(String[] args) {
 8         //新建一个大小无界的线程池，适用于执行很多的短期异步任务的小程序，或者负载较轻的服务器
 9         ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
10         //新建一个固定线程数的线程池，适用于负载较重的服务器
11         ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
12         //在给定的延迟后运行命令，或者定期执行命令
13         ExecutorService sheduledThreadPool = Executors.newScheduledThreadPool(3);
14         //创建单个线程的线程池，适用于需要保证顺序执行各个人物，并在任意时间点不会有多个线程是活动的场景
15         ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
16     }
17     
18 }