Java多线程Callable接口实现代码示例

下面是Java多线程Callable接口实现的完整攻略步骤：

1.什么是Callable接口

Callable和Runnable类似，都是用来创建线程的接口，但是Callable的call()方法有返回值，并且可以抛出异常。

public interface Callable<V> {
    V call() throws Exception;
}

2.Callable接口的实现

要实现Callable接口，需要实现其中的call()方法，并且指定返回值类型。

import java.util.concurrent.Callable;
public class MyCallable implements Callable<String>{
    @Override
    public String call() throws Exception {
        //操作逻辑
        return "Callable执行完成!";
    }
}

3.创建线程池

在使用Callable的时候，需要创建线程池，并且将Callable任务提交到线程池中，通过FutureTask来获取任务的返回结果。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class TestCallable{
    public static void main(String[] args) throws Exception {
        //创建线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //创建Callable任务
        MyCallable myCallable = new MyCallable();
        //创建FutureTask
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        //提交FutureTask任务
        executorService.submit(futureTask);
        //获取结果
        String result = futureTask.get();
        System.out.println(result);
        //关闭线程池
        executorService.shutdown();
    }
}

4.第一个示例：计算斐波那契数列

import java.util.concurrent.Callable;
public class CalcFibTask implements Callable<Integer> {
    private int n;
    public CalcFibTask(int n) {
        this.n = n;
    }
    @Override
    public Integer call() throws Exception {
        int first = 0, second = 1;
        for (int i = 0; i < n; i++) {
            int temp = first + second;
            first = second;
            second = temp;
        }
        return first;
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class TestCalcFib{
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        CalcFibTask task = new CalcFibTask(10);
        FutureTask<Integer> futureTask = new FutureTask<>(task);
        executorService.submit(futureTask);
        int result = futureTask.get();
        System.out.println(result);
        executorService.shutdown();
    }
}

以上示例计算了斐波那契数列的第10个数字，通过Callable接口实现，线程池提高了线程运行任务的效率。

5.第二个示例：文件处理

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.concurrent.Callable;
public class FileTask implements Callable<String> {
    private String filename;
    public FileTask(String filename) {
        this.filename = filename;
    }
    @Override
    public String call() throws Exception {
        FileReader fileReader = new FileReader(filename);
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        StringBuilder stringBuilder = new StringBuilder();
        String line;
        while ((line = bufferedReader.readLine()) != null) {
            stringBuilder.append(line);
            stringBuilder.append("\n");
        }
        bufferedReader.close();
        fileReader.close();
        return stringBuilder.toString();
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class TestFileTask{
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        FileTask task = new FileTask("test.txt");
        FutureTask<String> futureTask = new FutureTask<>(task);
        executorService.submit(futureTask);
        String result = futureTask.get();
        System.out.println(result);
        executorService.shutdown();
    }
}

以上示例通过Callable接口实现，读取文件的内容并打印输出，通过线程池提高了文件读取的效率，避免了高并发情况下的阻塞。

通过以上两个示例，我们可以更好的理解Java多线程Callable接口的实现方式及其应用场景。