Wielowątkowość JavaScript

Zastanawiam się - jak inaczej można osiągnąć wielowątkowość w JavaScript? Jakieś inne ważne metody?

Możesz przekształcić swój kod w kod JavaScript, który nie ma żadnych jawnych pętli ani bezpośrednich wywołań funkcji, zamiast tego kod jest podzielony na małe jednostki wykonania, które są zarządzane przez silnik wątków. W moim przykładowym kodzie pokazuję jak funkcja z pętlami byłaby przekształcana, ale pominąłem mechanizm wywoływania funkcji tylko po to, aby zachować przykład prosty.

Proces transformacji zasadniczo działa przez dzielenie kodu w punktach podziału. Te punkty podziału są wywołaniami funkcji i pętlami (jak pokazano powyżej). W przykładzie użyłem obiektów i kluczy, ale może być znacznie łatwiejsze w silnikach JavaScript przeglądarki, jeśli jednostki przechowują stos jako zmienną obiektową (tzn. przechowują za pomocą this.foo = bar zamiast stack["foo"] = bar).

Na przykład następujący kod:

// Phoney method purely to demonstrate structure
function Foo() {
  var i,
      sum = 0,
      accumulator_list = [],
      accumulator_modulus = [],
      kMaxAccumulatorCount = 100;

  // Calculate accumulations
  for(i = 0; i < kMaxAccumulatorCount; ++i) {
    current_accumulator = GetNextAccumulator()
    accumulator_list[i] = current_accumulator;
    sum = sum + current_accumulator;
  }

  // Calculate accumulator modulus
  for(i = 0; i < kMaxAccumulatorCount; ++i) {
    current_accumulator = accumulator_list[i];
    accumulator_modulus[i] = current_accumulator % kMaxAccumulatorCount;
  }
}

... do coś takiego:

function Foo_A(caller,stack) {
  var stack = {};
  stack["i"] = undefined;
  stack["sum"] = 0;
  stack["accumulator_list"] = [];
  stack["accumulator_modulus"] = [];
  stack["kMaxAccumulatorCount"] = 100;

  stack["i"] = 0;
  return {caller: caller, stack: stack, next=Foo_B};
}

function Foo_B(caller, stack) {
  stack["current_accumulator"] = GetNextAccumulator();
  stack["accumulator_list"][stack["i"]] = stack["current_accumulator"];
  stack["sum"] = stack["sum"] + stack["current_accumulator"];

  // For-loop condition satisfied ?
  if(stack["i"] < stack["kMaxAccumulatorCount"]) {
    ++stack["i"];
    return {caller: caller, stack: stack, next:Foo_B};
  } else {
    // Initialise the next for loop.
    stack["i"] = 0;
    return {caller: caller, stack: stack, next:Foo_C};
  }
}

function Foo_C(caller, stack) {
  stack["current_accumulator"] = stack["current_accumulator"][stack["i"]];
  stack["accumulator_modulus"][stack["i"]] = stack["current_accumulator"] % stack["kMaxAccumulatorCount"];

  // For-loop condition satisfied ?
  if(stack["i"] < stack["kMaxAccumulatorCount"]) {
    ++stack["i"];
    return {caller: caller, stack: stack, next:Foo_C};
  } else {
    // Function has finished so the next will be null. When the thread-engine sees this it simulates the behaviour of a return, pops its virtual stack and returns execution to the caller
    return {caller: caller, stack: stack, next:null};
  }
}

Multithread.js jest biblioteką do naprawdę łatwego wielowątkowości w JS, która owija pracowników sieci i wykonuje większość twojej pracy za Ciebie. :)

Nie ma bezpośredniego wsparcia dla wielowątkowości w JavaScript. Jednak można to osiągnąć, stosując kilka pomysłów i metod.

Istnieją metody takie jak:

var id = window.timeout("javascript code", time);

Tutaj kod JavaScript jest wywoływany po określonym czasie i możemy użyć

window.clearTimeout(id);

Do oczyszczenia. Dzięki temu możemy osiągnąć fałszywą współbieżność.

Q: jak inaczej można osiągnąć współbieżność w Javascript

Możesz używać metod typu async lub 'non-blocking'. To ma jeden z głównych brzęczy o węźle.js system. Nie jest do końca wielowątkowy, ale zazwyczaj jest szybszy.