javascript - threads - web workers chrome

Multiprocesamiento de JavaScript

Question

Estoy trabajando en la comparación de varios métodos diferentes de implementación (multihilo real o falso) en JavaScript. Por lo que sé, solo los webworkers y Google Gears WorkerPool pueden darte hilos reales (es decir, distribuidos en múltiples procesadores con ejecución paralela real). He encontrado los siguientes métodos:

• cambiar entre tareas usando yield()

• use setInterval() (u otra función que no sea de bloqueo) con hilos esperando uno por otro

• utilizar los hilos de Google Worker WorkerPool (con un complemento)

• utilizar trabajadores web html5

Leí preguntas relacionadas y encontré varias variaciones de los métodos anteriores, pero la mayoría de esas preguntas son antiguas, por lo que podría haber algunas ideas nuevas.

Me pregunto, ¿de qué otra manera puedes lograr multihilo en JavaScript? ¿Algún otro método importante?

ACTUALIZACIÓN: Como se señaló en los comentarios, lo que realmente quise decir fue concurrencia.

ACTUALIZACIÓN 2: encontré información de que Silverlight + JScript es compatible con múltiples subprocesos, pero no puedo verificar esto.

ACTUALIZACIÓN 3: Gears desaprobados de Google: http://code.google.com/apis/gears/api_workerpool.html

Answer 1

Me pregunto, ¿de qué otra manera puedes lograr multihilo en JavaScript? ¿Algún otro método importante?

Puede hacer que su código se transforme en código JavaScript que no tenga ningún bucle explícito o llamadas a funciones directas, en cambio el código se divide en pequeñas unidades de ejecución que son administradas por un motor de subprocesamiento. En mi código de ejemplo, muestro cómo se transformaría una función con bucles pero he omitido el mecanismo para llamadas a funciones solo para mantener el ejemplo simple.

El proceso de transformación básicamente funciona dividiendo el código en puntos de división. Estos puntos de división son llamadas de función y bucles (como se demostró anteriormente). En el ejemplo, he usado objetos y claves, pero puede ser mucho más fácil en los motores de JavaScript del navegador si las unidades almacenan la pila como una variable de objeto (es decir, almacenar usando this.foo = bar lugar de stack["foo"] = bar )

Por ejemplo, el siguiente código:

// 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 algo como esto:

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};
}
}

Answer 2

No hay soporte directo para multihilo en JavaScript. Sin embargo, puede lograrlo aplicando algunas ideas y métodos.

Hay métodos como:

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

aquí se llama el código JavaScript después de la hora especificada y podemos usar

window.clearTimeout(id);

para limpiar Por esto podemos lograr simultaneidad falsa.

Answer 3

P: ¿De qué otra forma puedes lograr la concurrencia en Javascript?

Puede usar métodos de tipo asincrónico o ''no bloqueante''. Esto tiene uno de los mayores zumbidos sobre el sistema node.js. No es exactamente multiproceso, pero tiende a ser más rápido.

Answer 4

Multithread.js es una biblioteca para multihilo muy fácil en JS que envuelve a los trabajadores de la Web y hace la mayor parte de su trabajo por usted. :)

Answer 5

Trabajadores web . Son un estándar W3C (bueno, un borrador en funcionamiento en este momento) para exactamente esto, y no requieren complementos:

Esta especificación define una API que permite a los autores de la aplicación web engendrar trabajadores en segundo plano ejecutando scripts en paralelo a su página principal.

La especificación también analiza la propagación de trabajadores a través de múltiples núcleos, para la verdadera concurrencia (esto se maneja de forma invisible por el motor de JavaScript del navegador):

Con las CPU multinúcleo cada vez más frecuentes, una forma de obtener un mejor rendimiento es dividir tareas costosas desde el punto de vista informático entre varios trabajadores. En [un] ejemplo, una tarea computacionalmente costosa que se realizará para cada número de 1 a 10,000,000 se asigna a diez subtrabajadores.

yield() y setInterval() solo programan que las cosas sucedan más tarde, no se ejecutan al mismo tiempo que cualquier otra cosa.