Почему JavaScript не поддерживает многопоточность?

Question

Это намеренное дизайнерское решение или проблема с нашими современными браузерами, которая будет исправлена ​​в следующих версиях?

Answer 1

JavaScript не поддерживает многопоточность, потому что интерпретатор JavaScript в браузере является однопоточным (AFAIK). Даже Google Chrome не позволяет одновременно запускать JavaScript-код одной веб-страницы, поскольку это может вызвать серьезные проблемы с параллелизмом на существующих веб-страницах. Все, что делает Chrome - это разделяет несколько компонентов (разные вкладки, плагины и т. Д.) На отдельные процессы, но я не могу представить, чтобы на одной странице было несколько потоков JavaScript.

Однако вы можете использовать, как было предложено, setTimeout разрешить какое-то планирование и "поддельный" параллелизм. Это заставляет браузер восстановить контроль над потоком рендеринга и запустить код JavaScript, предоставленный для setTimeout после заданного количества миллисекунд. Это очень полезно, если вы хотите, чтобы окно просмотра (что вы видите) обновлялось при выполнении операций с ним. Простое прохождение, например, координат и обновление элемента соответственно, позволит вам увидеть начальную и конечную позиции, и ничего между ними.

Мы используем библиотеку абстракций в JavaScript, которая позволяет нам создавать процессы и потоки, которые управляются одним и тем же интерпретатором JavaScript. Это позволяет нам выполнять действия следующим образом:

• Процесс А, Поток 1
• Процесс А, Поток 2
• Процесс Б, Поток 1
• Процесс А, Поток 3
• Процесс А, Поток 4
• Процесс Б, Поток 2
• Пауза Процесс А
• Процесс B, Поток 3
• Процесс B, Поток 4
• Процесс B, Поток 5
• Начать процесс A
• Процесс А, Поток 5

Это допускает некоторую форму планирования и ложного параллелизма, запуска и остановки потоков и т. Д., Но это не будет настоящей многопоточностью. Я не думаю, что это когда-либо будет реализовано в самом языке, поскольку настоящая многопоточность полезна только в том случае, если браузер может запускать многопотоковую одностраничную страницу (или даже более одного ядра), а трудности там намного больше. чем дополнительные возможности.

Для будущего JavaScript, проверьте это: https://web.archive.org/web/20170920070053/https://developer.mozilla.org/presentations/xtech2006/javascript/

Answer 2

Многопоточность JavaScript (с некоторыми ограничениями) здесь. Google внедрил рабочих для Gears, а рабочие включены в HTML5. Большинство браузеров уже добавили поддержку этой функции.

Потоковая безопасность данных гарантируется, потому что все данные, передаваемые в / из работника, сериализуются / копируются.

Для получения дополнительной информации читайте:

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

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

Answer 3

Традиционно JS предназначался для коротких, быстро исполняемых фрагментов кода. Если у вас были серьезные вычисления, вы делали это на сервере - идея приложения JS+HTML , которое долгое время работало в вашем браузере и делало нетривиальные вещи, было абсурдным.

Конечно, теперь у нас есть это. Но браузерам понадобится немало времени, чтобы наверстать упущенное - большинство из них было разработано на основе однопоточной модели, и изменить ее непросто. Google Gears обходит многие потенциальные проблемы, требуя изолированного фонового выполнения - не нужно менять DOM (так как это не является потокобезопасным), нет доступа к объектам, созданным основным потоком (так же). Несмотря на ограниченность, это, вероятно, будет наиболее практичным дизайном для ближайшего будущего, поскольку он упрощает дизайн браузера и снижает риск, связанный с тем, что неопытные JS-кодеры могут связываться с потоками...

@marcio:

Почему это не является причиной реализации многопоточности в Javascript? Программисты могут делать с инструментами все, что хотят.

Итак, давайте не будем давать им инструменты, которыми так легко злоупотреблять, что любой другой веб-сайт, который я открываю, приводит к сбою моего браузера. Наивная реализация этого привела бы вас прямо на территорию, которая вызывала много головных болей у MS во время разработки IE7: авторы дополнений быстро и свободно играли с моделью потоков, что приводило к скрытым ошибкам, которые становились очевидными, когда жизненные циклы объектов менялись в основном потоке., ПЛОХОЙ. Если вы пишете многопоточные дополнения ActiveX для IE, я думаю, это идет с территорией; не значит, что нужно идти дальше.

Answer 4

Я не знаю обоснования этого решения, но я знаю, что вы можете смоделировать некоторые преимущества многопоточного программирования с помощью setTimeout. Вы можете создать иллюзию того, что несколько процессов делают что-то одновременно, хотя в действительности все происходит в одном потоке.

Просто сделайте так, чтобы ваша функция немного поработала, а затем вызовите что-то вроде:

setTimeout(function () {
    ... do the rest of the work...
}, 0);

И любые другие вещи, которые нужно сделать (например, обновления пользовательского интерфейса, анимированные изображения и т. Д.), Произойдут, когда они получат шанс.

Answer 5

Вы имеете в виду, почему язык не поддерживает многопоточность или почему движки JavaScript в браузерах не поддерживают многопоточность?

Ответ на первый вопрос заключается в том, что JavaScript в браузере предназначен для запуска в песочнице и независимым от машины / ОС способом, чтобы добавить поддержку многопоточности усложнил бы язык и слишком привязал бы язык к ОС.

Answer 6

Node.js 10.5+ поддерживает рабочие потоки в качестве экспериментальной функции (вы можете использовать ее с включенным флагом --experimental-worker): https://nodejs.org/api/worker_threads.html

Итак, правило таково:

• если вам нужно выполнить операции ввода-вывода с привязкой, то используйте внутренний механизм (он же callback / обещание / async-await)
• если вам нужно выполнить операции с привязкой к процессору, используйте рабочие потоки.

Рабочие потоки предназначены для долгоживущих потоков, то есть вы создаете фоновый поток, а затем общаетесь с ним посредством передачи сообщений.

В противном случае, если вам нужно выполнить значительную нагрузку на процессор с помощью анонимной функции, вы можете воспользоваться https://github.com/wilk/microjob, крошечной библиотекой, построенной на рабочих потоках.

Answer 7

Multithread.js оборачивает Web Workers и обеспечивает простую многопоточность в JS. Работает на всех новых браузерах, включая iOS Safari.:)

Answer 8

Как сказал Мэтт Б, вопрос не очень ясен. Предположим, что вы спрашиваете о поддержке многопоточности на языке: потому что это не требуется для 99,999% приложений, работающих в браузере в настоящее время. Если вам это действительно нужно, есть обходные пути (например, использование window.setTimeout).

В общем, многопоточность - это очень, очень, очень, очень, очень, очень, очень трудно (я говорил, что это трудно?), Чтобы получить права, если вы не вводите дополнительные ограничения (например, использование только неизменяемых данных).

Answer 9

Корпорация Intel провела несколько исследований с открытым исходным кодом о многопоточности в Javascript, недавно она была продемонстрирована на GDC 2012. Вот ссылка на видео. Исследовательская группа использовала OpenCL, которая в первую очередь ориентирована на наборы микросхем Intel и ОС Windows. Проект с кодовым названием RiverTrail и код доступен на GitHub

Еще несколько полезных ссылок:

Создание вычислительного шоссе для веб-приложений

Answer 10

В настоящее время некоторые браузеры поддерживают многопоточность. Итак, если вам это нужно, вы можете использовать определенные библиотеки. Например, просмотрите следующие материалы:

• https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers(поддержка фоновых потоков);

• https://keithwhor.github.io/multithread.js/ (библиотека).

Answer 11

Javascript - это однопоточный язык. Это означает, что у него есть один стек вызовов и одна куча памяти. Как и ожидалось, он выполняет код по порядку и должен завершить выполнение фрагмента кода, прежде чем перейти к следующему. Это синхронно, но временами это может быть вредно. Например, если функция требует времени для выполнения или должна чего-то ждать, она тем временем все замораживает.

Answer 12

Это реализации, которые не поддерживают многопоточность. В настоящее время Google Gears предоставляет способ использовать некоторую форму параллелизма, выполняя внешние процессы, но это все.

Новый браузер, который Google должен выпустить сегодня (Google Chrome), выполняет некоторый код параллельно, разделяя его в процессе.

Основной язык, конечно, может иметь такую ​​же поддержку, как, скажем, Java, но поддержка чего-то вроде параллелизма Эрланга далеко не за горизонтом.

Answer 13

Без надлежащей языковой поддержки синхронизации потоков даже не имеет смысла пробовать новые реализации. Существующие сложные приложения JS (например, любые, использующие ExtJS), скорее всего, неожиданно завершат работу, но без synchronized Ключевое слово или что-то подобное, было бы очень трудно или даже невозможно написать новые программы, которые ведут себя правильно.

Answer 14

Вы можете использовать jetworker, обертку на веб-сайте https://github.com/uxitten/jetworker

Answer 15

Насколько я слышал, в Google Chrome будет многопоточный javascript, поэтому это проблема "текущих реализаций".

Answer 16

На самом деле многопоточность не связана с самим языком. Вот многопоточный движок Javascript для .NET. Он довольно хорошо работает со сценариями многопоточности. Он интегрируется со средой выполнения C#, поэтому вся логика синхронизации аналогична C#. Вы можете запускать / ждать / ждать задачи, а также запускать потоки. Можно даже замки поставить. В следующем примере демонстрируется параллельный цикл с использованием синтаксиса Javascript в среде выполнения .NET.

https://github.com/koculu/topaz

      var engine = new TopazEngine();
engine.AddType(typeof(Console), "Console");
topazEngine.AddType(typeof(Parallel), "Parallel");
engine.ExecuteScript(@"
var sharedVariable = 0
function f1(i) {
    sharedVariable = i
}
Parallel.For(0, 100000 , f1)
Console.WriteLine(`Final value: {sharedVariable}`);
");

Кроме того, Microsoft работает над Napa.js, клоном Node.js с поддержкой многопоточности.

https://github.com/microsoft/napajs

Answer 17

Согласно этой статье уже возможно реализовать многопоточность JavaScript.

Answer 18

Однако вы можете использовать функцию eval для обеспечения параллелизма в некотором объеме.

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

Answer 19

Многопоточность с использованием javascript явно возможна при использовании веб-разработчиков HTML5.

Основное различие между веб-работниками и стандартной многопоточной средой заключается в том, что ресурсы памяти не используются совместно с основным потоком, ссылка на объект не видна из одного потока в другой. Потоки взаимодействуют путем обмена сообщениями, поэтому возможно реализовать алгоритм синхронизации и одновременного вызова метода, следуя шаблону проектирования, управляемого событиями.

Существует множество платформ, позволяющих структурировать программирование между потоками, в том числе OODK-JS, фреймворк OOP js, поддерживающий параллельное программирование https://github.com/GOMServices/oodk-js-oop-for-js