在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-tw/n/289020.html
微信掃一掃 
支付寶掃一掃 