class Thread::Mutex

Родитель:: Объект

Thread::Mutex реализует простой семафор, который можно использовать для координации доступа к общим данным из нескольких потоков.

Пример:

semaphore = Thread::Mutex.new

a = Thread.new {
  semaphore.synchronize {
    # access shared resource
  }
}

b = Thread.new {
  semaphore.synchronize {
    # access shared resource
  }
}

Публичные методы класса

Thread::Mutex.new → mutex

Исходный код

static VALUE
mutex_initialize(VALUE self)
{
    return self;
}

Создает новый Mutex

Публичные методы экземпляра

lock → self

Исходный код

VALUE
rb_mutex_lock(VALUE self)
{
    return do_mutex_lock(self, 1);
}

Попытка захватить блокировку, ожидая, если она недоступна. Вызывает ThreadError, если блокировка была захвачена текущим потоком.

locked? → true или false

Исходный код

VALUE
rb_mutex_locked_p(VALUE self)
{
    rb_mutex_t *mutex = mutex_ptr(self);

    return RBOOL(mutex->fiber);
}

Возвращает true, если эта блокировка в данный момент удерживается каким-то потоком.

owned? → true или false

Исходный код

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);
}

Возвращает true, если эта блокировка в данный момент удерживается текущим потоком.

sleep(timeout = nil) → число или nil

Исходный код

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);
}

Освобождает блокировку и засыпает на timeout секунд, если задано и не равно nil, или навсегда. Вызывает ThreadError, если блокировка не была захвачена текущим потоком.

Когда поток снова проснется, он попытается повторно захватить блокировку.

Обратите внимание, что этот метод может проснуться без явного вызова Thread#wakeup. Например, при получении сигнала и т. д.

Возвращает время сна в секундах, если проснулся, или nil при истечении времени.

synchronize { ... } → результат выполнения блока

Исходный код

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);
}

Получает блокировку, выполняет блок и освобождает блокировку по завершении блока. См. пример в разделе Thread::Mutex.

try_lock → true или false

Исходный код

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;
    }
}

Попытка получить блокировку и немедленное возвращение. Возвращает true, если блокировка получена.

unlock → self

Исходный код

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;
}

Освобождает блокировку. Вызывает ThreadError, если блокировка не была захвачена текущим потоком.

Ruby Core © 1993–2024 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.