ゆっちのBlog

食事する哲学者の問題（Dining Philosophers Problem） Semaphore で遊ぶその２

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 はウェイターの役割をはたします。

つまり、スパゲッティを食べる権利( パーミット取得 )があることを許可してくれます。

綺麗な女性は左のフォーク、そして右のフォークと使うことができればスパゲッティを食べることができます。

ただし、隣の女性がフォークを使っていたら（ロックがかかっていたら）フォークがあくのを待たなければ( ロックが解放される )いけません。

ウエイターは綺麗な女性がスパゲッティを食べ終わり左右のフォークを置いたなら、

その綺麗な女性のスパゲッティを食べる権利( パーミット )を戻してもらい、

次に待機している綺麗な女性がいれば「どうぞ、お食べください」とスパゲッティを食べる権利( パーミット )を与えます。。

そして綺麗な女性はフォークが空いていれば手に取りスパゲッティを食べられます。

フォークが空いていなければ待ちます。

これの繰り返しです。

最大二人の綺麗な女性がスパゲッティを同時に食べることがこれで可能となります。

左右のフォークの使用状況( ロックの状態 )によりフォーク待ち時間が発生してしまいますがこれでデッドロックは解消されます。

きっと綺麗な女性達は美味しいスパゲッティをお腹いっぱい食べて満足してお帰りになられたでしょう。

これをプログラムにすると次のようになりました。

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();
    }

}

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();

}

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() + "回目食事終了");
    }

}

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() + "回目食事終了");

}

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. --------(^_^)");
        }

    }

}

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年、確実に進化しています。

どんどん進化していく並行処理を日本語で優しく解説しているサイトはあまり無いのが残念です。

便利なものほど正しく使わないと痛い目をみますからね。

もっと正しい知識を優しい日本語の解説で入手したい今日この頃です。

今月の私は健康診断でコレステロールと中性脂肪の値が高いと指摘されたにもかかわらずこういった美味しいケーキをたくさん食べてしまいました。

美味しさそのままで中性脂肪とコレステロールの値をさげるケーキって無いものか。

お終い！

Hatena タグ: Java

TAGS: Java,NetBeans | 2015年5月5日2:50 PM

« Semaphore で遊ぶ java.util.ConcurrentModificationException 対処法 »

Comment

Fermin Pinsonneaultsays:
2018年1月26日 9:00 AM

If ever you desire to get outstanding services and worth for your money, search for dependable professionals.
Such professionals provide you to most fulfillment
and top quality text offers. Ann turned her thesis into a book entitled Now or Neverland: Peter
Pan and the Myth of Eternal Youth, published by Inner City Books (1998), which offers a psychological perspective on that popular literary icon, Peter Pan. It helps
him to think creatively and lets him read different lingual books or literature.
Literature review gives: (1) research questions/ hypotheses,(2) justification for the study/ research topic.
For instance, your research proposal’s chances of getting approved increase through expert editing.

This way, you will not waste time and you will increase the chances of
quickly finding the job of your dreams. Switch off music, television, messenger, video
games, avoid conversations, etc. Your mind cannot commit to more than one activity at a time.

Almost any activity that you focus powerfully on may occasionally introduce a
light trance state. This may include an internship.
– https://gpa-calculator.co Thank you

返信

食事する哲学者の問題（Dining Philosophers Problem） Semaphore で遊ぶその２

Comment

Leave a Reply (or Cancel)

Trackback URL

Recent Comments

Java

NetBeans

カテゴリー

アーカイブ

RSS FEED

ねこび～ん

メタ情報

ゆっちのカレンダー

2024年11月
月	火	水	木	金	土	日
« 1月
				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

ゆっちのBlog

食事する哲学者の問題（Dining Philosophers Problem） Semaphore で遊ぶ その２

Comment

Leave a Reply (or Cancel)

Trackback URL

Popular post ranking

Recent Comments

Java

NetBeans

カテゴリー

アーカイブ

RSS FEED

ねこび～ん

メタ情報

ゆっちのカレンダー

食事する哲学者の問題（Dining Philosophers Problem） Semaphore で遊ぶその２