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

並行システム

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

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

■連絡事項

期末試験は行いません。期末レポートもありません。毎回のレポートで成績を付けます。
レポート出していない人は Web ページから出してください。
レポートは、7月14日までに全部提出してください。締切過ぎたものも、提出して下さい。
一部、再提出になっているものがあります。

■今日の重要な話

並行オブジェクト指向モデル 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

(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

Ted Neward: "多忙な Java 開発者のための Scala ガイド: Scala の並行性を掘り下げる", IBM DeveloperWorks, 2009年 4月 10日. https://www.ibm.com/developerworks/jp/java/library/j-scala04109.html

Ted Neward: "The busy Java developer's guide to Scala: Dive deeper into Scala concurrency", IBM DeveloperWorks, 10 Apr 2009. https://www.ibm.com/developerworks/java/library/j-scala04109.html

リスト 9. Counter の例 (アクターによる方法) より。

object CountingSample
{
  case class Incr
  case class Value(sender : Actor)
  case class Lock(sender : Actor)
  case class UnLock(value : Int)

  class Counter extends Actor
  {
    override def act(): Unit = loop(0)

    def loop(value: int): Unit = {
      receive {
	case Incr()   => loop(value + 1)
	case Value(a) => a ! value; loop(value)
	case Lock(a)  => a ! value
			 receive { case UnLock(v) => loop(v) }
	case _        => loop(value)
      }
    }
  }

  def main(args : Array[String]) : Unit =
  {
    val counter = new Counter
    counter.start()
    counter ! Incr()
    counter ! Incr()
    counter ! Incr()
    counter ! Value(self)
    receive { case cvalue => Console.println(cvalue) }    
    counter ! Incr()
    counter ! Incr()
    counter ! Value(self)
    receive { case cvalue => Console.println(cvalue) }    
  }
}

「!」で、メッセージを送信する。
receive で受信。case でパタンマッチしながら複数待てる。
クライアント側は send して receive、サーバ側は、receive して reply で、RPC 的な動きをさせられる。

◆カウンタ(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 を使っている。

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

Concurrency in Erlang & Scala: The Actor Model

-module(counter).
-export([run/0, counter/1]).

run() ->
    S = spawn(counter, counter, [0]),
    send_msgs(S, 100000),
    S.

counter(Sum) ->
    receive
        value -> io:fwrite("Value is ~w~n", [Sum]);
        {inc, Amount} -> counter(Sum+Amount)
    end.

send_msgs(_, 0) -> true;
send_msgs(S, Count) ->
    S ! {inc, 1},
    send_msgs(S, Count-1).

% Usage:
%    1> c(counter).
%    2> S = counter:run().
%       ... Wait a bit until all children have run ...
%    3> S ! value.
%    Value is 100000

■並行論理型プログラミング言語/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 並列。Prolog の :- の右側を全部並列に実行する。
OR 並列。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).

H ₁ :- G ₁₁, G ₁₂,...,G _1n | B ₁₁, B ₁₂, ..., B _1m.

H ₂ :- G ₂₁, G ₂₂,...,G _2n | B ₂₁, B ₂₂, ..., B _2m.

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 Plugand 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の一部ではない。

◆サービス/Services

サービスは、Java のオブジェクトで実現される。

サービスの提供者とサービスの利用者の間は、最終的にはに RMI で接続される。

ServiceIDLister インタフェースを implements する。

package com.sun.jini.lookup;
public interface ServiceIDListener extends java.util.EventListener {
    void serviceIDNotify(net.jini.core.lookup.ServiceID serviceID);
}

ルックアップ・サービスからコールバックされる。

◆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 を使う。

Last updated: 2020/06/24 15:34:46

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

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

■連絡事項

■今日の重要な話

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

◆アクタモデル/The Actor models

◆継続/Continuations

◆階乗/Factorial in Actor

◆階乗/Factorial in Actor

◆銀行口座/A bank account in Actor

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

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

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

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

◆Prolog

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

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

◆規則/Rules

◆リスト/Lists

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

◆quicksort

◆GHC (Guarded Horn Clauses)

◆GHCの構文/Syntax of GHC

■Jini

◆UPnP (Universal Plugand Play)

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

◆リース/Leasing

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

◆サービス/Services

◆Discovery と Join/Discovery and Join

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

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

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

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

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

◆Jiniのクライアントの例

◆Leasing

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

★問題(901) Actorの並列性/Concurrency in Actor

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

★問題(903) Jini