Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
BEGIN LICENSE BLOCK ***** Version: EPL 1.0/GPL 2.0/LGPL 2.1 The contents of this file are subject to the Eclipse Public License Version 1.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.eclipse.org/legal/epl-v10.html Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License. Copyright (C) 2002 Jason Voegele <jason@jvoegele.com> Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com> Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> Alternatively, the contents of this file may be used under the terms of either of the GNU General Public License Version 2 or later (the "GPL"), or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), in which case the provisions of the GPL or the LGPL are applicable instead of those above. If you wish to allow use of your version of this file only under the terms of either the GPL or the LGPL, and not to allow others to use your version of this file under the terms of the EPL, indicate your decision by deleting the provisions above and replace them with the notice and other provisions required by the GPL or the LGPL. If you do not delete the provisions above, a recipient may use your version of this file under the terms of any one of the EPL, the GPL or the LGPL. END LICENSE BLOCK ***
32
  
33
  package org.jruby;
34
  
41
  import java.util.Vector;
43
  import java.util.HashMap;
44
  import java.util.List;
47
  import java.util.Map;
48
  
49
  import java.util.Set;
63
  
71
  import static org.jruby.runtime.Visibility.*;
72
  
78
  
79
  import static org.jruby.CompatVersion.*;
Implementation of Ruby's Thread class. Each Ruby thread is mapped to an underlying Java Virtual Machine thread.

Thread encapsulates the behavior of a thread of execution, including the main thread of the Ruby script. In the descriptions that follow, the parameter aSymbol refers to a symbol, which is either a quoted string or a Symbol (such as :name). Note: For CVS history, see ThreadClass.java. 

96
  
97
  @JRubyClass(name="Thread")
98
  public class RubyThread extends RubyObject implements ExecutionContext {
99
  
100
     private static final Logger LOG = LoggerFactory.getLogger("RubyThread");

    
The thread-like think that is actually executing
102
 
103
     private ThreadLike threadImpl;

    
Normal thread-local variables
105
 
106
     private transient Map<IRubyObject, IRubyObject> threadLocalVariables;

    
Context-local variables, internal-ish thread locals
108
 
109
     private final Map<Object, IRubyObject> contextVariables = new WeakHashMap<Object, IRubyObject>();

    
Whether this thread should try to abort the program on exception
111
 
112
     private boolean abortOnException;

    
The final value resulting from the thread's execution
114
 
115
     private IRubyObject finalResult;

    
The exception currently being raised out of the thread. We reference it here to continue propagating it while handling thread shutdown logic and abort_on_exception. 
121
 
122
     private RaiseException exitingException;

    
The ThreadGroup to which this thread belongs
124
 
125
     private RubyThreadGroup threadGroup;

    
Per-thread "current exception"
127
 
128
     private IRubyObject errorInfo;

    
Weak reference to the ThreadContext for this thread.
130
 
131
     private volatile WeakReference<ThreadContext> contextRef;
132
 
133
     private static final boolean DEBUG = false;
134
     private int RUBY_MIN_THREAD_PRIORITY = -3;
135
     private int RUBY_MAX_THREAD_PRIORITY = 3;

    
Thread statuses
137
 
138
     public static enum Status { 
139
         RUN, SLEEP, ABORTING, DEAD;
140
         
141
         public final ByteList bytes;
142
         
143
         Status() {
144
              = new ByteList(toString().toLowerCase().getBytes(.));
145
         }
146
     }

    
Current status in an atomic reference
148
 
149
     private final AtomicReference<Status> status = new AtomicReference<Status>(.);

    
Mail slot for cross-thread events
151
 
152
     private final AtomicReference<ThreadService.Event> mail = new AtomicReference<ThreadService.Event>();

    
The current task blocking a thread, to allow interrupting it in an appropriate way
154
 
155
     private volatile BlockingTask currentBlockingTask;

    
The list of locks this thread currently holds, so they can be released on exit
157
 
158
     private final List<Lock> heldLocks = new Vector<Lock>();

    
Whether or not this thread has been disposed of
160
 
161
     private volatile boolean disposed = false;

    
The thread's initial priority, for use in thread pooled mode
163
 
164
     private int initialPriority;
165
 
166
     protected RubyThread(Ruby runtime, RubyClass type) {
167
         super(runtime, type);
168
 
169
          = runtime.getNil();
170
          = runtime.getNil();
171
     }
172
     
173
     public RubyThread(Ruby runtime, RubyClass klass, ThreadedRunnable runnable) {
174
         this(runtime, klass);
175
         
176
         startWith(runnable);
177
     }
178
 
179
     public void receiveMail(ThreadService.Event event) {
180
         synchronized (this) {
181
             // if we're already aborting, we can receive no further mail
182
             if (.get() == .) return;
183
 
184
             // FIXME: this was not checking null before, but maybe it should
185
             .set(event);
186
             switch (event.type) {
187
             case :
188
                 .set(.);
189
             }
190
 
191
             // If this thread is sleeping or stopped, wake it
192
             notify();
193
         }
194
 
195
         // interrupt the target thread in case it's blocking or waiting
196
         // WARNING: We no longer interrupt the target thread, since this usually means
197
         // interrupting IO and with NIO that means the channel is no longer usable.
198
         // We either need a new way to handle waking a target thread that's waiting
199
         // on IO, or we need to accept that we can't wake such threads and must wait
200
         // for them to complete their operation.
201
         //threadImpl.interrupt();
202
 
203
         // new interrupt, to hopefully wake it out of any blocking IO
204
         this.interrupt();
205
 
206
     }
207
 
208
     public void checkMail(ThreadContext context) {
209
         ThreadService.Event myEvent = .getAndSet(null);
210
         
211
         if (myEvent != null) {
212
             switch (myEvent.type) {
213
             case :
214
                 receivedAnException(context, myEvent.exception);
215
             case :
216
                 throwThreadKill();
217
             }
218
         }
219
     }
220
 
221
     public IRubyObject getErrorInfo() {
222
         return ;
223
     }
224
 
225
     public IRubyObject setErrorInfo(IRubyObject errorInfo) {
226
         this. = errorInfo;
227
         return errorInfo;
228
     }
229
 
230
     public void setContext(ThreadContext context) {
231
         this. = new WeakReference<ThreadContext>(context);
232
     }
233
 
234
     public ThreadContext getContext() {
235
         return  == null ? null : .get();
236
     }
237
 
238
 
239
     public Thread getNativeThread() {
240
         return .nativeThread();
241
     }

    
Perform pre-execution tasks once the native thread is running, but we have not yet called the Ruby code for the thread. 
246
 
247
     public void beforeStart() {
248
         // store initial priority, for restoring pooled threads to normal
249
         this. = Thread.currentThread().getPriority();
250
     }

    
Dispose of the current thread by tidying up connections to other stuff 
254
 
255
     public void dispose() {
256
         if () return;
257
         
258
         synchronized (this) {
259
             if () return;
260
             
261
              = true;
262
 
263
             // remove from parent thread group
264
             .remove(this);
265
 
266
             // unlock all locked locks
267
             unlockAll();
268
 
269
             // reset thread priority to initial if pooling
270
             if (..load()) {
271
                 .setPriority();
272
             }
273
 
274
             // mark thread as DEAD
275
             beDead();
276
         }
277
 
278
         // unregister from runtime's ThreadService
279
         getRuntime().getThreadService().unregisterThread(this);
280
     }
281
    
282
     public static RubyClass createThreadClass(Ruby runtime) {
283
         // FIXME: In order for Thread to play well with the standard 'new' behavior,
284
         // it must provide an allocator that can create empty object instances which
285
         // initialize then fills with appropriate data.
286
         RubyClass threadClass = runtime.defineClass("Thread", runtime.getObject(), .);
287
         runtime.setThread(threadClass);
288
 
289
         threadClass.index = .;
290
         threadClass.setReifiedClass(RubyThread.class);
291
 
292
         threadClass.defineAnnotatedMethods(RubyThread.class);
293
 
294
         RubyThread rubyThread = new RubyThread(runtime, threadClass);
295
         // TODO: need to isolate the "current" thread from class creation
296
         rubyThread.threadImpl = new NativeThread(rubyThread, Thread.currentThread());
297
         runtime.getThreadService().setMainThread(Thread.currentThread(), rubyThread);
298
         
299
         // set to default thread group
300
         runtime.getDefaultThreadGroup().addDirectly(rubyThread);
301
         
302
         threadClass.setMarshal(.);
303
         
304
         if (runtime.is2_0()) {
305
             // set up Thread::Backtrace::Location class
306
             RubyClass backtrace = threadClass.defineClassUnder("Backtrace", runtime.getObject(), .);
307
             RubyClass location = backtrace.defineClassUnder("Location", runtime.getObject(), .);
308
             
309
             location.defineAnnotatedMethods(Location.class);
310
             
311
             runtime.setLocation(location);
312
         }
313
         
314
         return threadClass;
315
     }
316
     
317
     public static class Location extends RubyObject {
318
         public Location(Ruby runtime, RubyClass klass, RubyStackTraceElement element) {
319
             super(runtime, klass);
320
             this. = element;
321
         }
322
         
323
         @JRubyMethod
324
         public IRubyObject absolute_path(ThreadContext context) {
325
             return context.runtime.newString(.getFileName());
326
         }
327
         
328
         @JRubyMethod
329
         public IRubyObject base_label(ThreadContext context) {
330
             return context.runtime.newString(.getMethodName());
331
         }
332
         
333
         @JRubyMethod
334
         public IRubyObject inspect(ThreadContext context) {
335
             return to_s(context).inspect();
336
         }
337
         
338
         @JRubyMethod
339
         public IRubyObject label(ThreadContext context) {
340
             return context.runtime.newString(.getMethodName());
341
         }
342
         
343
         @JRubyMethod
344
         public IRubyObject lineno(ThreadContext context) {
345
             return context.runtime.newFixnum(.getLineNumber());
346
         }
347
         
348
         @JRubyMethod
349
         public IRubyObject path(ThreadContext context) {
350
             return context.runtime.newString(.getFileName());
351
         }
352
         
353
         @JRubyMethod
354
         public IRubyObject to_s(ThreadContext context) {
355
             return context.runtime.newString(.mriStyleString());
356
         }
357
 
358
         public static IRubyObject newLocationArray(Ruby runtime, RubyStackTraceElement[] elements) {
359
             RubyArray ary = runtime.newArray(elements.length);
360
 
361
             for (RubyStackTraceElement element : elements) {
362
                 ary.append(new RubyThread.Location(runtime, runtime.getLocation(), element));
363
             }
364
 
365
             return ary;
366
         }
367
         
368
         private final RubyStackTraceElement element;
369
     }

    
Thread.new

Thread.new( [ arg ]* ) {| args | block } -> aThread

Creates a new thread to execute the instructions given in block, and begins running it. Any arguments passed to Thread.new are passed into the block. 

 x = Thread.new { sleep .1; print "x"; print "y"; print "z" }
 a = Thread.new { print "a"; print "b"; sleep .2; print "c" }
 x.join # Let the threads finish before
 a.join # main thread exits...
produces: abxyzc 
386
 
387
     @JRubyMethod(name = {"new", "fork"}, rest = true, meta = true)
388
     public static IRubyObject newInstance(IRubyObject recv, IRubyObject[] args, Block block) {
389
         return startThread(recv, args, true, block);
390
     }

    
Basically the same as Thread.new . However, if class Thread is subclassed, then calling start in that subclass will not invoke the subclass's initialize method. 
396
 
397
     @JRubyMethod(rest = true, meta = true, compat = )
398
     public static RubyThread start(IRubyObject recv, IRubyObject[] args, Block block) {
399
         return startThread(recv, args, false, block);
400
     }
401
     
402
     @JRubyMethod(rest = true, name = "start", meta = true, compat = )
403
     public static RubyThread start19(IRubyObject recv, IRubyObject[] args, Block block) {
404
         Ruby runtime = recv.getRuntime();
405
         // The error message may appear incongruous here, due to the difference
406
         // between JRuby's Thread model and MRI's.
407
         // We mimic MRI's message in the name of compatibility.
408
         if (! block.isGiven()) throw runtime.newArgumentError("tried to create Proc object without a block");
409
         return startThread(recv, args, false, block);
410
     }
411
     
412
     public static RubyThread adopt(IRubyObject recv, Thread t) {
413
         return adoptThread(recv, t, .);
414
     }
415
 
416
     private static RubyThread adoptThread(final IRubyObject recv, Thread t, Block block) {
417
         final Ruby runtime = recv.getRuntime();
418
         final RubyThread rubyThread = new RubyThread(runtime, (RubyClass) recv);
419
         
420
         rubyThread.threadImpl = new NativeThread(rubyThread, t);
421
         ThreadContext context = runtime.getThreadService().registerNewThread(rubyThread);
422
         runtime.getThreadService().associateThread(t, rubyThread);
423
         
424
         context.preAdoptThread();
425
         
426
         // set to default thread group
427
         runtime.getDefaultThreadGroup().addDirectly(rubyThread);
428
         
429
         return rubyThread;
430
     }
431
     
432
     @JRubyMethod(rest = true, visibility = )
433
     public IRubyObject initialize(ThreadContext context, IRubyObject[] args, Block block) {
434
         Ruby runtime = getRuntime();
435
         if (!block.isGiven()) throw runtime.newThreadError("must be called with a block");
436
         if ( != null) throw runtime.newThreadError("already initialized thread");
437
 
438
         RubyRunnable runnable = new RubyRunnable(this, args, block);
439
         
440
         return startWith(runnable);
441
     }
442
 
443
     private IRubyObject startWith(ThreadedRunnable runnable) throws RaiseException, OutOfMemoryError {
444
         Ruby runtime = getRuntime();
445
         ThreadContext context = runtime.getCurrentContext();
446
         
447
         try {
448
             if (.) {
449
                 FutureThread futureThread = new FutureThread(this, runnable);
450
                  = futureThread;
451
 
452
                 addToCorrectThreadGroup(context);
453
 
454
                 .start();
455
 
456
                 // JRUBY-2380, associate future early so it shows up in Thread.list right away, in case it doesn't run immediately
457
                 runtime.getThreadService().associateThread(futureThread.getFuture(), this);
458
             } else {
459
                 Thread thread = new Thread(runnable);
460
                 thread.setDaemon(true);
461
                 thread.setName("Ruby-" + runtime.getRuntimeNumber() + "-" + thread.getName() + ": " + context.getFile() + ":" + (context.getLine() + 1));
462
                  = new NativeThread(this, thread);
463
 
464
                 addToCorrectThreadGroup(context);
465
 
466
                 // JRUBY-2380, associate thread early so it shows up in Thread.list right away, in case it doesn't run immediately
467
                 runtime.getThreadService().associateThread(thread, this);
468
 
469
                 .start();
470
             }
471
 
472
             // We yield here to hopefully permit the target thread to schedule
473
             // MRI immediately schedules it, so this is close but not exact
474
             Thread.yield();
475
         
476
             return this;
477
         } catch (OutOfMemoryError oome) {
478
             if (oome.getMessage().equals("unable to create new native thread")) {
479
                 throw runtime.newThreadError(oome.getMessage());
480
             }
481
             throw oome;
482
         } catch (SecurityException ex) {
483
           throw runtime.newThreadError(ex.getMessage());
484
         }
485
     }
486
     
487
     private static RubyThread startThread(final IRubyObject recv, final IRubyObject[] args, boolean callInit, Block block) {
488
         RubyThread rubyThread = new RubyThread(recv.getRuntime(), (RubyClass) recv);
489
         
490
         if (callInit) {
491
             rubyThread.callInit(args, block);
492
         } else {
493
             // for Thread::start, which does not call the subclass's initialize
494
             rubyThread.initialize(recv.getRuntime().getCurrentContext(), args, block);
495
         }
496
         
497
         return rubyThread;
498
     }
499
     
500
     public synchronized void cleanTerminate(IRubyObject result) {
501
          = result;
502
     }
503
 
504
     public synchronized void beDead() {
505
         .set(.);
506
     }
507
 
508
     public void pollThreadEvents() {
510
     }
511
     
512
     public void pollThreadEvents(ThreadContext context) {
513
         if ( != null) checkMail(context);
514
     }
515
     
516
     private static void throwThreadKill() {
517
         throw new ThreadKill();
518
     }

    
Returns the status of the global ``abort on exception'' condition. The default is false. When set to true, will cause all threads to abort (the process will exit(0)) if an exception is raised in any thread. See also Thread.abort_on_exception= . 
525
 
526
     @JRubyMethod(name = "abort_on_exception", meta = true)
527
     public static RubyBoolean abort_on_exception_x(IRubyObject recv) {
528
         Ruby runtime = recv.getRuntime();
529
         return runtime.isGlobalAbortOnExceptionEnabled() ? runtime.getTrue() : runtime.getFalse();
530
     }
531
 
532
     @JRubyMethod(name = "abort_on_exception=", required = 1, meta = true)
533
     public static IRubyObject abort_on_exception_set_x(IRubyObject recv, IRubyObject value) {
534
         recv.getRuntime().setGlobalAbortOnExceptionEnabled(value.isTrue());
535
         return value;
536
     }
537
 
538
     @JRubyMethod(name = "current", meta = true)
539
     public static RubyThread current(IRubyObject recv) {
540
         return recv.getRuntime().getCurrentContext().getThread();
541
     }
542
 
543
     @JRubyMethod(name = "main", meta = true)
544
     public static RubyThread main(IRubyObject recv) {
545
         return recv.getRuntime().getThreadService().getMainThread();
546
     }
547
 
548
     @JRubyMethod(name = "pass", meta = true)
549
     public static IRubyObject pass(IRubyObject recv) {
550
         Ruby runtime = recv.getRuntime();
551
         ThreadService ts = runtime.getThreadService();
552
         boolean critical = ts.getCritical();
553
         
554
         ts.setCritical(false);
555
         
556
         Thread.yield();
557
         
558
         ts.setCritical(critical);
559
         
560
         return recv.getRuntime().getNil();
561
     }
562
 
563
     @JRubyMethod(name = "list", meta = true)
564
     public static RubyArray list(IRubyObject recv) {
565
         RubyThread[] activeThreads = recv.getRuntime().getThreadService().getActiveRubyThreads();
566
         
567
         return recv.getRuntime().newArrayNoCopy(activeThreads);
568
     }
569
 
570
     private void addToCorrectThreadGroup(ThreadContext context) {
571
         // JRUBY-3568, inherit threadgroup or use default
572
         IRubyObject group = context.getThread().group();
573
         if (!group.isNil()) {
574
             ((RubyThreadGroup) group).addDirectly(this);
575
         } else {
576
             context.runtime.getDefaultThreadGroup().addDirectly(this);
577
         }
578
     }
579
     
580
     private IRubyObject getSymbolKey(IRubyObject originalKey) {
581
         if (originalKey instanceof RubySymbol) {
582
             return originalKey;
583
         } else if (originalKey instanceof RubyString) {
584
             return getRuntime().newSymbol(originalKey.asJavaString());
585
         } else if (originalKey instanceof RubyFixnum) {
586
             getRuntime().getWarnings().warn(., "Do not use Fixnums as Symbols");
587
             throw getRuntime().newArgumentError(originalKey + " is not a symbol");
588
         } else {
589
             throw getRuntime().newTypeError(originalKey + " is not a symbol");
590
         }
591
     }
592
     
593
     private synchronized Map<IRubyObject, IRubyObject> getThreadLocals() {
594
         if ( == null) {
595
              = new HashMap<IRubyObject, IRubyObject>();
596
         }
597
         return ;
598
     }
599
 
600
     private void clearThreadLocals() {
601
          = null;
602
     }
603
 
604
     public final Map<Object, IRubyObject> getContextVariables() {
605
         return ;
606
     }
607
 
608
     public boolean isAlive(){
609
         return .isAlive() && .get() != .;
610
     }
611
 
612
     @JRubyMethod(name = "[]", required = 1)
613
     public IRubyObject op_aref(IRubyObject key) {
614
         IRubyObject value;
615
         if ((value = getThreadLocals().get(getSymbolKey(key))) != null) {
616
             return value;
617
         }
618
         return getRuntime().getNil();
619
     }
620
 
621
     @JRubyMethod(name = "[]=", required = 2)
622
     public IRubyObject op_aset(IRubyObject key, IRubyObject value) {
623
         key = getSymbolKey(key);
624
         
625
         getThreadLocals().put(key, value);
626
         return value;
627
     }
628
 
629
     @JRubyMethod(name = "abort_on_exception")
630
     public RubyBoolean abort_on_exception() {
631
         return  ? getRuntime().getTrue() : getRuntime().getFalse();
632
     }
633
 
634
     @JRubyMethod(name = "abort_on_exception=", required = 1)
636
          = val.isTrue();
637
         return val;
638
     }
639
 
640
     @JRubyMethod(name = "alive?")
641
     public RubyBoolean alive_p() {
642
         return isAlive() ? getRuntime().getTrue() : getRuntime().getFalse();
643
     }
644
 
645
     @JRubyMethod(name = "join", optional = 1)
646
     public IRubyObject join(IRubyObject[] args) {
647
         Ruby runtime = getRuntime();
648
         long timeoutMillis = .;
649
 
650
         if (args.length > 0 && !args[0].isNil()) {
651
             if (args.length > 1) {
652
                 throw getRuntime().newArgumentError(args.length,1);
653
             }
654
             // MRI behavior: value given in seconds; converted to Float; less
655
             // than or equal to zero returns immediately; returns nil
656
             timeoutMillis = (long)(1000.0D * args[0].convertToFloat().getValue());
657
             if (timeoutMillis <= 0) {
658
             // TODO: not sure that we should skip calling join() altogether.
659
             // Thread.join() has some implications for Java Memory Model, etc.
660
                 if (.isAlive()) {
661
                     return getRuntime().getNil();
662
                 } else {   
663
                    return this;
664
                 }
665
             }
666
         }
667
 
668
         if (isCurrent()) {
669
             throw getRuntime().newThreadError("thread " + identityString() + " tried to join itself");
670
         }
671
 
672
         try {
673
             if (runtime.getThreadService().getCritical()) {
674
                 // If the target thread is sleeping or stopped, wake it
675
                 synchronized (this) {
676
                     notify();
677
                 }
678
                 
679
                 // interrupt the target thread in case it's blocking or waiting
680
                 // WARNING: We no longer interrupt the target thread, since this usually means
681
                 // interrupting IO and with NIO that means the channel is no longer usable.
682
                 // We either need a new way to handle waking a target thread that's waiting
683
                 // on IO, or we need to accept that we can't wake such threads and must wait
684
                 // for them to complete their operation.
685
                 //threadImpl.interrupt();
686
             }
687
 
688
             RubyThread currentThread = getRuntime().getCurrentContext().getThread();
689
             final long timeToWait = Math.min(timeoutMillis, 200);
690
 
691
             // We need this loop in order to be able to "unblock" the
692
             // join call without actually calling interrupt.
693
             long start = System.currentTimeMillis();
694
             while(true) {
695
                 currentThread.pollThreadEvents();
696
                 .join(timeToWait);
697
                 if (!.isAlive()) {
698
                     break;
699
                 }
700
                 if (System.currentTimeMillis() - start > timeoutMillis) {
701
                     break;
702
                 }
703
             }
704
         } catch (InterruptedException ie) {
705
             ie.printStackTrace();
706
             assert false : ie;
707
         } catch (ExecutionException ie) {
708
             ie.printStackTrace();
709
             assert false : ie;
710
         }
711
 
712
         if ( != null) {
713
             // Set $! in the current thread before exiting
715
             throw ;
716
         }
717
 
718
         if (.isAlive()) {
719
             return getRuntime().getNil();
720
         } else {
721
             return this;
722
         }
723
     }
724
 
725
     @JRubyMethod
726
     public IRubyObject value() {
727
         join(new IRubyObject[0]);
728
         synchronized (this) {
729
             return ;
730
         }
731
     }
732
 
733
     @JRubyMethod
734
     public IRubyObject group() {
735
         if ( == null) {
736
             return getRuntime().getNil();
737
         }
738
         
739
         return ;
740
     }
741
     
742
     void setThreadGroup(RubyThreadGroup rubyThreadGroup) {
743
          = rubyThreadGroup;
744
     }
745
     
746
     @JRubyMethod(name = "inspect")
747
     @Override
748
     public synchronized IRubyObject inspect() {
749
         // FIXME: There's some code duplication here with RubyObject#inspect
750
         StringBuilder part = new StringBuilder();
751
         String cname = getMetaClass().getRealClass().getName();
752
         part.append("#<").append(cname).append(":");
753
         part.append(identityString());
754
         part.append(' ');
755
         part.append(.toString().toLowerCase());
756
         part.append('>');
757
         return getRuntime().newString(part.toString());
758
     }
759
 
760
     @JRubyMethod(name = "key?", required = 1)
761
     public RubyBoolean key_p(IRubyObject key) {
762
         key = getSymbolKey(key);
763
         
764
         return getRuntime().newBoolean(getThreadLocals().containsKey(key));
765
     }
766
 
767
     @JRubyMethod(name = "keys")
768
     public RubyArray keys() {
769
         IRubyObject[] keys = new IRubyObject[getThreadLocals().size()];
770
         
771
         return RubyArray.newArrayNoCopy(getRuntime(), getThreadLocals().keySet().toArray(keys));
772
     }
773
     
774
     @JRubyMethod(name = "critical=", required = 1, meta = true, compat = .)
775
     public static IRubyObject critical_set(IRubyObject receiver, IRubyObject value) {
776
         receiver.getRuntime().getThreadService().setCritical(value.isTrue());
777
 
778
         return value;
779
     }
780
 
781
     @JRubyMethod(name = "critical", meta = true, compat = .)
782
     public static IRubyObject critical(IRubyObject receiver) {
783
         return receiver.getRuntime().newBoolean(receiver.getRuntime().getThreadService().getCritical());
784
     }
785
     
786
     @JRubyMethod(name = "stop", meta = true)
787
     public static IRubyObject stop(ThreadContext context, IRubyObject receiver) {
788
         RubyThread rubyThread = context.getThread();
789
         
790
         synchronized (rubyThread) {
791
             rubyThread.checkMail(context);
792
             try {
793
                 // attempt to decriticalize all if we're the critical thread
794
                 receiver.getRuntime().getThreadService().setCritical(false);
795
 
796
                 rubyThread.status.set(.);
797
                 rubyThread.wait();
798
             } catch (InterruptedException ie) {
799
                 rubyThread.checkMail(context);
800
                 rubyThread.status.set(.);
801
             }
802
         }
803
         
804
         return receiver.getRuntime().getNil();
805
     }
806
     
807
     @JRubyMethod(required = 1, meta = true)
808
     public static IRubyObject kill(IRubyObject receiver, IRubyObject rubyThread, Block block) {
809
         if (!(rubyThread instanceof RubyThread)) throw receiver.getRuntime().newTypeError(rubyThread, receiver.getRuntime().getThread());
810
         return ((RubyThread)rubyThread).kill();
811
     }
812
     
813
     @JRubyMethod(meta = true)
814
     public static IRubyObject exit(IRubyObject receiver, Block block) {
815
         RubyThread rubyThread = receiver.getRuntime().getThreadService().getCurrentContext().getThread();
816
 
817
         synchronized (rubyThread) {
818
             rubyThread.status.set(.);
819
             // FIXME: This was not checking for non-null before, but maybe it should
820
             rubyThread.mail.set(null);
821
             receiver.getRuntime().getThreadService().setCritical(false);
822
             throw new ThreadKill();
823
         }
824
     }
825
 
826
     @JRubyMethod(name = "stop?")
827
     public RubyBoolean stop_p() {
828
         // not valid for "dead" state
829
         return getRuntime().newBoolean(.get() == . || .get() == .);
830
     }
831
     
832
     @JRubyMethod(name = "wakeup")
833
     public synchronized RubyThread wakeup() {
834
         if(!.isAlive() && .get() == .) {
835
             throw getRuntime().newThreadError("killed thread");
836
         }
837
 
838
         .set(.);
839
         notifyAll();
840
 
841
         return this;
842
     }
843
     
844
     @JRubyMethod(name = "priority")
845
     public RubyFixnum priority() {
846
         return RubyFixnum.newFixnum(getRuntime(), javaPriorityToRubyPriority(.getPriority()));
847
     }
848
 
849
     @JRubyMethod(name = "priority=", required = 1)
850
     public IRubyObject priority_set(IRubyObject priority) {
851
         int iPriority = RubyNumeric.fix2int(priority);
852
         
853
         if (iPriority < ) {
854
             iPriority = ;
855
         } else if (iPriority > ) {
856
             iPriority = ;
857
         }
858
 
859
         if (.isAlive()) {
860
             int jPriority = rubyPriorityToJavaPriority(iPriority);
861
             if (jPriority < .) {
862
                 jPriority = .;
863
             } else if (jPriority > .) {
864
                 jPriority = .;
865
             }
866
             .setPriority(jPriority);
867
         }
868
 
869
         return RubyFixnum.newFixnum(getRuntime(), iPriority);
870
     }
871
      
872
     /* helper methods to translate java thread priority (1-10) to
873
      * Ruby thread priority (-3 to 3) using a quadratic polynoimal ant its
874
      * inverse
875
      * i.e., j = r^2/18 + 3*r/2 + 5
876
      *       r = 3/2*sqrt(8*j + 41) - 27/2
877
      */
878
     private int javaPriorityToRubyPriority(int javaPriority) {
879
         double d; // intermediate value
880
         d = 1.5 * Math.sqrt(8.0*javaPriority + 41) - 13.5;
881
         return Math.round((float) d);
882
     }
883
     
884
     private int rubyPriorityToJavaPriority(int rubyPriority) {
885
         double d;
886
         if (rubyPriority < ) {
887
             rubyPriority = ;
888
         } else if (rubyPriority > ) {
889
             rubyPriority = ;
890
         }
891
         d = Math.pow(rubyPriority, 2.0)/18.0 + 1.5 * rubyPriority + 5;
892
         return Math.round((float) d);
893
     }
    
    
Simplified utility method for just raising an existing exception in this thread.

Parameters:
exception the exception to raise
Returns:
this thread
901
 
902
     public IRubyObject raise(IRubyObject exception) {
903
         return raise(new IRubyObject[]{exception}, .);
904
     }
905
 
906
     @JRubyMethod(optional = 3)
907
     public IRubyObject raise(IRubyObject[] args, Block block) {
908
         Ruby runtime = getRuntime();
909
         ThreadContext context = runtime.getCurrentContext();
910
         if (this == context.getThread()) {
911
             return RubyKernel.raise(context, runtime.getKernel(), args, block);
912
         }
913
         
914
         debug(this, "before raising");
915
         RubyThread currentThread = getRuntime().getCurrentContext().getThread();
916
 
917
         debug(this, "raising");
918
         IRubyObject exception = prepareRaiseException(runtime, args, block);
919
 
920
         runtime.getThreadService().deliverEvent(new ThreadService.Event(currentThread, this, ..., exception));
921
 
922
         return this;
923
     }

    
This is intended to be used to raise exceptions in Ruby threads from non- Ruby threads like Timeout's thread.

Parameters:
args Same args as for Thread#raise
block Same as for Thread#raise
931
 
932
     public void internalRaise(IRubyObject[] args) {
933
         Ruby runtime = getRuntime();
934
 
935
         IRubyObject exception = prepareRaiseException(runtime, args, .);
936
 
937
         receiveMail(new ThreadService.Event(this, this, ..., exception));
938
     }
939
 
940
     private IRubyObject prepareRaiseException(Ruby runtime, IRubyObject[] args, Block block) {
941
         if(args.length == 0) {
942
             IRubyObject lastException = ;
943
             if(lastException.isNil()) {
944
                 return new RaiseException(runtime, runtime.getRuntimeError(), "", false).getException();
945
             } 
946
             return lastException;
947
         }
948
 
949
         IRubyObject exception;
950
         ThreadContext context = getRuntime().getCurrentContext();
951
         
952
         if(args.length == 1) {
953
             if(args[0] instanceof RubyString) {
954
                 return runtime.getRuntimeError().newInstance(context, args, block);
955
             } else if (args[0] instanceof ConcreteJavaProxy) {
956
                 return args[0];
957
             } else if(!args[0].respondsTo("exception")) {
958
                 return runtime.newTypeError("exception class/object expected").getException();
959
             }
960
             exception = args[0].callMethod(context, "exception");
961
         } else {
962
             if (!args[0].respondsTo("exception")) {
963
                 return runtime.newTypeError("exception class/object expected").getException();
964
             }
965
             
966
             exception = args[0].callMethod(context, "exception", args[1]);
967
         }
968
         
969
         if (!runtime.getException().isInstance(exception)) {
970
             return runtime.newTypeError("exception object expected").getException();
971
         }
972
         
973
         if (args.length == 3) {
974
             ((RubyException) exception).set_backtrace(args[2]);
975
         }
976
         
977
         return exception;
978
     }
979
     
980
     @JRubyMethod(name = "run")
981
     public synchronized IRubyObject run() {
982
         return wakeup();
983
     }

    
We can never be sure if a wait will finish because of a Java "spurious wakeup". So if we explicitly wakeup and we wait less than requested amount we will return false. We will return true if we sleep right amount or less than right amount via spurious wakeup. 
989
 
990
     public synchronized boolean sleep(long millis) throws InterruptedException {
991
         assert this == getRuntime().getCurrentContext().getThread();
992
         boolean result = true;
993
 
994
         synchronized (this) {
995
             pollThreadEvents();
996
             try {
997
                 .set(.);
998
                 if (millis == -1) {
999
                     wait();
1000
                } else {
1001
                    wait(millis);
1002
                }
1003
            } finally {
1004
                result = (.get() != .);
1005
                pollThreadEvents();
1006
                .set(.);
1007
            }
1008
        }
1010
        return result;
1011
    }
1013
    public IRubyObject status() {
1014
        return status(getRuntime());
1015
    }
1016
    @JRubyMethod(name = "status")
1017
    public IRubyObject status(ThreadContext context) {
1018
        return status(context.runtime);
1019
    }
1020
    
1021
    private synchronized IRubyObject status(Ruby runtime) {
1022
        if (.isAlive()) {
1023
            return RubyString.newStringShared(runtime, .get().);
1024
        } else if ( != null) {
1025
            return runtime.getNil();
1026
        } else {
1027
            return runtime.getFalse();
1028
        }
1029
    }
1031
    public static interface BlockingTask {
1032
        public void run() throws InterruptedException;
1033
        public void wakeup();
1034
    }
1036
    public static final class SleepTask implements BlockingTask {
1037
        private final Object object;
1038
        private final long millis;
1039
        private final int nanos;
1041
        public SleepTask(Object object, long millis, int nanos) {
1042
            this. = object;
1043
            this. = millis;
1044
            this. = nanos;
1045
        }
1047
        public void run() throws InterruptedException {
1048
            synchronized () {
1049
                .wait(, );
1050
            }
1051
        }
1053
        public void wakeup() {
1054
            synchronized () {
1055
                .notify();
1056
            }
1057
        }
1058
    }
1060
    public void executeBlockingTask(BlockingTask task) throws InterruptedException {
1061
        enterSleep();
1062
        try {
1063
             = task;
1064
            pollThreadEvents();
1065
            task.run();
1066
        } finally {
1067
            exitSleep();
1068
             = null;
1069
            pollThreadEvents();
1070
        }
1071
    }
1073
    public void enterSleep() {
1074
        .set(.);
1075
    }
1077
    public void exitSleep() {
1078
        .set(.);
1079
    }
1081
    @JRubyMethod(name = {"kill", "exit", "terminate"})
1082
    public IRubyObject kill() {
1083
        // need to reexamine this
1084
        RubyThread currentThread = getRuntime().getCurrentContext().getThread();
1085
        
1086
        // If the killee thread is the same as the killer thread, just die
1087
        if (currentThread == this) throwThreadKill();
1089
        debug(this, "trying to kill");
1091
        currentThread.pollThreadEvents();
1092
        
1093
        getRuntime().getThreadService().deliverEvent(new ThreadService.Event(currentThread, this, ...));
1095
        debug(this, "succeeded with kill");
1096
        
1097
        return this;
1098
    }
    
    
Used for finalizers that need to kill a Ruby thread. Finalizers run in a VM thread to which we do not want to attach a ThreadContext and within which we do not want to check for Ruby thread events. This mechanism goes directly to mail delivery, bypassing all Ruby Thread-related steps. 
1106
    public void dieFromFinalizer() {
1107
        receiveMail(new ThreadService.Event(null, this, ...));
1108
    }
1110
    private static void debug(RubyThread thread, String message) {
1111
        if () .debug(Thread.currentThread() + "(" + thread.status + "): " + message);
1112
    }
1113
    
1114
    @JRubyMethod(name = {"kill!", "exit!", "terminate!"}, compat =