並行プログラミング言語(2)/Concurrent Programming Languages(2)

並行システム

                               システム情報系/情報工学域,
			       システム情報工学研究群/情報理工学位プログラム
			       システム情報工学研究科/コンピュータサイエンス専攻
                               新城 靖
                               <yas@cs.tsukuba.ac.jp>

このページは、次の URL にあります。
http://www.cs.tsukuba.ac.jp/~yas/cs/csys-2023/2023-06-16
あるいは、次のページから手繰っていくこともできます。
http://www.cs.tsukuba.ac.jp/~yas/cs/
http://www.cs.tsukuba.ac.jp/~yas/

■今日の重要な話

並行オブジェクト指向モデル Concurrent object-oriented models
Actor
並列論理型プログラミング言語 Concurrent logic programming languages
Jini ルックアップ・サービス、リース。Jinu lookup services, lease.

参考文献 References

Robert E. Filman, Daniel P. Friedman: "Coordinated Computing: Tools and Techniques for Distributed Software", Mcgraw-Hill (1984). ISBN-10: 0070224390
R.E. フィルマン, D.P. フリードマン著, 雨宮真人, 尾内理紀夫, 高橋直久 (訳): "協調型計算システム -- 分散型ソフトウェアの技法と道具立て", マグロウヒル (1986). ISBN-10: 4895010309.
Marko Boger: Java in Distributed Systems: Concurrency, Distribution and Persistence, John Wiley & Sons, 2001. ISBN: 0471498386

■並行オブジェクト指向モデル/Concurrent object-oriented models.

オブジェクト指向の一種。世の中をオブジェクトとして扱う。

（逐次）オブジェクト指向では、受動的(passive) なオブジェクトを多用する。受動的なオブジェクトは、構造体の延長で、メッセージを受け取ると応答するが、自らメッセージを発することはない。
並行オブジェクトは、能動的(active)なオブジェクトしかない。人間のように、相互にメッセージを送受信する。

◆アクタモデル/The Actor models

1977年 C.Hewitt らによって提唱された並行計算モデル。アクタと呼ばれる計算主体が独立に、かつ、並列に計算を行う能力を持つ。アクタ内部も可能な限り並列に実行できる枠組みを持つ。

言語としては、何種類か(Plasma、Act-1、Act-2、Act-3、Omega、Ether)ある。各言語で見かけがけっこうちがう。

現在では、アクタを「(並行)オブジェクト」と読み替えると分かりやすい。

図? アクタの基本概念/Basic concepts of the Actor model

アクタは、メッセージを受け取り、それに対して行為を行うような、通信を行うエージェントである。行為(behavior)の種類には、次のようなものがある。

メッセージを、自分自身、または、他のアクタに送信する。
アクタを生成する。
次の振る舞い(replacement behavior)を規定する。

アクタは、メッセージを受信するために１つのメールボックスを持つ。メッセージは、アクタに直接届くというよりは、メールボックスに間接的に届く。メールボックスは、バッファリングの機能がある。メールボックスにあるメッセージは、FIFO に処理されるとは限らない。

アクタがメッセージを受け取ると、いったんロックされる。ロックされるとメッセージは処理されない。次のアクタに become したら、新しい後継のアクタが同じメールボックスからメッセージを読み出して処理を続ける。

要素

プリミティブ・アクタ(primitive actor)。データと手続き。たとえば、整数5や関数+。
非プリミティブミィブアクタ
- 順次アクタ(serialized actor)。内部に状態変数を持つ。
- 非順次アクタ(unserialized actor)。

アクタは、メッセージを送受信できる。メッセージ自身も、アクタの一種。

◆継続/Continuations

継続(continuation、継続点ともいう)を用いる。究極の goto 文。C 言語の関数で

    goto f(1, 2, 3);

のようなもの。

通常の階乗(in Scheme)

(define (fact n)
    (if (= n 0) 1
        (* n (fact (- n 1)))))

継続を取るような階乗

(define (fact-c n c)
  (if (= n 0)
      (c 1)
      (let ((c2 (lambda (x) (c (* n x)))))
        (fact-c (- n 1) c2))))

実行例

> (fact 3)
6
> (fact 4)
24
> (fact-c 3 print)
6> (fact-c 4 print)
24>

◆階乗/Factorial in Actor

[Hewitt 77a]

factorial≡λm.
  match m <n c>
    if n = 1 then
      (send c <1>)
    else if n > 1 then
      (send factorial <(n-1) (λk.(send c <n * k>))>)

3の階乗を計算して、継続print_answerに送りたい時には、次のように書く。

   (send factorial <3 print_answer>)

◆階乗/Factorial in Actor

Gul Agha. 1986. An overview of actor languages. In Proceedings of the 1986 SIGPLAN workshop on Object-oriented programming (OOPWORK 86. Association for Computing Machinery',58-67. )

(define (Factorial( ))
  (Is-Communication (a doit (with customer =m)
		       (with number =n)) do
      (become Factorial)
      (if (NOT (= n 0))
	(then (send m 1))
	(else (let (x = (new FactCust (with customer m)
			     (with number n)))
		(send Factorial (a do (with customer x)
				   (with number (- n 1)))))))))
(define (FactCust (with customer =m)
		  (with number =n))
  (Is-Communicaton (a number k) do
    (send m (* n k))))

2つのパラメタを持つメッセージ ((with customer x) (with number n)) を受け取る。customer は、継続。
(become Factorial) で、自分自身を再生成。そうでないと、1個の Factorial を計算しただけでアクタが消滅してしまう。
新しいアクタ FactCust を生成している。

振る舞い記述
    (define (名前 (with id パタン))
      通信ハンドラの並び)

通信ハンドラ
    (Is-Communication パタン do コマンド)

letコマンド
    (let (変数名 = 式) do コマンド)

条件コマンド
    (if 式 (then do コマンドの並び) (else do コマンドの並び))

メッセージ送信コマンド
    (send メールボックス 値)

becomコマンド
    (become 式)

新しいアクタの生成
  (new 式)

◆銀行口座/A bank account in Actor

(define (Account (with Balance =b))
  (Is-Request (a Balance) do 
    (become (Account (with Balance b)))
    (reply b))
  (Is-Request (a Deposit (with Amount =a)) do
    (become (Account (with Balance (+ b a))))
    (reply (a Deposit-Receipt (with Amount a))))
  (Is-Request (a Withdrawal (with Amount =a)) do
    (if (> a b)
      (then do 
        (become (Account (with Balnce b)))
        (complain (an Overdraft)))
      (else do 
        (become (Account (with Balnce(- b a))))
	(reply (a Withdrawal-Receipt (with Amount a)))))))

Is-Request は、client-server 型のメッセージの受信を表す。表面的には現れていないが、継続を受け取っている。
reply は、Is-Request に対する通常の応答を返す。
complain は、Is-Request に対する例外の応答を返す。
become と reply は、同時に処理できる。

◆カウンタ(Scala)/Counter actor in Scala

初期の Scala には、Actor の機能が含まれていて、「!」で、メッセージの送受信ができる。 Sala 2.11 で Actor は、非推奨(deprecated)に。新しくプログラムを書くなら、 Akkaを使う。 Classic ActorからTyped Actor への移行について by taketora 参照。

import akka.actor.typed.scaladsl.Behaviors
import akka.actor.typed.{ActorRef, Behavior}

object Counter {
  sealed trait Command
  case object Increment                               extends Command
  final case class GetValue(replyTo: ActorRef[Value]) extends Command
  final case class Value(n: Int)

  def apply(): Behavior[Command] = counter(0)

  private def counter(n: Int): Behavior[Command] =
    Behaviors.receive { (context, message) => //※１
      message match {
        case Increment         =>
          val newValue = n + 1
          context.log.debug("Incremented counter to [{}]", newValue)
          counter(newValue) //※2

        case GetValue(replyTo) =>
          replyTo ! Value(n)
          Behaviors.same
      }
    }
}

「!」で、メッセージを送信する。
Behaviors.receive で受信。match case でパタンマッチしながら、複数種類のメッセージを待つ。
RPC 的な動きを実装するには、クライアント側は、自分の ID をメッセージに含めて送信し、 receive で待つ。サーバ側は、receive して、メッセージの内容に含まれた ID のアクタに送信。

◆カウンタ(Kotlin)/Counter actor in Kotlin

Shared mutable state and concurrency/Actors

// This function launches a new counter actor
fun CoroutineScope.counterActor() = actor<CounterMsg> {
    var counter = 0 // actor state
    for (msg in channel) { // iterate over incoming messages
        when (msg) {
            is IncCounter -> counter++
            is GetCounter -> msg.response.complete(counter)
        }
    }
}

fun main() = runBlocking {
    val counter = counterActor() // create the actor
    withContext(Dispatchers.Default) {
        massiveRun {
            counter.send(IncCounter)
        }
    }
    // send a message to get a counter value from an actor
    val response = CompletableDeferred<Int>()
    counter.send(GetCounter(response))
    println("Counter = ${response.await()}")
    counter.close() // shutdown the actor
}

a = actor {...}で、アクタ生成。無限ループ含む。
内部の実装はコルーチン。
a.send(...) で、アクタへメッセージ送信。
返り値の受け取りには、CompletableDeferred を使っている。

◆カウンタ(Elixir)/Counter actor in Elixir

Concurrency and Actor Model

defmodule Counter do
  def start(initial_count) do
    spawn fn -> listen(initial_count) end
  end

  def listen(count) do
    receive do
      :inc -> listen(count + 1)
      {sender, :val} ->
        send sender, count
        listen(count)
    end
  end
end

iex> counter_pid = Counter.start(10)
#PID<...>

iex> send counter_pid, :inc
:inc
iex> send counter_pid, :inc
:inc
iex> send counter_pid, :inc
:inc
iex> send counter_pid, {self, :val}
{#PID<...>, :val}

iex> receive do
...(13)>   value -> value
...(13)> end
13

Elixir は関数型言語。それだけでは状態を持つことができない。
Elixir は、プロセスを生成すれば、状態を保持できる。
再帰呼び出しで無限ループを表現する。再帰呼び出しの引数で状態を更新する。

Erlang も同じ。 Concurrency in Erlang & Scala: The Actor Model 参照。

◆Ruby 3.0 Ractor

Ruby 3.0 (2021/12) に導入された機能 Ractor (Ruby + actor) を使うと、多くのプラットフォームで CPU レベルの並列処理ができる。 (Ruby のスレッドは、 Giant VM lock (GVL)/Global Interpreter Lock (GIL) を保持して実行されるので、 CPUレベルで並列に実行されない。)

カウンタの例。

   1: #!/opt/local/bin/ruby3.0
   2: 
   3: Warning[:experimental] = false
   4: 
   5: class CounterActor
   6:     def initialize(val)
   7:         @r = Ractor.new(val) {|val|
   8:             loop {
   9:                 msg = Ractor.receive()
  10:                 case msg
  11:                 in [:inc]
  12:                     val += 1
  13:                 in [:getvalue, c]
  14:                     c.send(val)
  15:                 end
  16:             }
  17:         }
  18:     end
  19:     def send( msg )
  20:         @r.send( msg )
  21:     end
  22: end
  23: 
  24: c = CounterActor.new(10)
  25: 
  26: c.send([:inc])
  27: c.send([:inc])
  28: c.send([:getvalue, Ractor.current()])
  29: v = Ractor.receive()
  30: printf("Counter value == %d\n",v)

実行例

$ ./ractor-counter.rb 
Counter value == 12
$

Ruby 3.0 の Ractor の特徴。

CPU レベルの並列処理のために設計されている。単にアクタ・モデルを使いたいという目的では、使い難い。
標準的なアクタモデルと同様に、入力用のメールボックスを使って send(), receive() で通信ができる。
Ractor 独自の通信機能として、 (出力用のメールボックスを使って) yield() と take() で通信できる。
Ractor 間は隔離されている。多くのオブジェクトは、Ractor 間で共有できないので、競合は生じない。共有できるオブジェクトには、次のものがある。
- 不変オブジェクト。
- クラス／モジュールオブジェクト
- 特殊なオブジェクト。Ractor オブジェクト等。
$stdin, $stdout, $stderr 等は、Ractor local object。スレッド固有データ(Thread specific data)のようなもの。 Ractor の中で printf() は動く。
Ractor.new() {} の中のブロックでは、外側の変数がアクセスできない。 Ractor.new(v1,v2,v3) {|v1,v2,v3| ...} のように明示的に渡す必要がある。
send() では、オブジェクトがコピーされて渡されるのが基本。
Ractor.receive_if{|msg| 条件 } で、ガードが書ける。

新城のコメント。

Ractor 間での有限バッファ(channel)による通信機能が欲しい。有限バッファを Ractor で作れるのだろうが、パッシブオブジェクトで作るのが自然に思える。
メッセージの送り手は、Ractor.current() で取れるので、上のカウンタの例のように、そこに結果を送り返してもらうことはできる。しかし、1つの Ractor が複数の Ractor に同時に要求を送った時、複数の応答が混じってしまう。
Elixir のように、receive でパタンマッチが使えると、プログラムは書きやすいが性能は落ちそう。

■並行論理型プログラミング言語/Concurrent logic programming languages

◆Prolog

Prolog (Programming in Logic) は、フランスマルセイユ大学の Alain Colmerauer らによって開発された言語。１階述語論理(first-order predicate logic)に基づいている。

◆１階述語論理/first-order predicate logic

述語論理では、次のような概念を用いる。

述語 P(t ₁, t ₂, ..., t _n)
(∀x)P(x)。全てのxについてP(x)が成り立つ。
(∃x)P(x)。あるxについてP(x)が成り立つ。
P∧Q、P∨Q、～P。 and, or, not
P←Q。Qが真ならばPも真。

１階述語論理の論理式は、次の形式で書ける。

P ₁ ∨ P ₂ ∨ ... ∨ P _n ← Q ₁ ∧ Q ₂ ∧ ... ∧ Q _n.

「←」の左がたかだか1個のものがホーン節(Horn clause)。(ORが複数書きたくなったら、複数行にわたって書く)。ホーン節には3種類ある。

表明: P←.
公理: P← Q ₁ ∧ Q ₂ ∧ ... ∧ Q _n.
目標: ← Q ₁ ∧ Q ₂ ∧ ... ∧ Q _n.

◆単純なモデル(事実(fact))/Facts

fatherof(isaac,abraham).  -- isaac の父は abraham である
fatherof(ishmail,abraham).
fatherof(shuah,abraham).
fatherof(jacob,isaac).
fatherof(esau,isaac).
fatherof(reuben,jacob).
fatherof(dinah,jacob).
fatherof(dan,jacob).
fatherof(asher,jacob).
fatherof(joseph,jacob).
motherof(isaac,sarah).  -- isaac の母は sarah である。
motherof(ishmail,hagar).
motherof(shuah,ketura).
motherof(jacob,rebeccah).
motherof(easu,rebeccah).
motherof(reuben,leah).
motherof(dinah,leah).
motherof(dan,bilhah).
motherof(asher,zilpah).
motherof(joseph,rachel).

"_" は、無名変数。値は残らない。
"motherof(isaac,_)?" の質問には、 "motherof(isaac,sarha)" だけがマッチする。
"fatherof(_,_)" の質問には、全ての"fatherof" がマッチする。
"fatherof(joseph,X)" の質問には、"X=jacob" の時にマッチする。この時に変数 "X" は、"jacob" に束縛(bind)されている。
Prolog の変数は、同じコンテキストでは単一代入(single assignment)で、 C 言語の x = x + 1 のような意味で書き換えられることはない。
"motherof(C,leah)?" の質問には、 "C=reuben" という束縛が起きた後に、バックトラックが行われて、「別のコンテキストで」 "C=dinah" という束縛が起きることがある。
変数を含むパタンマッチは、単一化(unification)と呼ばれる。

◆規則/Rules

parentof(C,P) :- motherof(C, P). -- P が C の母なら、 P は C の親である。
parentof(C,P) :- fatherof(C, P). -- P が C の父なら、 P は C の親である。

grandparentof(C,GP) :- parentof(C,P), parentof(P,GP).
                         -- C の親が P で、かつ、P の親が GP なら、GP は C の祖父母である。
ancestor(C,A) :- parentof(C,A).
ancestor(C,A) :- parentof(C,P), ancestor(P,A).
                         -- C の親が P で、かつ、P の祖先が A ならば、A は C の祖先である。

◆リスト/Lists

append([],Y,Y).
append([A|B],Y,[A|B1]) :- append(B,Y,B1).

append は、3 つの引数がある。第1引数のリストと第2引数のリストを append して、第3引数に答えを返す。 (逆方向にも使える。)
[] は、空リスト(nil)。
[] と Y を append したものは Y である。
[A|B] と Y を append するには、まず、B と Y を append して、その結果を B1 とし、B1 の先頭に A を付ける。

図? Prolog の append

◆AND並列とOR並列/and-parallelism and or-parallelism

論理式の評価に順番の考え方はないので、並列に処理を行ってもよい。

AND 並列性(AND parallelism)。Prolog の :- の右側を全部並列に実行する。
OR 並列性(OR parallelism)。Prolog で同じ頭の述語を全部並列に実行する。

OR並列を考えると、バックトラックという考えるは存在しなくなる。

◆quicksort

quicksort(List,Sorted) :- qsort(List, Sorted, []).
qsort([],H,H).
qsort([A|B],H,T) :-
    partition(B,A,S,L),
    qsort(S,H,[A|T1]), 
    qsort(L,T1,T). 
partition([],X,[],[]).
partition([A|B],X,[A|S],L) :- A<X, partition(B,X,S,L).
partition([A|B],X,S,[A|L]) :- A>=X, partition(B,X,S,L).

quicksort() は、2引数。第1引数のリストをソートして、第2引数に結果を返す。
下請けの 3 引数の qsort を呼ぶ。第1引数がソートすべきリスト。第2引数と第3引数の「差分」が、ソート結果。
空リストをソートすると、空リストになる。第2引数と第3引数が同じなので、差分リスト H-H は、空リスト。
リスト [A|B] をソートするには、まず、そのリストを先頭以外の部分 B を、A より小さい部分 S と A より大きい部分 L に分割する。
再帰で、S をソートする。結果は、差分リスト H-[A|T1]で保持する。
再帰で、L をソートする。結果は、差分リスト T1-T で保持する。
それぞれソートした後、全体の結果は、差分リスト H-T で返す。

図? Prolog によるクイックソート

quicksort にある並列性。Parallelism in quicksort.

S と L の qsort が並列に実行可能。 We can execute qsort of S and qsort of L in parallel.
partition と sort の並列性(パイプライン型並列性)。分割が一部だけ終わった段階でソートの作業に取り掛かれる。 We can execute "partition" and "qsort" in parallel (pipeline parallelism). After finishing a part of "partition", we can start "qsort".

◆GHC (Guarded Horn Clauses)

Prolog と同様に、１階述語論理に基づいている。並列(並行)論理型言語。

Prolog では、入出力が書けないが、GHC ではかける。
Prolog ではバックトラックで全解探索ができるが、GHC ではできない。

◆GHCの構文/Syntax of GHC

H :- G ₁, G ₂,...,G _n | B ₁, B ₂, ..., B _m.

「|」は、コミット演算子。 G ₁, G ₂,...,G _n はガード部。 B ₁, B ₂, ..., B _m は、ボディ部。

append([A|X1],Y,Z) :- true | Z = [A|Z1], append(X1,Y,Z1).  
append([],Y,Z) :- true | Z=Y.

Prolog ならこうなる

append([A|X1],Y,[A|Z1]) :- append(X1,Y,Z1).  
append([],Y,Y).

GHC では、方向がある。入力と出力が分かれる。
GHC では、複数のガード部分を並列に実行してもよい。しかし、具体化しようとすると、中断させる。たとえば、
```
:- append(U,[4,5],W),U=[1,2,3].
```
なら、append の処理は最初は中断する。U が具体化された後で再開する。
GHC では、ガード部分が成功した節のうち１つしか使われない。 (他の OR の節の処理は無駄になる。効率のためには止めた方が良いが、止めるコストもバカにならないこともある。動かしたままでも答えは変わらない。 OR部分を１つひとつ実行することも考えられる。 )

quicksort(Xs,Ys) :- true | qsort(Xs, Ys-[]).
qsort([X|Xs],Ys0-Ys3) :- true |
    partition(Xs,X,S,L),
    qsort(S,Ys0-Ys1), Ys1=[X|Ys2],
    qsort(L,Ys2-Ys3). 
qsort([],Ys0-Ys1) :- true | Ys0 = Ys1.

partition([X|Xs],A,S,L0) :- A<X  | L0=[X|L1], partition(Xs,A,S,L1).
partition([X|Xs],A,S0,L) :- A>=X | S0=[X|S1], partition(Xs,A,S1,L).
partition([],A,S,L) := true | S=[], L=[].

差分リストの表記方法として A-B が使える。
複数の節が並列に実行されることがある。

■Jini

Jini (ジニー)は、Java を中核にした、情報家電製品を相互接続するための通信技術。

1999年に、サン・マイクロシステムズ社のビル・ジョイらによって開発され発表された。

Jini の目標は、ネットワークで Plug & Play を実現すること。機器をネットワークに接続しただけで、特別な設定をしなくてもすぐに利用可能になること。

目標

「サービス」の提供者と利用者が、お互いに事前の知識なしでつながる。
- (IP)アドレス
- 名前サーバの位置(/etc/resolv.conf)
サービスの位置がわからなくてもよい。
古典的な「ネットワーク管理者」を廃したい。

サービスには、ハード的なもの（プリンタ、ディジタルカメラ、CD Player）の他に、ソフト的なもの(スペルチェック、翻訳、アドレス帳)がふくまれる。

JavaSpaces は、内部的に Jini のルックアップ・サービスの実現で使われている。JavaSpaces も、Jini でアクセス可能なサービスの１つと考えることもできる。

Jini のクラスライブラリは、 JavaSpaces の回で紹介した Apache River が利用できる。

◆UPnP (Universal Plug and Play)

Microsoft の、Jini に対抗した技術。

◆ルックアップ・サービス/Loockup service in Jini

Jini中心的な技術が、ルックアップ・サービス。

サービスの登録と検索

インタフェース
属性

ルックアップ・サービス自身も、最初から知られている必要はない。ネットワーク上で自動的に探される。 Discovery と Join。

◆リース/Leasing

サービスは、永続的に登録されるではなくて、特定の時間だけ利用可能になる。

Java のオブジェクトが Lease。

リース期間は、延長することができる。延長されなかった lease は、ルックアップ・サービスから削除される。登録されているサービスを明示的に削除する仕組みは、存在しない。

サービスが削除された時には、分散型イベント配送サービスにより関係している所に知らされる。

トランザクションのインタフェースは定められているが、具体的な実現は各サービスにまかされている。

◆Jiniを使うのに必要とされているもの/Requirements to run Jini

Java JDK 1.2以降の JavaVM
ネットワーク Networks
- TCP/IP
- 無線LAN(wireless LAN)、Bluetooth
- USB

IPアドレスの割り当ては、Jiniの一部ではない。

◆Discovery と Join/Discovery and Join

各ネットワークには、ルックアップ・サーバを置く。

Discovery: Jini を使うには、まず、ルックアップ・サーバを探す。
Join: サービスの提供者が、インタフェースと属性をルックアップ・サーバに登録する。

Discovery の実現方法

マルチキャスト(グループ通信)。 UDP で 224.0.1.85:4160 に要求を投げる。
ユニキャスト(IPアドレスを事前に知っている必要がある)。ルータを越えて、マルチキャストが届かない範囲でも使える。

ルックアップ・サーバは、起動時、再起動時、224.0.1.84:4160 にMulticast Announcement Protocol で、利用可能性を広告する。

図1 マルチキャストによる Discovery/Discovery by multicast

図2 Join

◆サービスのグループ/Grouping services

サービスは、１つ以上のグループに属する。

グループは、名前(文字列)で区別される。

"Printer"
"Conference Room"
"public"

名前としては、DNS 風の表記のものが推奨されている。

◆JoinManager(サーバ側)/JoinManager at the server-side

Discovery と Join は、規格上は、ネットワーク・プロトコルになっている。

Jini パッケージは、JoinManager という参照クラスを含む。

    public JoinManager(Object obj,  Entry[] attrSets,
                       ServiceIDListener callback,
                       LeaseRenewalManager leaseMgr)
        throws IOException
    public JoinManager(Object obj, Entry[] attrSets, String[] groups,
                       LookupLocator[] locators,
                       ServiceIDListener callback,
                       LeaseRenewalManager leaseMgr )
        throws IOException

◆Jiniのサーバの例/Example of a Jini server

import java.rmi.*;

public interface RemoteBall extends Remote {
   public void hit() throws java.rmi.RemoteException;
}

import java.rmi.*;
import java.rmi.server.*;
import net.jini.core.lookup.*;
import com.sun.jini.lookup.*;

public class Ball extends UnicastRemoteObject 
                  implements RemoteBall, ServiceIDListener {
   public Ball() throws RemoteException {
      super();
   }
   public void serviceIDNotify(ServiceID id) {
      System.out.println("ServiceId is "+id);
   }
   public void hit() {
      System.out.println("Ball has been hit");
   }
}

import java.rmi.*;
import net.jini.core.entry.*;
import net.jini.lookup.entry.*;
import com.sun.jini.lookup.*;
import com.sun.jini.lease.*;

public class BallStarter {
   public static void main(String[] args) {
      try {
         System.setSecurityManager(new RMISecurityManager());
         RemoteBall ball = (RemoteBall) new Ball();
         LeaseRenewalManager renewal = new LeaseRenewalManager();
         Entry[] attributes = new Entry [] { new Name("Jini enabled ball")};
         JoinManager join = new JoinManager( ball, attributes, (Ball) ball, renewal );
         System.out.println("Ball started and registered at Lookup-Server");

      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

◆Lookup(クライアント側)/Lockup in a client

クライアントは、サービスを探す。

図3 Lookup

サービスは、次の３つで区別される。

ServiceID. 128ビット。ルックアップ・サービスが生成する。
インタフェース( Class オブジェクト )
属性。JavaSpaces の Entry クラスと同じ。

サービスを検索する時に ServiceTemplate のオブジェクトを作成する。 JavaSpaces のように、null を指定すれば、ワイルドカードを意味する。

    public ServiceTemplate(ServiceID serviceID,
                           Class[] serviceTypes,
                           Entry[] attrSetTemplates)

サービス(オブジェクト)の探し方

LookupLocator により、マルチキャスト、または、ユニキャストでルックアップ・サービスを探す。
ルックアップ・サービスを利用するための、ServiceRegistrar オブジェクトを作る。
テンプレートを作り、ServiceRegistrar に渡す。

サービスを見つける過程で、サービス(オブジェクト)のRMI のスタブ(クライアント側スタブ)が転送される。

◆サービスの利用/Using a service

最終的にクライアントは、サービス・プロバイダを RMI で呼び出す。

図4 Invoke

◆Jiniのクライアントの例

import java.rmi.*;
import net.jini.core.discovery.*;
import net.jini.core.lookup.*;

public class Bat {

   public Ball ball;

   public void play(RemoteBall ball) {
      try {
         ball.hit();
         System.out.println("I hit the ball");
      } catch (RemoteException e) {
         System.out.println(e);
      }
   }

   public static void main (String[] args) {
      Bat bat = new Bat();
      try {
         System.setSecurityManager(new RMISecurityManager());
         LookupLocator locator = new LookupLocator("jini://localhost");
         ServiceRegistrar registrar = locator.getRegistrar();
         Class[] classes = new Class[] { RemoteBall.class  };
         ServiceTemplate template = new ServiceTemplate( null, classes, null);
         RemoteBall remoteBall = (RemoteBall) registrar.lookup(template);
         bat.play(remoteBall);
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

◆Leasing

信頼性が低いネットワークと、どう戦う方法の１つ。

lease には、期限がある。

延長できる(通常)
短縮もできる

期限の長さは、交渉可能。期限が短い(1分以下、数秒)というのは、あまり想定されていない。

リースの利点

情報を最新のものにできる。
古い情報を安全に消すことができる。

Jini のサービスを提供しているオブジェクトは、Lease インタフェースを実装している。

public interface Lease {
    long FOREVER = Long.MAX_VALUE;
...
    long getExpiration();
    void renew(long duration)
        throws LeaseDeniedException, UnknownLeaseException, RemoteException;
    void cancel() throws UnknownLeaseException, RemoteException;
...
}

getExpiration() で、リースの残り時間がわかる。ミリ秒単位。

renew() で延長する。延長できない時には、LeaseDeniedException が返される。

もう使わなくなった時には、cancel() できる。期限切れと同じことになる。

リースの管理には、LeaseRenewalManager を使う。

■練習問題(exercise)9 並行プログラミング言語(2)/Concurrent Programming Languages(2)

★問題(901) アクタモデルの操作/The operations in the Actor models

Scala, Kotlin, Elixir, および Ruby Ractor では、ある種のアクタモデルに基づきプログラムを記述することができる。これらの言語から１つを選び、その中でアクタモデルの以下の操作をどのように記述するか述べなさい。

In Scala, Kotlin, Elixir, and Ruby Ractor, we can write a program based on a kind of the actor model. Choose one language from these languages, and provide how to describe the following operations in the language.

receive
send
become

★問題(902) Prologプログラム中の並列性/Concurrency in a Prolog program

quicksort のプログラムは、次の 2 つの並列性がある。 The quicksort program includes two types of parallelism.

2 つの AND で結ばれた述語間の並列性。
Parallelsim between two predicates that are connected with "AND".
パイプライン並列性。
Pipeline parallelism。

各並列性について、その並列性が存在する場所を1つ示しなさい。 For each parallelism, show one place where the parallelism exists.

★問題(903) Jini における Plug and play の実装/Implementing plug-and-play in Jini

Jini において、plug and play とは何か。 What is plug-and-play in Jini?

Jini において、plug and play を実装している重要な技術を選び、簡単に説明しなさい。 Select a key technique that implements plug-and-play in Jini and provide a brief description of it.

Last updated: 2023/06/22 16:24:30

Yasushi Shinjo / <yas@cs.tsukuba.ac.jp>