Java - スレッド

TOP > Java > スレッド

スレッド

Javaでは2つの意味で用いられる。

java.lang.Threadのインスタンス

実行スレッド

java.lang.Threadはただのオブジェクト。実行スレッドは、独自のコールスタックを備えた独立したプロセス。Javaでは、一つのコールスタックに一つのスレッドが存在する。例えば、main()メソッドは「メインスレッド」と呼ばれる一つのスレッド内で実行される。

新しいスレッドを作成すると、すぐにコールスタックが確保され、その新しいスレッドから実行されたメソッドは、その独自のコールスタック内で動作する。

スレッドに関して一番注意しなくてはいけないのは、「スレッドに関して保障されている事は何一つない」ということ。

スレッドの作成

Javaのスレッドは、java.lang.Threadのインスタンスとして作成される。スレッドの処理はrun()メソッドを呼び出す事によりはじまる。行いたい作業を「ジョブ」という。

java.lang.Threadクラスの拡張。

Runnableインタフェースを実装。

スレッドの定義

java.lang.Threadを拡張する

１．Threadクラスを拡張する

２．run()メソッドをオーバーライドする

java.lang.Threadを拡張する例

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

Threadクラスを拡張した場合、ほかのクラスを一切拡張できなくなる。Threadのサブクラスでは、run()メソッドを自由にオーバーロードする事ができる。但し、オーバーロードしたメソッドは、各自明示的に呼び出さないと、実行されない。

java.lang.Threadを拡張し、run()メソッドをオーバーロードする例

class MyThread extends Thread{
    public void run(){
        System.out.println("Test") ;
    }
    public void run(String s){
        System.out.println(s) ;
    }
}

Runnableインタフェースの実装

Runnableインタフェースを実装した場合は、必要に応じてクラスを拡張しつつ、独立したスレッドで実行すべき動作を定義することができる。

Runnableインタフェースを実装する例

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

スレッドのインスタンス化

スレッドの実行には、Threadオブジェクトが必要になる。これは、どちらの場合でも必要。Threadクラスを拡張した場合は、単にThreadクラスをインスタンス化すればよい。Runnableインタフェースを実装した場合は、スレッドとジョブ(run()メソッドのコード)を一つのクラスにまとめるのではなく、Threadクラスにはスレッド固有のコードを記述し、Runnable実装クラスにはジョブを記述する

Threadクラスを拡張した場合のインスタンス化の例

MyThread my = new MyThread() ;

Runnableインタフェースを実装した場合のインスタンス化の例

MyRunnable my = new MyRunnable() ;//実装クラスのインスタンス化

Thread t = new Thread(my) ; //インスタンスをThreadオブジェクトに渡す。

引数無しのコンストラクタでスレッドを作成した場合、スレッドは起動すべきときになると自身のrun()メソッドを呼び出す。Runnableインタフェースを実装した場合は、スレッド自身のrun()メソッドではなく、独自で定義したrun()メソッドを呼び出すように指示をしなくてはいけない。そのためThreadコンストラクタにRunnableのインスタンスを渡す。ちなみにこの渡すインスタンスを「ターゲット」もしくは、「ターゲットRunnable」と呼ぶ。

スレッドの初期状態

実行スレッド(新しいコールスタック)を作成するには、スレッドを起動する必要がある。Threadオブジェクトを生成しただけでは、まだ起動していない。この起動していない状態を「初期状態」という。初期状態の時は、スレッドはまだ生存しているとはいえない。スレッドが生存しているかどうか調べるには、Threadインスタンスに対して、「isAlive()」メソッドを使う。

スレッドの起動

スレッドを起動するには、新しいコールスタックを立ち上げる必要がある。start()メソッドで新しいコールスタックを立ち上げる。start()メソッドを呼び出す事により、以下の事柄が実行される。

１．新しい実行スレッドが起動する(新しいコールスタックも確保される)

２．スレッドの状態が「初期状態」から「実行可能状態」になる。

３．スレッドに実行の機会が与えられて、ターゲットのrun()メソッドが実行される。

※起動されるのは、RunnableではなくThread。Threadインスタンスに対してstart()メソッドを呼び出す。

スレッドは、ターゲットのrun()メソッドを実行し終わると、実行スレッドはなくなる。すなわち、Threadオブジェクトではあるが、実行スレッドがなくなる。よって、コールスタックが解散され、スレッドは「死んだ」状態になる。→「いったん終了したスレッドは2度と実行できない。」

スレッドの起動の例

class MyRunnable implements Runnable{
    public void run(){
        for(int i = 1 ; i < 6 ; i++){
            System.out.println("はじめてのスレッド") ;
        }
    }
}

class Test{
    public static void main(String[] argsa){
        MyRunnable r = new MyRunnable() ;

        Thread t = new Thread(r) ;

        t.start() ;
    }
}

現在実行しているスレッドの名前を出力する例

class MyRunnable implements Runnable{
    public void run(){
        System.out.print("現在実行中のスレッドは、") ;
        System.out.println(Thread.currentThread().getName() + "です。") ;//①
    }
}

class Test{
    public static void main(String[] args){
        MyRunnable r = new MyRunnable() ;
        Thread t = new Thread(r) ;//②
        t.setName("MyRunnable") ;//③
        t.start() ;
    }
}

①：currentThread()は静的メソッド。従って、クラス名.メソッド名で呼び出せる。このメソッドは、「現在実行中のスレッドオブジェクトの参照を返します。」この場合、現在実行中のスレッドは、②で作成したスレッド。getName()メソッドで現在のスレッド名を取得する。

③：setName(String name)メソッドは、「このスレッドの名前を引数 name に等しくなるように変更します。よって、現在実行中のスレッド名を「MyRunnable」と変更し、そのスレッド名をsetName()メソッドで取得する。

③を設定しないと、明示的に名前が割り当てられる。

スレッドの名前を自動的に出力する例

class MyRunnable implements Runnable{
    public void run(){
        System.out.print("現在実行中のスレッドは、") ;
        System.out.println(Thread.currentThread().getName() + "です。") ;
    }
}

class Test{
    public static void main(String[] args){
        MyRunnable r = new MyRunnable() ;
        Thread t = new Thread(r) ;
        t.start() ;
    }
}

このソースコードを実行すると、「Thread-0」と出力される。

currentThread()メソッドは現在実行中のスレッドのオブジェクトを返すので、以下のようにできる。

main()メソッド名を出力する例

class Test{
    public static void main(String[] args){
        System.out.println(Thread.currentThread().getName()) ;
    }
}

このソースコードの現在実行中のスレッドはmain()メソッドで実行されるスレッドなので、mainと表示される。

複数のスレッドを起動する

Threadインスタンスに対して、start()メソッドを呼び出す。Java仕様では、各スレッドの起動した順序通りに起動するとは書かれていない。すなわち、プログラマーの意図している通りに起動する保障はない。これは、スレッドの実行順序は「スケジューラ」によって決定され、プログラマーはスケジューラを制御できないため。

スレッド自体を制御できないが、あるスレッドを起動した後に、他のスレッドが完了するまでそのスレッドを停止しておくことはできる。

マルチスレッドの例

class MyRunnable implements Runnable{
    public void run(){
        for(int i = 1 ; i < 6 ; i++){
            System.out.println(Thread.currentThread().getName()) ;
        }
    }
}

class Test{
    public static void main(String[] argsa){
        MyRunnable r = new MyRunnable() ;
        Thread t1 = new Thread(r) ;
        t1.setName("Thread1") ;
        Thread t2 = new Thread(r) ;
        t2.setName("Thread2") ;
        Thread t3 = new Thread(r) ;
        t3.setName("Thread3") ;
        t1.start() ;
        t2.start() ;
        t3.start() ;
    }
}

上記の例の繰り返しを、100にかえてみると出力結果が変わってくる。これは、スケジューラが実行順序を決める為。

スレッドスケジューラ

スレッドスケジューラはJVMの一部であり、いつどの実行可能状態にあるスレッドを実行すべきか判断する。また、スレッドの実行中状態を解除する事もある。スレッドスケジューラは、次にどのスレッドを実行するかを、実行可能状態のスレッドの中から一つだけ任意に選択される。スレッドの十個人所によく使われるのが、「キュー方式」の動作であるが必ずそうなるとも限らない。

「キュー方式」とは、各スレッドが自分の順番を終えると、実行可能プールの列の末尾に移動し、列の先頭が回ってくるまでずっと待ち、先頭が来たらまた実行の順番を獲得するという方式。

スレッドの状態

初期状態・・・Threadインスタンスは作成されたが、まだstart()メソッドは呼び出されていない状態。初期状態のスレッドは有効なThreadオブジェクトだが、実行スレッドではない。まだ生存しているとはみなされない。

実行可能状態・・・実行対象として資格を持っているが、まだ実行するスレッドとして選択されていない状態。start()メソッドが呼び出されると、スレッドは実行可能状態になる。但し、実行された後や、ブロック状態・スリープ状態・待機状態から復帰した後でも、再び実行可能状態に戻る事がある。

実行中状態・・・スレッドが活動するとき。スレッドスケジューラが実行可能プールからそのスレッドを現在の実行プロセスとして選択している状態を指す。実行中状態が解除される要因は、「スレッドスケジューラの気まぐれ」「待機状態」「ブロック状態」「スリープ状態」が選択された時。実行中状態に至るには、スレッドスケジューラが選択する以外に方法はない。

スリープ状態／待機状態／ブロック状態・・・これら3つの状態は、スレッドは生存しているが、現在は実行対象としての資格を持っていなかった状態。

終了状態・・・run()メソッドが完了すると、スレッドは終了状態になる。この状態のThreadオブジェクトはまだ形を残しているが、独立した実行スレッドではなくなっている。いったん終了したスレッドは2度と起動できない。終了状態のThreadインスタンスに対してstart()メソッドを呼び出すと、ランタイム例外が発生する。

スレッドの実行抑制[スリープ状態]

sleep()メソッドはThreadクラスの静的メソッド。スレッドの進行具合を遅らせたいときに使用。実行中のスレッドをスリープ状態にして、その後「実行可能状態」にする。スレッドは実行可能可能状態になるので、スレッドスケジューラに選択されない限りスレッドは実行されない。

sleep()メソッドでスレッドを停止させ眠らせた後、スレッドを起こさないと実行可能状態には戻らない。

スレッドを一時停止するには、静的なThread.sleep()メソッドを呼び出し、停止する時間をミリ秒単位で指定する。

sleep()メソッドを記述する場所は、run()メソッド内に記述する。また、sleep()メソッドはチェック例外InterruptedExceptionを投げる可能性があるので、必ずtry-catch文内に記述すること。このメソッドは、ロックは開放しない。

sleep()メソッドの例1

class MyRunnable implements Runnable{
    public void run(){
        for(int i = 1 ; i < 11 ; i++){
            System.out.println("スレッド" + i) ;
        try{
            Thread.sleep(60*1000) ;
        }
        catch(InterruptedException ex){ }
        }
    }
}

class Test{
    public static void main(String[] args){
        MyRunnable r = new MyRunnable() ;
        Thread t = new Thread(r) ;
        t.start() ;
    }
}

sleep()メソッドの例1

class MyRunnable implements Runnable{
    public void run(){
        for(int i = 1 ; i < 101 ; i ++){
            if(i % 10 == 0){
                System.out.println(i + "は10の倍数です。") ;
            }
            else{
                System.out.println(i) ;
            }
            try{
                Thread.sleep(1000) ;
            }
            catch(InterruptedException ex){ }
        }
    }
}

class Test{
    public static void main(String[] args){
        MyRunnable r = new MyRunnable() ;
        Thread t = new Thread(r) ;
        t.start() ;
    }
}

スレッドの優先順位とyield()メソッド

スレッドは通常1～10までの優先順位の値が割り当てられる。（範囲が10未満になる時もある）

スレッドが実行可能状態になった時、そのスレッドの優先順位が実行可能プール内のそのスレッドのものよりも高く、かつ、現在実行中のスレッドのものよりも高かった場合、現在実行中のスレッドは実行可能状態に戻され、その時点で最も優先順位の高いスレッドが実行される。すなわち、いついかなる時でも、最も優先順位の高いスレッドが実行される。

優先順位が一緒の場合は、どのスレッドが呼び出されるかはスケジューラ次第。ちなみに優先順位は、数が大きいほうが上位になる。

静的メソッドsetPriority()を使って優先順位を変更する。尚、以下のfinal定数があり必ずしもスレッドの優先範囲が10とは限らない。

[final定数]

MIN_PRIORITY

NORM_PRIORITY

MAX_PRIORITY

setPriority()とyield()メソッド

class MyRunnable implements Runnable{
    public void run(){
        for(int i = 0 ; i < 100 ; i++ ){
            System.out.println(Thread.currentThread().getName()) ;
        }
    }
}

class Test{
    public static void main(String[] args){
        MyRunnable r = new MyRunnable() ;
        Thread t1 = new Thread(r) ;
        Thread t2 = new Thread(r) ;
        Thread t3 = new Thread(r) ;
        t1.setName("Thread1") ;
        t1.setPriority(3) ;
        t2.setName("Thread2") ;
        t2.setPriority(3) ;
        t3.setName("Thread3") ;
        t3.setPriority(5) ;
        t1.start() ;
        t1.yield() ;
        t2.start() ;
        t2.yield() ;
        t3.start() ;
    }
}

join()メソッド

非静的メソッドjoin()は結合の働きをする。例えば、スレッド「a」の後に「あるスレッド」を実行したい時に、「a.join()」とする事で「あるスレッド」を「a」が実行し終わった後に続けて実行できる。すなわち、「a」が終了した後に、「あるスレッド」実行したいのであれば、join()メソッドを使う。

join()メソッドは、interruptedExceptionを投げる可能性があるので、try-catch文で記述する。

join()メソッドの例

class MyRunnable implements Runnable{
    public void run(){
        for(int i = 1 ; i < 50 ; i++){
            System.out.println(Thread.currentThread().getName()) ;
        }
    }
}
class Test{
    public static void main(String[] argsa){
        MyRunnable r = new MyRunnable() ;
        MyRunnable2 r2 = new MyRunnable2() ;
        Thread t1 = new Thread(r) ;
        Thread t2 = new Thread(r) ;
        Thread t3 = new Thread(r) ;
        t1.setName("Thread1") ;
        t2.setName("Thread2") ;
        t3.setName("Thread3") ;
        t1.start() ;
        try{
        t1.join() ;
        }
        catch(InterruptedException ex){}
        t2.start() ;
        try{
        t2.join() ;
        }
        catch(InterruptedException ex){}
        t3.start() ;
    }
}

コードの同期化[異なるスレッドが同じオブジェクトの設定メソッドにアクセスする]

リアルタイムに在庫が変動するものに異なる二人が在庫を確認して、その後在庫があった場合、購入するというプログラムを作成する事にする。ここでは、宝くじを10枚単位で販売しており、10枚以上あったら購入することにする。以下の設定にする。

1.宝くじの在庫を50枚とする。この変数はprivate変数とする。

2.一回購入する毎に、10枚在庫を減らす。

3.購入する前に在庫確認を行う。

4.購入者は「太郎」と「花子」とする。

5.在庫確認をした後、1秒sleep()メソッドで止め、購入する。

宝くじ購入の例

//宝くじ在庫確認クラス
class Takara{
    private int zaiko =50 ;//総在庫数
    //在庫確認メソッド
    public int getNum(){
        return zaiko ;
    }
    //購入後の在庫処理メソッド
    public void sousu(int amount){
        zaiko = zaiko - amount ;
    }
}

//スレッドクラス（メインクラス）
public class Test implements Runnable{
    Takara ta = new Takara() ;
    public static void main(String[] args){
        Test r = new Test() ;
        Thread t1 = new Thread(r) ;
        Thread t2 = new Thread(r) ;
        t1.setName("太郎") ;
        t2.setName("花子") ;
        t1.start() ;
        t2.start() ;
    }
    public void run(){
        for(int i = 0 ; i < 5 ; i++){
            //getStock()メソッドの呼び出し
            getStock(10) ;
            //在庫が0の場合
            if(ta.getNum() < 0){
                System.out.println("在庫が0未満の為、購入できません") ;
            }
        }
    }
    //在庫確認と購入メソッド
    private void getStock(int num){
        //在庫数を取得し、10枚以上あった場合
        if(ta.getNum() >= num){
            System.out.println(Thread.currentThread().getName() + 
                "は、「在庫が十分にあるから買えるな!」と思いました。") ;
            try{
                Thread.sleep(1000) ;
            }
            catch(InterruptedException ex){}
            //10枚購入して、総在庫数を減らす
            ta.sousu(num) ;
            System.out.println(Thread.currentThread().getName() + 
                "は、在庫を確認したので10枚買いました") ;
        }
        //在庫が無かった場合
        else{
            System.out.println(Thread.currentThread().getName() + 
                "は、在庫がなかったのでもう買えませんでした") ;
        }
    }
}

このソースでの出力結果では、太郎と花子が宝くじを購入するが、設定メソッドgetStock()に双方がアクセスする為、在庫確認がスムーズに行われず在庫がないにも関わらず、購入するという結果が起こってしまう。この動作を防ぐためには、設定メソッドgetStock()を同期化する事により、「在庫確認」・「購入」この二つの動作を一つの動作とし、一つの動作が終わらないと、他者は「在庫確認」・「購入」がおこえなくするようにする。同期化するには、synchronizedキーワードを使う。

メソッドの同期化の例

class Takara{
    private int zaiko =50 ;
    public int getNum(){
        return zaiko ;
    }
    public void sousu(int amount){
        zaiko = zaiko - amount ;
    }
}


public class Test implements Runnable{
    Takara ta = new Takara() ;
    public static void main(String[] args){
        Test r = new Test() ;
        Thread t1 = new Thread(r) ;
        Thread t2 = new Thread(r) ;
        t1.setName("太郎") ;
        t2.setName("花子") ;
        t1.start() ;
        t2.start() ;
    }
    public void run(){
        for(int i = 0 ; i < 5 ; i++){
            getStock(10) ;
            if(ta.getNum() < 0){
                System.out.println("在庫が0未満の為、購入できません") ;
            }
        }
    }
    private synchronized void getStock(int num){
        if(ta.getNum() >= num){
            System.out.println(Thread.currentThread().getName() + 
                "は、「在庫が十分にあるから買えるな!」と思いました。") ;
            try{
                Thread.sleep(1000) ;
            }
            catch(InterruptedException ex){}
            ta.sousu(num) ;
            System.out.println(Thread.currentThread().getName() + 
                "は、在庫を確認したので10枚買いました") ;
        }
        else{
            System.out.println(Thread.currentThread().getName() + 
                "は、在庫がなかったのでもう買えませんでした") ;
        }
    }
}

上記のコードでは、「在庫確認」「購入」の二つが、一つの動作となったので、在庫がない場合は購入できなくなる。

同期化とブロック

同期化はブロックにより実現されている。Javaのオブジェクトにはブロックが組み込まれている。この機能は、オブジェクトに同期メソッドが組み込まれている時にはじめて作用する。一つのオブジェクトにブロックは一個だけなので、あるスレッドがロックを取得したら、他のスレッドは同期コードの中に入れない。ロックが解除された後、他のスレッドがロックを取得して同期コード内に入れる。

同期化できるのは、メソッドだけである。変数は同期化できない。

オブジェクトには必ずロックが一つだけ組み込まれている。

クラスの全てを同期化する必要はない。同期化したいものだけ、同期化すればよい。

クラスの中で複数の同期化メソッドがあった場合、その同期化メソッドにアクセスできるのは、一つのスレッドだけである。すなわち、同期化メソッド同士がワンセットと考える事ができる。

同期化されていないメソッドは、複数のスレッドがアクセスできる。

スレッドはそれまでに取得したロックを保持したままスリープ状態になる。

スレッドは複数のロックを取得する事ができる。また、あるオブジェクトのロックを取得した後、そのスレッドが同じオブジェクトに対してさらに同期メソッドを呼び出してもエラーにならない。

メソッド全体ではなく、コードブロック全体を同期化することもできる。同期化は同時アクセスを防ぐものだから、データの保護を必要としないコードは同期化しないほうがよい。

コードの同期化の例

class Test extends Thread{
    StringBuffer letters;

    public Test(StringBuffer s){
        this.letters = s ;
    }

    public void run(){
        synchronized(this.letters){
            for(int i = 1 ; i <= 100 ; ++i){
                System.out.println(letters) ;
            }
            System.out.println() ;
            char temp = letters.charAt(0) ;
            ++temp ;
            letters.setCharAt(0, temp) ;
        }
    }
    public static void main(String[] args){
        StringBuffer sb = new StringBuffer("A") ;
        new Test(sb).start() ;
        new Test(sb).start() ;
        new Test(sb).start() ;

    }
}

デッドロック

2つのスレッドがお互いが持つロックを待機してブロックしあっている状態の事。

デッドロックの例

class A{
    void echo(){
        System.out.println("a") ;
    }
    void echo2(){
        System.out.println("A") ;
    }
}
class B{
    void echo(){
        System.out.println("b") ;
    }
    void echo2(){
        System.out.println("B") ;
    }
}
public class Test{
    public static void main(String[] args){
        A a = new A() ;//インスタンス生成
        B b = new B() ;//インスタンス生成

        ThreadA t1 = new ThreadA(a,b) ;//スレッドオブジェクトの生成
        ThreadB t2 = new ThreadB(a,b) ;//スレッドオブジェクトの生成
        t1.start() ;
        t2.start() ;
        try{
            t1.join() ;
            t2.join() ;
        }catch (InterruptedException ex){ }
        System.out.println("正常に終了") ;
    }
}
class ThreadA extends Thread{
    int cnt = 0 ;
    A a;
    B b;

    ThreadA(A a, B b){
        this.a = a;
        this.b = b;
    }

    void methodA(){
        synchronized(a){//オブジェクトaをロック
            System.out.println("ThreadAから" + (++cnt) + "回目") ;
            a.echo() ;
            synchronized(b){//オブジェクトbの解除待ち
                b.echo2() ;
                try{
                    sleep(1000) ;
                } catch(InterruptedException ex){ }
            }
        }
    }
    public void run(){
        for(int i = 0 ; i <= 100 ; i++){
            methodA() ;
        }
    }
}


class ThreadB extends Thread{
    int cnt = 0 ;
    A a;
    B b;

    ThreadB(A a, B b){
        this.a = a;
        this.b = b;
    }

    void methodB(){
        synchronized(b){//オブジェクトbをロック
            System.out.println("ThreadBから" + (++cnt) + "回目") ;
            b.echo() ;
            synchronized(a){//オブジェクトaの解除待ち
                a.echo2() ;
                try{
                    sleep(1000) ;
                } catch(InterruptedException ex){ }
            }
        }
    }
    public void run(){
        for(int i = 0 ; i <= 100 ; i++){
            methodB() ;
        }
    }
}

お互いのスレッドが、ロックの解除を待ちwait状態になってしまう。ThreadAは、ThreadBがロックしたオブジェクトbの解除を待っており、ThreadBはThreadAがロックしたオブジェクトaの解除を待っている。

スレッド間のやりとり

スレッドは、他のスレッドとお互いのロック状態などの情報をやりとりする事ができる。java.lang.Objectには、wait()、notify()、notifyall()メソッドがあり、これらのメソッドは、スレッド同士がイベントの状態でやりとりする時に役立つ。

wait()とnotify()メソッドは、同期コンテキスト内で呼び出す必要がある。スレッドは、オブジェクトのロックを取得しない限り、オブジェクトに対して待機メソッドや通知メソッドを呼び出す事はできない。

wait()メソッドとnotify()メソッドの例

class ThreadA{
    public static void main(String[] args){
        ThreadB b = new ThreadB() ;
        b.start() ;

        synchronized(b){//オブジェクトbロックの取得
            try{
                System.out.println("Waiting for to complete...") ;
                b.wait() ;//ロックを開放し待機する
            } catch(InterruptedException ex){ }
        }
        System.out.println("Total is: " + b.total) ;
    }
}


class ThreadB extends Thread{
    int total ;

    public void run(){
        synchronized(this){
            for(int i = 0 ; i < 100 ; i++){
                total += i ;
            }
            notify() ;//現在待機している任意のスレッドに通知を送る。
        }
     }
}

このコードでは2つのスレッドが実行される。一つはメインスレッド、もう一つはスレッドB。スレッドBは、合計を求めるスレッドであるが、合計を求める前にメインスレッドが実行してしまう可能性がある。これを打破する為に、スレッドBが終了するまで待機してもらうようにしなければならない。

そこで、wait()メソッドとnotify()メソッドを使う。wait()メソッドで待機させ(メインスレッド)、notify()メソッドで待機中のスレッドを再開される。すなわち、スレッドBが実行し終わるまでメインスレッドを待機させたいので、wait()メソッドで待機させ、notify()メソッドでロックを開放する。

wait()メソッドやnotify()メソッドを呼び出すスレッドは、その対象となるオブジェクトのロックを取得しなければならない。wait()メソッドを呼び出して待機状態になったスレッドは、他のスレッドの為にオブジェクトのロックを一時的に開放するが、待機してから復帰して実行を再開する時には再度ロックを取得しなければならない。

notifyAll()メソッド

特定のオブジェクトを待機しているすべてのスレッドにまとめて通知を送りたい時にnotifyAll()メソッドを使う。notifyAll()メソッドを呼び出すと、全てのスレッドが通知を受け取り、ロックを取得しようと競争がはじまる。

notifyAll()メソッドの例

class Reader extends Thread{
    Calculator c ;

    public Reader(Calculator calc){
        c = calc ;
    }

    public void run(){
        synchronized(c) {
            try{
                System.out.println("Waiting for calculation...") ;
                c.wait() ;
            } catch(InterruptedException ex){ }
        }
        System.out.println("Total is: " + c.total) ;
    }

    public static void main(String[] args) {
        Calculator calculator = new Calculator() ;
        new Reader(calculator).start() ;
        new Reader(calculator).start() ;
        new Reader(calculator).start() ;
        calculator.start() ;

    }
}


class Calculator extends Thread{
    int total ;

    public void run(){
        synchronized(this){
            for(int i = 0 ; i < 100 ; i++) {
                total += i ;
            }
            notifyAll() ;
        }
    }
}