How to use the threads.spawn function in threads

err.message);
      }
      broadcast.isLoading = false;
      skipSong(broadcast);
    });

    // Spawn thread for starting audio stream.
    const input = {
      song: broadcast.current.song,
      special: special,
      ytdlOpts: ytdlOpts,
    };
    if (broadcast.current.info) {
      input.song = broadcast.current.info.url;
    }
    broadcast.current.thread = spawn(startStream);
    broadcast.current.thread.send(input);
    broadcast.current.thread.on('progress', function(data) {
      if (data.ytdlinfo) {
        broadcast.current.oninfo(data.ytdlinfo);
        return;
      }
      if (data.data) data.data = Buffer.from(data.data);
      broadcast.current.readable.push(data.data);
    });
    broadcast.current.thread.on('done', function() {
      broadcast.current.thread.kill();
    });
    broadcast.current.thread.on('error', function(err) {
      self.error('Error in thread: ' + broadcast.current.song);
      console.log(err);
      if (broadcast.current.request) {

export async function fetchAllAssets(testnet: boolean): Promise {
  const storageKey = testnet ? "known-assets:testnet" : "known-assets:mainnet"

  const cachedAssetsString = localStorage.getItem(storageKey)
  const timestamp = localStorage.getItem("known-assets:timestamp")

  if (cachedAssetsString && timestamp && +timestamp > Date.now() - 24 * 60 * 60 * 1000) {
    // use cached assets if they are not older than 24h
    return JSON.parse(cachedAssetsString)
  } else {
    const fetcher = await spawn(new Worker("../workers/fetch-worker.ts"))
    const allAssets = await fetcher.fetchAllAssets(testnet)
    await Thread.terminate(fetcher)

    localStorage.setItem(storageKey, JSON.stringify(allAssets))
    localStorage.setItem("known-assets:timestamp", Date.now().toString())

    return allAssets
  }
}

'use strict';

const fs = require('fs');
const Log = require('log');
const settings = require('config');
const spawn = require('threads').spawn;
const stats = require('stats-lite');
const sprintf = require('sprintf-js').sprintf;
const terminal = spawn('./lib/terminal.js');
const threads = require('threads');

if (settings.get('general.log')) {
	var log = new Log(settings.get('general.log_level'), fs.createWriteStream('GDAX.log'));
} else {
	let dev_null = (process.platform === 'win32') ? 'nul' : '/dev/null'
	var log = new Log(settings.get('general.log_level'), fs.createWriteStream(dev_null));
}

var terminal_data = {
	account: {
	// 	timestamp: new Date,
	// 	profile_id: 'e316cb9a-TEMP-FAKE-DATA-97829c1925de',
	// 	id: '343bb963-TEMP-FAKE-DATA-8b562d2f7a4e',
	// 	account: {
	// 		id: "a1b2c3d4",

function spawnThread(inputCallback: Function, threadCallback: Function, timeoutCallback: Function): void {
    const thread = spawn((input: string, postMessage: Function) => {
        postMessage(eval(input));
    });

    const timeout = setTimeout(() => {
        thread.kill();
        timeoutCallback();
    }, 1500);

    thread
        .send(inputCallback())
        .on('message', (response: number) => {
            clearTimeout(timeout);
            thread.kill();
            threadCallback(response);
        });
}

constructor(dataConfig) {
    this.dataConfig = dataConfig;
    this.uid = slugid.nice();

    this.worker = spawn(
      new Worker('./bam-fetcher-worker.js')
    );

    this.initPromise = this.worker.then((tileFunctions) => {
      console.log('tileFunctions:', tileFunctions);
    
      return tileFunctions.init(
        this.uid, dataConfig.url, dataConfig.chromSizesUrl
      ).then(() => this.worker);
    });

    console.log('constructor');
  }

'use strict'

const axios = require('axios')
const container = require('@arkecosystem/core-container')
const logger = container.resolvePlugin('logger')
const config = container.resolvePlugin('config')
const threads = require('threads')
const thread = threads.spawn(`${__dirname}/workers/download.js`)

module.exports = class Peer {
  /**
   * @constructor
   * @param  {String} ip
   * @param  {Number} port
   * @param  {Object} config
   */
  constructor (ip, port, config) {
    this.ip = ip
    this.port = port
    this.ban = new Date().getTime()
    this.url = (port % 443 === 0 ? 'https://' : 'http://') + `${ip}:${port}`
    this.state = {}
    this.headers = {
      version: config.server.version,

function spawnNetWorker() {
  window.addEventListener("message", event => {
    if (event.data && ["app:pause", "app:resume"].indexOf(event.data) > -1) {
      netWorker.postMessage(event.data)
    }
  })

  return spawn(netWorker)
}

function open_websocket() {
	websocket = spawn('./lib/websocket.js');

	websocket
		.on('message', function (message) {
			log.info(process.pid, 'websocket message', message.action, message);

			switch (message.action) {
				case 'getAccounts':
					if (message.data && message.data.message) {
						log.error(process.pid, message.action, message.data.message);
					} else if (message.data)
					{
						if (terminal_data.account === undefined)
						{
							terminal_data.account = {};
						}
						terminal_data.account.timestamp = message.timestamp;

return new Promise(resolve => {
        var thread = spawn('./server/workers/graphLayoutWorker.js')
        .send(data)
        .on('message', (res) => resolve(res))
        .on('done', () => thread.kill());
    });
}