👼

神話のプログラム言語 Odin Thread 後編

に公開

前回のthread処理の続きです。
今回はスレッドプールとchannel制御について、説明します。

Thread処理

5.スレッドプール処理

スレッドプールとは、頻繁に発生するタスクを、新規にスレッドを作成して実行するのではなく、あらかじめ用意された待機中のスレッドに割り当てる事を言います。
以下の処理では、最大5個のスレッドを登録し、同時実行できるスレッド数は3つまでと設定しています。また、各スレッドは30秒間で60回の画面への出力を行う処理を行います。その間、メイン側のキー操作で各スレッドを停止し、待機スレッドが自動で動くのかを検証します。
(thread_poolディレクトリの中に、以下のmain.odinを作成して確認します。)

thread_pool/main.odin
package main

import "core:fmt"
import "core:thread"
import "core:time"
import "core:os"
import "core:sync"

lockMutex :sync.Mutex

// メイン処理
main :: proc() {

  POOL_CONCURRENT :: 3  // 同時並行出来るスレッド数
  POOL_THREAD_MAX :: 5  // 最大スレッド数
  threadPool :thread.Pool

  thread.pool_init( &threadPool, context.allocator, POOL_CONCURRENT ) // スレッド数を指定して
  thread.pool_start( &threadPool )
  defer thread.pool_destroy( &threadPool )  // poolの破棄(メモリの解放 PoolとQueueの解放)

  for i in 0 ..< POOL_THREAD_MAX {          // 最大スレッドを作成する(POOL_THREAD_MAX)
    thread.pool_add_task( &threadPool, context.allocator, pool_worker, &{}, i )
  }

  Exec( Clear, SetCursor( 0, 0 ) )          // Terminal画面のクリア

  // スレッド中にキー操作を行い、各スレッドを停止
  loop: for {
    // キー入力の確認
    key := key_interrupt()
    if key == -1 do continue
    if key == 20 {              // 'z'+ENTERが押された場合、全てのスレッドを停止
      thread.pool_stop_all_tasks( &threadPool )             // 実行中のスレッドを全て停止
      for thread.pool_num_outstanding( &threadPool ) > 0 {  // 実行中+待機中スレッド数がまだあるかチェック
        time.sleep( 100 * time.Millisecond )                // sleepで待機スレッドを起動させる
        thread.pool_stop_all_tasks( &threadPool )           // 実行中のスレッドを全て停止
      }
      lock_print( 8, 0, "stop : all" )
      break loop
    }
    if key >= 0 && key < 5 {  // 数字+ENTERが押された場合、指定thread_idのスレッドを停止
      thread.pool_stop_task( &threadPool, key )             // 指定スレッドだけを停止
      lock_print( 8, 0, "stop : %v", key )
    }
  }

  thread.pool_finish( &threadPool )                         // 内部でjoinしている
  lock_print( 8, 0, "thread pool 終了" )
}

// 各スレッド処理
pool_worker :: proc( t: thread.Task ){
  for i in 0 ..< 60 {  // 60 * 0.5 = 30秒実行する
    lock_print( t.user_index + 2, 0, "thread[%v]のworker : %v 回", t.user_index, i )

    time.sleep( 500 * time.Millisecond )
  }
}

// 複数のスレッドが同時出力を行うため、ロックさせて表示している
lock_print :: proc(y: int, x: int, format: string, arg: ..any) {
  sync.lock( &lockMutex )     // 同時に複数のスレッドから呼び出されるため排他ロックを行う
  Exec( SetCursor( y, x ) )
  fmt.printf( format, ..arg )
  sync.unlock( &lockMutex )   // ロック解除
}

// key操作 
key_interrupt :: proc() -> int {
  buf: [128]byte

  len, err := os.read( os.stdin, buf[:] )
  assert( err == nil )

  if len > 0 {
    if buf[0] == 'z' do return 20 // all thread停止 一度だけしか効かない breakするから
    if buf[0] >= '0' && buf[0] < '5' {
      return int( buf[0] - '0' ) // 文字を数字変換
    }
  }

  return -1
}

// --- [ 外部ライブラリのodin-inquirerの一部を拝借 ] ---
Clear:: "\u001b[2J"

SetCursor :: proc( x,y :int ) -> string {
    return fmt.tprintf( "\u001b[%d;%dH",x,y )
}

// RUN COMMANDS
Exec :: proc( commands: ..string ) {
    for cmd in commands {
        os.write_string(os.stdout, cmd)
    }
}

thread.pool_initでスレッドプールの初期化を行い、thread.pool_startでスレッドプールを起動した後、thread.pool_add_taskで実際のスレッドを起動させています。
また、動作中のスレッドの停止については、thread.pool_stop_all_tasksが実行中のスレッドの停止で、thread.pool_stop_taskがthread_id毎のスレッドの停止になります。
(データを垂れ流すだけだと、確認がわかりずらいため、外部ライブラリのodin-inquirerからターミナル・カーソル制御を拝借し、スレッド毎の表示を行っています。
そのため、スレッドプールの処理自体は40行程度なのですが、処理中のキー入力操作やカーソル制御を含めてしまっているので、100行以上のサンプルプログラムになって見づらくなって、すみません。)

  • Odin:実行結果
    odin run .\thread_pool\ で実行させた結果

    実行後に、キー入力で0+ENTERキーでThread0を停止させると、Thread3が自動起動します。
    更にキー入力で1+ENTERキーでThread1を停止させると、Thread4が自動起動します。
    その後、z+ENETRキーを押して、Threadを全て停止させます。

6.Channel処理

Channel処理とは、Thread間の送受信処理を言います。
以下の処理では、データを受け取るスレッドと、それぞれ別のディレクトリ内のファイルを検索するスレッドを3つ作成し、channel制御で送受信を行う処理です。
(channelディレクトリの中に、以下のmain.odinを作成して確認します。)

channel/main.odin
package main

import "core:fmt"
import "core:thread"
import "core:time"
import "core:sync"
import "core:sync/chan"
import "core:os"

Work_Dir1 :: "E:/temp/test01"
Work_Dir2 :: "E:/temp/test02"
Work_Dir3 :: "E:/temp/test03"

MessageData :: struct {   // Channel送受信用データ
  user_id: int,           // 送信元のタスクID
  data_no: int,           // 検索ファイル数
  data: string,           // 検索ファイル名
}
WorkerData :: struct {    // Threadへの受け渡しデータ
  dir_name: string,       // 検索するディレクトリ名
  wait_group: ^sync.Wait_Group,             // thread終了通知用
  message_channel: ^chan.Chan(MessageData)  // MessageDataを受け渡しする
}

// メイン処理
main :: proc() {
  // ファイル検索時にファイル名を格納するエリアにtemp_allocatorを使っているので最後に解放
  defer free_all( context.temp_allocator )

  wg : sync.Wait_Group
  // channelの生成
  mchan, err := chan.create( chan.Chan(MessageData), context.allocator )
  defer chan.destroy( mchan )

  // threadの生成
  t1 := thread.create( timeline_display )
  t2 := thread.create( channel_worker )
  t3 := thread.create( channel_worker )
  t4 := thread.create( channel_worker )

  // 各threadにcontext, thread_id, dataを設定  
  t1.init_context = context
  t1.user_index = 1
  t2.init_context = context
  t2.user_index = 2
  t3.init_context = context
  t3.user_index = 3
  t4.init_context = context
  t4.user_index = 4

  // dataには、検索ディレクトリとwaitgroupとchannelを設定する
  t1.data = &WorkerData{ wait_group = &wg, message_channel = &mchan }
  t2.data = &WorkerData{ dir_name = Work_Dir1, wait_group = &wg, message_channel = &mchan }
  t3.data = &WorkerData{ dir_name = Work_Dir2, wait_group = &wg, message_channel = &mchan }
  t4.data = &WorkerData{ dir_name = Work_Dir3, wait_group = &wg, message_channel = &mchan }

  // waitgroupにthread数を設定
  sync.wait_group_add( &wg, 4 ) // thread数を間違えると停止しないから注意

  // threadを起動
  thread.start( t1 )
  thread.start( t2 )
  thread.start( t3 )
  thread.start( t4 )

  // threadが停止するまで待機
  sync.wait_group_wait( &wg )
}

// 表示用スレッド 全てthreadのデータを受信し結果をコンソール出力
timeline_display :: proc(t: ^thread.Thread) {
  messanger := (cast(^WorkerData)t.data)  // mainからデータを受け取る

  Exec( Clear, SetCursor( 0, 0 ) )
  loop := 400       // ループ回数 400 x 10msecの間ループを行う
  sleep_time := 10  // 10msec毎にスリープを設定
  for i in 0 ..< loop {
    // 10msec毎に受信確認
    msg, ok := chan.try_recv(messanger.message_channel^)  // 各スレッドからデータを受信

    Exec( SetCursor( 2, 0 ) )   // 2行目から表示 何故かterminalが2行目から始めるので、そうしている
    fmt.printf( "thread display %04v msec", i * sleep_time )
    if msg.user_id > 1 {
      // 受信結果を表示
      Exec( SetCursor( msg.user_id + 1, 0 ) )
      fmt.printf( "%04vmsec thread[%02v] file_cnt[%03v] file_name[%-40v]                                 ",
                  i * sleep_time, msg.user_id, msg.data_no, msg.data )
    }
    time.sleep( cast(time.Duration)sleep_time * time.Millisecond )
  }
  Exec( SetCursor( 6, 0 ) )
  fmt.println("end.")
  // スレッドの終了通知を行う
  sync.wait_group_done( messanger.wait_group )
}

// ディレクトリ検索用スレッド 各スレッド毎にディレクトリ内のファイル情報を送信する
channel_worker :: proc(t: ^thread.Thread) {
  messanger := (cast(^WorkerData)t.data)  // mainからデータを受け取る

  dir := messanger.dir_name               // 受け取ったディレクトリ名を設定
  dir_num := 0                            // 検索カウンターを初期化
  file_search( dir, &dir_num, t.user_index, messanger )
  // スレッドの終了通知を行う
  sync.wait_group_done( messanger.wait_group )
}

// ファイル検索 ディレクトリ内のファイル検索を行う
file_search :: proc(filename: string, dir_num: ^int, user_id: int, messanger: ^WorkerData, allocator := context.temp_allocator) {
  if os.is_dir( filename ) {
    fd, _ := os.open( filename, os.O_RDONLY, 0 )
    defer os.close( fd )

    if fi, ok := os.read_dir( fd, -1, allocator ); ok == nil {
      for f in fi {
        if f.is_dir {
          file_search( f.fullpath, dir_num, user_id, messanger )
        } else {
          dir_num^ += 1
          // 検索したファイル名を設定し、channel送信を行う
          data := MessageData { user_id=user_id, data_no=dir_num^, data=f.fullpath }
          chan.send( messanger.message_channel^, data )
        }
      }
      delete( fi )
    }
  }
}

// --- [ 外部ライブラリのodin-inquirerの一部を拝借 ] ---
Clear:: "\u001b[2J"

SetCursor :: proc( x,y :int ) -> string {
    return fmt.tprintf( "\u001b[%d;%dH",x,y )
}

// RUN COMMANDS
Exec :: proc( commands: ..string ) {
    for cmd in commands {
        os.write_string(os.stdout, cmd)
    }
}

スレッドプールと違い、上記プログラムでは、timeline_display関数が画面への表示を行い、他のThread(channel_worker関数)をそれぞれ異なるディレクトリからファイルを検索し、channel送受信で通信を行っています。
chan.createでchannelを作成し、WorkerData構造体に、検索ディレクトリ名、channel情報、WaitGroup情報を各スレッドに渡しています。各スレッドは、指定されたディレクトリを元に、ファイル検索を行い、chan.send関数で検索ファイル名を送信しています。
(これまた、100行以上の長いプログラムになってしい、見づらく申し訳ございません。)

  • 実行結果
    odin run .\channel\ で実行させた結果

おわりに

今回はスレッドプール処理とWaitGroupを使ったchannel送受信の説明をしました。
スレッドプールに関しては、小さなスレッドを大量に生成し、常駐させる場合に用いられます。
channel送受信は良く使います。こちらの方を覚えておくといいでしょう。

Discussion