Simulando interruptores de contexto en JavaScript?

Question

He estado trabajando en la implementación de un sistema bastante complejo en JavaScript que necesita simular, entre otras cosas, procesos multiproceso. En un proceso real multiproceso (como un hilo del núcleo) es posible cambiar entre hilos mediante el cambio de contexto. Esto funciona porque puede almacenar el contador de programa del proceso actual y registrarse en una estructura temporal, restaurar el contador del programa y registrarse para algún otro proceso, y luego reanudar donde lo dejó en el proceso anterior.

Tengo curiosidad si es posible tener algo similar a esto en JavaScript. Actualmente no sé cómo hacer esto y he estado diseñando el sistema usando multitareas cooperativas. En particular, cualquier "función" que deseo ejecutar en el simulador de subprocesos múltiples se divide en una matriz de funciones. Para ejecutar la "función", repito a través de la matriz de funciones, ejecutándolas en orden mientras mantengo un "contador de programa" cuya función ejecutar a continuación. Esto me permite simular un cambio de contexto llamando a una de las funciones de la matriz, esperando que la función regrese, y luego cambiando a otra serie de funciones que deben ejecutarse.

Mi enfoque actual funciona, pero es difícil escribir código en este sistema. Cada función tiene que indicar específicamente cuándo se puede interrumpir, y dado que las funciones en la matriz están todas separadas, la lógica para comunicar datos entre diferentes partes de la función es complicada. Esperaba conseguir algo más cercano a trabajar en múltiples tareas preventivas.

Mi pregunta es: ¿es posible ejecutar una función de JavaScript arbitraria de manera que pueda ser suspendida y reanudada por una fuente externa?

Answer 1

Comprobar StratifiedJS cabo

Answer 2

primer lugar, es importante mencionar que JavaScript está completamente solo subproceso. Emular multi-threading realmente no es el camino a seguir. Es mucho mejor confiar en eventloops.

Como los trabajadores web mencionados podrían ser utilizados, pero no hay realmente un cumplimiento de navegador cruzado para ellos, así que ignoraré a los trabajadores web. Tampoco puedes hacer ninguna manipulación DOM con trabajadores web.

Yo diría que echa un vistazo a node.js para razonar detrás de por qué los bucles de eventos son una buena alternativa al multi-threading. Creo que toca bastante bien por qué es una buena alternativa en este video.

Entonces, en lugar de tener una serie de funciones e iterar sobre ellas, en su lugar puede crear un evento y vincular un conjunto de funciones a ellas y desencadenar dicho evento. Se puede encontrar una implementación de eventos muy ligera en backbone.js.

No puede simplemente pausar un hilo en JavaScript porque solo hay uno. No hay forma de suspender o reanudar una función sin una función que tenga puntos.

Solo hay una forma de emular esto. Escriba un analizador de JavaScript que rasgue su JavaScript bien diseñado y construya un sistema que le permita suspender y reanudar su JavaScript.

Tomemos por ejemplo esta función

function(i) { 
    j = i + 1; 
    console.log(j); 
    return foo(j); 
} 

y la convierte en este

var bar = function(i) { 
    var r = {}; 
    var j = i + 1; 
    var f = function() { 
     console.log(j); 
     var g = function() { 
       return foo(j); 
     }; 
     onNext(g, arguments.callee, this, r); 
    }; 
    onNext(f, arguments.callee, this); 
    return r; 
} 

el va a necesitar extender Función con .suspend y .resume

Function.prototype.suspend = function() { 
    this.__suspended = true; 
} 

Function.prototype.resume = function() { 
    this.__suspended = false; 
} 

function onNext(callback, function, context, returnObj) { 
    if (!function.__suspended) { 
      var cb = function() { 
       Backbone.Events.unbind("run", cb); 
       returnObj.r = callback.call(this); 
      } 
      Backbone.Events.bind("run", cb); 
    } 
} 

setInterval(function() { 
    Backbone.Events.trigger("run"); 
}, 5); 

También vas a tiene que reemplazar todas las referencias a var a = b() con

callFunctionAsync(b, context, args, function(return) { 
    var a = return; 
    ... 
}); 

Dejaré la implentación a su medida. Por el momento, todas las funciones devuelven un objeto r y solo cuando r.r se establece en un valor, se "devuelve". Así que simplemente revise el bucle de evento si ya ha "regresado" comprobando si r.r está configurado y si ha activado la función de devolución de llamada asincrónica.

Hola y mira lo que tenemos. Estamos emulando hilos ejecutándolos alrededor del ciclo de eventos. Es mucho mejor utilizar el bucle de evento de forma nativa en su código en lugar de emular hilos a través de él.

Básicamente, obtenga su función para ejecutar la siguiente línea de su código cuando recorra nuevamente el ciclo de eventos. Y verifique si la "función" en particular se suspende o reanuda cuando recorre su evento.

No implemente burbujeando el retorno de las funciones de nuevo a la "función" en aras de la brevedad. Esto no debería ser demasiado difícil de emular.

O utilice el bucle de evento directamente o utilice métodos de hebras falsas y obtenga un compilador para compilar su código para que no se vea horrible cuando lo codifica.

Si causa cerraduras muertas, buena suerte para usted.