程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。
而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。
线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
在JDK5之前,我们必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池
线程池的好处:线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
public class MyRunnable implements Runnable {
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(Thread.currentThread().getName() + "---" + x);
}
}
}
测试类
public class ExecutorsDemo {
public static void main(String[] args) {
// 创建线程池对象
// public static ExecutorService newFixedThreadPool(int nThreads)
ExecutorService pool = Executors.newFixedThreadPool(2);
//调用方法
//Future<?> submit(Runnable task)
pool.submit(new MyRunnable());
pool.submit(new MyRunnable());
//结束线程
pool.shutdown();
}
}
多线程同时对不同的数段进行求和
public class MyCallable implements Callable<Integer> {
// 由于这里需要2个数,开始和结束的数值。
// 所以创建对象,并且写构造方法接收数值
private int start;
private int end;
public MyCallable(int start, int end) {
this.start = start;
this.end = end;
}
int sum = 0;
public Integer call() throws Exception {
for (int x = start; x <= end; x++) {
sum += x;
}
return sum;
}
}
测试类
public class CallableDemo {
public static void main(String[] args) throws InterruptedException,
ExecutionException {
// 创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(3);
// 调用方法
// Future<?> submit(Runnable task)
// <T> Future<T> submit(Callable<T> task)
// 这里需要使用泛型来接收结果,由于Callable中的泛型就是返回类型,所以是用Future<T>
Future<Integer> f1 = pool.submit(new MyCallable(1, 100));
Future<Integer> f2 = pool.submit(new MyCallable(100, 200));
Future<Integer> f3 = pool.submit(new MyCallable(1, 200));
// 由于Mycallable类返回了计算的结果,所以这里需要一个方法来接收这个结果
// V get(); 这里需要抛异常
Integer n1 = f1.get();
Integer n2 = f2.get();
Integer n3 = f3.get();
System.out.println(n1);
System.out.println(n2);
System.out.println(n3);
//关闭线程
pool.shutdown();
}
}