Pourquoi ne pas JavaScript support de multithreading?

JavaScript ne prend pas en charge le multi-threading, car l'interpréteur JavaScript dans le navigateur est un seul thread (autant que je sache). Même Google Chrome ne va pas laisser une seule page web du JavaScript exécuté simultanément parce que ce serait la source de graves problèmes de concurrence dans les pages web existantes. Tous Chrome n'est séparée des composants multiples (différents onglets, plugins, etc...) dans des processus séparés, mais je ne peux pas imaginer une seule page ayant plus d'un JavaScript fil.

Vous pouvez cependant utiliser, comme on l'a suggéré, setTimeout pour permettre à certains de tri de la planification et de “faux” de la simultanéité. Cela provoque le navigateur de reprendre le contrôle de la thread de rendu, et de commencer le code JavaScript fourni à setTimeout après le nombre de millisecondes. Ceci est très utile si vous souhaitez autoriser la fenêtre d'affichage (ce que vous voyez) pour actualiser lors de l'exécution d'opérations sur elle. Juste en boucle par exemple, au moyen des coordonnées et de la mise à jour d'un élément en conséquence va simplement vous permettre de voir le début et la fin de positions, et rien entre les deux.

Nous utilisons une abstraction bibliothèque JavaScript qui permet de créer des processus et des threads qui sont tous gérés par le même interpréteur JavaScript. Cela nous permet d'exécuter des actions de la manière suivante:

• Processus, Thread 1
• Processus, Thread 2
• Processus B, Le Thread 1
• Processus, Thread 3
• Processus, Thread 4
• Processus B, Le Thread 2
• Suspendre Le Processus D'Une
• Processus B, Fil 3
• Processus B, Fil 4
• Processus B, Fil 5
• Processus De Démarrage D'Une
• Processus, Thread 5

Cela permet une certaine forme de planification et de faux parallélisme, le démarrage et l'arrêt des threads, etc, mais il ne sera pas le cas de multi-threading. Je ne pense pas que cela puisse être mis en œuvre dans la langue elle-même, puisque le vrai multi-threading n'est utile que si le navigateur peut exécuter une seule page multi-thread (ou même plus d'un noyau), et les difficultés sont beaucoup plus grands que les possibilités supplémentaires.

Pour l'avenir de JavaScript, check this out:
https://developer.mozilla.org/presentations/xtech2006/javascript/

JavaScript multi-threading (avec certaines limitations) est ici. Google mis en œuvre travailleurs pour Engrenages, et les travailleurs sont inclus avec le HTML5. La plupart des navigateurs ont déjà ajouté le support de cette fonctionnalité.

Fil-sécurité des données est garantie puisque toutes les données communiquées à/de la travailleur est sérialisé/copié.

Pour plus d'info, lire:

http://www.whatwg.org/specs/web-workers/current-work/

http://ejohn.org/blog/web-workers/

Multithread.js enveloppements Web des Travailleurs et permet de faciliter le multithreading en JS. Fonctionne sur tous les navigateurs, y compris iOS Safari. 🙂

Tout comme matt b a dit, la question n'est pas très clair. En supposant que vous vous posez sur le multithreading soutien dans la langue: car il n'est pas nécessaire pour 99.999% des applications s'exécutant dans le navigateur. Si vous en avez vraiment besoin, il existe des solutions de contournement (comme l'utilisation de la fenêtre.setTimeout).

En général le multithreading est très, très, très, très, très, très dur (j'ai dit que c'est dur?) pour obtenir le droit, sauf si vous les mettez dans des restrictions supplémentaires (en utilisant seulement les données immuables).

Actuellement, certains navigateurs ne support le multithreading. Donc, si vous avez besoin que vous pourriez utiliser des bibliothèques spécifiques. Par exemple, la vue de la prochaine matériaux:

• https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers
  (support des threads d'arrière-plan);

• https://keithwhor.github.io/multithread.js/ (la bibliothèque).

C'est l'implémentation qui ne prend pas en charge le multi-threading. Actuellement, Google Gears est de fournir un moyen d'utiliser une certaine forme de concurrence d'accès en exécution de processus externe, mais c'est tout.

Le nouveau navigateur de Google est censé communiqué aujourd'hui (Google Chrome) qui permet d'exécuter un code en parallèle en les séparant dans le processus.

Le langage de base, des cours peuvent avoir le même support, comme par exemple Java, mais le soutien pour quelque chose comme Erlang est la simultanéité est nulle part près de l'horizon.

Selon cet article il est déjà possible de mettre en œuvre JavaScript threading.

Cependant, vous pouvez utiliser la fonction eval pour apporter de la simultanéité, dans une CERTAINE MESURE

/* content of the threads to be run */
var threads = [
        [
            "document.write('Foo <br/>');",
            "document.write('Foo <br/>');",
            "document.write('Foo <br/>');",
            "document.write('Foo <br/>');",
            "document.write('Foo <br/>');",
            "document.write('Foo <br/>');",
            "document.write('Foo <br/>');",
            "document.write('Foo <br/>');",
            "document.write('Foo <br/>');",
            "document.write('Foo <br/>');"
        ],
        [
            "document.write('Bar <br/>');",
            "document.write('Bar <br/>');",
            "document.write('Bar <br/>');",
            "document.write('Bar <br/>');",
            "document.write('Bar <br/>');",
            "document.write('Bar <br/>');",
            "document.write('Bar <br/>');",
            "document.write('Bar <br/>');",
            "document.write('Bar <br/>');"
        ]
    ];

window.onload = function() {
    var lines = 0, quantum = 3, max = 0;

    /* get the longer thread length */
    for(var i=0; i<threads.length; i++) {
        if(max < threads[i].length) {
            max = threads[i].length;
        }
    }

    /* execute them */
    while(lines < max) {
        for(var i=0; i<threads.length; i++) {
            for(var j = lines; j < threads[i].length && j < (lines + quantum); j++) {
                eval(threads[i][j]);
            }
        }
        lines += quantum;
    }
}

Multi-threading avec javascript est clairement possible, en utilisant les web workers apporter par HTML5.

Principale différence entre les web workers et un standard multi-threading environnement ressources de la mémoire ne sont pas partagées avec le thread principal, une référence à un objet n'est pas visible à partir d'un thread à l'autre. Fils de communiquent par échange de messages, il est donc possible de mettre en œuvre un synchronzization et simultanées de l'appel de la méthode de l'algorithme à la suite d'un event-driven design pattern.

De nombreux frameworks existent permettant à la structure de la programmation entre les threads, parmi eux OODK-JS, une programmation orientée objet js cadre qui soutient la programmation simultanée
https://github.com/GOMServices/oodk-js-oop-for-js