Je me demande comment on peut réaliser le multithreading en JavaScript ? D'autres méthodes importantes ?
Vous pouvez faire transformer votre code en un code JavaScript qui ne comporte pas de boucles explicites ni d'appels directs de fonctions, mais qui est divisé en petites parties. unités d'exécution qui sont gérés par un moteur de threads. Dans mon exemple de code, je montre comment une fonction avec des boucles serait transformée, mais j'ai omis le mécanisme d'appel de fonction pour garder l'exemple simple.
Le processus de transformation fonctionne essentiellement comme suit fendant aux points de division. Ces points de division sont des appels de fonction et des boucles (comme démontré ci-dessus). Dans l'exemple, j'ai utilisé des objets et des clés, mais les moteurs JavaScript du navigateur seront plus faciles à utiliser si l'option unités stocké le pile en tant que variable objet (c'est-à-dire en stockant en utilisant la fonction this.foo = bar au lieu de stack["foo"] = bar ).
Par exemple, le code suivant :
// 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;
}
}
... en quelque chose comme ça :
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};
}
}
