Czy JavaScript może być jednowątkowy?

Powiedziałbym tak - ponieważ praktycznie wszystkie istniejące (przynajmniej wszystkie nietrywialne) kod javascript pękłby, gdyby silnik javascript przeglądarki uruchamiał go asynchronicznie.

Dodaj do tego fakt, że HTML5 określa już pracowników sieci (jawne, ustandaryzowane API dla wielowątkowego kodu javascript) wprowadzenie wielowątkowego do podstawowego Javascript byłoby w większości bezcelowe.

(Uwaga dla innych komentujących: Mimo setTimeout/setInterval, HTTP-request onload events (XHR), oraz zdarzenia UI (click, focus, itp.) zapewniają prymitywne wrażenie wielowątkowości - wszystkie są wykonywane wzdłuż jednej osi czasu-po kolei - więc nawet jeśli nie znamy ich kolejności wykonania wcześniej, nie ma potrzeby martwić się o warunki zewnętrzne zmieniające się podczas wykonywania obsługi zdarzeń, funkcji timed lub wywołania zwrotnego XHR.)

Tak, chociaż nadal możesz cierpieć na niektóre problemy związane z programowaniem współbieżnym (głównie warunki rasowe), gdy używasz dowolnego asynchronicznego API, takiego jak setInterval i wywołania zwrotne xmlhttp.

Tak, chociaż Internet Explorer 9 skompiluje Javascript na osobnym wątku w przygotowaniu do wykonania w głównym wątku. To jednak niczego nie zmienia dla Ciebie jako programisty.

JavaScript / ECMAScript jest zaprojektowany do życia w środowisku hosta. Oznacza to, że JavaScript w rzeczywistości nie robi nic , chyba że środowisko hosta zdecyduje się parsować i wykonać dany skrypt, i dostarczyć obiekty środowiska, które pozwalają JavaScript rzeczywiście być użyteczne (takie jak DOM w przeglądarkach).

Myślę, że dana funkcja lub blok skryptu będzie wykonywana linia po linii i to jest gwarantowane dla JavaScript. Jednak być może środowisko hosta mogłoby wykonać wiele skryptów w w tym samym czasie. Lub, środowisko hosta zawsze może dostarczyć obiekt, który zapewnia wielowątkowość. setTimeout i setInterval są przykładami, a przynajmniej pseudo-przykładami, środowiska hosta dostarczającego sposób wykonywania współbieżności (nawet jeśli nie jest to dokładnie współbieżność).

W rzeczywistości okno rodzica może komunikować się z oknami dziecka lub rodzeństwa lub ramkami, które mają uruchomione własne wątki wykonawcze.

Powiedziałbym, że specyfikacja nie uniemożliwia komuś stworzenia silnika, który uruchamia javascript na wielu wątkach, wymagającego od kodu synchronizacji dostępu do stanu współdzielonego obiektu.

Myślę, że jednowątkowy paradygmat nieblokujący powstał z potrzeby uruchamiania javascript w przeglądarkach, w których interfejs użytkownika nigdy nie powinien się blokować.

Nodejs zastosował podejście przeglądarki.

Rhino Silnik jednak obsługuje uruchamianie kodu js w różnych wątki . Wykonania nie mogą współdzielić kontekstu, ale mogą współdzielić zakres. W tym konkretnym przypadku dokumentacja stwierdza:

..."Rhino gwarantuje, że dostęp do właściwości obiektów JavaScript jest atomowy w różnych wątkach, ale nie daje żadnych więcej gwarancji dla skryptów wykonujących w tym samym zakresie w tym samym czasie.Jeśli dwa skrypty używają tego samego zakresu jednocześnie, skrypty są odpowiedzialne za koordynowanie dostępu do współdzielonego zmienne ."

Z lektury dokumentacji Rhino wnioskuję, że może być możliwe, aby ktoś napisał javascript api, które również rodzi nowe wątki javascript, ale api byłoby specyficzne dla rhino (np. węzeł może tylko wywołać nowy proces).

Wyobrażam sobie, że nawet dla silnika, który obsługuje wiele wątków w javascript, powinna być kompatybilność ze skryptami, które nie uwzględniają wielowątkowości lub blokowania.

Przeglądanie przeglądarek i nodejs w sposób Widzę, że jest:

• Czy cały kod js jest wykonywany w jednym wątku? : Tak.

• Czy kod js może powodować uruchamianie innych wątków? : Tak.

• Czy te wątki mogą mutować kontekst wykonania js?: Nie. Ale mogą (bezpośrednio / pośrednio (?)) dołącza do kolejki zdarzeń.

Tak więc w przypadku przeglądarek i nodejsów (i pewnie wielu innych silników) javascript nie jest wielowątkowy, ale same silniki są.

Nie.

var list = [];
for (var i = 0; i < 10000; i++) {
  list[i] = i * i;
}

Jest to napisane z oczekiwaniem, że na końcu pętli lista musi mieć 10000 pozycji, które są indeksem do kwadratu, ale maszyna wirtualna może zauważyć, że każda iteracja pętli nie wpływa na drugą, i reinterpretacja za pomocą dwóch wątków.

Pierwszy wątek

for (var i = 0; i < 5000; i++) {
  list[i] = i * i;
}

Drugi wątek

for (var i = 5000; i < 10000; i++) {
  list[i] = i * i;
}

Upraszczam tutaj, ponieważ tablice JS są bardziej skomplikowane niż głupie kawałki pamięci, ale jeśli te dwa skrypty są w stanie dodać wpisy do tablicy w sposób bezpieczny dla wątku, to do czasu wykonania obu będzie miał taki sam wynik jak wersja jednowątkowa.

Chociaż nie jestem świadomy żadnej maszyny wirtualnej wykrywającej taki równoległy kod, wydaje się prawdopodobne, że może to nastąpić do istnienia w przyszłości dla maszyn wirtualnych JIT, ponieważ może zaoferować większą prędkość w niektórych sytuacjach.

Kontynuując tę koncepcję, możliwe jest, że kod może być adnotowany, aby dać maszynie wirtualnej znać, co konwertować na kod wielowątkowy.

// like "use strict" this enables certain features on compatible VMs.
"use parallel";

var list = [];

// This string, which has no effect on incompatible VMs, enables threading on
// this loop.
"parallel for";
for (var i = 0; i < 10000; i++) {
  list[i] = i * i;
}

Ponieważ pracownicy sieci przychodzą do Javascript, jest mało prawdopodobne, że to... brzydszy system kiedykolwiek powstanie, ale myślę, że można śmiało powiedzieć, że Javascript jest jednowątkowy według tradycji.

@ Bobince daje naprawdę nieprzezroczystą odpowiedź.

Odpowiadając na odpowiedź mára Örlygssona, Javascript jest zawsze jednowątkowy z powodu tego prostego faktu: wszystko w Javascript jest wykonywane wzdłuż jednej osi czasu.

Jest to ścisła definicja jednowątkowego języka programowania.

Cóż, Chrome jest wieloprocesowy i myślę, że każdy proces zajmuje się własnym kodem Javascript, ale o ile kod wie, jest "jednowątkowy".

W Javascript nie ma żadnego wsparcia dla wielowątkowości, przynajmniej nie jawnie, więc to nie robi różnicy.

Wypróbowałem przykład @ bobince z drobnymi modyfikacjami:

<html>
<head>
    <title>Test</title>
</head>
<body>
    <textarea id="log" rows="20" cols="40"></textarea>
    <br />
    <button id="act">Run</button>
    <script type="text/javascript">
        let l= document.getElementById('log');
        let b = document.getElementById('act');
        let s = 0;

        b.addEventListener('click', function() {
            l.value += 'click begin\n';

            s = 10;
            let s2 = s;

            alert('alert!');

            s = s + s2;

            l.value += 'click end\n';
            l.value += `result = ${s}, should be ${s2 + s2}\n`;
            l.value += '----------\n';
        });

        window.addEventListener('resize', function() {
            if (s === 10) {
                s = 5;
            }

            l.value+= 'resize\n';
        });
    </script>
</body>
</html>

Więc, po naciśnięciu Uruchom, Zamknij wyskakujące okienko alertu i zrób "pojedynczy wątek", powinieneś zobaczyć coś takiego:

click begin
click end
result = 20, should be 20

Ale jeśli spróbujesz uruchomić to w operze lub Firefoksie stabilnym na Windows i zminimalizować / zmaksymalizować okno z wyskakującym ostrzeżeniem na ekranie, to będzie coś takiego:

click begin
resize
click end
result = 15, should be 20

Nie chcę mówić, że to jest "wielowątkowość" , ale jakiś fragment kodu został przeze mnie wykonany w niewłaściwym czasie nie spodziewam się tego, a teraz mam zepsuty stan. I lepiej wiedzieć o tym zachowaniu.

Spróbuj zagnieżdżać dwie funkcje setTimeout wewnątrz siebie i będą one zachowywać się wielowątkowo(tzn. zewnętrzny timer nie będzie czekał na zakończenie wewnętrznej przed wykonaniem swojej funkcji).