NetBeans
Java NetBeans
Java SE 9 の予習 その４です。
前回のエントリーの続きでおそらく今回も必要とされない無駄なお遊びとなります。
今回は JShell API を利用してアプリケーション内でスニペットの評価や実行を試してみます。
なお、今回のエントリーには 「Java SE 9のProject Kulla、JShellの動作とJShell API （3/4）(JShell API)」の記事を参考にさせていただきました。
ほとんどプログラムは丸写し状態になっていますので元記事をまず読んで理解してこのお遊びプログラムを堪能していただければ幸いです。
下記プログラムは普通に19行目のコンストラクタ内で JShell.create() メソッドによりオブジェクトを生成します。
スニペットの評価実行は29行目の eval(String snipetSource) メソッドでおこなわれます。（折り畳んでいるので隠れてます。）
( 最後にいろいろゴニョゴニョ遊んだコードを載せますので行番号はずれてしまいますが参考にしてくださいませ。)
List<SnippetEvent> eval(String snipetSource) メソッドで SnippetEvent オブジェクトを取得します。
JavaDoc では 戻り値：この評価によって直接的または間接的に発生したイベントのリスト となっています。
つまり、ステータスや値です。
種類は、jdk.jshell.Snippet クラスの public Kind kind() メソッドで取得します。
戻り値である jdk.jshell.Snippet.Kind は jdk.jshell.Snippet のサブクラスを示します。
jdk.jshell.Snippet.Kind は jdk.jshell.Snippet クラスの public static enum Kind extends Enum<Kind> となっています。
つまり種類は jdk.jshell.Snippet クラスのイミュータブルプロパティです。
jdk.jshell.Snippetクラスには 種類を補足するための public SubKind subKind() メソッドも用意されています。
これは jdk.jshell.Snippet クラスの public static enum SubKind extends Enum<SubKind> を返します。
これはユーザーへのフィードバックに役立ちます。
これは種類の詳細な情報を取得するのに利用されます。
ステータスの取得には jdk.jshell.SnippetEvent クラスの public Status status() メソッドを使用します。
戻り値は jdk.jshell.Snippet クラスの public static enum Status extends Enum<Status> です。
これは JShell ステート内の動的プロパティです。
したがって JShell クエリで取得されます。
ステータスには次の7つの状態があります。
DROPPED：スニペットは、JShell.drop（Snippet）への明示的な呼び出しのために非アクティブです。
NONEXISTENT：スニペットはまだ存在しないため、非アクティブです。
OVERWRITTEN : 新しいスニペットに置き換えられているため、このスニペットは無効です。
RECOVERABLE_DEFINED：スニペットは、（現在のJShell状態のコンテキストで）回復可能な未解決の参照やその他の問題が本体内にある可能性のある宣言スニペットです。
RECOVERABLE_NOT_DEFINED：スニペットは、（現在のJShell状態のコンテキストで）回復可能な未解決の参照やその他の問題がある可能性のある宣言スニペットです。
REJECTED：スニペットは、初期評価時にコンパイルに失敗し、JShell状態のさらなる変更で有効になることができないため、非アクティブです。
VALID：スニペットは有効なスニペット（現在のJShell状態のコンテキスト内）です。
このプログラムではステータスが VALID でなければ jdk.jshell.JShell クラスの public Stream<Diag> diagnostics(Snippet snippet) メソッドでスニペットの最新評価の診断を取得します。
そして jdk.jshell.Diag クラスの public abstract String getMessage(Locale locale) メソッドで指定されたロケールのローカライズされたメッセージを返します。
実際のメッセージは実装依存です。 ロケールがnullの場合、デフォルトのロケールを使用します。
値の取得には、jdk.jshell.SnippetEvent クラスの public String value() メソッドを使います。
戻り値は成功した実行の結果値。
実行されなかった場合、または例外がスローされた場合、値はnullです。
以上、だいたいこんな感じで JShell API を楽しんでいきたいと思います。
動かすスニペットは例の「よく見かけるネタ IntegerCache 問題」です。
これだけだとさみしいので FunctionalInterface を利用した挨拶プログラムも JShell API で動かしてみましょう。
非常にシンプルなスニペットの実行となります。
Import statement、FunctionalInterface、などのステータス、値、種類などの情報を正確に取得できれば OK です。
では、このプログラムの実行結果を見てみましょう。
FunctionalInterface は、ただの Interface として識別されるようです。
IntegerCache 問題 もちゃんと false となっています。
これだと普通すぎて面白くないですよね。
日本ではもうすぐ Java SE 9 がリリースされようという時代に End Of Life となった Java SE 7 でプロフラムを組まなければいけない
涙無くしては語れない非常に過酷な環境に置かれているプログラマが多く存在するらしい。
そこでそういう可愛そうなプログラマのためにコンパイラオプションを JDK7 にし、
IntegerCache 問題で遊ぶために JVM オプションに -XX:AutoBoxCacheMax=128 を設定して実行してみます。
JShell オブジェクトの生成を JShell.create() メソッドから JShell.builder() メソッドに変更します。
コンパイラオプションの設定は
jdk.jshell.JShell.Builder クラスの public Builder compilerOptions(String… options) メソッドと使い設定します。
可変長引数の使い方が独特で思いっきりドツボにはまったのは内緒です。
JVM オプションの設定は
jdk.jshell.JShell.Builder クラスの public Builder remoteVMOptions(String… options) メソッドを使い設定します。
後は入出力の設定です。
これらは連鎖初期化で使用するため Builderインスタンスを返します。
最後に jdk.jshell.JShell.Builder クラスの public JShell build() メソッドで JShell ステートエンジンを構築します。
これはすべてのJShell機能のエントリーポイントです。
これにより、実行のためのリモートプロセスが作成されます。
それではコンパイラオプションと JVM オプションが正しく機能するかプログラムを走らせてみましょう。
うわぁぁ！！
正しく期待通りの動作となったが何故か目から涙がこぼれそうに・・・
IntegerCache 問題の実行結果も true となり正しく JVM オプションが設定されたようです。
これだけで天の邪鬼な私のお遊びは終了です。
ここから先は思い込みでサプライズさせてもらったお話しです。
先のプログラムにコンパイラオプションと JVM オプションを設定しない元の状態に戻して下記スニペットの実行コードを追加してみました。
JShell では import 文を必要としないパッケージが何故か存在します。
java.util.Arrays もその一つだから無事にプログラムは実行されるだろうと思っていました。
((((；゜Д゜))))))) なんと！ ERROR! EXPRESSION [ シンボルを見つけられません・・・ ]
JShell API を利用する場合はおもてなしは無しなのか！？
しかたないから import 文を追記してみた。
今度は期待通りの動作で実行された。
ついでだから enum も試してみた。
ちゃんと enum 認識していた。
実は Linux 環境の NetBeans IDE だからちゃんと日本語対応されているのですが
Windows 環境だと日本語は文字化けしてしまいます。
セレブデベロッパーご愛用の IntelliJ IDEA (2017.2 EAP)でも Windows環境での JShellAPI で日本語は文字化けしてしまう。
これは Java SE 9 リリースまでに修正されるのだろうか？
ちなみに Windows のコマンドプロンプトからの実行は文字化けしません。
以上、JShell API を無駄に使って遊んでみたエントリーでした。
お終い！
おっと！JShell API と戯れた記念コードを載せておきますね。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 |
package jp.yucchi.jshellapiexample; import java.util.List; import java.util.Locale; import jdk.jshell.ErroneousSnippet; import jdk.jshell.ExpressionSnippet; import jdk.jshell.JShell; import jdk.jshell.MethodSnippet; import jdk.jshell.Snippet; import jdk.jshell.Snippet.Status; import jdk.jshell.SnippetEvent; import jdk.jshell.TypeDeclSnippet; import jdk.jshell.VarSnippet; public class JShellAPIExample { private final JShell shell; public JShellAPIExample() { shell = JShell.create(); // shell = JShell.builder() // .compilerOptions("-source", "1.7", "-target", "1.7", // "-bootclasspath", "/home/yucchi/Sun/jdk1.7.0_80/jre/lib/rt.jar", // "-extdirs", "") // .remoteVMOptions("-XX:AutoBoxCacheMax=128") // .in(System.in) // .err(System.err) // .out(System.out) // .build(); } public void close() { if (shell != null) { shell.close(); } } public void eval(String snippetSource) { System.out.println(snippetSource); List<SnippetEvent> se = shell.eval(snippetSource); se.forEach(e -> { if (e.causeSnippet() == null) { Snippet snippet = e.snippet(); switch (snippet.kind()) { case IMPORT: switch (snippet.subKind()) { case SINGLE_TYPE_IMPORT_SUBKIND: System.out.println("<< Single-Type-Import Declaration. >>"); break; case SINGLE_STATIC_IMPORT_SUBKIND: System.out.println("<< Single-Static-Import Declaration. >>"); break; case TYPE_IMPORT_ON_DEMAND_SUBKIND: System.out.println("<< Type-Import-on-Demand Declaration. >>"); break; case STATIC_IMPORT_ON_DEMAND_SUBKIND: System.out.println("<< Static-Import-on-Demand Declaration. >>"); break; default: break; } break; case ERRONEOUS: System.out.println("ERROR! " + ((ErroneousSnippet) snippet).probableKind() + ":"); break; case TYPE_DECL: TypeDeclSnippet type = (TypeDeclSnippet) snippet; System.out.print("<< Created "); switch (snippet.subKind()) { case CLASS_SUBKIND: System.out.print("Class: "); break; case INTERFACE_SUBKIND: System.out.print("Interface: "); break; case ENUM_SUBKIND: System.out.print("Enum: "); break; case ANNOTATION_TYPE_SUBKIND: System.out.print("Annotation: "); break; default: break; } System.out.println(type.name() + " >>"); break; case METHOD: MethodSnippet method = (MethodSnippet) snippet; System.out.println("<< Created Method: " + method.name() + "(" + method.parameterTypes() + ")" + " >>"); break; case VAR: switch (snippet.subKind()) { case VAR_DECLARATION_SUBKIND: System.out.println("<< A variable declaration without initializer. >>"); System.out.println(((VarSnippet) snippet).name() + " ==> " + e.value()); break; case TEMP_VAR_EXPRESSION_SUBKIND: System.out.println("<< An expression whose value has been stored in a temporary variable. >>"); System.out.println(((VarSnippet) snippet).name() + " ==> " + e.value()); break; case VAR_DECLARATION_WITH_INITIALIZER_SUBKIND: System.out.println("<< A variable declaration with an initializer expression. >>"); System.out.println(((VarSnippet) snippet).name() + " ==> " + e.value()); break; default: break; } break; case EXPRESSION: switch (snippet.subKind()) { case VAR_VALUE_SUBKIND: System.out.println("<< A simple variable reference expression. >>"); System.out.println(((ExpressionSnippet) snippet).name() + " ==> " + e.value()); break; case ASSIGNMENT_SUBKIND: System.out.println("<< An assignment expression. >>"); System.out.println(((ExpressionSnippet) snippet).name() + " ==> " + e.value()); break; default: break; } break; case STATEMENT: System.out.println("<< " + "Statement: " + e.snippet() + " >>"); break; default: System.out.println("<< " + e.getClass().getCanonicalName() + " >>"); break; } if (e.status() != Status.VALID) { this.shell.diagnostics(e.snippet()).forEach(i -> { System.out.println("[ " + i.getMessage(Locale.getDefault()) + " ]"); }); } } }); } public static void main(String[] args) throws Exception { JShellAPIExample example = new JShellAPIExample(); example.eval("import java.time.LocalTime;"); example.eval("@FunctionalInterface \n" + "interface Greeting<T, R> {\n" + "R apply(T time, R message);\n" + "\n" + " default void sayGreeting(String greeting) {\n" + " greeting(greeting);\n" + " }\n" + "\n" + " private void greeting(String greeting) {\n" + " System.out.println(greeting + \" from JShellAPI.\");\n" + " };\n" + "}"); example.eval("LocalTime now = LocalTime.now();"); example.eval("int hour = now.getHour();"); example.eval("Greeting<Integer, String> greeting\n" + " = (time, message) -> 4 <= time && time < 11 ? \"Good morning!\"\n" + " : 11 <= time && time < 18 ? \"Good afternoon!\"\n" + " : \"Good evening!\";"); example.eval("String message = null;"); example.eval("greeting.sayGreeting(greeting.apply(hour, message));"); example.eval(""); System.out.println("(○･ω･)ﾉ----------------------------------------------------------)\n"); example.eval("Integer x = 128;"); example.eval("Integer y = 128;"); example.eval("void equivalenceTest(Integer x, Integer y) { System.out.println(x == y); }"); example.eval("equivalenceTest(x, y);"); System.out.println("(○･ω･)ﾉ----------------------------------------------------------)\n"); example.eval("import java.util.Arrays;"); // 省略不可 example.eval("String str;"); example.eval("str = \"Java\";"); example.eval("String[] elems = str.split(\"\");"); example.eval("System.out.println(Arrays.toString(elems));"); example.eval("Arrays.stream(elems).forEach(System.out::println);"); System.out.println("(○･ω･)ﾉ----------------------------------------------------------)\n"); example.eval("public enum JavaPlusYou {\n" + "\n" + " Japanese(\"あなたとJAVA,今すぐダウンロード\"),\n" + " English(\"JAVA+YOU, DOWNLOAD TODAY!\");\n" + "\n" + " private final String downloadNow;\n" + "\n" + " private JavaPlusYou(final String downloadNow) {\n" + " this.downloadNow = downloadNow;\n" + " }\n" + "\n" + " public String getDownloadNow() {\n" + " return downloadNow;\n" + " }\n" + "\n" + "}"); example.eval("for (JavaPlusYou jpy : JavaPlusYou.values()) {\n" + " System.out.println(jpy + \": \" + jpy.getDownloadNow());\n" + " }"); System.out.println("(○･ω･)ﾉ----------------------------------------------------------)\n"); example.eval("System.out.println(System.getProperty(\"java.vm.version\"));"); example.eval("System.out.println(System.getProperty(\"java.class.version\"));"); System.out.println("(○･ω･)ﾉ----------------------------------------------------------)\n"); example.close(); } } |
実行結果は次のようになります。
run:
import java.time.LocalTime;
<< Single-Type-Import Declaration. >>
@FunctionalInterface
interface Greeting<T, R> {
R apply(T time, R message);
default void sayGreeting(String greeting) {
greeting(greeting);
}
private void greeting(String greeting) {
System.out.println(greeting + ” from JShellAPI.”);
};
}
<< Created Interface: Greeting >>
LocalTime now = LocalTime.now();
<< A variable declaration with an initializer expression. >>
now ==> 17:28:24.474604
int hour = now.getHour();
<< A variable declaration with an initializer expression. >>
hour ==> 17
Greeting<Integer, String> greeting
= (time, message) -> 4 <= time && time < 11 ? “Good morning!”
: 11 <= time && time < 18 ? “Good afternoon!”
: “Good evening!”;
<< A variable declaration with an initializer expression. >>
greeting ==> $Lambda$17/555826066@a67c67e
String message = null;
<< A variable declaration with an initializer expression. >>
message ==> null
greeting.sayGreeting(greeting.apply(hour, message));
Good afternoon! from JShellAPI.
<< Statement: Snippet:StatementKey#7-greeting.sayGreeting(greeting.apply(hour, message)); >>
(○･ω･)ﾉ———————————————————-)
Integer x = 128;
<< A variable declaration with an initializer expression. >>
x ==> 128
Integer y = 128;
<< A variable declaration with an initializer expression. >>
y ==> 128
void equivalenceTest(Integer x, Integer y) { System.out.println(x == y); }
<< Created Method: equivalenceTest(Integer,Integer) >>
equivalenceTest(x, y);
false
<< Statement: Snippet:StatementKey#11-equivalenceTest(x, y); >>
(○･ω･)ﾉ———————————————————-)
import java.util.Arrays;
<< Single-Type-Import Declaration. >>
String str;
<< A variable declaration without initializer. >>
str ==> null
str = “Java”;
<< An assignment expression. >>
str ==> “Java”
String[] elems = str.split(“”);
<< A variable declaration with an initializer expression. >>
elems ==> String[4] { “J”, “a”, “v”, “a” }
System.out.println(Arrays.toString(elems));
[J, a, v, a]
<< Statement: Snippet:StatementKey#16-System.out.println(Arrays.toString(elems)); >>
Arrays.stream(elems).forEach(System.out::println);
J
a
v
a
<< Statement: Snippet:StatementKey#17-Arrays.stream(elems).forEach(System.out::println); >>
(○･ω･)ﾉ———————————————————-)
public enum JavaPlusYou {
Japanese(“あなたとJAVA,今すぐダウンロード”),
English(“JAVA+YOU, DOWNLOAD TODAY!”);
private final String downloadNow;
private JavaPlusYou(final String downloadNow) {
this.downloadNow = downloadNow;
}
public String getDownloadNow() {
return downloadNow;
}
}
<< Created Enum: JavaPlusYou >>
for (JavaPlusYou jpy : JavaPlusYou.values()) {
System.out.println(jpy + “: ” + jpy.getDownloadNow());
}
Japanese: あなたとJAVA,今すぐダウンロード
English: JAVA+YOU, DOWNLOAD TODAY!
<< Statement: Snippet:StatementKey#19-for (JavaPlusYou jpy : JavaPlusYou.values()) {
System.out.println(jpy + “: ” + jpy.getDownloadNow());
} >>
(○･ω･)ﾉ———————————————————-)
System.out.println(System.getProperty(“java.vm.version”));
9-ea+169
<< Statement: Snippet:StatementKey#20-System.out.println(System.getProperty(“java.vm.version”)); >>
System.out.println(System.getProperty(“java.class.version”));
53.0
<< Statement: Snippet:StatementKey#21-System.out.println(System.getProperty(“java.class.version”)); >>
(○･ω･)ﾉ———————————————————-)
ビルド成功(合計時間: 4秒)
TAGS: Java,NetBeans |
2017年5月21日8:52 PM |
Java NetBeans
食事する哲学者の問題（Dining Philosophers Problem）を J2SE5.0 で追加された java.util.concurrent.Semaphore を使ってプログラムを組んでみます。
Semaphore については前回のエントリーでざっくり説明し、シンプルなプログラムも紹介しています。
Semaphore で遊ぶ
それでは、食事する哲学者の問題（Dining Philosophers Problem）とは何か調べてみます。
WikiPedia によると、食事する哲学者の問題（Dining Philosophers Problem）とは、並列処理に関する問題を一般化した例である。古典的なマルチプロセスの同期（排他制御）問題である。とされています。
もともとは、1965年、エドガー・ダイクストラは5台のコンピュータが5台のテープ装置に競合アクセスするという同期問題を提示した。
間もなく、この問題はアントニー・ホーアによって「食事する哲学者の問題」に変形して語られることとなった。
どうして食事する哲学者にすり替わったかは置いといて・・・
【問題】
5人の哲学者が食事したり、考え事をしたりしている。
かれらの前には、真ん中にスパゲッティの入った大きなボールが置かれた丸い食卓がある。
その食卓には5枚の皿が置かれ、皿と皿の間にフォークが1本ずつ置かれている。
スパゲッティをボールから取って自分の皿によそうには2本のフォークを必要とし、哲学者は一度に1本のフォークしかテーブルから取ることができない。
（左右の手で同時に両側にある2本のフォークを取ることはできない、という意味。まずどちらかの側のフォークを取ってから、逆の側のフォークを取る。）
哲学者同士は決して会話をしない。
このため、5人が左のフォークを手にとって右のフォークが食卓に置かれるのを待つという危険なデッドロック状態が発生する可能性がある。
スパゲッティではないけどこういう状況ですね。
【解説】
本来、デッドロック問題の解説手段として使われた。このシステムがデッドロックに到るのは「満たされない要求の円環」が存在する場合である。
例えば、哲学者 P1 が哲学者 P2 の手にしているフォークを待っていて、P2 は哲学者 P3 のものを……といったように円環形に要求が連鎖する。
例えば、それぞれの哲学者が次のように振る舞うとする。
1.左のフォークが得られるまで思索して待ち、フォークを取り上げる。
2.右のフォークが得られるまで思索して待ち、フォークを取り上げる。
3.食事する。
4.右のフォークを置く。
5.左のフォークを置く。
6.最初にもどって繰り返す。
この解法は正しくない。
このやりかたではデッドロックが発生し、全哲学者が左のフォークを持ち、右のフォークが持てるようになるのを待つという状況が発生しうる。
その場合、右のフォークは決して得られない (>_<｡)
今回はこの方法でデッドロックを起こさないように Semaphore を使ってリソースへのアクセスを制限し対処するプログラムを組んでみることにします。
これって少し考えてみれば食事をしている両隣の哲学者はフォークをとれない状況ができるので同時に食事出来る哲学者の最大数は５人の場合は二人となります。
つまり、使われるフォークの数は４本となります。
これを利用すれば比較的簡単に Semaphore を利用してプログラムを組むことができますね。
それではプログラムを組んでみることにしますが、素直に哲学者に登場していただくより綺麗な女性を食事にお誘いしました。
今回デッドロックを避けるために使う Semaphore はウェイターの役割をはたします。
つまり、スパゲッティを食べる権利( パーミット取得 )があることを許可してくれます。
綺麗な女性は左のフォーク、そして右のフォークと使うことができればスパゲッティを食べることができます。
ただし、隣の女性がフォークを使っていたら（ ロックがかかっていたら ）フォークがあくのを待たなければ( ロックが解放される )いけません。
ウエイターは綺麗な女性がスパゲッティを食べ終わり左右のフォークを置いたなら、
その綺麗な女性のスパゲッティを食べる権利( パーミット )を戻してもらい、
次に待機している綺麗な女性がいれば「どうぞ、お食べください」とスパゲッティを食べる権利( パーミット )を与えます。。
そして綺麗な女性はフォークが空いていれば手に取りスパゲッティを食べられます。
フォークが空いていなければ待ちます。
これの繰り返しです。
最大二人の綺麗な女性がスパゲッティを同時に食べることがこれで可能となります。
左右のフォークの使用状況( ロックの状態 )によりフォーク待ち時間が発生してしまいますがこれでデッドロックは解消されます。
きっと綺麗な女性達は美味しいスパゲッティをお腹いっぱい食べて満足してお帰りになられたでしょう。
これをプログラムにすると次のようになりました。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
package jp.yucchi.dining.philosophers.problem.and.semaphore; import java.util.concurrent.locks.ReentrantLock; /** * * @author Yucchi */ public class Fork { private final ReentrantLock lock = new ReentrantLock(true); void useFork() { lock.lock(); } void releaseFork() { lock.unlock(); } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 |
package jp.yucchi.dining.philosophers.problem.and.semaphore; import java.security.SecureRandom; import java.util.Random; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.LongAdder; import java.util.logging.Level; import java.util.logging.Logger; import java.util.stream.IntStream; /** * * @author Yucchi */ public class Philosopher { private static final int NUMBERS_TO_EAT = 10; private final Semaphore semaphore; private final Fork leftFork; private final Fork rightFork; private final String name; private final Random random = new SecureRandom(); public Philosopher(String name, Fork leftFork, Fork rightFork, Semaphore semaphore) { this.name = name; this.leftFork = leftFork; this.rightFork = rightFork; this.semaphore = semaphore; } String eat() { long startTime = System.nanoTime(); LongAdder count = new LongAdder(); // AtomicInteger より高速らしい。 IntStream.rangeClosed(1, NUMBERS_TO_EAT) .forEach(i -> { try { semaphore.acquire(2); } catch (InterruptedException ex) { Logger.getLogger(Philosopher.class.getName()).log(Level.SEVERE, null, ex); } pickLeftFork(); pickRightFork(); eatingSpaghetti(count); putRightFork(); putLeftFork(); semaphore.release(2); }); long time = System.nanoTime() - startTime; String result = name + " が " + (int) count.doubleValue() + "回食事するのに要した時間は、" + (int) (time * 1e-9 % 60) + "秒" + Double.toString((time * 1e-9 % 60) % 1).substring(2) + "でした。"; return result; } private void pickLeftFork() { long startTime = System.nanoTime(); leftFork.useFork(); long time = System.nanoTime() - startTime; System.out.println(name + " 左のフォークをとりあげる思索した時間は、" + (int) (time * 1e-9 % 60) + "秒" + Double.toString((time * 1e-9 % 60) % 1).substring(2)); } private void pickRightFork() { long startTime = System.nanoTime(); rightFork.useFork(); long time = System.nanoTime() - startTime; System.out.println(name + " 右のフォークをとりあげる思索した時間は、" + (int) (time * 1e-9 % 60) + "秒" + Double.toString((time * 1e-9 % 60) % 1).substring(2)); } private void putLeftFork() { leftFork.releaseFork(); } private void putRightFork() { rightFork.releaseFork(); } private void eatingSpaghetti(LongAdder count) { count.increment(); System.out.println(name + " " + (int) count.doubleValue() + "回目の食事"); try { TimeUnit.MILLISECONDS.sleep(random.nextInt(1_000) + 500); } catch (InterruptedException ex) { Logger.getLogger(Philosopher.class.getName()).log(Level.SEVERE, null, ex); } System.out.println(name + " " + (int) count.doubleValue() + "回目食事終了"); } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
package jp.yucchi.dining.philosophers.problem.and.semaphore; import java.util.List; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; import java.util.concurrent.Semaphore; import java.util.logging.Level; import java.util.logging.Logger; import java.util.stream.Collectors; import java.util.stream.Stream; /** * * @author Yucchi */ public class DiningPhilosophersProblemAndSemaphore { private static final int PHILOSOPHERS_NUMBER = 5; public static void main(String[] args) { List<Fork> fork = Stream.generate(Fork::new).limit(PHILOSOPHERS_NUMBER).collect(Collectors.toList()); final Semaphore semaphore = new Semaphore(PHILOSOPHERS_NUMBER, true); // 公平性を有効にしないと偏る。 Philosopher maki = new Philosopher("堀北真希", fork.get(0), fork.get(1), semaphore); Philosopher yui = new Philosopher("新垣結衣", fork.get(1), fork.get(2), semaphore); Philosopher ayame = new Philosopher("剛力彩芽", fork.get(2), fork.get(3), semaphore); Philosopher keiko = new Philosopher("北川景子", fork.get(3), fork.get(4), semaphore); Philosopher mirei = new Philosopher("桐谷美玲", fork.get(4), fork.get(0), semaphore); CompletableFuture<String> philosopherMaki = CompletableFuture.supplyAsync(() -> maki.eat()); CompletableFuture<String> philosopherYui = CompletableFuture.supplyAsync(() -> yui.eat()); CompletableFuture<String> philosopherAyame = CompletableFuture.supplyAsync(() -> ayame.eat()); CompletableFuture<String> philosopherKeiko = CompletableFuture.supplyAsync(() -> keiko.eat()); CompletableFuture<String> philosopherMirei = CompletableFuture.supplyAsync(() -> mirei.eat()); CompletableFuture<Void> allTask = CompletableFuture.allOf(philosopherMaki, philosopherYui, philosopherAyame, philosopherKeiko, philosopherMirei); allTask.join(); if (allTask.isDone()) { try { System.out.print(System.getProperty("line.separator")); System.out.println(philosopherMaki.get()); System.out.println(philosopherYui.get()); System.out.println(philosopherAyame.get()); System.out.println(philosopherKeiko.get()); System.out.println(philosopherMirei.get()); } catch (InterruptedException | ExecutionException ex) { Logger.getLogger(DiningPhilosophersProblemAndSemaphore.class.getName()).log(Level.SEVERE, null, ex); } System.out.print(System.getProperty("line.separator")); System.out.println("(○･ω･)ﾉ-------- I eat delicious spaghetti and am stuffed. --------(^_^)"); } } } |
プログラムを実行させてデッドロックが発生せず動作するか確認します。
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒7838E-5
北川景子 左のフォークをとりあげる思索した時間は、0秒8168E-5
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒313E-6
桐谷美玲 1回目の食事
桐谷美玲 1回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、1秒3359217400000001
北川景子 1回目の食事
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
北川景子 1回目食事終了
剛力彩芽 右のフォークをとりあげる思索した時間は、1秒3721449000000001
剛力彩芽 1回目の食事
堀北真希 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
堀北真希 右のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
堀北真希 1回目の食事
剛力彩芽 1回目食事終了
堀北真希 1回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒375070565
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
新垣結衣 右のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒652E-6
桐谷美玲 2回目の食事
新垣結衣 1回目の食事
新垣結衣 1回目食事終了
北川景子 左のフォークをとりあげる思索した時間は、0秒652E-6
桐谷美玲 2回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、0秒08200188600000001
北川景子 2回目の食事
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒652E-6
北川景子 2回目食事終了
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒583391387
堀北真希 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
堀北真希 右のフォークをとりあげる思索した時間は、0秒652E-6
堀北真希 2回目の食事
剛力彩芽 2回目の食事
堀北真希 2回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒652E-6
剛力彩芽 2回目食事終了
新垣結衣 右のフォークをとりあげる思索した時間は、0秒436658855
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒652E-6
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒652E-6
新垣結衣 2回目の食事
桐谷美玲 3回目の食事
新垣結衣 2回目食事終了
北川景子 左のフォークをとりあげる思索した時間は、0秒294E-6
桐谷美玲 3回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、0秒23805942200000002
北川景子 3回目の食事
堀北真希 左のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
堀北真希 右のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
堀北真希 3回目の食事
北川景子 3回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒312E-6
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
剛力彩芽 3回目の食事
堀北真希 3回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒652E-6
剛力彩芽 3回目食事終了
新垣結衣 右のフォークをとりあげる思索した時間は、0秒18132323900000002
新垣結衣 3回目の食事
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒652E-6
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
桐谷美玲 4回目の食事
新垣結衣 3回目食事終了
北川景子 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
桐谷美玲 4回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、0秒39374600600000004
北川景子 4回目の食事
堀北真希 左のフォークをとりあげる思索した時間は、0秒652E-6
堀北真希 右のフォークをとりあげる思索した時間は、0秒312E-6
堀北真希 4回目の食事
堀北真希 4回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒9640000000000005E-6
北川景子 4回目食事終了
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒023616073
剛力彩芽 4回目の食事
新垣結衣 左のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
剛力彩芽 4回目食事終了
新垣結衣 右のフォークをとりあげる思索した時間は、0秒7176410350000001
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒312E-6
新垣結衣 4回目の食事
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
桐谷美玲 5回目の食事
桐谷美玲 5回目食事終了
堀北真希 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
新垣結衣 4回目食事終了
堀北真希 右のフォークをとりあげる思索した時間は、0秒718831517
堀北真希 5回目の食事
北川景子 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
北川景子 右のフォークをとりあげる思索した時間は、0秒3543E-5
北川景子 5回目の食事
堀北真希 5回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒6430000000000004E-6
北川景子 5回目食事終了
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒140569047
剛力彩芽 5回目の食事
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒981E-6
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
桐谷美玲 6回目の食事
桐谷美玲 6回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒6420000000000003E-6
剛力彩芽 5回目食事終了
新垣結衣 右のフォークをとりあげる思索した時間は、0秒256017732
新垣結衣 5回目の食事
堀北真希 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
新垣結衣 5回目食事終了
堀北真希 右のフォークをとりあげる思索した時間は、0秒908995176
堀北真希 6回目の食事
北川景子 左のフォークをとりあげる思索した時間は、0秒973E-6
北川景子 右のフォークをとりあげる思索した時間は、0秒313E-6
北川景子 6回目の食事
堀北真希 6回目食事終了
北川景子 6回目食事終了
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒156232277
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒652E-6
桐谷美玲 7回目の食事
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
剛力彩芽 6回目の食事
桐谷美玲 7回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒312E-6
剛力彩芽 6回目食事終了
新垣結衣 右のフォークをとりあげる思索した時間は、0秒200991297
新垣結衣 6回目の食事
堀北真希 左のフォークをとりあげる思索した時間は、0秒652E-6
新垣結衣 6回目食事終了
堀北真希 右のフォークをとりあげる思索した時間は、1秒3822943870000002
堀北真希 7回目の食事
北川景子 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
北川景子 右のフォークをとりあげる思索した時間は、0秒3030000000000004E-6
北川景子 7回目の食事
堀北真希 7回目食事終了
北川景子 7回目食事終了
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒089658099
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
桐谷美玲 8回目の食事
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒625000000000001E-6
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒313E-6
剛力彩芽 7回目の食事
剛力彩芽 7回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒955E-6
新垣結衣 右のフォークをとりあげる思索した時間は、0秒652E-6
新垣結衣 7回目の食事
桐谷美玲 8回目食事終了
堀北真希 左のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
新垣結衣 7回目食事終了
堀北真希 右のフォークをとりあげる思索した時間は、0秒8264462760000001
北川景子 左のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
堀北真希 8回目の食事
北川景子 右のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
北川景子 8回目の食事
堀北真希 8回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒6420000000000003E-6
北川景子 8回目食事終了
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒217371327
剛力彩芽 8回目の食事
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒312E-6
桐谷美玲 9回目の食事
剛力彩芽 8回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
新垣結衣 右のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
新垣結衣 8回目の食事
桐谷美玲 9回目食事終了
堀北真希 左のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
新垣結衣 8回目食事終了
堀北真希 右のフォークをとりあげる思索した時間は、1秒21894861600000004
北川景子 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
堀北真希 9回目の食事
北川景子 右のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
北川景子 9回目の食事
堀北真希 9回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒652E-6
北川景子 9回目食事終了
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒780406594
剛力彩芽 9回目の食事
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒294E-6
桐谷美玲 10回目の食事
剛力彩芽 9回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒973E-6
新垣結衣 右のフォークをとりあげる思索した時間は、0秒652E-6
新垣結衣 9回目の食事
桐谷美玲 10回目食事終了
堀北真希 左のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
新垣結衣 9回目食事終了
堀北真希 右のフォークをとりあげる思索した時間は、0秒475458529
堀北真希 10回目の食事
北川景子 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
北川景子 右のフォークをとりあげる思索した時間は、0秒312E-6
北川景子 10回目の食事
堀北真希 10回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒652E-6
北川景子 10回目食事終了
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒34860347900000005
新垣結衣 左のフォークをとりあげる思索した時間は、0秒652E-6
剛力彩芽 10回目の食事
剛力彩芽 10回目食事終了
新垣結衣 右のフォークをとりあげる思索した時間は、1秒0036094330000000507
新垣結衣 10回目の食事
新垣結衣 10回目食事終了
堀北真希 が 10回食事するのに要した時間は、28秒6504769030000013でした。
新垣結衣 が 10回食事するのに要した時間は、30秒9585105100000035でした。
剛力彩芽 が 10回食事するのに要した時間は、30秒0028747960000004014でした。
北川景子 が 10回食事するのに要した時間は、28秒998852129000003でした。
桐谷美玲 が 10回食事するのに要した時間は、27秒3586783140000023でした。
(○･ω･)ﾉ——– I eat delicious spaghetti and am stuffed. ——–(^_^)
ちゃんと動きました。(^_^)
このプログラムでは Semaphore インスタンス生成時のコンストラクタ引数に哲学者の人数を割り当てました。
また、公平性も設定しました。
パーミット数の設定は同時アクセスは 2 スレッドまでなので 2 と設定して、acquire()、release() とパーミット取得数とパーミット解放数を 1 してもいいでしょう。
今回は、パーミット数の設定を 5 , acquire(2)、release(2) とパーミット取得数とパーミット解放数を 2 としました。
同時アクセス可能なのが 2 スレッドで左右のフォークをロックするのでこの問題の鍵となるフォークの数を考慮にいれました。（あまり意味の無いこだわり）
final Semaphore semaphore = new Semaphore(PHILOSOPHERS_NUMBER, true);
NetBeans のプロファイラでスレッドの状態を確認してみましょう。
5 個の ForkJoinPool.commonPool-worker-29 とかのスレッドが最大で二つ同時アクセスされているのが確認できます。
スレッド終了後にフォークのロック解放待ちが無い場合はすぐに新たなスレッドが実行されているのも確認できます。
Semaphore って本当に便利ですね！
さて、ここでちょっとしたことを試してみよう。
Semaphore の公平性の設定をしなかったらどうなるのか？
final Semaphore semaphore = new Semaphore(PHILOSOPHERS_NUMBER); // 公平性無し
では、プログラムを実行させてみます。
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒0810000000000002E-5
堀北真希 左のフォークをとりあげる思索した時間は、0秒0810000000000002E-5
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
堀北真希 右のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
剛力彩芽 1回目の食事
堀北真希 1回目の食事
堀北真希 1回目食事終了
堀北真希 左のフォークをとりあげる思索した時間は、0秒313E-6
堀北真希 右のフォークをとりあげる思索した時間は、0秒652E-6
堀北真希 2回目の食事
剛力彩芽 1回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒312E-6
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒652E-6
剛力彩芽 2回目の食事
堀北真希 2回目食事終了
堀北真希 左のフォークをとりあげる思索した時間は、0秒312E-6
堀北真希 右のフォークをとりあげる思索した時間は、0秒652E-6
堀北真希 3回目の食事
剛力彩芽 2回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒910000000000001E-7
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
剛力彩芽 3回目の食事
堀北真希 3回目食事終了
堀北真希 左のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
堀北真希 右のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
堀北真希 4回目の食事
剛力彩芽 3回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒910000000000001E-7
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
剛力彩芽 4回目の食事
堀北真希 4回目食事終了
堀北真希 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
堀北真希 右のフォークをとりあげる思索した時間は、0秒652E-6
堀北真希 5回目の食事
剛力彩芽 4回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒6420000000000003E-6
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
剛力彩芽 5回目の食事
堀北真希 5回目食事終了
堀北真希 左のフォークをとりあげる思索した時間は、0秒312E-6
堀北真希 右のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
堀北真希 6回目の食事
剛力彩芽 5回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒910000000000001E-7
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒652E-6
剛力彩芽 6回目の食事
剛力彩芽 6回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒312E-6
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
剛力彩芽 7回目の食事
堀北真希 6回目食事終了
堀北真希 左のフォークをとりあげる思索した時間は、0秒910000000000001E-7
堀北真希 右のフォークをとりあげる思索した時間は、0秒652E-6
堀北真希 7回目の食事
剛力彩芽 7回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
剛力彩芽 8回目の食事
堀北真希 7回目食事終了
堀北真希 左のフォークをとりあげる思索した時間は、0秒910000000000001E-7
堀北真希 右のフォークをとりあげる思索した時間は、0秒652E-6
堀北真希 8回目の食事
剛力彩芽 8回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒973E-6
剛力彩芽 9回目の食事
堀北真希 8回目食事終了
堀北真希 左のフォークをとりあげる思索した時間は、0秒6430000000000004E-6
堀北真希 右のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
堀北真希 9回目の食事
剛力彩芽 9回目食事終了
剛力彩芽 左のフォークをとりあげる思索した時間は、0秒652E-6
剛力彩芽 右のフォークをとりあげる思索した時間は、0秒652E-6
剛力彩芽 10回目の食事
堀北真希 9回目食事終了
堀北真希 左のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
堀北真希 右のフォークをとりあげる思索した時間は、0秒652E-6
堀北真希 10回目の食事
剛力彩芽 10回目食事終了
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒312E-6
堀北真希 10回目食事終了
北川景子 左のフォークをとりあげる思索した時間は、0秒616E-6
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒830071894
桐谷美玲 1回目の食事
桐谷美玲 1回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、0秒888391644
北川景子 1回目の食事
北川景子 1回目食事終了
北川景子 左のフォークをとりあげる思索した時間は、0秒6420000000000003E-6
桐谷美玲 左のフォークをとりあげる思索した時間は、1秒44702734600000005
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒652E-6
桐谷美玲 2回目の食事
桐谷美玲 2回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、1秒2932113780000001
北川景子 2回目の食事
北川景子 2回目食事終了
北川景子 左のフォークをとりあげる思索した時間は、0秒3030000000000004E-6
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒6195947270000001
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒312E-6
桐谷美玲 3回目の食事
桐谷美玲 3回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、1秒23741232
北川景子 3回目の食事
北川景子 3回目食事終了
北川景子 左のフォークをとりあげる思索した時間は、0秒6420000000000003E-6
桐谷美玲 左のフォークをとりあげる思索した時間は、1秒2788060170000002
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒652E-6
桐谷美玲 4回目の食事
桐谷美玲 4回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、0秒9319671190000001
北川景子 4回目の食事
北川景子 4回目食事終了
北川景子 左のフォークをとりあげる思索した時間は、0秒633E-6
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒55758825
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒3543E-5
桐谷美玲 5回目の食事
桐谷美玲 5回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、0秒7469512070000001
北川景子 5回目の食事
北川景子 5回目食事終了
北川景子 左のフォークをとりあげる思索した時間は、0秒910000000000001E-7
桐谷美玲 左のフォークをとりあげる思索した時間は、1秒08432603500000013
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒973E-6
桐谷美玲 6回目の食事
桐谷美玲 6回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、0秒733817256
北川景子 6回目の食事
北川景子 6回目食事終了
北川景子 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
桐谷美玲 左のフォークをとりあげる思索した時間は、1秒1698336330000001
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒312E-6
桐谷美玲 7回目の食事
桐谷美玲 7回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、1秒4533695360000001
北川景子 7回目の食事
北川景子 7回目食事終了
北川景子 左のフォークをとりあげる思索した時間は、0秒322E-6
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒8525430700000001
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒652E-6
桐谷美玲 8回目の食事
桐谷美玲 8回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、0秒669598278
北川景子 8回目の食事
北川景子 8回目食事終了
北川景子 左のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
桐谷美玲 左のフォークをとりあげる思索した時間は、1秒3454052980000002
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
桐谷美玲 9回目の食事
桐谷美玲 9回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、1秒25630280000000005
北川景子 9回目の食事
北川景子 9回目食事終了
北川景子 左のフォークをとりあげる思索した時間は、0秒652E-6
桐谷美玲 左のフォークをとりあげる思索した時間は、0秒598060677
桐谷美玲 右のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
桐谷美玲 10回目の食事
桐谷美玲 10回目食事終了
北川景子 右のフォークをとりあげる思索した時間は、1秒09184714699999996
北川景子 10回目の食事
新垣結衣 左のフォークをとりあげる思索した時間は、0秒946E-6
新垣結衣 右のフォークをとりあげる思索した時間は、0秒312E-6
新垣結衣 1回目の食事
北川景子 10回目食事終了
新垣結衣 1回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒973E-6
新垣結衣 右のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
新垣結衣 2回目の食事
新垣結衣 2回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒6430000000000004E-6
新垣結衣 右のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
新垣結衣 3回目の食事
新垣結衣 3回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒312E-6
新垣結衣 右のフォークをとりあげる思索した時間は、0秒652E-6
新垣結衣 4回目の食事
新垣結衣 4回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒322E-6
新垣結衣 右のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
新垣結衣 5回目の食事
新垣結衣 5回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒024E-5
新垣結衣 右のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
新垣結衣 6回目の食事
新垣結衣 6回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒973E-6
新垣結衣 右のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
新垣結衣 7回目の食事
新垣結衣 7回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒6430000000000004E-6
新垣結衣 右のフォークをとりあげる思索した時間は、0秒9820000000000003E-6
新垣結衣 8回目の食事
新垣結衣 8回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒652E-6
新垣結衣 右のフォークをとりあげる思索した時間は、0秒3210000000000001E-6
新垣結衣 9回目の食事
新垣結衣 9回目食事終了
新垣結衣 左のフォークをとりあげる思索した時間は、0秒910000000000001E-7
新垣結衣 右のフォークをとりあげる思索した時間は、0秒6510000000000002E-6
新垣結衣 10回目の食事
新垣結衣 10回目食事終了
堀北真希 が 10回食事するのに要した時間は、10秒9469584730000005でした。
新垣結衣 が 10回食事するのに要した時間は、40秒20581136300000225でした。
剛力彩芽 が 10回食事するのに要した時間は、10秒11629695400000095でした。
北川景子 が 10回食事するのに要した時間は、31秒21609595200000342でした。
桐谷美玲 が 10回食事するのに要した時間は、30秒20136357100000168でした。
(○･ω･)ﾉ——– I eat delicious spaghetti and am stuffed. ——–(^_^)
うわぁぁぁ・・・ 思いっきり不公平じゃないですか！
NetBeans のプロファイラでスレッドの状態を確認してみます。
今回のようなフォークのロック解放待ちがあるような場合はまずいような・・・
こんなとこもあるよね。
プログラムの処理時間が大幅に増えてます。
公平性の設定はよく考えないと思わぬ結果をもたらすかもしれませんね。
CompletableFuture を使えば楽に並行処理を記述できるし、Java って世に出たときはマルチスレッド対応だぜ！って誇らしげに売りにしていた。
あれから20年、確実に進化しています。
どんどん進化していく並行処理を日本語で優しく解説しているサイトはあまり無いのが残念です。
便利なものほど正しく使わないと痛い目をみますからね。
もっと正しい知識を優しい日本語の解説で入手したい今日この頃です。
今月の私は健康診断でコレステロールと中性脂肪の値が高いと指摘されたにもかかわらずこういった美味しいケーキをたくさん食べてしまいました。
美味しさそのままで中性脂肪とコレステロールの値をさげるケーキって無いものか。
お終い！
TAGS: Java,NetBeans |
2015年5月5日2:50 PM |
Java NetBeans
早いもので今日は五月五日 こどもの日です。
祝日法2条によれば、「こどもの人格を重んじ、こどもの幸福をはかるとともに、母に感謝する」となっています。
5月5日は古来から端午の節句として日本では男子の健やかな成長を祈願し各種の行事を行う風習があります。
ということで、私も男子の健やかな成長を祈願するプログラムを組むことにしました。
今さらですが、J2SE5.0 で追加された java.util.concurrent.Semaphore をつかってふざけた 夢のようなプログラム組みました。
男子の健やかな成長には素敵な女性との出会いは必要不可欠です。
だから４人の素敵な女性にデートに誘われると言う内容です。
しかし、体は一つしかありませんので一度に４人では収集付かなくなります。
そこで恭平さんにヘルプをお願いしました。(^_^;)
これでも、素敵な女性４人に対して男子は二人です。
これでなんとかするために Semaphore を使って二組のカップルまでがデートに出かけられるとします。
残りの二人の女性は先に出かけた二組のカップルのどちらか片方が帰ってきたらデートに出かけるという設定です。
つまり、男子二人というリソースに同時アクセス出来るのは素敵な女性スレッド二つまでということになります。
それが Semaphore を使えば実現できてしまうのです。
Semaphore はざっくり説明するとリソースに対するアクセスが可能か不可能かのいずれかの値をとる Binary Semaphore と
アクセス可能なリソース数を任意に設定することが出来る Counting Semaphore があります。
Java で採用された Semaphore は Counting Semaphore にあたります。
有限リソースに対して並行アクセス可能なスレッド数を自由に設定できます。
今回組むプログラムにうってつけの優れものとなっています。(^_^)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 |
package jp.yucchi.playboy; import java.util.concurrent.Semaphore; import java.util.concurrent.locks.ReentrantLock; import java.util.logging.Level; import java.util.logging.Logger; /** * * @author Yucchi */ class Guy { private final String[] guys = {"ゆっち", "恭平"}; private final int MAX_AVAILABLE = guys.length; private final boolean[] played = new boolean[MAX_AVAILABLE]; private final Semaphore semaphore = new Semaphore(MAX_AVAILABLE, true); // 公平性あり // private final Semaphore semaphore = new Semaphore(MAX_AVAILABLE); // 公平性なし String getGuyName() { System.out.println("待っているのは、" + Thread.currentThread().getName()); try { semaphore.acquire(); System.out.println("今からデートに行くのは、" + Thread.currentThread().getName()); } catch (InterruptedException ex) { Logger.getLogger(Guy.class.getName()).log(Level.SEVERE, null, ex); } return getGuy(); } void byeGuy(String guysName) { if (isplayed(guysName)) { semaphore.release(); } } // ReentrantLock を使う場合 ReentrantLock lock = new ReentrantLock(true); // 公平性あり private String getGuy() { try { lock.lock(); for (int i = 0; i < MAX_AVAILABLE; i++) { if (!played[i]) { played[i] = true; return guys[i]; } } } finally { lock.unlock(); } return null; } private boolean isplayed(String guysName) { try { lock.lock(); for (int i = 0; i < MAX_AVAILABLE; i++) { if (guys[i].equals(guysName)) { if (played[i]) { played[i] = false; return true; } else { return false; } } } } finally { lock.unlock(); } return false; } // // synchronized を使う場合 // private synchronized String getGuy() { // for (int i = 0; i < MAX_AVAILABLE; i++) { // if (!played[i]) { // played[i] = true; // return guys[i]; // } // } // return null; // } // // private synchronized boolean isplayed(String guysName) { // for (int i = 0; i < MAX_AVAILABLE; i++) { // if (guys[i].equals(guysName)) { // if (played[i]) { // played[i] = false; // return true; // } else { // return false; // } // } // } // return false; // } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
package jp.yucchi.playboy; import java.security.SecureRandom; import java.util.Random; import java.util.concurrent.TimeUnit; import java.util.logging.Level; import java.util.logging.Logger; /** * * @author Yucchi */ class Lovers { private final String loversName; private final Guy guy; Lovers(String loversName, Guy guyName) { this.loversName = loversName; this.guy = guyName; } void play() { Thread.currentThread().setName(loversName); try { Random random = new SecureRandom(); String guysName = guy.getGuyName(); System.out.println(loversName + " は " + guysName + " とデートに行きました。"); TimeUnit.SECONDS.sleep(random.nextInt(7)); guy.byeGuy(guysName); System.out.println(loversName + " は " + guysName + " とデートから帰ってきました。"); } catch (InterruptedException ex) { Logger.getLogger(Lovers.class.getName()).log(Level.SEVERE, null, ex); } } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
package jp.yucchi.playboy; import java.lang.management.ManagementFactory; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * * @author Yucchi */ public class PlayBoy { public static void main(String[] args) { final int procs = ManagementFactory.getOperatingSystemMXBean().getAvailableProcessors(); ExecutorService executor = Executors.newFixedThreadPool(procs); Guy guy = new Guy(); Lovers maki = new Lovers("堀北真希", guy); Lovers yui = new Lovers("新垣結衣", guy); Lovers ayame = new Lovers("剛力彩芽", guy); Lovers keiko = new Lovers("北川景子", guy); CompletableFuture<Void> lovers1 = CompletableFuture.runAsync(() -> maki.play(), executor); CompletableFuture<Void> lovers2 = CompletableFuture.runAsync(() -> yui.play(), executor); CompletableFuture<Void> lovers3 = CompletableFuture.runAsync(() -> ayame.play(), executor); CompletableFuture<Void> lovers4 = CompletableFuture.runAsync(() -> keiko.play(), executor); CompletableFuture<Void> allTask = CompletableFuture.allOf(lovers1, lovers2, lovers3, lovers4); allTask.join(); if (allTask.isDone()) { executor.shutdownNow(); System.out.println("(○･ω･)ﾉ-------- Are you happy? --------"); } } } |
17 行目で Semaphore を生成しています。
コンストラクタの引数はパーミット数と公平性を設定します。
今回のプログラムではパーミット数はリソース数と同じ 2 となっています。
公平性は API ドキュメントを見ると今回のプログラムの場合は優しい私はパフォーマンスより平等性を重視して true と設定しました。
ちなみに API ドキュメントによると
このクラスのコンストラクタは、オプションで公平性パラメータを受け入れます。
falseに設定すると、このクラスはスレッドがパーミットを取得する順序について保証しません。
特に、バージ(barging)が許可されています。
つまり、acquire()を呼び出すスレッドに、待機していたスレッドより先にパーミットを割り当てることができます。
論理的には、新しいスレッドが、待機中のスレッドのキューの先頭に配置されます。
公平性がtrueに設定されると、セマフォは、acquireメソッドのいずれかを呼び出すスレッドが、これらのメソッドの呼出しが処理された順序(先入れ先出し、FIFO)でパーミットを取得するように選択されることを保証します。
FIFO順序付けは、必然的にこれらのメソッド内の特定の内部実行ポイントに適用されます。
そのため、あるスレッドが別のスレッドより前にacquireを呼び出しても、そのスレッドよりあとに順序付けポイントに到達する可能性があります。
また、メソッドからの復帰時も同様です。また、時間指定のないtryAcquireメソッドは公平性の設定に従いませんが、利用可能なパーミットをすべて取得することにも注意してください。
となっています。
実は今回のプログラムではこの公平性の設定の違いというのは解りにくいのですが
食事する哲学者の問題（Dining Philosophers Problem）を Semaphore を使った簡易的なプログラムを組んでみるとよく解ります。
次に Semaphore からパーミットを取得するために acquire() メソッドを使います。
このプログラムでは 23 行目で使っています。
public void acquire() throws InterruptedException は API ドキュメントによると次のようになっています。
このセマフォからパーミットを取得します。パーミットが利用可能になるか、またはスレッドが割り込みされるまでブロックします。
パーミットが利用可能な場合はパーミットを取得してすぐに復帰するため、利用可能なパーミットの数は1つずつ減ります。
パーミットが利用可能でない場合、現在のスレッドはスレッドのスケジューリングに関して無効になり、次の2つのいずれかが起きるまで待機します。
•ほかのスレッドがこのセマフォに対してrelease()メソッドを呼び出し、現在のスレッドが次にパーミットを割り当てられるスレッドになる。
•ほかのスレッドが現在のスレッドに割り込みを行う。
現在のスレッドで、
•このメソッドへのエントリ上で設定された割込みステータスが保持されるか、
•パーミットの待機中に割り込みが発生した場合、
InterruptedExceptionがスローされ、現在のスレッドの割込みステータスがクリアされます。例外:InterruptedException – 現在のスレッドで割込みが発生した場合
これとは別に引数で取得するパーミット数を設定できるメソッドもあります。
次は取得したパーミットを解放する release() メソッドを調べてみます。
33 行目で使っています。
デートが終了したらパーミットを保持する必要はないので解放します。
public void release() は API ドキュメントによると次のように書かれています。
パーミットを解放し、セマフォに戻します。
パーミットを解放すると、利用可能なパーミットの数が1つずつ増えます。
いくつかのスレッドがパーミットを取得しようと試みている場合は、その中の1つのスレッドが選択され、解放されたばかりのパーミットが与えられます。
そのスレッドは、スレッドのスケジューリングに関して(ふたたび)有効になります。
パーミットを解放するスレッドは、acquire()の呼出しでそのパーミットを取得している必要はありません。
セマフォの適切な使用法は、アプリケーションでのプログラミング規約で確立されます。
たったこれだけでリソースにアクセスできる並行スレッド数を制限できてしまうんですねぇ・・・
このプログラムの実行結果は次のようになります。
待っているのは、堀北真希
待っているのは、北川景子
待っているのは、新垣結衣
待っているのは、剛力彩芽
今からデートに行くのは、北川景子
今からデートに行くのは、堀北真希
北川景子 は ゆっち とデートに行きました。
堀北真希 は 恭平 とデートに行きました。
北川景子 は ゆっち とデートから帰ってきました。
今からデートに行くのは、新垣結衣
新垣結衣 は ゆっち とデートに行きました。
新垣結衣 は ゆっち とデートから帰ってきました。
今からデートに行くのは、剛力彩芽
剛力彩芽 は ゆっち とデートに行きました。
剛力彩芽 は ゆっち とデートから帰ってきました。
堀北真希 は 恭平 とデートから帰ってきました。
(○･ω･)ﾉ——– Are you happy? ——–
さて、疑い深い私は NetBeans のプロファイラでスレッドの状態を確認してみました。（ 注意：先ほどの実行結果とはことなります。）
期待通りの動きをしてくれてます。(^_^) NetBeans のプロファイア手軽に使えて便利だね。
Semaphore 使える良い娘じゃないか！
もし、あなたが 恭平さん に素敵な女性とデートさせずに全ての女性を独り占めしたいとしたらこのプログラムをどのように変更したらいいでしょうか？
答えは簡単ですね！
私はヘルプを頼んだ 恭平さん に悪いのでプログラムの変更はいたしません。
どうしてもというかたはご自由に。(^_^;)
ちなみに今回のプログラムでは
CompletableFuture<Void> lovers1 = CompletableFuture.runAsync(() -> maki.play(), executor);
として ExecutorService を使いましたが
CompletableFuture<Void> lovers1 = CompletableFuture.runAsync(() -> maki.play());
として Fork/Join Framework を使うのもありです。
こどもの日の休日スペシャルはこれでお終いです。
食事する哲学者の問題（Dining Philosophers Problem）に続く かも？
TAGS: Java,NetBeans |
2015年5月5日2:18 PM |
Java NetBeans Ubuntu
お盆休みも今日が最後になったのにダラダラして終わることになった。(^_^;
ビール飲んでグダグダしながらこんなことを今さらしていたので記念にエントリーしておく。
最初に GitHub に新しいリポジトリを作成する。
そしてまだ SSD 公開鍵を設定してなければ設定しておく。
NetBeans IDE で新規プロジェクトを作成する。
Git ローカルリポジトリを作成する。
ローカルリポジトリを作成する場所を指定する。
出力ウィンドウでローカルリポジトリが作成されたことが解る。
プロジェクトウィンドウでもリポジトリのバッジが付いたことが確認できる。
HelloGitHub.java ファイルを add する。
そしてコミットする。
コミットされるファイルを確認し、解りやすいメッセージを書いておく。
GitHub は公開だと全世界と繋がるので地球標準の英語でメッセージを書いておくと良いことがあるかもしれない。
ローカルリポジトリにコミットした状態を Git リポジトリ・ブラウザで確認。
まだ寂しい状態であることが一目で解りますね。（ちょっと表現がおかしいけど気にしない。プレミアム・モルツのせいだ！）
それではリモートリポジトリにプッシュしましょう。
はじめてリモートリポジトリに接続する場合は下図のように必要事項を設定します。
これは SSH 接続を利用しています。(OpenSSH)
一度設定してしまえば後はラクチン、ラクチンです。
接続が完了すると下図のような画面が表示されます。
チェックをいれて次へ進めます。
終了ボタンを押してプッシュを実行します。
リモートリポジトリへのプッシュが完了したことを Git リポジトリ・ブラウザで確認します。
疑り深い人は GitHub のサイトをブラウザで開いて確認してみてください。
さらにソースコードを編集します。
変更されたことが色づけとバージョンラベルで確認できます。
さっきと同様にローカルリポジトリをコミットします。
そしてリモートリポジトリへプッシュします。
今度は先ほど設定したリモートリポジトリが選択されているので「次へ」ボタンを押すだけです。
さて、疑り深い人は GitHub のサイトをブラウザで開いて確認ですね。
完璧ですね。
ついでに履歴も確認。
NetBeans IDE で Git をそれなりに使うには十分ですね。
ただ、大規模なプロジェクトだと専用のツールを使ったほうが痒いところに手が届きます。
必要十分な機能は備えているみたいなんでやっぱり NetBeans IDE は素晴らしい！
TAGS: Java,NetBeans,Ubuntu |
2014年8月16日8:59 PM |
JavaFX NetBeans
前回のプログラムを利用して今回も JavaFX で足し算アプリに手を加えてみることにしました。
今回追加する機能は アプリのウィンドウサイズの変更をできないようにする。
チェックボックスを利用して BGM を流せるようにする。
問題の難易度を選択できるようにトグルボタンを排他制御して可能にする。
ツールチップを設定する。
ニーモニックを設定する。
結局、こんな感じにできあがりました。
トグルボタンは私の実力ではニーモニックを正しく動作させることができなかったので諦めました。(>_<｡)
素直にラジオボタンを使えばよかったかも・・・
トグルボタンの排他制御のイベント処理はかなり怪しいことをしています。
我ながらこれは無いだろうと思いながら他に良い方法を知らないので動けばいいやってのりでやってます。（オヒ
だからニーモニックが・・・・・ とどのつまりラジオボタンを使おう、今度からは。
いちおう、なんとか動いたので良しとしました。(^_^;)
それではそんなこんなでいい加減ですがプログラムを晒しておきます。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
package jp.yucchi.calc; import javafx.application.Application; import javafx.fxml.FXMLLoader; import javafx.scene.Parent; import javafx.scene.Scene; import javafx.stage.Stage; public class Calc2 extends Application { @Override public void start(Stage stage) throws Exception { Parent root = FXMLLoader.load(getClass().getResource("CalcForm.fxml")); Scene scene = new Scene(root); stage.setTitle("足し算できますか？"); stage.setScene(scene); stage.setResizable(false); stage.show(); } public static void main(String[] args) { launch(args); } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 |
package jp.yucchi.calc; import java.awt.Toolkit; import static java.lang.Integer.parseInt; import java.net.URL; import java.util.Random; import java.util.ResourceBundle; import java.util.regex.Matcher; import java.util.regex.Pattern; import javafx.beans.value.ChangeListener; import javafx.beans.value.ObservableValue; import javafx.event.ActionEvent; import javafx.fxml.FXML; import javafx.fxml.Initializable; import javafx.scene.control.CheckBox; import javafx.scene.control.Label; import javafx.scene.control.TextField; import javafx.scene.control.ToggleButton; import javafx.scene.control.ToggleGroup; import javafx.scene.media.Media; import javafx.scene.media.MediaPlayer; public class CalcFormController implements Initializable { private int x; private int y; private int resultAnswer; private int modeNumber = 99; Random rnd = new Random(); private final Media start = new Media(getClass().getResource("start.mp3").toExternalForm()); private final Media ok = new Media(getClass().getResource("ok.mp3").toExternalForm()); private final Media ng = new Media(getClass().getResource("ng.mp3").toExternalForm()); private final Media bgm = new Media(getClass().getResource("bgm.mp3").toExternalForm()); private final Media m_easy = new Media(getClass().getResource("easy.mp3").toExternalForm()); private final Media m_normal = new Media(getClass().getResource("normal.mp3").toExternalForm()); private final Media m_hard = new Media(getClass().getResource("hard.mp3").toExternalForm()); @FXML private Label questionLabel; @FXML private TextField answerField; @FXML private Label resultLabel; @FXML CheckBox bgmCheck; @FXML ToggleGroup mode; @FXML ToggleButton easy; @FXML ToggleButton normal; @FXML ToggleButton hard; @FXML public void handleAnswer(ActionEvent event) { Pattern intPattern = Pattern.compile("[0-9]+"); Matcher match = intPattern.matcher(answerField.getText()); if (match.matches() != false || answerField.getText().isEmpty()) { } else { resultLabel.setText("数値を入力してね！"); Toolkit.getDefaultToolkit().beep(); } if (answerField.getText().isEmpty()) { resultLabel.setText("答えを入力してね！"); Toolkit.getDefaultToolkit().beep(); } else { boolean result = calc(answerField.getText()); if (result) { resultLabel.setText("正解！"); MediaPlayer mp_ok = new MediaPlayer(ok); mp_ok.play(); } else { resultLabel.setText("不正解！"); MediaPlayer mp_ng = new MediaPlayer(ng); mp_ng.play(); } } } @FXML public void handleClear(ActionEvent event) { answerField.clear(); resultLabel.setText(null); x = rnd.nextInt(modeNumber) + 1; y = rnd.nextInt(modeNumber) + 1; resultAnswer = x + y; questionLabel.setText(" " + x + " + " + y + " = "); } @FXML public void handleEasy(ActionEvent event) { if (easy.isSelected()) { modeNumber = 99; answerField.clear(); resultLabel.setText(null); x = rnd.nextInt(modeNumber) + 1; y = rnd.nextInt(modeNumber) + 1; resultAnswer = x + y; questionLabel.setText(" " + x + " + " + y + " = "); MediaPlayer mp_easy = new MediaPlayer(m_easy); mp_easy.play(); } else { easy.setSelected(true); } } @FXML public void handleNormal(ActionEvent event) { if (normal.isSelected()) { modeNumber = 999; answerField.clear(); resultLabel.setText(null); x = rnd.nextInt(modeNumber) + 1; y = rnd.nextInt(modeNumber) + 1; resultAnswer = x + y; questionLabel.setText(" " + x + " + " + y + " = "); MediaPlayer mp_normal = new MediaPlayer(m_normal); mp_normal.play(); } else { normal.setSelected(true); } } @FXML public void handleHard(ActionEvent event) { if (hard.isSelected()) { modeNumber = 99999; answerField.clear(); resultLabel.setText(null); x = rnd.nextInt(modeNumber) + 1; y = rnd.nextInt(modeNumber) + 1; resultAnswer = x + y; questionLabel.setText(" " + x + " + " + y + " = "); MediaPlayer mp_hard = new MediaPlayer(m_hard); mp_hard.play(); } else { hard.setSelected(true); } } @Override public void initialize(URL url, ResourceBundle rb) { x = rnd.nextInt(modeNumber) + 1; y = rnd.nextInt(modeNumber) + 1; resultAnswer = x + y; questionLabel.setText(" " + x + " + " + y + " = "); MediaPlayer mp_start = new MediaPlayer(start); mp_start.play(); bgmCheck.selectedProperty().addListener(new ChangeListener<Boolean>() { MediaPlayer mp_bgm; @Override public void changed(ObservableValue<? extends Boolean> ov, Boolean oldVal, Boolean newVal) { if (newVal.booleanValue()) { mp_bgm = new MediaPlayer(bgm); mp_bgm.setVolume(0.07); mp_bgm.play(); mp_bgm.setCycleCount(MediaPlayer.INDEFINITE); } else { mp_bgm.stop(); } } }); } private boolean calc(String ans) { int answer = parseInt(ans); return answer == resultAnswer; } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 |
<?xml version="1.0" encoding="UTF-8"?> <?import java.lang.*?> <?import java.util.*?> <?import javafx.geometry.*?> <?import javafx.scene.*?> <?import javafx.scene.control.*?> <?import javafx.scene.layout.*?> <?import javafx.scene.text.*?> <AnchorPane id="AnchorPane" maxHeight="-1.0" maxWidth="-1.0" minHeight="160.0" minWidth="320.0" prefHeight="160.0" prefWidth="320.0" xmlns:fx="http://javafx.com/fxml/1" xmlns="http://javafx.com/javafx/2.2" fx:controller="jp.yucchi.calc.CalcFormController"> <children> <VBox prefHeight="-1.0" prefWidth="-1.0" AnchorPane.bottomAnchor="12.0" AnchorPane.leftAnchor="12.0" AnchorPane.rightAnchor="12.0" AnchorPane.topAnchor="12.0"> <children> <AnchorPane prefHeight="47.0" prefWidth="-1.0"> <children> <Label fx:id="questionLabel" prefHeight="30.0" prefWidth="184.0" text="" AnchorPane.leftAnchor="5.0" AnchorPane.topAnchor="10.0"> <font> <Font size="16.0" fx:id="x1" /> </font> </Label> <TextField fx:id="answerField" alignment="CENTER_RIGHT" onAction="#handleAnswer" prefHeight="30.0" prefWidth="95.0" text="" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="10.0"> <tooltip> <Tooltip text="半角 0 ~ 9 で入力してね！" /> </tooltip> </TextField> </children> </AnchorPane> <HBox alignment="CENTER_RIGHT" prefHeight="47.0" prefWidth="296.0"> <children> <ToggleButton fx:id="easy" mnemonicParsing="false" onAction="#handleEasy" prefWidth="65.0" selected="true" text="Easy" wrapText="false"> <toggleGroup> <ToggleGroup fx:id="mode" /> </toggleGroup> <tooltip> <Tooltip text="2桁以内の足し算" /> </tooltip> <HBox.margin> <Insets /> </HBox.margin> </ToggleButton> <ToggleButton fx:id="normal" mnemonicParsing="false" onAction="#handleNormal" prefWidth="65.0" text="Normal" toggleGroup="$mode"> <tooltip> <Tooltip text="3桁以内の足し算" /> </tooltip> <HBox.margin> <Insets left="5.0" fx:id="x2" /> </HBox.margin> </ToggleButton> <ToggleButton fx:id="hard" mnemonicParsing="false" onAction="#handleHard" prefWidth="65.0" selected="false" text="Hard" textAlignment="LEFT" toggleGroup="$mode" HBox.margin="$x2"> <tooltip> <Tooltip text="5桁以内の足し算" /> </tooltip> </ToggleButton> </children> </HBox> <HBox alignment="CENTER_RIGHT" prefHeight="47.0" prefWidth="296.0" spacing="12.0"> <children> <Button fx:id="clearButton" mnemonicParsing="true" onAction="#handleClear" text="_Clear"> <tooltip> <Tooltip text="次の問題" /> </tooltip> </Button> <Button fx:id="answerButton" mnemonicParsing="true" onAction="#handleAnswer" text="_Answer"> <tooltip> <Tooltip text="ファイナルアンサー？" /> </tooltip> </Button> </children> <padding> <Insets /> </padding> </HBox> </children> </VBox> <Label fx:id="resultLabel" prefHeight="30.0" prefWidth="-1.0" text="" textFill="RED" AnchorPane.leftAnchor="10.0" AnchorPane.topAnchor="110.0"> <font> <Font size="20.0" /> </font> </Label> <CheckBox fx:id="bgmCheck" alignment="CENTER_LEFT" allowIndeterminate="false" contentDisplay="LEFT" mnemonicParsing="true" selected="false" text="_BGM" textAlignment="LEFT" AnchorPane.leftAnchor="5.0" AnchorPane.topAnchor="73.0"> <font> <Font size="14.0" /> </font> <tooltip> <Tooltip text="BGM 設定" /> </tooltip> </CheckBox> </children> </AnchorPane> |
アプリのウィンドウサイズの変更をできないようにするために Calc2.java の 19 行目で
stage.setResizable(false);
としています。
チェックボックスを利用して BGM を流せるようにするために CalcFormController.java の 163 行目から 178 行目までで
チェックボックスにリスナーを設定して制御しています。
トグルボタンはグループ化して排他制御可能としてます。
これは JavaFX Scene Builder を使って簡単に設定できます。
トグルボタンのイベントをそれぞれ実装して JavaFX Scene Builder で結びつければいいだけです。
トグルボタンのグループも JavaFX Scene Builder で簡単に設定できます。便利！便利！
ただ前述したとおりトグルボタンが必ずどれか一つ選択状態にあるようにしたいため適当なことをやっています。
おそらく、なんだこれは？といいたくなるかもしれませんがスマートな方法を知らないのでこうなりました。(^_^;)
よってトグルボタンにニーモニックを設定しても上手く動作しなくなります。だからニーモニックはあきらめました。（ヲヒ
チェックボックス、テキストフィールド、ボタンにはニーモニックを JavaFX Scene Builder で簡単に設定できます。
プロパティの Text 欄に _ を先頭につけて記入し（_BGM)
Mnemonic Parsing のチェックボックスを ON にすればいいだけです。
ツールチップも同様に JavaFX Scene Builder を使えば楽勝です！
JavaFX Scene Builder のライブラリ Popup Controls から Tooltip をドラッグアンドドロップして
プロパティを設定してやればいいだけという非常に楽ちんな作業です。
以上、こんな感じでできあがりました。
Webstart: click to launch this app as webstart
ちょっと五月蠅くなってしまいましたがご勘弁を。
もっといろいろ楽しいことが出来るようなのでボチボチと遊んでみたいと思ってます。
TAGS: JavaFX,NetBeans |
2013年8月6日11:03 PM |
« 古い記事
新しい記事 »
