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

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

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://developer.mozilla.org/presentations/xtech2006/javascript/

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

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

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

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

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

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

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

@marcio :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Однако вы можете использовать функцию 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;
    }
}

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

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

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