Future

1. cancel(boolean mayInterruptIfRunning)和isCancelled()

package Five_cancel_and_isCancelled;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("begin :  " + System.currentTimeMillis());
        Thread.sleep(2000);
        System.out.println("end :  " + System.currentTimeMillis());
        return "我的年龄是2000";
    }

}

package Five_cancel_and_isCancelled;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.Future;

public class Test {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        MyCallable mc = new MyCallable();

        ExecutorService executor = new ThreadPoolExecutor(50, Integer.MAX_VALUE, 5, TimeUnit.SECONDS,
                new LinkedBlockingDeque<Runnable>());

        Future<String> f = executor.submit(mc);
        System.out.println(f.get());
        System.out.println(f.cancel(true) + "----------" + f.isCancelled());
    }
}

运行结果：

分析：

　　线程已经运行完毕，线程对象已经销毁，所以方法cancel(true)的返回值是false,代表发送中断线程的命令没有成功。因为这个命令中的参数的作用是：如果线程正在运行，则发送中断线程的命令。而线程已经运行结束了，所以没有满足这个命令执行的条件，所以命令没有执行成功。

 

修改：将这行代码注释掉

    //System.out.println(f.get());

运行结果：

true----------true

成功中断正在执行中的线程。

 分析：

　　将这行注释掉，意味着没有取线程的返回值，那么线程就一直在call()方法中运行，直到接到了取返回值的命令，才会走到return,这时也意味着线程执行结束。

 

2. Future的缺点

　　Future接口调用get()方法取得处理结果时是阻塞性的，就是说如果你调用了这个方法，它没有取到值，那么就会一直等在这儿，直到取到值为止，然后下面的程序才能接着运行。

　　这样带来的问题就是：如果当前分支线程执行的任务很多，那么在主线程使用get()方法调用这个分支线程的返回值的程序会一直阻塞在这里，直到分支线程运行完毕并返回值，而在这个过程中，主线程get()方法后面的程序将无法运行，就一直在这里排队等待，这样会大大影响运行的效率，也就是说主线程不能保证首先获得的是最先完成任务的返回值。

package Five_Future_Shortcoming;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {

    private String username;
    private long sleepValue;

    public MyCallable(String username, long sleepValue) {
        super();
        this.username = username;
        this.sleepValue = sleepValue;
    }

    @Override
    public String call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println(username);
        Thread.sleep(sleepValue);
        return "return " + username;
    }

}

package Five_Future_Shortcoming;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Test {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        MyCallable mc1 = new MyCallable("uer-1", 5000);
        MyCallable mc2 = new MyCallable("uer-2", 4000);
        MyCallable mc3 = new MyCallable("uer-3", 3000);
        MyCallable mc4 = new MyCallable("uer-4", 2000);
        MyCallable mc5 = new MyCallable("uer-5", 1000);

        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingDeque<Runnable>());

        Future<String> f1 = executor.submit(mc1);
        Future<String> f2 = executor.submit(mc2);
        Future<String> f3 = executor.submit(mc3);
        Future<String> f4 = executor.submit(mc4);
        Future<String> f5 = executor.submit(mc5);

        System.out.println("Run first time : " + System.currentTimeMillis());

        System.out.println(f1.get() + "----" + System.currentTimeMillis());
        System.out.println(f2.get() + "----" + System.currentTimeMillis());
        System.out.println(f3.get() + "----" + System.currentTimeMillis());
        System.out.println(f4.get() + "----" + System.currentTimeMillis());
        System.out.println(f5.get() + "----" + System.currentTimeMillis());

        

    }

}

运行结果：

分析：

　　线程uer-1，睡眠的时间最长，为5秒钟，而在主线程中，第一个调用的就是uer-1的返回值，所以在主线程中，其他get()方法一直在等待uer-1的值get到之后才能运行，而uer-1的get()在等待uer-1线程执行完毕再返回值，所以就造成主线程里其它线程get的阻塞。

如果将get的顺序换过来，先get睡眠时间最短的

package Five_Future_Shortcoming;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class Test {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        MyCallable mc1 = new MyCallable("uer-1", 5000);
        MyCallable mc2 = new MyCallable("uer-2", 4000);
        MyCallable mc3 = new MyCallable("uer-3", 3000);
        MyCallable mc4 = new MyCallable("uer-4", 2000);
        MyCallable mc5 = new MyCallable("uer-5", 1000);

        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingDeque<Runnable>());

        Future<String> f1 = executor.submit(mc1);
        Future<String> f2 = executor.submit(mc2);
        Future<String> f3 = executor.submit(mc3);
        Future<String> f4 = executor.submit(mc4);
        Future<String> f5 = executor.submit(mc5);

        System.out.println("Run first time : " + System.currentTimeMillis());



        System.out.println(f5.get() + "----" + System.currentTimeMillis());
        System.out.println(f4.get() + "----" + System.currentTimeMillis());
        System.out.println(f3.get() + "----" + System.currentTimeMillis());
        System.out.println(f2.get() + "----" + System.currentTimeMillis());
        System.out.println(f1.get() + "----" + System.currentTimeMillis());

    }

}

 

 

　　注：使用CompletionService接口可以解决这个问题

package Five_Future_Shortcoming;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;

public class Test1 {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        MyCallable mc1 = new MyCallable("uer-1", 5000);
        MyCallable mc2 = new MyCallable("uer-2", 4000);
        MyCallable mc3 = new MyCallable("uer-3", 3000);
        MyCallable mc4 = new MyCallable("uer-4", 2000);
        MyCallable mc5 = new MyCallable("uer-5", 1000);

        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
                new LinkedBlockingDeque<Runnable>());

        CompletionService csRef = new ExecutorCompletionService(executor);

        csRef.submit(mc1);
        csRef.submit(mc2);
        csRef.submit(mc3);
        csRef.submit(mc4);
        csRef.submit(mc5);

        System.out.println("Run first time : " + System.currentTimeMillis());

        System.out.println(csRef.take().get() + "----" + System.currentTimeMillis());
        System.out.println(csRef.take().get() + "----" + System.currentTimeMillis());
        System.out.println(csRef.take().get() + "----" + System.currentTimeMillis());
        System.out.println(csRef.take().get() + "----" + System.currentTimeMillis());
        System.out.println(csRef.take().get() + "----" + System.currentTimeMillis());

    }

}

运行结果：

可以看到，哪个线程先执行完，哪个任务的返回值就先打印。解决了Future阻塞的特性。