线程池
是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源
目的：节省资源
通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。
使用线程池方式--Runnable接口
使用线程池中线程对象的步骤：
n 创建线程池对象
n 创建Runnable接口子类对象
n 提交Runnable接口子类对象
n 关闭线程池
package com.oracle.Demo02;
public class MyRunnable2 implements Runnable{
public void run() {
for (int i = 0; i <100; i++) {
//getName（） 得到线程名称
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
package com.oracle.Demo02;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo01 {
public static void main(String[] args) {
//从线程池工厂中创建线程池对象
ExecutorService es=Executors.newFixedThreadPool(2);
//创建线程任务对象
MyRunnable2 mr=new MyRunnable2();
//提交线程任务，让线程随机挑选一条想吃执行线程任务
es.submit(mr);
es.submit(mr);
es.submit(mr);
//释放资源
es.shutdown();
}
}
使用线程池方式—Callable接口
l Callable接口：与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。
l ExecutorService：线程池类
n <T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法
l Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
l 使用线程池中线程对象的步骤：
n 创建线程池对象
n 创建Callable接口子类对象
n 提交Callable接口子类对象
n 关闭线程池
package com.oracle.Demo02;
import java.util.concurrent.Callable;
public class MyCallble implements Callable<String> {
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return "abc";
}
}
package com.oracle.Demo02;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Demo02 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//从线程池工厂中创建线程池对象
ExecutorService ex=Executors.newFixedThreadPool(2);
//创建线程任务对象
MyCallble mc=new MyCallble();
//执行线程任务并获取call方法返回值
Future<String> f=ex.submit(mc);
//从Future中获取返回值
String str=f.get();
System.out.println(str);
//释放资源
ex.shutdown();
}
}
2个线程，1个线程计算1-100的和，另一个线程计算1-200的和
package com.oracle.Demo02;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Demo04 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//2个线程，1个线程计算1-100的和，另一个线程计算1-200的和
//创建俩个线程任务
GetSum sum1=new GetSum(1,100);
GetSum sum2=new GetSum(1,200);
//从线程池中创建线程池对象
ExecutorService ex=Executors.newFixedThreadPool(2);
//执行线程任务并获取call方法返回值
Future<Integer> f1=ex.submit(sum1);
Future<Integer> f2=ex.submit(sum2);
//获取返回值
System.out.println(f1.get());
System.out.println(f2.get());
//关闭线程
ex.shutdown();
}
}
package com.oracle.Demo02;
import java.util.concurrent.Callable;
public class GetSum implements Callable<Integer>{
private int a;
private int b;
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
public int getB() {
return b;
}
public void setB(int b) {
this.b = b;
}
public GetSum() {
super();
}
public GetSum(int a, int b) {
super();
this.a = a;
this.b = b;
}
@Override
public Integer call() throws Exception {
// TODO Auto-generated method stub
int sum=0;
for (int i = a; i < b; i++) {
sum=sum+i;
}
return sum;
}
}