import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

//在主線程獲取callable線程返回值時，如果callable線程還存在線程沒有執行完，則主線程會等待callable線程全部執行完畢獲取所有的返回值之后才會繼續執行下面的代碼。如果任務已經完成，get會立即返回或者拋出一個Exception,如果任務沒有完成，get會阻塞知道它完成。如果任務拋出了異常。get會將改異常封裝為ExecutionException.然后重新拋出。如果任務被取消，get會拋出CancellationException。當拋出ExecutionException時。可以用getCause重新獲得被封裝的原始異常。

/** *//**

* Callable 和 Future接口

* Callable是類似于Runnable的接口，實現Callable接口的類和實現Runnable的類都是可被其它線程執行的任務。

* Callable和Runnable有幾點不同：

* (1)Callable規定的方法是call()，而Runnable規定的方法是run().

* (2)Callable的任務執行后可返回值，而Runnable的任務是不能返回值的。

* (3)call()方法可拋出異常，而run()方法是不能拋出異常的。

* (4)運行Callable任務可拿到一個Future對象，

* Future 表示異步計算的結果。它提供了檢查計算是否完成的方法，以等待計算的完成，并檢索計算的結果。

* 通過Future對象可了解任務執行情況，可取消任務的執行，還可獲取任務執行的結果。

*/

public class CallableAndFuture {

/** *//**

* 自定義一個任務類，實現Callable接口

*/

public static class MyCallableClass implements Callable{

// 標志位

private int flag = 0;

public MyCallableClass(int flag){

this.flag = flag;

}

public String call() throws Exception{

if (this.flag == 0){

// 如果flag的值為0，則立即返回

return "flag = 0";

}

if (this.flag == 1){

// 如果flag的值為1，做一個無限循環

try {

while (true) {

System.out.println("looping.");

Thread.sleep(2000);

}

} catch (InterruptedException e) {

System.out.println("Interrupted");

}

return "false";

} else {

// falg不為0或者1，則拋出異常

throw new Exception("Bad flag value!");

}

}

}

public static void main(String[] args) {

// 定義3個Callable類型的任務

MyCallableClass task1 = new MyCallableClass(0);

MyCallableClass task2 = new MyCallableClass(1);

MyCallableClass task3 = new MyCallableClass(2);

// 創建一個執行任務的服務

ExecutorService es = Executors.newFixedThreadPool(3);

try {

// 提交并執行任務，任務啟動時返回了一個 Future對象，

// 如果想得到任務執行的結果或者是異常可對這個Future對象進行操作

Future future1 = es.submit(task1);

// 獲得第一個任務的結果，如果調用get方法，當前線程會等待任務執行完畢后才往下執行

System.out.println("task1: " + future1.get());

Future future2 = es.submit(task2);

//此線程是否執行完畢

future2.isDone();

// 等待5秒后，再停止第二個任務。因為第二個任務進行的是無限循環

Thread.sleep(5000);

System.out.println("task2 cancel: " + future2.cancel(true));

// 獲取第三個任務的輸出，因為執行第三個任務會引起異常

// 所以下面的語句將引起異常的拋出

Future future3 = es.submit(task3);

System.out.println("task3: " + future3.get());

} catch (Exception e){

System.out.println(e.toString());

}

// 停止任務執行服務

es.shutdownNow();

}

}

//線程池具有返回值

package com.thread.threadpool;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.RejectedExecutionHandler;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicLong;

public class ThreadPool {

private int corePoolSize = 1; // 線程池維護線程的最少數量

private int maximumPoolSize = 10;// 線程池維護線程的最大數量

private long keepAliveTime = 3; // 線程池維護線程所允許的空閑時間

private TimeUnit unit = TimeUnit.SECONDS;// 線程池維護線程所允許的空閑時間的單位

private BlockingQueue workQueue; // 線程池所使用的緩沖隊列

private RejectedExecutionHandler handler; // 線程池對拒絕任務的處理策略

private static AtomicLong along = new AtomicLong(0);

public void run() throws InterruptedException, ExecutionException {

ExecutorService pool = new ThreadPoolExecutor(corePoolSize,

maximumPoolSize, keepAliveTime, unit,

new LinkedBlockingQueue(),

new ThreadPoolExecutor.DiscardOldestPolicy()) {

// 線程執行之前運行

@Override

protected void beforeExecute(Thread t, Runnable r) {

System.out.println("...............beforeExecute");

}

// 線程執行之后運行

@Override

protected void afterExecute(Runnable r, Throwable t) {

System.out.println("...............afterExecute");

}

// 整個線程池停止之后

protected void terminated() {

System.out.println("...............thread stop");

}

};

List all = new ArrayList();

for (int i = 1; i <= 10; i++) {

all.add(pool.submit(new ThreadPoolTask(i, along)).get());

}

for (int i = 1; i <= 10; i++) {

all.add(pool.submit(new ThreadPoolTask(-i, along)).get());

}

for (Object o : all) {

System.out.println(o);

}

pool.shutdown();

Thread.sleep(25000);

System.out.println(along.get());

}

public static void main(String[] args) {

try {

try {

new ThreadPool().run();

} catch (ExecutionException e) {

e.printStackTrace();

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

class ThreadPoolTask implements Callable {

private int i = 0;

private AtomicLong along;

ThreadPoolTask(int i, AtomicLong along) {

this.i = i;

this.along = along;

}

//@Override

public Object call() {

try {

// 模擬業務邏輯

Thread.sleep(1000);

along.addAndGet(i);

} catch (InterruptedException e) {

e.printStackTrace();

}

//System.out.println(Thread.currentThread().getName() + " ?" + i);

return Thread.currentThread().getName() + " ?" + i;

}

}

總結

以上是生活随笔為你收集整理的java callable接口_Java多线程之Callable接口的实现有返回值的线程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。