线程池是以上两种问题很好的解决方案。一方面,线程池避免了反复的创建、销毁线程,浪费时间;另外一方面, 线程池可以避免创建过多的线程,而是让超出承载能力的请求排队。
2>如何实现?
Java 提供了线程池的管理类Executor, 可以用来实现常用的多数线程池。同时,你也可以按照自己需求,自己编写自己的线程池。
Executor/Executor Service
a) 初始化一个pool
ExecutorService pool =Executor.newCachedThreadPool(); //1
ExecutorService pool =Executor.newFixedThreadPool(5);//2
ExecutorService pool =Executor.newSingleThreadPool();//3
(ExecutorService 是Executor的子类,从Executor继承了execute(Runnable r) 的方法 )
CachedThreadPool: 是指带缓冲的线程池机制。线程池本身为空,当有作业时便会开启新的线程。这个线程池的特点是,当作业结束后,线程池并不会立即销毁,而会延迟某个时间再销毁。这样,当延迟时间内有新的作业进入时,就省去了开启新的线程池的时间。
FixedThreadPool: 是指指定线程池指定线程数量。无论有没有没作业,线程池都回保有这么多线程,当作业来的时候,就会放到这些线程上。当作业数量超过了线程数,作业就必须排队等待。
SingleThreadPool: 就是FixedThreadPool(1) 的情况,完全一样。
b)执行作业
通过 exexute (Runnable r)的方法来执行新的作业。比如:
pool.execute(new mRunnable);
c)执行带返回结果的作业
ExecutorService 提供了带返回结果的作业执行方法,包括:
import java.util.concurrent.*;
import java.util.*;
class TaskWithResult implements Callable<String> {
private int id;
public TaskWithResult(int id) {
this.id = id;
}
public String call() {
return "result of TaskWithResult " + id;
}
}
public class CallableDemo {
public static void main(String[] args) {
ExecutorService exec = Executors.newCachedThreadPool();
ArrayList<Future<String>> results =
new ArrayList<Future<String>>();
for(int i = 0; i < 10; i++)
results.add(exec.submit(new TaskWithResult(i)));
for(Future<String> fs : results)
try {
// get() blocks until completion:
System.out.println(fs.get());
} catch(InterruptedException e) {
System.out.println(e);
return;
} catch(ExecutionException e) {
System.out.println(e);
} finally {
exec.shutdown();
}
}
} /* Output:
result of TaskWithResult 0
result of TaskWithResult 1
result of TaskWithResult 2
result of TaskWithResult 3
result of TaskWithResult 4
result of TaskWithResult 5
result of TaskWithResult 6
result of TaskWithResult 7
result of TaskWithResult 8
result of TaskWithResult 9
*///:~
e) shutdown();