Struct Thread

pub struct Thread { /* private fields */ }

Thread

Implementations

impl Thread

pub fn new<F, R>(func: F) -> Self

where F: FnOnce() -> R, R: Object,

Creates a new green thread.

The returning value of the closure will be available as #value of the thread

Examples

use ruru::{Fixnum, Thread, VM};

Thread::new(|| {
    let computation_result = 1 + 2;

    Fixnum::new(computation_result)
});

Ruby:

Thread.new do
  computation_result = 1 + 2

  computation_result
end

pub fn wait_fd(fd: RawFd)

Tells scheduler to switch to other threads while current thread is waiting for a readable event on the given file descriptor.

Examples

use std::os::unix::io::AsRawFd;
use std::os::unix::net::UnixStream;

use ruru::{Thread, VM};

let (unix_socket, _) = UnixStream::pair().unwrap();

Thread::wait_fd(unix_socket.as_raw_fd());

pub fn call_without_gvl<F, R, G>(func: F, unblock_func: Option<G>) -> R

where F: FnOnce() -> R, G: FnOnce(),

Release GVL for current thread.

Warning! Due to MRI limitations, interaction with Ruby objects is not allowed while GVL is released, it may cause unexpected behaviour. Read more at Ruby documentation

You should extract all the information from Ruby world before invoking thread_call_without_gvl.

GVL will be re-acquired when the closure is finished.

Examples

#[macro_use] extern crate ruru;

use ruru::{Class, Fixnum, Object, Thread};

class!(Calculator);

methods!(
    Calculator,
    itself,

    fn heavy_computation() -> Fixnum {
        let computation = || { 2 * 2 };
        let unblocking_function = || {};

        // release GVL for current thread until `computation` is completed
        let result = Thread::call_without_gvl(
            computation,
            Some(unblocking_function)
        );

        // GVL is re-acquired, we can interact with Ruby-world
        Fixnum::new(result)
    }
);

fn main() {
    Class::new("Calculator", None).define(|itself| {
        itself.def("heavy_computation", heavy_computation);
    });
}

pub fn call_without_gvl2<F, R, G>(func: F, unblock_func: Option<G>) -> R

where F: FnOnce() -> R, G: FnOnce(),

pub fn call_with_gvl<F, R>(func: F) -> R

where F: FnOnce() -> R,

Trait Implementations

impl Debug for Thread

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Value> for Thread

fn from(value: Value) -> Self

Converts to this type from the input type.

impl Object for Thread

fn value(&self) -> Value

Returns internal value of current object.

fn class(&self) -> Class

Returns a class of current object.

fn singleton_class(&self) -> Class

Returns a singleton class of current object.

fn get_data<'a, T>(&'a self, wrapper: &'a dyn DataTypeWrapper<T>) -> &mut T

Gets a Rust structure that is wrapped into a Ruby object.

fn define<F: Fn(&mut Self)>(&mut self, f: F) -> &Self

Wraps calls to the object.

fn define_method<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O>, )

Defines an instance method for the given class or object.

fn define_singleton_method<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O>, )

Defines a class method for given class or singleton method for object.

fn def<I: Object, O: Object>(&mut self, name: &str, callback: Callback<I, O>)

An alias for define_method (similar to Ruby syntax def some_method).

fn def_self<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O>, )

An alias for define_singleton_method (similar to Ruby def self.some_method).

fn send(&self, method: &str, arguments: Vec<AnyObject>) -> AnyObject

Calls a given method on an object similarly to Ruby Object#send method

fn respond_to(&self, method: &str) -> bool

Checks whether the object responds to given method

fn is_nil(&self) -> bool

Checks whether the object is nil

fn to_any_object(&self) -> AnyObject

Converts struct to AnyObject

fn instance_variable_get(&self, variable: &str) -> AnyObject

Gets an instance variable of object

fn instance_variable_set<T: Object>( &mut self, variable: &str, value: T, ) -> AnyObject

Sets an instance variable for object

fn is_frozen(&self) -> bool

Returns the freeze status of the object.

fn freeze(&mut self) -> Self

Prevents further modifications to the object.

unsafe fn to<T: Object>(&self) -> T

Unsafely casts current object to the specified Ruby type

fn try_convert_to<T: VerifiedObject>(&self) -> Result<T>

Safely casts current object to the specified Ruby type

fn ty(&self) -> ValueType

Determines the value type of the object

impl PartialEq for Thread

fn eq(&self, other: &Thread) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl VerifiedObject for Thread

fn is_correct_type<T: Object>(object: &T) -> bool

fn error_message() -> &'static str

impl StructuralPartialEq for Thread