Connection

此类用于执行位于模块上的远程方法，这些模块通过 workers framework 加载到单独的线程中。

workers.open() 方法可加载脚本并向主线程返回 Promise。解析后，您可以访问 Connection 的实例，该实例允许您通过 invoke() 或 broadcast() 方法调用模块的方法。

调用远程方法

若要将工作委托给 worker，则需要创建一个公开函数的模块或将由框架进行实例化的类。每个远程方法只能接受一个参数。参数值可以是任何基元类型，也可以是由结构化克隆算法处理的 JavaScript 对象，或是使用其中一个基元类型解析的 JavaScript Promise。

例如，让我们创建一个简单的 worker 来计算数字数组的总和。

// Module loaded in worker : calculator.js
export function getSum(numbers) {
  let sum = 0;

  for (let i = 0; i < numbers.length; i++) {
    sum += numbers[i];
  }

  return sum;
}

现在，我们将计算器模块加载到一个 worker 中并调用其 getSum 函数。

// Module loaded in main thread
export function getSumAsync(numbers) {
  let connection = null;

  return workers.open("./calculator.js")
    .then(function(conn) {
      // Keep the connection reference to later close it.
      connection = conn;

      return connection.invoke("getSum", numbers);
    })
    .then(function(result) {
      // close the connection
      connection.close();
      connection = null;

      return result;
    });
}

// Invoke our method.
getSumAsync([0, 2, 4, 6, 8])
  .then(function(result) {
    console.log("Result:", result);
  });

传递多个参数

如上所述，使用 worker 加载的远程方法只能接受一个参数。但是，要将多个参数传递给远程方法，请使用具有多个密钥值对的 JavaScript 对象。

下面的示例显示了一个函数，该函数将数字数组乘以一个因子。

// Module loaded in worker : calculator.js
export function mapMultiply(params) {
  // params has numbers and factor values.
  let numbers = params.numbers;
  let factor = params.factor;

  for (let i = 0; i < numbers.length; i++) {
    numbers[i] *= factor;
  }

  return numbers;
}

若要调用此函数，需要将具有两个属性的对象传递到函数中。

// Module loaded in main thread
export function mapMultiplyAsync(numbers, factor) {
  let connection = null;

  return workers.open("./calculator.js")
    .then(function(conn) {
      // Keep the connection reference to later close it.
      connection = conn;

       // invoke mapMultiply and pass in object with two key-value pairs.
      return connection.invoke("mapMultiply", {
        numbers: numbers,
        factor: factor
      });
    })
    .then(function(result) {
      // close the connection after we are done.
      connection.close();
      connection = null;

      return result;
    });
}

// Invoke the method.
mapMultiplyAsync([0, 2, 4, 6, 8], 2)
  .then(function(result) {
    console.log("Result:", result);
  });

使用 transferables

Transferable 对象可用于在主线程和 worker 线程之间传输数据，以避免复制数据。使用此方法，对象的所有权将转移到其他上下文。使用此技术可使用 ArrayBuffers、MessagePort 或 ImageBitmap 传输大量内存。

要将对象传输给 worker，请使用 invoke() 方法的 transferList 参数。对于使用 transferable 对象返回或解析的远程方法，返回的结果必须具有两个属性：result 和 transferList。result 是一个对象，而 transferList 是 transferable 对象数组。请注意，transferList 中的每个 transferable 对象都应在 result 的对象结构中。

让我们重温前面的示例以探索 transferable 对象。

// Module loaded in worker : calculator.js
export function mapMultiplyFloat64(params) {
  // the numbers parameter is an ArrayBuffer
  // we create a typed array from it.
  let numbers = new Float64Array(params.numbers);
  let factor = params.factor;

  for (let i = 0; i < numbers.length; i++) {
    numbers[i] *= factor;
  }

  // Transfer back the buffer
  return {
    result: numbers.buffer,
    transferList: [numbers.buffer]
  };
}

在主线程上，我们传输输入类型化数组的缓冲区。然后，我们从返回的缓冲区重新创建 Float64Array。

// Module loaded in main thread
export function mapMultiplyFloat64Async(numbers, factor) {
  let connection = null;

  return workers.open("./calculator.js")
    .then(function(conn) {
      // Keep the connection reference to later close it.
      connection = conn;

      return connection.invoke("mapMultiplyFloat64", {
        numbers: numbers,
        factor: factor
      });
    })
    .then(function(result) {
      // close the connection after we are done.
      connection.close();
      connection = null;

      return result;
    });
}

// Invoke our method.
let floats = new Float64Array(5);
floats[0] = 0;
floats[1] = 2;
floats[2] = 4;
floats[3] = 6;
floats[4] = 8;
mapMultiplyFloat64Async(floats, 2)
  .then(function(result) {
    let resultFloats = new Float64Array(result);
    console.log("Result:", resultFloats);
  });