< prev index next >

src/hotspot/share/runtime/thread.hpp

Concurrent class unloading

259 
260     _external_suspend       = 0x20000000U, // thread is asked to self suspend                                                        
261     _ext_suspended          = 0x40000000U, // thread has self-suspended                                                              
262     _deopt_suspend          = 0x10000000U, // thread needs to self suspend for deopt                                                 
263 
264     _has_async_exception    = 0x00000001U, // there is a pending async exception                                                     
265     _critical_native_unlock = 0x00000002U, // Must call back to unlock JNI critical lock                                             
266 
267     _trace_flag             = 0x00000004U  // call tracing backend                                                                   
268   };                                                                                                                                 
269 
270   // various suspension related flags - atomically updated                                                                           
271   // overloaded for async exception checking in check_special_condition_for_native_trans.                                            
272   volatile uint32_t _suspend_flags;                                                                                                  
273 
274  private:                                                                                                                            
275   int _num_nested_signal;                                                                                                            
276 
277   DEBUG_ONLY(bool _suspendible_thread;)                                                                                              
278 
                                                                                                                                     
                                                                                                                                     
                                                                                                                                     
                                                                                                                                     
                                                                                                                                     
                                                                                                                                     
279  public:                                                                                                                             
280   void enter_signal_handler() { _num_nested_signal++; }                                                                              
281   void leave_signal_handler() { _num_nested_signal--; }                                                                              
282   bool is_inside_signal_handler() const { return _num_nested_signal > 0; }                                                           
283 
284 #ifdef ASSERT                                                                                                                        
285   void set_suspendible_thread() {                                                                                                    
286     _suspendible_thread = true;                                                                                                      
287   }                                                                                                                                  
288 
289   void clear_suspendible_thread() {                                                                                                  
290     _suspendible_thread = false;                                                                                                     
291   }                                                                                                                                  
292 
293   bool is_suspendible_thread() { return _suspendible_thread; }                                                                       
294 #endif                                                                                                                               
295 
296  private:                                                                                                                            
297   // Active_handles points to a block of handles                                                                                     

259 
260     _external_suspend       = 0x20000000U, // thread is asked to self suspend
261     _ext_suspended          = 0x40000000U, // thread has self-suspended
262     _deopt_suspend          = 0x10000000U, // thread needs to self suspend for deopt
263 
264     _has_async_exception    = 0x00000001U, // there is a pending async exception
265     _critical_native_unlock = 0x00000002U, // Must call back to unlock JNI critical lock
266 
267     _trace_flag             = 0x00000004U  // call tracing backend
268   };
269 
270   // various suspension related flags - atomically updated
271   // overloaded for async exception checking in check_special_condition_for_native_trans.
272   volatile uint32_t _suspend_flags;
273 
274  private:
275   int _num_nested_signal;
276 
277   DEBUG_ONLY(bool _suspendible_thread;)
278 
279   bool                  _in_nmethod_entry_barrier;
280 
281 public:
282   bool in_nmethod_entry_barrier() const { return _in_nmethod_entry_barrier; }
283   void set_is_in_nmethod_entry_barrier(bool value) { _in_nmethod_entry_barrier = value; }
284 
285  public:
286   void enter_signal_handler() { _num_nested_signal++; }
287   void leave_signal_handler() { _num_nested_signal--; }
288   bool is_inside_signal_handler() const { return _num_nested_signal > 0; }
289 
290 #ifdef ASSERT
291   void set_suspendible_thread() {
292     _suspendible_thread = true;
293   }
294 
295   void clear_suspendible_thread() {
296     _suspendible_thread = false;
297   }
298 
299   bool is_suspendible_thread() { return _suspendible_thread; }
300 #endif
301 
302  private:
303   // Active_handles points to a block of handles
< prev index next >