java多线程、FutureTask的⽤法及两种常⽤的使⽤场景
Jav a多线程实现的⽅式有四种
1.继承Thread类，重写run⽅法
2.实现Runnable接⼝，重写run⽅法，实现Runnable接⼝的实现类的实例对象作为Thread构造函数的target
3.通过Callable和FutureTask创建线程
4.通过线程池创建线程
前⾯两种可以归结为⼀类：⽆返回值，原因很简单，通过重写run⽅法，run⽅式的返回值是void，所以没有办法返回结果
后⾯两种可以归结成⼀类：有返回值，通过Callable接⼝，就要实现call⽅法，这个⽅法的返回值是Object，所以返回的结果可以放在Object对象中
//继承Thread类实现多线程
class MyThread extends Thread{
private int index;
public MyThread(int index){
this.index = index;
}
public void run(){
System.out.println("⼦线程：" + index + "，开始！");
}
}
//开启多线程
for(int i = 0;i < 10;i++){
final int index = i;
//实现runnable接⼝实现多线程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("⼦线程：" + index + "，开始！");
}
}).start();
new MyThread(index).start();
}
下⾯重点介绍FutureTask的⽤法：
FutureTask可⽤于异步获取执⾏结果或取消执⾏任务的场景。通过传⼊Runnable或者Callable的任务给FutureTask，直接调⽤其run⽅法或者放⼊线程池执⾏，之后可以在外部通过FutureTask的get⽅法异步获取执⾏结果，因此，FutureTask⾮常适合⽤于耗时的计算，主线程可以在完成⾃⼰的任务后，再去获取结果。另外，FutureTask还可以确保即使调⽤了多次run⽅法，它都只会执⾏⼀次Runnable或者Callable任务，或者通过cancel取消FutureTask的执⾏等。
1. FutureTask执⾏多任务计算的使⽤场景
利⽤FutureTask和ExecutorService，可以⽤多线程的⽅式提交计算任务，主线程继续执⾏其他任务，当主线程需要⼦线程的计算结果时，在异步获取⼦线程的执⾏结果。
ExecutorService executorService = Runtime().availableProcessors());
List<FutureTask<Integer>> futureTaskList = new ArrayList<FutureTask<Integer>>();
for(int i = 0;i < 10 ;i ++){
final int index = i;
FutureTask<Integer> ft = new FutureTask<Integer>(new Callable<Integer>() {
private  Integer result = 0;
@Override
public Integer call() throws Exception {
for(int j = 0;j < 100;j++){
result += j;
}
Thread.sleep(5000);
System.out.println("⼦线程：" + index + "，执⾏完成！");
return result;
}
});
futureTaskList.add(ft);
executorService.submit(ft);
}
System.out.println("⼦线程提交完毕，主线程继续执⾏！");
java线程池创建的四种try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("主线程执⾏完毕！");
Integer totalResult = 0;
for(FutureTask<Integer> ft : futureTaskList){
try {
totalResult =+ ft.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
System.out.println("⼦线程计算的结果为：" + totalResult);
2. FutureTask在⾼并发环境下确保任务只执⾏⼀次
在很多⾼并发的环境下，往往我们只需要某些任务只执⾏⼀次。这种使⽤情景FutureTask的特性恰能胜任。举⼀个例⼦，假设有⼀个带key 的连接池，当key存在时，即直接返回key对应的对象；当key不存在时，则创建连接。对于这样的应⽤场景，通常采⽤的⽅法为使⽤⼀个Map对象来存储key和连接池对应的对应关系，典型的代码如下⾯所⽰：
private Map<String, Connection> connectionPool = new HashMap<String, Connection>();
private ReentrantLock lock = new ReentrantLock();
public Connection getConnection(String key){
try{
lock.lock();
ainsKey(key)){
(key);
}
else{
//创建 Connection
Connection conn = createConnection();
connectionPool.put(key, conn);
return conn;
}
}
finally{
lock.unlock();
}
}
/
/创建Connection
private Connection createConnection(){
return null;
}
在上⾯的例⼦中，我们通过加锁确保⾼并发环境下的线程安全，也确保了connection只创建⼀次，然⽽确牺牲了性能。改⽤ConcurrentHash的情况下，⼏乎可以避免加锁的操作，性能⼤⼤提⾼，但是在⾼并发的情况下有可能出现Connection被创建多次的现象。这时最需要解决的问题就是当key不存在时，创建Connection的动作能放在connectionPool之后执⾏，这正是FutureTask发挥作⽤的时机，基于ConcurrentHashMap和FutureTask的改造代码如下：
private ConcurrentHashMap<String,FutureTask<Connection>>connectionPool = new ConcurrentHashMap<String, FutureTask<Connection>>();
public Connection getConnection(String key) throws Exception{
FutureTask<Connection>(key);
if(connectionTask!=null){
();
}
else{
Callable<Connection> callable = new Callable<Connection>(){
@Override
public Connection call() throws Exception {
// TODO Auto-generated method stub
return createConnection();
}
};
FutureTask<Connection>newTask = new FutureTask<Connection>(callable);
connectionTask = connectionPool.putIfAbsent(key, newTask);
if(connectionTask==null){
connectionTask = newTask;
connectionTask.run();
}
();
}
}
//创建Connection
private Connection createConnection(){
return null;
}
经过这样的改造，可以避免由于并发带来的多次创建连接及锁的出现。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。