【Java】非同期処理/スレッドのついて（ThreadやRunnableの使い方）

はじめに
非同期処理とは
1. Threadクラス
  1. 実装方法
2. Runnableインタフェース
  1. 実装方法
スレッドの排他制御
スレッド待機
スレッドの一時停止
同時実行数を制御
単一のスレッドで実行
ドキュメント
最後に

はじめに

今回はJavaの「非同期処理/スレッド(Thread)」について勉強したことを記載していきたいと思います。

非同期処理とは

非同期処理とは、処理の実行中に処理を止めることなく別の処理を実行する仕組みのことです。Javaでは「Threadクラス」や「Runnableインタフェース」を使用することで実現可能となっています。

Threadクラス

Threadクラスを継承したクラスでrunメソッドをオーバーライドすることでそのメソッドは非同期で処理できるメソッドとなります。

実装方法

public class TestThread extends Thread {
    @Override
    public void run() {
        // 非同期処理を記載
    }
}

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        TestThread thread = new TestThread();
        thread.start();
    }

Runnableインタフェース

別クラスを継承していてThreadクラスが継承できない場合は、Runnableインタフェースを実装することでThreadクラスと同様に非同期処理を実施することができます。
ThreadクラスのコンストラクタにRunnableインタフェースを実装したクラスを渡すことで非同期処理が実行可能になります。

実装方法

public class TestRunnable implements Runnable {
    @Override
    public void run() {
        // 非同期処理を記載
    }
}

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(new TestRunnable());
        thread.start();
    }

スレッドの排他制御

複数のスレッドを同時に実行する場合に、「synchronized」を使用することで排他制御をかけることができます。別のスレッドが使用している場合、待ち状態になります。

    public void test() {
        synchronized(this) {
            System.err.println("排他制御");
        }
    }

    public synchronized void test2() {
        System.err.println("排他制御");
    }

スレッド待機

joinメソッドを使用することでスレッドの終了を待つことができます。

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        TestThread thread = new TestThread();
        thread.start();

        // スレッドが終わるまで待つ
        thread.join();
    }

スレッドの一時停止

sleepメソッドを使用することで指定した時間スレッドを一時停止することができます。

    @Override
    public void run() {
        // 非同期処理を記載
        try {
            // 1000ミリ秒待機
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

同時実行数を制御

Semaphoreクラスを使用することで、同時実行数を制御を制御することもできます。

public class TestThread extends Thread {

    private Semaphore semaphore;

    public TestThread(Semaphore semaphore) {
        this.semaphore = semaphore;
    }

    @Override
    public void run() {
        // 非同期処理を記載
        try {
            // semaphore取得
            this.semaphore.acquire();
            System.out.println(getName());;
            // 1000ミリ秒待機
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            // semaphoreの解放
            this.semaphore.release();
        }
    }
}

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        // スレッドの同時実行可能数を設定したsemaphoreを作成
        Semaphore semaphore = new Semaphore(2);
        
        // 同時に実行できるのは2個までのため並列処理は2つずつ動作
        new TestThread(semaphore).start();
        new TestThread(semaphore).start();
        new TestThread(semaphore).start();
        new TestThread(semaphore).start();
        new TestThread(semaphore).start();
    }

単一のスレッドで実行

newSingleThreadExecutorメソッドで生成したExecutorServiceクラスを使用することで単一でのスレッド実行が可能です。

    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        ExecutorService excecutorService = Executors.newSingleThreadExecutor();

        // スレッドを一つずつ実行
        excecutorService.execute(new TestThread());
        excecutorService.execute(new TestThread());

        excecutorService.shutdown();
    }