在Java開發中，線程是非常常見的一種操作。而在多線程操作中，callable接口則扮演了重要的角色。本文將從多個方面對callable接口進行詳細的闡述。
一、callable接口和主線程循環輸出
在java中，callable接口是一種核心接口。callable接口是一種可以返回值的多線程接口，該接口和Runnable接口類似，但是callable可以返回執行完任務後的結果。
import java.util.concurrent.*;
public class CallableDemo {
public static void main(String[] args) {
ExecutorService executor = Executors.newSingleThreadExecutor();
Future future = executor.submit(new Task());
try {
while (!future.isDone()) {
System.out.println("Task is not yet completed....");
Thread.sleep(1);
}
System.out.println("Task completed.\nRetrieved result is " + future.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
static class Task implements Callable {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i++) {
sum += i;
}
return sum;
}
}
}
在上述代碼中，我們使用了ExecutorService.submit（）方法，並傳遞了實現了Callable接口的Task對象。我們可以看到，該程序會先打印出”Task is not yet completed….”，然後在獲取返回值之前，每隔1毫秒打印一次。這表明主線程正在等待任務完成。一旦任務完成並且返回結果，程序會打印出”Task completed. Retrieved result is 4950″。
二、線程callable接口創建
接下來，我們將要學習如何在Java中創建callable接口的線程。
import java.util.concurrent.Callable;
public class CallableTask implements Callable {
private final String taskName;
public CallableTask(String taskName) {
this.taskName = taskName;
}
@Override
public String call() throws Exception {
Thread.sleep(100);
return "Task " + taskName + " is complete.";
}
}
在上述代碼中，我們創建了一個實現了callable接口的CallableTask對象。該對象需要在call（）方法中提供返回值。在本例中，返回值是一個字符串，表示任務已完成。輸出語句是在該方法中控制的。
三、callable接口使用
1、callable接口返回值是什麼
Callable接口的返回值可以是任意類型的對象。在上個示例中，返回了一個字符串。因此，通常情況下，開發人員需要根據任務的需求來選擇返回值類型。
2、callable接口如何循環
在下面的示例中，我們將演示如何在Java中使用Callable接口來運行一個無限循環的任務。當控制台讀取到大寫字母Q時，程序會退出。
import java.util.Scanner;
import java.util.concurrent.Callable;
public class LoopTask implements Callable {
@Override
public Void call() throws Exception {
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("Enter a command (Q to quit): ");
String command = scanner.nextLine();
if ("Q".equalsIgnoreCase(command)) {
break;
}
System.out.println("Command " + command + " is not recognized.");
}
System.out.println("Loop task completed!");
return null;
}
}
在上述代碼中，我們創建了一個名為LoopTask的類。在該類中，我們實現了callable接口，並且使用了Scanner類讀取控制台輸入。在循環結束之後，控制台會顯示”Loop task completed!”消息。
3、callable接口創建線程
在下面的示例中，我們將演示如何使用Java中的callable接口創建線程。
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executor = Executors.newSingleThreadExecutor();
Future future = executor.submit(new Callable() {
@Override
public Integer call() throws Exception {
return 1 + 2;
}
});
System.out.println("Result: " + future.get());
executor.shutdown();
}
}
在上述代碼中，我們創建了一個Callable對象，並將其傳遞給ExecutorService.submit()方法。該對象可以返回一個整型值，並將其返回給主線程。在示例中，我們將獲取的返回值輸出到控制台。
4、callable接口實現多線程
下面的示例演示了如何使用Java中的Callable接口實現多線程。
import java.util.concurrent.*;
public class MultiThreadDemo {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executor = Executors.newFixedThreadPool(5);
Future[] futureTasks = new Future[5];
for (int i = 0; i < 5; i++) {
Callable task = new CallableImpl();
futureTasks[i] = executor.submit(task);
}
for (int i = 0; i < futureTasks.length; i++) {
if (futureTasks[i].isDone()) {
String result = futureTasks[i].get();
System.out.println("Result: " + result);
}
}
executor.shutdown();
}
static class CallableImpl implements Callable {
@Override
public String call() throws Exception {
Thread.sleep(1000);
return Thread.currentThread().getName();
}
}
}
在上述代碼中，我們使用了Executors.newFixedThreadPool()方法，該方法會創建一個最多包含5個線程的線程池。我們然後使用一個for循環創建了5個實現了callable接口的CallableImpl對象，並將其傳遞給ExecutorService.submit()方法。在接下來的for循環中，我們使用Future.get()方法獲取Future對象的結果。在本例中，我們輸出了執行每個任務的線程的名稱。
5、callable接口如何使用循環
下面的示例演示了如何使用Java中的Callable接口和循環。
import java.util.concurrent.*;
public class LoopCallableDemo {
public static void main(String[] args) {
ExecutorService executor = Executors.newSingleThreadExecutor();
Future future = executor.submit(new LoopTask());
try {
while (!future.isDone()) {
System.out.println("Task is not yet completed....");
Thread.sleep(1000);
}
System.out.println("Task completed.\nRetrieved result is " + future.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
executor.shutdown();
}
static class LoopTask implements Callable {
@Override
public String call() throws Exception {
int count = 0;
for (int i = 0; i < 10; i++) {
count++;
Thread.sleep(1000);
}
return "Task completed - iterations performed: " + count;
}
}
}
在上述代碼中，我們使用了一個實現了Callable接口的LoopTask對象。在call()方法中，我們使用了一個for循環，在循環結束時返回了一個包含執行次數的字符串。在main（）方法中，我們使用了ExecutorService.submit（）方法，將實現了LoopTask的Callable對象傳遞給了該方法。
四、callable接口是線程安全的嗎
callable接口是線程安全的，因為每次調用call（）方法時都會創建一個新的實例。每個調用都是獨立的，不會對其他線程造成影響。因此，無需擔心在多線程應用程序中使用callable接口會出現線程安全問題。
五、callable接口的線程通信
在Java中，callable接口的線程通信可以通過使用Future接口實現。
import java.util.concurrent.*;
public class ThreadCommunicationDemo {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService executor = Executors.newSingleThreadExecutor();
Future future = executor.submit(new Task());
while (!future.isDone()) {
System.out.println("Task is not yet completed");
Thread.sleep(500);
}
int result = future.get();
System.out.println("Task is completed, result: " + result);
executor.shutdown();
}
static class Task implements Callable {
@Override
public Integer call() throws Exception {
Thread.sleep(2000);
return 100;
}
}
}
在上述代碼中，我們使用了ExecutorService.submit()方法來執行Task對象。在接下來的while循環中，我們使用了Future.isDone()方法，來檢查Task對象是否已經完成。一旦任務完成，我們可以使用Future.get（）方法來獲取Future對象的結果，並將其輸出到控制台。
總結
以上就是本文對callable接口的詳細闡述。通過本文，我們了解了callable接口和主線程循環輸出、線程callable接口創建，callable接口返回值是什麼、callable接口如何循環、callable接口創建線程，callable接口實現多線程、callable接口如何使用循環、callable接口是線程安全的嗎、callable接口的線程通信等知識。希望對讀者有所幫助。
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hk/n/289020.html
微信掃一掃 
支付寶掃一掃 