Java多线程之ThreadPool

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

package com.jadyer.thread.pool;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
/**
* ThreadPool Test
* @see ================================================================================================
* @see 线程与进程的区别
* @see 1）多个进程的内部数据和状态是完全独立的，而多线程则会共享一块内存空间和一组系统资源，有可能互相影响
* @see 2）线程本身的数据通常只有寄存器数据，以及一个程序执行时使用的堆栈。所以线程的切换比进程切换的负担要小
* @see ================================================================================================
* @see 线程的启动方式和消亡
* @see 1）以Thread.start（）启动时，JVM会以线程的方式运行它。start（）首先会为线程的执行准备系统资源，然后才去调用run方法
* @see 2）以Thread.run（）启动时，JVM会以普通方法运行它。此时就不会存在线程所特有的交替执行的效果
* @see 3）一个线程类的两个对象，同时以start（）方式运行时，JVM仍会把它们当作两个线程类来执行
* @see 4）终止线程时，绝对不能使用stop（）方法，而应该让run（）自然结束
* @see ================================================================================================
* @author 宏宇
* @create Feb 29, 2012 1:13:43 AM
*/
public class ThreadPoolTest {
public static void main（String[] args） {
new ThreadPoolTest（）.threadPoolTest（）;
new ThreadPoolTest（）.threadPoolScheduledTest（）;
new ThreadPoolTest（）.threadPoolCallbaleAndFutureSignTest（）;
new ThreadPoolTest（）.threadPoolCallbaleAndFutureMoreTest（）;
}
/**
* 创建线程池的几种方式
* @see Executors.newFixedThreadPool（3）; //创建固定大小的线程池
* @see Executors.newCachedThreadPool（）; //创建缓存线程池。它会根据实际请求的线程数量动态创建线程
* @see Executors.newSingleThreadExecutor（）; //创建单个线程池。它可以实现线程死掉后重新启动的效果，但实际启动的是"替补线程"
*/
public void threadPoolTest（）{
//newSingleThreadExecutor（）的好处就是，若池中的线程死了，它会把一个"替补的线程"扶上位，即它会保证池中始终有一个线程存在
ExecutorService threadPool = Executors.newSingleThreadExecutor（）;
for（int i=1; i<=10; i++） {
final int task = i;
threadPool.execute（new MyThread（task））; //注意execute（）的返回值是void
}
System.out.println（"all of 10 tasks have committed......"）;
//线程池中的任务均执行完毕后，关闭线程池
threadPool.shutdown（）;
}
/**
* 线程池启动定时器
* @see Executors.newScheduledThreadPool（3）.schedule（）; //创建并执行在给定延迟后启用的一次性操作
* @see Executors.newScheduledThreadPool（3）.scheduleAtFixedRate（）; //首次启动后，以固定的频率自动执行操作
* @see scheduleAtFixedRate（）支持间隔重复任务的定时方式，但不直接支持绝对定时方式，我们需要转换为相对时间的方式，来执行
*/
public void threadPoolScheduledTest（）{
//10秒后自动执行一次
//Executors.newScheduledThreadPool（3）.schedule（new MyScheduledThread（）, 10, TimeUnit.SECONDS）;
//6秒后首次执行，之后每2秒均自动执行一次
Executors.newScheduledThreadPool（3）.scheduleAtFixedRate（new MyScheduledThread（）, 6, 2, TimeUnit.SECONDS）;
}
/**
* 线程池返回一个任务的值
* @see 注意：这里需使用java.util.concurrent.ExecutorService.submit（）来提交，它会返回Future对象
* @see 注意：Future取得的结果类型，与Callable返回的结果类型，必须一致。我们这里是通过泛型来实现的
*/
public void threadPoolCallbaleAndFutureSignTest（）{
ExecutorService threadPool = Executors.newSingleThreadExecutor（）;
Future<String> future = threadPool.submit（
new Callable<String>（） {
@Override
public String call（） throws Exception {
Thread.sleep（2000）;
return "张起灵";
};
}
）;
System.out.println（"等待结果"）;
try {
System.out.println（"拿到结果：" + future.get（））; //future.get（4, TimeUnit.SECONDS）
} catch （InterruptedException e） {
e.printStackTrace（）;
} catch （ExecutionException e） {
e.printStackTrace（）;
}
}
/**
* 线程池返回多个任务的值
* @see java.util.concurrent.CompletionService用于提交一组Callable任务
* @see CompletionService.take（）会返回已完成的一个Callable任务所对应的Future对象
* @see 这就好比同时种植了几块菜地，然后等待收菜。收菜时，哪块菜熟了，就先去收哪块菜地的菜
*/
public void threadPoolCallbaleAndFutureMoreTest（）{
ExecutorService threadPool = Executors.newFixedThreadPool（5）;
CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>（threadPool）;
for（int i=1; i<=5; i++）{
final int taskCode = i;
completionService.submit（
new Callable<Integer>（）{
@Override
public Integer call（） throws Exception {
Thread.sleep（new Random（）.nextInt（5000））;
return taskCode;
}
}
）;
}
for（int i=0; i<5; i++）{
try {
System.out.println（completionService.take（）.get（））;
} catch （InterruptedException e） {
e.printStackTrace（）;
} catch （ExecutionException e） {
e.printStackTrace（）;
}
}
}
}
class MyThread implements Runnable{
private Integer task;
public MyThread（Integer task）{
this.task = task;
}
@Override
public void run（） {
//这里不需要写成j，因为它和threadPoolTest（）里面的for（）循环中的i并不是同一个方法中的变量，故其不会冲突
for（int i=1; i<=10; i++） {
try {
Thread.sleep（20）;
} catch （InterruptedException e） {
e.printStackTrace（）;
}
System.out.println（Thread.currentThread（）.getName（） + " is looping of " + i + " for task of " + task）;
}
}
}
class MyScheduledThread implements Runnable{
@Override
public void run（） {
System.out.println（"bombing......"）;
}
}