LuneScript で非同期処理を行なうには、 __Runner インタフェースを実装します。

__Runner インタフェースは、以下の型です。 __async については後述します。

// @lnsFront: skip
pub interface __Runner {
   pub fn run() __async mut;
}

このインタフェースを実装すると、 新しい組込み関数の __run(), __join() を利用できます。

例えば、以下のような処理を実行すると、 print("hoge:", self.val ); が非同期で処理されます。

// @lnsFront: ok
class Hoge extend (__Runner) {
   let val:int;
   pub fn run() __async mut {
      print("hoge:", self.val );
   }
}

let list:List<Hoge> = [];
for index = 0, 10 {
   let mut hoge = new Hoge(index);
   __run( hoge, __lns.runMode.Sync, "" );
   list.insert( hoge );
}
foreach hoge in list {
   __join( hoge );
}

// @lnsFront: skip
pub fn __run( runner:__Runner, mode: RunMode, name:str ) : bool

// @lnsFront: skip
pub fn __join( runner:__Runner )

// @lnsFront: error
class Test {
   pub fn func() __async {
   }
}
final class Foo {
   pub fn func() __noasync {
   }
}
class Hoge extend (__Runner) {
   pub fn __init( test:Test, list:List<int>, foo:Foo ) __async { // error
   }
   pub fn run() __async mut {
   }
}

// @lnsFront: ok
class Test {
   pub fn func() __async {
   }
}
final class Foo {
   pub fn func() __noasync {
   }
}
class Hoge extend (__Runner) {
   pub fn __init( test:&Test, list:&List<int>, foo:Foo ) __async { // ok
   }
   pub fn run() __async mut {
   }
}

__Runner インタフェースの run() メソッドの定義を見ると、 __async が追加されているのが分かります。

これは、その関数を非同期に実行可能であることを宣言しています。

LuneScript は、スレッドが一つだけで動作する従来の同期処理と、 新しくスレッドを起動して実行する非同期処理に分けて管理します。

ある関数を非同期で実行するには、 その関数が非同期で実行可能であることを宣言する必要があります。

それが __async です。

一方で、従来の同期処理は __noasyc です。

普通は async の対になるのは sync だと思いますが、 以下の理由からあえて noasync にしています。

• async と sync だと区別しづらい
• 主体が非同期処理(async)であり、 同期処理は例外だから noasync

__async, __noasync どちらも宣言していない場合はデフォルトで __noasyc ですが、 デフォルトを __async として扱える方法を用意しています。

__async 宣言された関数には、以下の制限があります。

• __async 宣言された関数内から __noasync 宣言された関数にアクセスできない。
• __async 宣言された関数内から、スコープ外の mutable な変数にアクセスできない。

一方で __noasync 宣言された関数には、このような制限はありません。

これは、安全に非同期処理を実行するためのガードです。

非同期処理は、 排他制御 を考慮する必要があります。 必要な箇所で 排他制御 を行なわないと、バグになります。

排他制御の必要性については、ここを参考に。

しかし、どこに 排他制御 が必要か、 を全てのケースにおいて人手で網羅することは非常に困難です。

そこで、 LuneScript では文法上にメタ情報を宣言し、 その不整合をコンパイラがチェックすることによって、 ヒューマンエラーによる 排他制御 の抜け漏れを軽減する方法を採用しています。

このアプローチを採用する代表的な言語に Rust があります。

Rust は厳格なメタ情報の定義によって、高度な 排他制御 を実現しています。

LuneScript では、 Rust ほど高度な 排他制御 を実現していない変わりに、 比較的に手軽で扱い易いメタ情報定義を採用しています。

なお、後述する __asyncLock を利用することで、 __async から __noasync をアクセスすることが可能 になります。

// @lnsFront: error
class Test {
   fn func1() __noasync {
   }
   fn func2() __async {
      self.func1(); // error
   }
}

// @lnsFront: error
let mut list = [ 1, 2 ];
let list2 = [ 1, 2 ];
class Test {
   fn func() __async {
      foreach val in list { // error
         print( val );
      }
      foreach val in list2 { // ok
         print( val );
      }
   }
}

LuneScript では、 非同期(__async)で動作するスレッドが複数(N)あり、 __noasync で動作するスレッドは 1 つになるように設計しています。

__noasync で動作するスレッドが複数あると、もはやそれは非同期なので、 __noasync のスレッドが一つなのは当然ですね。

前述の通り、 __async 宣言された関数には制限があります。

理想は、全てにおいてこの制限を満すことですが、 現実問題それでは対応できないケースもあります。

そこで、 __async 宣言された関数の制限を一時的に解除する方法を用意しています。

それが __asyncLock です。

例えば、以下のように __asyncLock を利用します。

// @lnsFront: ok
class Test {
   fn func1() __noasync {
   }
   fn func2() __async {
      __asyncLock {
         self.func1(); // ok
      }
   }
}

func2 は __async なので、__noasync である func2 に本来はアクセスできませんが、 __asyncLock ブロック内では __async の制限が解除されます。

// @lnsFront: ok
class Test {
   fn func1() __noasync {
   }
   fn func2() __async {
      __asyncLock {
         self.func1();
      }
   }
   fn func3() __async {
      __asyncLock {
         self.func2();
      }
   }
}

// @lnsFront: error
class Test {
   fn func1() __noasync {
   }
   fn func2() __async {
      __asyncLock {
         __asyncLock { // error
            self.func1();
         }
      }
   }
}

// @lnsFront: ok
class Test {
   fn func1() __noasync {
   }
   fn func2() __async {
      for _ = 1, 10000000 {
         __asyncLock {
            self.func1();
         }
      }
   }
}

// @lnsFront: error
class Test {
   fn func1() __noasync : bool {
      return true;
   }
   fn func2() __async : int {
      __asyncLock {
         if self.func1() {
            return 1; // error
         }
      }
      return 0;
   }
}

// @lnsFront: ok
class Test {
   fn func1() __noasync : bool {
      return true;
   }
   fn func2() __async : int {
      let mut val = 0;
      __asyncLock {
         if self.func1() {
            val = 1;
         }
      }
      return val;
   }
}

何も宣言していない関数は __noasync です。

これを、 デフォルト __async にする方法を用意しています。

_lune_control default_async_all

上記が .lns ファイルの先頭に宣言されている場合、 その .lns ファイル内では デフォルト __async になります。

これまでの特徴をまとめると以下になります。

• __async スレッドが複数(N)で __noasync スレッドは 1 つの N:1 になる。
• 他に __noasync スレッド実行中、 __asyncLock はブロックする。

これらから、 LuneScript において非同期処理を行なうには以下が必要になります。

「基本は __Runner で __async 処理し、 __noasync の処理は必要最低限に留める」

例えば、 __main() で起動直後に __Runner を起動し、その __Runner の終了を __join で待つ。 というデザインをするのが基本となります。

LuneScript では、以下によって排他制御の抜け漏れを防止しています。

• __async 宣言された関数の制限
• __Runner を extend したクラスのコンストラクタの制限

// @lnsFront: error
let mut list = [ 1, 2 ];
class Test {
   fn func() __async {
      foreach val in list { //error
         print( val );
      }
   }
}

例えば、上記の func() から list へのアクセスは本来コンパイルエラーになりますが、 これをエラーとしない場合、 func() メソッドを実行している間に、 別のスレッドで list の値を更新した場合、 list に対して参照と変更が同時に発生し、不定な動作になります。

これをガードするために、 __async 宣言した関数には制限が付きます。

また、次のようなコードを実行した場合、

// @lnsFront: error
class Hoge extend (__Runner) {
   let list:List<int>;
   pub fn __init( list:List<int> ) __async { // error
      self.list = list;

      __run( self, __lns.runMode.Queue, "test" );
   }
   pub fn run() __async mut {
      self.list.insert(1);
   }
}

let mut workList = [1];
let hoge1 = new Hoge( workList );
let hoge2 = new Hoge( workList );

本来 Hoge のコンストラクタの list の型が mutable であるためコンパイルエラーになりますが、 これをエラーとしない場合、同じ workList に対して、 複数の Hoge の非同期処理によって insert() が同時に発生し、 不定な動作になります。

これをガードするために、 __Runner を extend したコンストラクタには制限が付きます。

// @lnsFront: ok
let mut list = [ 1, 2 ];
let list2 = list;
class Test {
   fn func() __async {
      foreach val in list2 {
         print( val );
      }
   }
}