Ruby » Ruby master

Feature #6694

Updated by ko1 (Koichi Sasada) about 7 years ago

# =begin 
 = Abstract 

 Support Thread.new() without block. 

 Before: `Thread.new(params...){|thread_local_params| ...}` Thread.new(params...){|thread_local_params| ...} 

 After: `Thread.new(proc: Thread.new(proc: lambda{|tl_params...| ...}, args: params..., other_thread_config...)` other_thread_config...) 

 # = Background 

 Thread.new creates new Thread object and run passed block in another thread immediately.    Thread.new can receive parameters and pass all parameters to block. 

 ``` 
   

   Thread.new(a, b, c) do |ta, tb, tc| 
     # ta, tb, tc is thread local 
   } 
 ``` 

 There are some request to specify thread configurations such as stack size described in [Ruby 1.9 - Feature #3187] (in this case, stack size for Fiber.new).    However, we have no way to pass such thread configuration on the Thread.new(). 

 # = Proposal 

 Allow Thread.new() without block.    A block will be passed with proc parameter.    Passed arguments will be passed with args parameter. 

 ``` 
   

   # ex1 
   Thread.new(){...} 
   #=> 
   Thread.new(proc: -> {...}) 
  
   # ex2 
   Thread.new(a, b, c){|ta, tb, tc| ...} 
   #=> 
   Thread.new(proc: ->(ta, tb, tc){ ... }, params: [a, b, c]) 
 ``` 

 If you want to specify stack size, then: 

   Thread.new(stack_size: 4096, proc: proc{...}, args: [a, b, c]) 

 Note that I'll make another ticket for thread (and fiber) creation parameters. 

 This change can be described with the following pseudo code: 

 ``` 
   

   def Thread.new(*args, &block) 
     if block 
       Thread.new_orig(*args, &block) 
     else 
       config = args[0] || raise ArgumentError 
       stack_size = config[:stack_size] 
       # ... and process another parameters  
       Thread.new_orig(*config[:args], &config[:proc]) 
     end 
   end 
 ``` 

 # = Another proposal 

 On the [ruby-core:43385], Nahi-san proposed that if no block given on Thread.new(), then create "waiting" thread.    Thread#run kicks waiting thread with parameters. 

 ``` 
   

   th = Thread.new(thread_config_params) 
   ... 
   th.run(params){|thread_local_params| 
     ... 
   } 
 ``` 

 We can combine with `proc:` proc: parameter and this proposal. 
    If `Thread.new()` Thread.new() doesn't have block and `proc:` proc: parameter, then making a waiting thread. 

 NOTE: Because we have already Thread#run, Thread#start is better than Thread#run? 

 # 


 = Note 

 I don't make any survey on other languages.    Please give us your comments. 

 =end 

Back