Java高並發，創建線程的新方式Callable接口

我們已經知道創建線程的方式有1.繼承thread類。2.實現Runnable接口

接下來講創建線程的新方式Callable接口，首先對比一下Runnable接口和Callable接口的區別：

首先創建兩個資源類：分別是實現了Runnable接口和實現了Callable接口：

//Runnable接口
class MyThreadRunnable implements Runnable {

    @Override
    public void run() {
      
    }
}

//Callable
class MyThreadCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("******come in here");
        return 1024;
    }
}

我們可以看到Callable存在泛型，以及返回值，這是對原來的老技術的增強，因為存在了返回值，提高了線程的細粒度。

接着我們看看Runnable創建線程的方式：

//Runnable
MyThreadRunnable myThread1=new MyThreadRunnable();
Thread t1=new Thread(myThread1);

但是通過該方式我們利用Callable來創建線程，卻報錯了，這是為什么 呢？

原因：Thread並不存在Callable的構造器！

如何創建Callable線程

首先查看API，看Runable接口：

 

 

 

 

 

 

 過程如下：

 

 

 我們可以看到的是，這個構造器需要的參數就是Callable接口的實現類。
所以，我們創建線程的方式如下：

public class CallableDemo {
    public static void main(String[] args) {
//        MyThreadCallable myThread = new MyThreadCallable();
        FutureTask futureTask = new FutureTask(new MyThreadCallable());
        new Thread(futureTask, "A").start();
        System.out.println(futureTask.get());// 1024  通過get方法來獲取返回值
    }
}

get方法具有阻塞性

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        MyThreadCallable myThread = new MyThreadCallable();
        FutureTask futureTask = new FutureTask(new MyThreadCallable());
        new Thread(futureTask, "A").start();
        System.out.println(futureTask.get());// 1024  通過get方式來獲取返回值  該方法會阻塞！
        System.out.println(Thread.currentThread().getName()+"***計算完成");
    }
}
//Callable
class MyThreadCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("******come in here");
        Thread.sleep(5000);
        return 1024;
    }
}

然后調轉依一下主線程與futureTask線程執行的順序：

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        MyThreadCallable myThread = new MyThreadCallable();
        FutureTask futureTask = new FutureTask(new MyThreadCallable());
        new Thread(futureTask, "A").start();
         System.out.println(Thread.currentThread().getName()+"***計算完成");
        System.out.println(futureTask.get());// 1024  通過get方式來獲取返回值  該方法會阻塞！
    }
}
//Callable
class MyThreadCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("******come in here");
        Thread.sleep(5000);
        return 1024;
    }
}

 

往往futureTask里面的get方法會被阻塞， 所以一般情況下我們先讓main線程執行完畢防止由於等待futureTask而耗時。

 futureTask的單一性

新增一個線程B：

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        MyThreadCallable myThread = new MyThreadCallable();
        FutureTask futureTask = new FutureTask(new MyThreadCallable());
        new Thread(futureTask, "A").start();
        new Thread(futureTask, "B").start();
        System.out.println(Thread.currentThread().getName() + "***計算完成");
        System.out.println(futureTask.get());// 1024  通過get方式來獲取返回值  該方法會阻塞！
    }
}

//Callable
class MyThreadCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("******come in here");
        Thread.sleep(5000);
        return 1024;
    }
}

 只執行了一次，因為一個futureTask，不管幾個線程調用，調用的都是同一個futureTask對象！而且Runnable接口就不一樣了：

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThreadRunnable t = new MyThreadRunnable();
        Thread thread = new Thread(t);
        new Thread(thread).run();
        new Thread(thread).run();
    }
}

//Runnable接口
class MyThreadRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("******come in here");
    }
}

 

---

 

以上..