最近看了一些多线程处理的代码,将所用的的内容和看到的资料整理了一下,如下:
java.util.concurrent 包
Executor :具体Runnable任务的执行者。
ExecutorService :一个线程池管理者,其实现类有多种,我会介绍一部分。我们能把Runnable,Callable提交到池中让其调度。
Future :是与Runnable,Callable进行交互的接口,比如一个线程执行结束后取返回的结果等等,还提供了cancel终止线程。
Executors主要方法说明
newFixedThreadPool(固定大小线程池)
创建一个可重用固定线程集合的线程池,以共享的无界队列方式来运行这些线程(只有要请求的过来,就会在一个队列里等待执行)。如果在关闭前的执行期间由于失败而导致任何线程终止,那么一个新线程将代替它执行后续的任务(如果需要)。
newCachedThreadPool(无界线程池,可以进行自动线程回收)
创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言,这些线程池通常可提高程序性能。调用 execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此,长时间保持空闲的线程池不会使用任何资源。注意,可以使用 ThreadPoolExecutor 构造方法创建具有类似属性但细节不同(例如超时参数)的线程池。
newSingleThreadExecutor(单个后台线程)
创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程。(注意,如果因为在关闭前的执行期间出现失败而终止了此单个线程,那么如果需要,一个新线程将代替它执行后续的任务)。可保证顺序地执行各个任务,并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool(1) 不同,可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。
这些方法返回的都是ExecutorService对象,这个对象可以理解为就是一个线程池。
这个线程池的功能还是比较完善的。可以提交任务submit()可以结束线程池shutdown()。
示例代码:
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ExecutorTest {
// =============== 测试1(start) ===============
// 实现Runnable接口
private class MyRunnable implements Runnable {
private int index = 0;
public MyRunnable(int i) {
this.index = i;
}
@Override
public void run() {
try {
System.out.println("thread [" + this.index + "] start....");
Thread.sleep((int) (Math.random() * 3000));
System.out.println("thread [" + this.index + "] end.");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// 通过ExecutorService调用多线程
public void doExecutorService_excute() {
ExecutorService executorService = Executors.newFixedThreadPool(3);
for (int i = 1; i <= 10; i++) {
executorService.execute(new MyRunnable(i));
}
executorService.shutdown();
}
// =============== 测试1(end) ===============
// =============== 测试2(start) ===============
// 实现
private class MyCallable implements Callable<String> {
private int index = 0;
public MyCallable(int i) {
this.index = i;
}
@Override
public String call() throws Exception {
System.out.println("thread [" + this.index + "] start....");
Thread.sleep((int) (Math.random() * 3000));
return "thread [" + this.index + "] end.";
}
}
// 通过ExecutorService调用多线程
public void doExecutorService_submit() throws InterruptedException, ExecutionException {
ExecutorService executorService = Executors.newFixedThreadPool(3);
Deque<Future<?>> futures = new ArrayDeque<Future<?>>();
for (int i = 1; i <= 10; i++) {
futures.add(executorService.submit(new MyCallable(i)));
}
System.out.println("show return str:");
for (Future<?> future : futures) {
System.out.println(future.get().toString());
}
executorService.shutdown();
}
// =============== 测试2(end) ===============
//执行测试
public static void main(String[] args) throws InterruptedException, ExecutionException {
//new ExecutorTest().doExecutorService_excute();
new ExecutorTest().doExecutorService_submit();
}
}