Javaにおける「implements Runnable」と「extends Thread」のコード例

Javaにおける「implements Runnable」と「extends Thread」の違い

Javaにおけるマルチスレッドプログラミングでは、複数のタスクを並行して実行することができます。この際、タスクの実行単位として、ThreadクラスまたはRunnableインターフェースが使用されます。

implements Runnable

• Runnableインターフェースを実装することで、スレッドのタスクを定義します。
• Runnableインターフェースには、run()メソッドを定義する必要があります。このメソッドがスレッドの実際の処理を実行します。
• Runnableインターフェースを実装したクラスは、直接スレッドではありません。スレッドを作成するには、ThreadクラスのコンストラクタにRunnableオブジェクトを渡す必要があります。

extends Thread

• Threadクラスを継承することで、スレッド自体を定義します。
• Threadクラスを継承したクラスは、直接スレッドです。スレッドを作成するために、クラスのインスタンスを生成するだけで済みます。

比較

例

// implements Runnable
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable thread is running.");
    }
}

// extends Thread
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new MyRunnable());
        thread1.start();

        MyThread thread2 = new MyThread();
        thread2.start   ();
    }
}

• implements Runnableは、タスクを定義するための柔軟な方法です。
• extends Threadは、スレッド自体を定義するための直接的な方法ですが、他のクラスを継承できないという制限があります。
• どちらの方法を使用するかは、設計上の要件や好みによって決まります。

• Runnableインターフェースは、他のスレッドから実行することもできます。
• Threadクラスは、多くの便利なメソッドを提供しており、スレッドの管理や制御が容易です。

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.s   tart();
    }
}

• MyRunnableクラスは、Runnableインターフェースを実装しています。
• run()メソッドは、スレッドの実際の処理を実行します。
• Mainクラスのmain()メソッドで、MyRunnableオブジェクトをThreadクラスのコンストラクタに渡し、新しいスレッドを作成します。
• thread.start()メソッドで、スレッドを開始します。

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

• MyThreadクラスは、Threadクラスを継承しています。
• Mainクラスのmain()メソッドで、MyThreadクラスのインスタンスを生成し、新しいスレッドを作成します。

Javaスレッド実装の違い

• implements Runnableは、タスクを定義するための柔軟な方法です。他のクラスを継承できるため、複数のインターフェースを実装することができます。

• 両方の方法で、スレッドの処理は並行して実行されます。
• Threadクラスは、スレッドの優先度、名前、デーモンフラグなどの属性を設定することができます。

Callableインターフェース

• Callableインターフェースは、Runnableインターフェースと似ていますが、戻り値を持つことができます。
• Callableインターフェースを実装したクラスは、FutureTaskクラスを使用してスレッドを作成し、実行することができます。
• FutureTaskクラスは、スレッドの終了状態や結果を取得するためのメソッドを提供します。

ExecutorServiceインターフェース

• ExecutorServiceインターフェースは、スレッドプールを管理するためのインターフェースです。
• ExecutorServiceインターフェースを使用して、複数のタスクをスレッドプールに提出することができます。
• スレッドプールは、スレッドの再利用や管理を自動的に行います。

ForkJoinPoolクラス

• ForkJoinPoolクラスは、ワークスチールアルゴリズムを使用して、タスクを分割し、並列に実行するフレームワークです。
• ForkJoinPoolクラスは、大規模なタスクを効率的に処理することができます。

コード例

// Callableインターフェース
import java.util.concurrent.*;

class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        return 42;
    }
}

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService exe   cutor = Executors.newSingleThreadExecutor();
        Future<Integer> future = executor.submit(new MyCallable());
        int result = future.get();
        System.out.println(re   sult);
        executor.shutdown();
    }
}

// ExecutorServiceインターフェース
import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService exe   cutor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            executor.submit(() -> System.o   ut.println("Task " + i));
        }
        executor.shutdown();
        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
    }
}

// ForkJoinPoolクラス
import java.util.concurrent.*;

class MyRecursiveTask extends RecursiveTask<Integer> {
    private final int threshold = 10;
    private final int[] array;
    private final int start;
    private final int end;

    public MyRecursiveTask(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    protected Integer comp   ute() {
        if (end - start <= threshold) {
            //    小さい範囲は直接計算
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        } else {
            // 大きい範囲は分割して再帰的に計算
            int mid = (start + end) / 2;
            MyRecursiveTask left = new MyRecursiveTask(array, start, mid);
            MyRecursiveTask right = new MyRecursiveTask(array, mid, end);
            left.fork();
            int rightResult = right.compute();
            int leftResult = left.join();
            return leftResult + rightResult;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        ForkJoinPool pool = new ForkJoinPool();
        MyRecursiveTask task = new MyRecursiveTask(array, 0, array.length);
        int result = pool.invoke(task);
        System.out.println(result);
    }
}

• implements Runnableとextends Threadは、基本的なスレッド実装方法です。
• Callableインターフェースは、戻り値を持つタスクを定義することができます。