Class: Thread::Mutex
Relationships & Source Files | |
Inherits: | Object |
Defined in: | thread_sync.c, thread_sync.c |
Overview
Mutex
implements a simple semaphore that can be used to coordinate access to shared data from multiple concurrent threads.
Example:
semaphore = Thread::Mutex.new
a = Thread.new {
semaphore.synchronize {
# access shared resource
}
}
b = Thread.new {
semaphore.synchronize {
# access shared resource
}
}
Class Method Summary
-
.new ⇒ Mutex
constructor
Creates a new
Mutex
.
Instance Attribute Summary
-
#locked? ⇒ Boolean
readonly
Returns
true
if this lock is currently held by some thread. -
#owned? ⇒ Boolean
readonly
Returns
true
if this lock is currently held by current thread.
Instance Method Summary
-
#lock ⇒ self
Attempts to grab the lock and waits if it isn’t available.
-
#sleep(timeout = nil) ⇒ Numeric?
Releases the lock and sleeps
timeout
seconds if it is given and non-nil or forever. -
#synchronize ⇒ result of the block
Obtains a lock, runs the block, and releases the lock when the block completes.
-
#try_lock ⇒ Boolean
Attempts to obtain the lock and returns immediately.
-
#unlock ⇒ self
Releases the lock.
Constructor Details
.new ⇒ Mutex
Creates a new Mutex
# File 'thread_sync.c', line 184
static VALUE mutex_initialize(VALUE self) { return self; }
Instance Attribute Details
#locked? ⇒ Boolean
(readonly)
Returns true
if this lock is currently held by some thread.
# File 'thread_sync.c', line 202
VALUE rb_mutex_locked_p(VALUE self) { rb_mutex_t *mutex = mutex_ptr(self); return RBOOL(mutex->fiber); }
#owned? ⇒ Boolean
(readonly)
Returns true
if this lock is currently held by current thread.
# File 'thread_sync.c', line 443
VALUE rb_mutex_owned_p(VALUE self) { rb_fiber_t *fiber = GET_EC()->fiber_ptr; rb_mutex_t *mutex = mutex_ptr(self); return mutex_owned_p(fiber, mutex); }
Instance Method Details
#lock ⇒ self
Attempts to grab the lock and waits if it isn’t available. Raises ::ThreadError
if mutex
was locked by the current thread.
# File 'thread_sync.c', line 431
VALUE rb_mutex_lock(VALUE self) { return do_mutex_lock(self, 1); }
#sleep(timeout = nil) ⇒ Numeric?
Releases the lock and sleeps timeout
seconds if it is given and non-nil or forever. Raises ::ThreadError
if mutex
wasn’t locked by the current thread.
When the thread is next woken up, it will attempt to reacquire the lock.
Note that this method can wakeup without explicit Thread#wakeup call. For example, receiving signal and so on.
Returns the slept time in seconds if woken up, or nil
if timed out.
# File 'thread_sync.c', line 616
static VALUE mutex_sleep(int argc, VALUE *argv, VALUE self) { VALUE timeout; timeout = rb_check_arity(argc, 0, 1) ? argv[0] : Qnil; return rb_mutex_sleep(self, timeout); }
#synchronize ⇒ result
of
the
block
Obtains a lock, runs the block, and releases the lock when the block completes. See the example under Mutex
.
# File 'thread_sync.c', line 647
static VALUE rb_mutex_synchronize_m(VALUE self) { if (!rb_block_given_p()) { rb_raise(rb_eThreadError, "must be called with a block"); } return rb_mutex_synchronize(self, rb_yield, Qundef); }
#try_lock ⇒ Boolean
Attempts to obtain the lock and returns immediately. Returns true
if the lock was granted.
# File 'thread_sync.c', line 251
VALUE rb_mutex_trylock(VALUE self) { rb_mutex_t *mutex = mutex_ptr(self); if (mutex->fiber == 0) { RUBY_DEBUG_LOG("%p ok", mutex); rb_fiber_t *fiber = GET_EC()->fiber_ptr; rb_thread_t *th = GET_THREAD(); mutex->fiber = fiber; mutex_locked(th, self); return Qtrue; } else { RUBY_DEBUG_LOG("%p ng", mutex); return Qfalse; } }
#unlock ⇒ self
Releases the lock. Raises ::ThreadError
if mutex
wasn’t locked by the current thread.
# File 'thread_sync.c', line 504
VALUE rb_mutex_unlock(VALUE self) { const char *err; rb_mutex_t *mutex = mutex_ptr(self); rb_thread_t *th = GET_THREAD(); err = rb_mutex_unlock_th(mutex, th, GET_EC()->fiber_ptr); if (err) rb_raise(rb_eThreadError, "%s", err); return self; }