Struct napi::threadsafe_function::ThreadsafeFunction

pub struct ThreadsafeFunction<T: 'static> { /* fields omitted */ }

Communicate with the addon's main thread by invoking a JavaScript function from other threads.

Example

An example of using ThreadsafeFunction:

#[macro_use]
extern crate napi_derive;

use std::thread;

use napi::{
    threadsafe_function::{
        ThreadSafeCallContext, ThreadsafeFunctionCallMode, ThreadsafeFunctionReleaseMode,
    },
    CallContext, Error, JsFunction, JsNumber, JsUndefined, Result, Status,
};

#[js_function(1)]
pub fn test_threadsafe_function(ctx: CallContext) -> Result<JsUndefined> {
  let func = ctx.get::<JsFunction>(0)?;

  let tsfn =
      ctx
          .env
          .create_threadsafe_function(&func, 0, |ctx: ThreadSafeCallContext<Vec<u32>>| {
            ctx.value
                .iter()
                .map(|v| ctx.env.create_uint32(*v))
                .collect::<Result<Vec<JsNumber>>>()
          })?;

  let tsfn_cloned = tsfn.try_clone()?;

  thread::spawn(move || {
      let output: Vec<u32> = vec![0, 1, 2, 3];
      // It's okay to call a threadsafe function multiple times.
      tsfn.call(Ok(output.clone()), ThreadsafeFunctionCallMode::Blocking);
  });

  thread::spawn(move || {
      let output: Vec<u32> = vec![3, 2, 1, 0];
      // It's okay to call a threadsafe function multiple times.
      tsfn_cloned.call(Ok(output.clone()), ThreadsafeFunctionCallMode::NonBlocking);
  });

  ctx.env.get_undefined()
}

Implementations

impl<T: 'static> ThreadsafeFunction<T>

pub fn create<V: NapiValue, R: 'static + Send + FnMut(ThreadSafeCallContext<T>) -> Result<Vec<V>>>(
    env: napi_env,
    func: &JsFunction,
    max_queue_size: usize,
    callback: R
) -> Result<Self>

See napi_create_threadsafe_function for more information.

pub fn call(&self, value: Result<T>, mode: ThreadsafeFunctionCallMode) -> Status

See napi_call_threadsafe_function for more information.

pub fn refer(&mut self, env: &Env) -> Result<()>

See napi_ref_threadsafe_function for more information.

"ref" is a keyword so that we use "refer" here.

pub fn unref(&mut self, env: &Env) -> Result<()>

See napi_unref_threadsafe_function for more information.

pub fn aborted(&self) -> bool

pub fn abort(self) -> Result<()>

pub fn try_clone(&self) -> Result<Self>

pub fn raw(&self) -> napi_threadsafe_function

Get the raw ThreadSafeFunction pointer

Trait Implementations

impl<T: 'static> Drop for ThreadsafeFunction<T>

pub fn drop(&mut self)

Executes the destructor for this type.

impl<T> Send for ThreadsafeFunction<T>

impl<T> Sync for ThreadsafeFunction<T>