Java – Callableの基本的な使い方を解説 – スレッドとの関係性

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

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class App {
    public static void main(String[] args) {
        // Callableインターフェースを実装したクラスを作成
        Callable<String> task = new Callable<String>() {
            @Override
            public String call() throws Exception {
                // タスクの処理
                return "タスクの実行結果";
            }
        };
        // ExecutorServiceを使用してタスクを実行
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(task);
        try {
            // タスクの結果を取得
            String result = future.get();
            System.out.println(result); // 結果を出力
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown(); // ExecutorServiceをシャットダウン
        }
    }
}

タスクの実行結果

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class App {
    public static void main(String[] args) {
        // Callableインターフェースを実装したクラスを作成
        Callable<Integer> task = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                // 何らかの計算を行う
                int sum = 0;
                for (int i = 1; i <= 10; i++) {
                    sum += i; // 1から10までの合計を計算
                }
                return sum; // 合計を返す
            }
        };
        // ExecutorServiceを使用してタスクを実行
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> future = executor.submit(task);
        try {
            // タスクの結果を取得
            Integer result = future.get();
            System.out.println("1から10までの合計: " + result); // 結果を出力
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown(); // ExecutorServiceをシャットダウン
        }
    }
}

1から10までの合計: 55

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class App {
    public static void main(String[] args) {
        // Callableインターフェースを実装したクラスを作成
        Callable<String> task = new Callable<String>() {
            @Override
            public String call() throws Exception {
                // スレッドの処理を模擬
                Thread.sleep(2000); // 2秒待機
                return "スレッド処理完了"; // 結果を返す
            }
        };
        // ExecutorServiceを使用してタスクを実行
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(task);
        try {
            // タスクの結果を取得
            String result = future.get(); // 結果を取得
            System.out.println(result); // 結果を出力
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown(); // ExecutorServiceをシャットダウン
        }
    }
}

スレッド処理完了

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class App {
    public static void main(String[] args) {
        // ExecutorServiceを作成
        ExecutorService executor = Executors.newFixedThreadPool(3); // 3つのスレッドを持つプール
        // Callableタスクのリストを作成
        List<Future<Long>> futures = new ArrayList<>();
        // 1から5までの階乗を計算するタスクを作成
        for (int i = 1; i <= 5; i++) {
            final int number = i; // final修飾子を使って変数をキャプチャ
            Callable<Long> task = new Callable<Long>() {
                @Override
                public Long call() throws Exception {
                    return factorial(number); // 階乗を計算
                }
            };
            futures.add(executor.submit(task)); // タスクを実行し、Futureをリストに追加
        }
        // 結果を取得して出力
        for (int i = 0; i < futures.size(); i++) {
            try {
                Long result = futures.get(i).get(); // タスクの結果を取得
                System.out.println(i + 1 + "の階乗: " + result); // 結果を出力
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
        executor.shutdown(); // ExecutorServiceをシャットダウン
    }
    // 階乗を計算するメソッド
    private static Long factorial(int number) {
        long result = 1;
        for (int i = 1; i <= number; i++) {
            result *= i; // 階乗を計算
        }
        return result; // 結果を返す
    }
}

1の階乗: 1
2の階乗: 2
3の階乗: 6
4の階乗: 24
5の階乗: 120