Struct napi::threadsafe_function::ThreadsafeFunction

pub struct ThreadsafeFunction<T: 'static, ES: T = CalleeHandled> { /* 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.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, ES: T> ThreadsafeFunction<T, ES>

pub fn create<V: NapiRaw, 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 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 raw(&self) -> napi_threadsafe_function

Get the raw ThreadSafeFunction pointer

impl<T: 'static> ThreadsafeFunction<T, CalleeHandled>

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

See napi_call_threadsafe_function for more information.

impl<T: 'static> ThreadsafeFunction<T, Fatal>

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

See napi_call_threadsafe_function for more information.

Trait Implementations

impl<T: 'static, ES: T> Clone for ThreadsafeFunction<T, ES>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

fn drop(&mut self)

Executes the destructor for this type.

impl<T, ES: T> Send for ThreadsafeFunction<T, ES>

impl<T, ES: T> Sync for ThreadsafeFunction<T, ES>