Aritalab:Lecture/Programming/Java/Parallel - Revision history

Adm: /* スレッドの作成 */

2013-06-24T02:43:39Z

‎スレッドの作成

Adm at 02:29, 24 June 2013

2013-06-24T02:29:58Z

Adm: /* Concurrentパッケージ */

2012-07-01T16:06:39Z

‎Concurrentパッケージ

Adm at 16:04, 1 July 2012

2012-07-01T16:04:56Z

Adm: /* スレッド間のやり取り */

2012-07-01T14:41:32Z

‎スレッド間のやり取り

Adm: /* 排他制御：ロックとクリティカルリージョン */

2012-07-01T14:31:58Z

‎排他制御：ロックとクリティカルリージョン

Adm: /* 競合するスレッド */

2012-07-01T14:26:32Z

‎競合するスレッド

Adm at 14:21, 1 July 2012

2012-07-01T14:21:51Z

Adm: Created page with "==Javaによる並列プログラミング== 並列プログラミングの基本は * スレッド * 排他制御 * 同期制御になります。個々の概念をサンプ..."

2012-07-01T06:33:21Z

Created page with "==Javaによる並列プログラミング== 並列プログラミングの基本は * スレッド * 排他制御 * 同期制御になります。個々の概念をサンプ..."

New page

==Javaによる並列プログラミング==

並列プログラミングの基本は
* スレッド
* 排他制御
* 同期制御
になります。個々の概念をサンプルプログラムを用いて解説します。

===スレッド===
コンピュター上のアプリケーション・プログラムは、OSからみると「プロセス」という単位で実行されています。個々のプロセスはメモリ空間やファイル入出力などを独自に備えています。（個々のアプリケーションプログラムは独立ですから、当たり前です。）並列プログラミングを行う場合、こうしたプロセスを複数作成して並列処理を実装することも可能ですが、複数プロセスを操作するにはOSのカーネルモードとユーザーモード（アプリケーション自身のモード」を行き来することになります。このオーバーヘッドは望ましくありません。そこで単一のプロセス内に（つまりメモリ空間やファイルデスクリプタを共有した形で）複数の実行単位を持たせたものを「スレッド」と呼びます。以前は軽量 (lightweight) プロセスとも呼ばれました。

===スレッドの作成===
まずは以下のプログラムを実行してみてください。このプログラムは２つのスレッドを作成し、それぞれ 0-50 ms 休みながら数字をカウントして終了します。実行するたびに出力結果が異なることを確認して下さい。また、メイン関数から呼ばれる test() の処理がスレッドよりも早く終了することも確認して下さい。
<pre>
import java.util.Random;

class Counter extends Thread {
Random rand = new Random();
String indent;
public Counter(int c) {
StringBuffer sb = new StringBuffer();
for(int i=0; i < c; i++) sb.append('\t');
indent = sb.toString();
}

public void run() {
System.out.println(indent+"ready");
try {
for (int i=0; i < 5; i++) {
Thread.sleep(rand.nextInt(50)); // sleep for 0-50 ms
System.out.println(indent+"count: " + i);
}
} catch (Exception e) { e.printStackTrace(); }
System.out.println(indent+"done");
}
}

public class ThreadTest {
static void test() {
Counter thread1 = new Counter(0);
Counter thread2 = new Counter(1);
System.out.println("START");
thread1.start();
thread2.start();
System.out.println("FINISH");
}

public static void main(String[] args) {
ThreadTest.test();
}
}
</pre>
実行例（毎回異なる）
<pre>
START
FINISH
ready
ready
count: 0
count: 1
count: 2
count: 0
count: 1
count: 3
count: 2
count: 4
done
count: 3
count: 4
done
</pre>
Java におけるスレッドは二通りの作成法があります。
# Thread クラスを継承する
# Runnable インターフェースを継承する
最初のほうが簡単ですが、後者のほうが（自分でクラスのデザインをできるぶん）柔軟です。Counter テストプログラムの場合、Runnable を用いて書くには以下のようにします。
<pre>
class Counter implements Runnable {
...
}

static void test() {
Counter thread1 = new Counter(0);
Counter thread2 = new Counter(1);
System.out.println("START");
new Thread(thread1).run();
new Thread(thread2).run();
System.out.println("FINISH");
}
</pre>
つまり、クラス定義の部分で implements Runnable 「インターフェース」を継承します。こうすると run() というメソッドを必ず実装しなくてはなりません。extends Thread のようにクラスを継承すると、デフォールトの run() メソッドとしてThread クラスの run() を継承しますが、implements Runnable の場合は名前の通り必要なメソッドを必ず実装します。この違いはC++と異なり Java は多重継承を許さない点に起因します。例えば Applet クラスでスレッドを使いたい場合、Thread と Applet と両方を継承できないので Runnable というインターフェースを継承するのです。

@@ Line 70: / Line 70: @@
 # Thread クラスを継承する
 # Runnable インターフェースを継承する
-最初のほうが簡単ですが、後者のほうが（自分でクラスのデザインをできるぶん）柔軟です。Counter テストプログラムの場合、Runnable を用いて書くには以下のようにします。
+最初のほうが簡単ですが、後者のほうが（自分でクラスのデザインをできるぶん）柔軟です。インターフェースとは、「これこれの機能を実装しなくてはならない」という制約のみを付加する概念です。クラスとして実際に継承する中身はありません。
 <pre>
 class Counter implements Runnable {
@@ Line 85: / Line 90: @@
+  }
 </pre>
-つまり、クラス定義の部分で implements Runnable 「インターフェース」を継承します。こうすると run() というメソッドを必ず実装しなくてはなりません。extends Thread のようにクラスを継承すると、デフォールトの run() メソッドとしてThread クラスの run() を継承しますが、implements Runnable の場合は名前の通り必要なメソッドを必ず実装します。この違いはC&#43;&#43;と異なり Java は多重継承を許さない点に起因します。例えば Applet クラスでスレッドを使いたい場合、Thread と Applet と両方を継承できないので Runnable というインターフェースを継承するのです。
+クラス定義の部分で implements Runnable と、Runnableインターフェースを継承しています。このとき、インターフェースの定義から run() というメソッドを必ず実装しなくてはなりません。敬称の時に extends Thread とThreadクラスを継承すると、デフォールトの run() メソッドとしてThread クラスの run() を継承しますが（もちろん上書きすることもできる）、implements Runnable の場合は必要なメソッドを自分で実装しなくてはなりません。この違いはC&#43;&#43;と異なり Java は多重継承を許さない点に起因します。例えば Applet クラスでスレッドを使いたい場合、Thread と Applet と両方を継承できないので Runnable というインターフェースを継承するのです。
 ==リソースの共有==

← Older revision		Revision as of 16:06, 1 July 2012
Line 235:		Line 235:

	==Concurrentパッケージ==		==Concurrentパッケージ==
−	[Aritalab:Lecture/Programming/Java/Parallel2\|このページ]をみて下さい。	+	[[Aritalab:Lecture/Programming/Java/Parallel2\|このページ]]をみて下さい。

← Older revision		Revision as of 16:04, 1 July 2012
Line 233:		Line 233:
	</pre>		</pre>
	上記のプログラムを実行するとどうなるでしょうか。考えてみて下さい。Creator メソッドは 4 つのタスクを for ループで作成しますが Processor メソッドが処理するまでは wait() によって待たされます。Processor スレッドはタスクを処理するたびに notifyAll() で通知をおこない、そのたびに Processor メソッドが新たなタスクを登録する仕組みになっています。		上記のプログラムを実行するとどうなるでしょうか。考えてみて下さい。Creator メソッドは 4 つのタスクを for ループで作成しますが Processor メソッドが処理するまでは wait() によって待たされます。Processor スレッドはタスクを処理するたびに notifyAll() で通知をおこない、そのたびに Processor メソッドが新たなタスクを登録する仕組みになっています。
		+
		+	==Concurrentパッケージ==
		+	[Aritalab:Lecture/Programming/Java/Parallel2\|このページ]をみて下さい。

@@ Line 150: / Line 150: @@
 Javaではすべてのクラスがロックを獲得できますが、int, boolean などの基本データ型はロック機能を持ちません。Integer や Boolean 等のラッパークラスを使えば良いのですが volatile 指定することでロックらしき機能を実現することができます。volatile 指定されたフィールドは直ちにメモリ上および全てのスレッドに反映されます。よって複数スレッドが異なるコピーを持ち合う競合を起こしません。
-===スレッド間のやり取り===
+==スレッド間のやり取り==
-では複数のスレッド間でリソースをやり取りするにはどうすればよいでしょうか。複数のスレッドでタスクを処理する例を考えましょう。タスクの置き場所を共有し、そこに Creator メソッドがタスクを置きます。また Processor メソッドがタスクを処理します。Creator メソッドがタスクを 1 個置く毎に Processor メソッドの処理を待つようにするには、置き場所へ常に 1 スレッドがアクセスするように制限するだけでなく、Creator がタスクを一つ置いたら Processor の処理を待たねばなりません。これには wait(), notifyAll() メソッドを利用します。
+複数のスレッド間でリソースをやり取りするにはどうすればよいでしょうか。汎用の解決策はなく、事例別にプログラムを組まねばなりません。ここでは２つのスレッドでタスクを処理する例を考えましょう。タスクの置き場所を共有し、そこに Creator メソッドがタスクを置きます。また Processor メソッドがタスクを処理します。Creator メソッドがタスクを 1 個置く毎に Processor メソッドの処理を待つようにするには、置き場所へ常に 1 スレッドがアクセスするように制限するだけでなく、Creator がタスクを一つ置いたら Processor の処理を待たねばなりません。これには wait(), notifyAll() メソッドを利用します。
 <pre>
 class Task {
@@ Line 232: / Line 232: @@
+}
 </pre>
-上記のプログラムを実行するとどうなるでしょうか。考えてみて下さい。
+上記のプログラムを実行するとどうなるでしょうか。考えてみて下さい。Creator メソッドは 4 つのタスクを for ループで作成しますが Processor メソッドが処理するまでは wait() によって待たされます。Processor スレッドはタスクを処理するたびに notifyAll() で通知をおこない、そのたびに Processor メソッドが新たなタスクを登録する仕組みになっています。

@@ Line 146: / Line 146: @@
 </pre>
 |}
 ===スレッド間のやり取り===

@@ Line 1: / Line 1: @@
 ==Javaによる並列プログラミング==
-並列プログラミングの基本は
+このページでは並列プログラムの基本概念を習得します。並列プログラミングの基本は
 * スレッド
 * 排他制御

@@ Line 88: / Line 88: @@
 ==リソースの共有==
-===競合するスレッド===
+===排他制御：ロックとクリティカルリージョン===
 以下の Java プログラムを実行してみてください。スレッドが２つあり、それぞれが 1 を足していますが結果も 1 になります。なぜでしょうか。
@@ Line 121: / Line 121: @@
+}
 </pre>
-この不整合は、addValue メソッドが 2 つのスレッドに同時に呼ばれることが原因です。それぞれのスレッドが変数 val のコピーを持つために結果が 2 になりません。この解決は簡単で、addValue メソッドを synchronized 指定します。同一クラスの synchronized メソッドは複数のスレッドが同時実行できません。このような制限をロック (lock) と呼びます。Javaではメソッドだけでなくメソッド内の特定ブロックのみを synchronized 指定することも可能です。以下のようにすると、どちらも同じく 2 を返すようになります。メソッド内のブロックを指定する時はロックするクラスを指定（以下の場合は val ）する必要があります。このため、このプログラムは val を Integer にしていたのでした。
+この不整合は、addValue メソッドが 2 つのスレッドに同時に呼ばれることが原因です。それぞれのスレッドが変数 val のコピーを持つために結果が 2 になりません。この解決は簡単で、addValue メソッドを synchronized 指定します。同一クラスの synchronized メソッドは複数のスレッドが同時実行できません。このような制限をロック (lock) と呼びます。Javaではメソッドだけでなくメソッド内の特定ブロックのみを synchronized 指定することも可能です。以下のようにすると、どちらも同じく 2 を返すようになります。このようにスレッド間で共有するリソースが使われる部分をクリティカルリージョン (critical region) と呼びます。
 {|
 |valign="top"|

@@ Line 13: / Line 13: @@
 まずは以下のプログラムを実行してみてください。このプログラムは２つのスレッドを作成し、それぞれ 0-50 ms 休みながら数字をカウントして終了します。実行するたびに出力結果が異なることを確認して下さい。また、メイン関数から呼ばれる test() の処理がスレッドよりも早く終了することも確認して下さい。
 <pre>
 class Counter extends Thread {
    String indent;
    public Counter(int c) {
@@ Line 28: / Line 25: @@
      try {
      for (int i=0; i < 5; i&#43;&#43;) {
-       Thread.sleep(rand.nextInt(50)); // sleep for 0-50 ms
+       Thread.sleep((int)(Math.random()*50)); // sleep for 0-50 ms
        System.out.println(indent+"count: " + i);
+     }
@@ Line 89: / Line 86: @@
 </pre>
 つまり、クラス定義の部分で implements Runnable 「インターフェース」を継承します。こうすると run() というメソッドを必ず実装しなくてはなりません。extends Thread のようにクラスを継承すると、デフォールトの run() メソッドとしてThread クラスの run() を継承しますが、implements Runnable の場合は名前の通り必要なメソッドを必ず実装します。この違いはC&#43;&#43;と異なり Java は多重継承を許さない点に起因します。例えば Applet クラスでスレッドを使いたい場合、Thread と Applet と両方を継承できないので Runnable というインターフェースを継承するのです。