initial commit

13 files changed, 1268 insertions, 0 deletions

diff --git a/files/de/web/javascript/reference/global_objects/atomics/add/index.html b/files/de/web/javascript/reference/global_objects/atomics/add/index.html
new file mode 100644
index 0000000000..f9b8e98b1b
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/atomics/add/index.html
@@ -0,0 +1,83 @@
+---
+title: Atomics.add()
+slug: Web/JavaScript/Reference/Global_Objects/Atomics/add
+tags:
+  - Atomics
+  - JavaScript
+  - Method
+  - Shared Memory
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/add
+---
+<div>{{JSRef}}</div>
+
+<p>Die statische <code><strong>Atomics</strong></code><strong><code>.add()</code></strong> Methode addiert eine gegebenen Wert an einer gegebenen Position im Array und gibt den alten Wert zurück. Diese atomare Operation garantiert, dass keine andere Schreiboperation während der Operation durchgeführt werden kann.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/atomics-add.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Atomics.add(typedArray, index, value)
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>typedArray</code></dt>
+ <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd>
+ <dt><code>index</code></dt>
+ <dd>Die Position in <code>typedArray</code>, zu der <code>value</code> addiert wird.</dd>
+ <dt><code>value</code></dt>
+ <dd>Die Zahl, die addiert werden soll.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<ul>
+ <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li>
+ <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li>
+ <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li>
+</ul>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+var ta = new Uint8Array(sab);
+
+Atomics.add(ta, 0, 12); // returns 0, the old value
+Atomics.load(ta, 0); // 12</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-atomics.add', 'Atomics.add')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initiale Definition in ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Atomics.add")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Atomics")}}</li>
+ <li>{{jsxref("Atomics.sub()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/atomics/and/index.html b/files/de/web/javascript/reference/global_objects/atomics/and/index.html
new file mode 100644
index 0000000000..34093b64e7
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/atomics/and/index.html
@@ -0,0 +1,129 @@
+---
+title: Atomics.and()
+slug: Web/JavaScript/Reference/Global_Objects/Atomics/and
+tags:
+  - Atomics
+  - JavaScript
+  - Method
+  - Shared Memory
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/and
+---
+<div>{{JSRef}}</div>
+
+<p>Die statische <code><strong>Atomics</strong></code><strong><code>.and()</code></strong> Methode berechnet eine bitweises UND mit einem gegebenen Wert auf einem Wert an einer gegebenen Position im Array und gibt den alten Wert an der Position zurück. Die atomare Operation garantiert, dass kein anderer Schreibprozess während der Operation durchgeführt wird.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/atomics-and.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Atomics.and(typedArray, index, value)
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>typedArray</code></dt>
+ <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd>
+ <dt><code>index</code></dt>
+ <dd>Die Position in <code>typedArray</code>, mit der das bitweise UND berechnet wird.</dd>
+ <dt><code>value</code></dt>
+ <dd>Die Zahl, mit der das bitweise UND berechnet wird.</dd>
+</dl>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<ul>
+ <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li>
+ <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li>
+ <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li>
+</ul>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Die bitweise UND Operation ergibt nur 1, wenn beide Werte, <code>a</code> und <code>b</code>, 1 sind. Die Wahrheitstabelle für die UND Operation ist:</p>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th><code>a</code></th>
+   <th><code>b</code></th>
+   <th><code>a &amp; b</code></th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>0</td>
+   <td>0</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>1</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>0</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Zum Beispiel resultiert ein bitweises UND auf <code>5 &amp; 1</code> in <code>0001</code>, was im Dezimalsystem 1 ist.</p>
+
+<pre>5  0101
+1  0001
+   ----
+1  0001</pre>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+var ta = new Uint8Array(sab);
+ta[0] = 5;
+
+Atomics.and(ta, 0, 1); // returns 0, the old value
+Atomics.load(ta, 0);  // 1
+</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-atomics.and', 'Atomics.and')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initiale Definition in ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Atomics.and")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Atomics")}}</li>
+ <li>{{jsxref("Atomics.or()")}}</li>
+ <li>{{jsxref("Atomics.xor()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/atomics/compareexchange/index.html b/files/de/web/javascript/reference/global_objects/atomics/compareexchange/index.html
new file mode 100644
index 0000000000..1c61ef7d26
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/atomics/compareexchange/index.html
@@ -0,0 +1,86 @@
+---
+title: Atomics.compareExchange()
+slug: Web/JavaScript/Reference/Global_Objects/Atomics/compareExchange
+tags:
+  - Atomics
+  - JavaScript
+  - Method
+  - Shared Memory
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/compareExchange
+---
+<div>{{JSRef}}</div>
+
+<p>Die statische <code><strong>Atomics</strong></code><strong><code>.compareExchange()</code></strong> Methode ersetzt einen Wert an einer gegebenen Position im einem Array mit einem gegebene Wert aus, wenn ein gegebenen Wert gleich dem alten Wert ist. Es wird der alte Wert an der Position zurückgegeben, egal ob der abzugleichende Wert gleich oder nicht ist. Die atomare Operation garantiert, dass kein anderer Schreibprozess während der Operation durchgeführt wird.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/atomics-compareexchange.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Atomics.compareExchange(typedArray, index, expectedValue, replacementValue)
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>typedArray</code></dt>
+ <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd>
+ <dt><code>index</code></dt>
+ <dd>Die Position in <code>typedArray</code>, an den ein Wert ersetzt wird.</dd>
+ <dt><code>expectedValue</code></dt>
+ <dd>Wert, auf dem die gleichheit geprüft wird.</dd>
+ <dt>replacementValue</dt>
+ <dd>Neu Zahl, die geschreiben wird.</dd>
+</dl>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<ul>
+ <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li>
+ <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li>
+ <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li>
+</ul>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+var ta = new Uint8Array(sab);
+ta[0] = 7;
+
+Atomics.compareExchange(ta, 0, 7, 12); // returns 7, the old value
+Atomics.load(ta, 0); // 12</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-atomics.compareexchange', 'Atomics.compareExchange')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initiale Definition in ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Atomics.compareExchange")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Atomics")}}</li>
+ <li>{{jsxref("Atomics.exchange()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/atomics/exchange/index.html b/files/de/web/javascript/reference/global_objects/atomics/exchange/index.html
new file mode 100644
index 0000000000..df040868a6
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/atomics/exchange/index.html
@@ -0,0 +1,85 @@
+---
+title: Atomics.exchange()
+slug: Web/JavaScript/Reference/Global_Objects/Atomics/exchange
+tags:
+  - Atomics
+  - JavaScript
+  - Method
+  - Shared Memory
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/exchange
+---
+<div>{{JSRef}}</div>
+
+<p>Die statische <code><strong>Atomics</strong></code><strong><code>.exchange()</code></strong> Methode ersetzt einen Wert an einer gegebenen Position im einem Array mit einem gegebene Wert aus. Die atomare Operation garantiert, dass kein anderer Schreibprozess während der Operation durchgeführt wird.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/atomics-exchange.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Atomics.compareExchange(typedArray, index, value)
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>typedArray</code></dt>
+ <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd>
+ <dt><code>index</code></dt>
+ <dd>Die Position in <code>typedArray</code>, an den ein Wert ersetzt wird.</dd>
+ <dt><code>value</code></dt>
+ <dd>Neu Zahl, die geschreiben wird.</dd>
+</dl>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<ul>
+ <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li>
+ <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li>
+ <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li>
+</ul>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+var ta = new Uint8Array(sab);
+
+Atomics.compareExchange(ta, 0, 12); // returns 0, the old value
+Atomics.load(ta, 0); // 12</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-atomics.exchange', 'Atomics.exchange')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initiale Definition in ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Atomics.exchange")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Atomics")}}</li>
+ <li>{{jsxref("Atomics.compareExchange()")}}</li>
+</ul>
+
+<p> </p>
diff --git a/files/de/web/javascript/reference/global_objects/atomics/index.html b/files/de/web/javascript/reference/global_objects/atomics/index.html
new file mode 100644
index 0000000000..e8a945060e
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/atomics/index.html
@@ -0,0 +1,116 @@
+---
+title: Atomics
+slug: Web/JavaScript/Reference/Global_Objects/Atomics
+tags:
+  - JavaScript
+  - Shared Memory
+  - Specifications
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics
+---
+<div>{{JSRef}}</div>
+
+<p>Das <strong><code>Atomics</code></strong> Objekt unterstützt atomare Operationen als statische Methoden. Diese werden mit {{jsxref("SharedArrayBuffer")}} Objekte benutzt.</p>
+
+<p>Die atomaren Operationen sind auf dem <code>Atomics</code> Modul installiert. Anders, als bei anderen globalen Objekten, ist, dass <code>Atomics</code> kein Konstruktor ist. Man kann <code>Atomics</code> nicht mit einem <a href="/de/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> Operator</a> oder als Funktion verwenden. Alle Eigenschaften und Methoden von <code>Atomics</code> sind statisch (genauso wie zum Beispiel bei dem {{jsxref("Math")}} Objekt).</p>
+
+<h2 id="Eigenschaften">Eigenschaften</h2>
+
+<dl>
+ <dt><code>Atomics[Symbol.toStringTag]</code></dt>
+ <dd>Der Wert dieser Eigenschaft ist: <code>"Atomics"</code>.</dd>
+</dl>
+
+<h2 id="Methoden">Methoden</h2>
+
+<h3 id="Atomare_Operationen">Atomare Operationen</h3>
+
+<p>Wenn Speicher geteilt wird, können mehrere Threads auf dem gleichen Speicher lesen und schreiben. Atomare Operationen stellen sicher, dass Werte in einer Operation geschrieben und gelesen werden bevor mit der nächste Operation begonnen wird und dass eine Operation nicht unterbrochen wird.</p>
+
+<dl>
+ <dt>{{jsxref("Atomics.add()")}}</dt>
+ <dd>Addiert den angegebenen Wert dem existierenden Wert an der gegebenen Position im Array hinzu. Gibt den alten Wert an der Position zurück.</dd>
+ <dt>{{jsxref("Atomics.and()")}}</dt>
+ <dd>Berechnet ein Bitweises UND mit dem Wert an der angegebenen Position im Array und dem angegebenen Wert. Gibt den alten Wert an der Position zurück.</dd>
+ <dt>{{jsxref("Atomics.compareExchange()")}}</dt>
+ <dd>Speichert einen angegebenen Wert an der angegebenen Position im Array, wenn dieser gleich einem angegebene Wert ist. Gibt den alten Wert zurück.</dd>
+ <dt>{{jsxref("Atomics.exchange()")}}</dt>
+ <dd>Speichert einen angegebenen Wert an einer angegebenen Position im Array. Gibt den alten Wert zurück.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("Atomics.load()")}}</dt>
+ <dd>Gibt den Wert an einer angegebenen Position im Array zurück.</dd>
+ <dt>{{jsxref("Atomics.or()")}}</dt>
+ <dd>Berechnet ein Bitweises ODER mit dem gegebenen Wert an der angegebenen Position im Array und dem angegebenen Wert. Gibt den alten Wert an der Position zurück.</dd>
+ <dt>{{jsxref("Atomics.store()")}}</dt>
+ <dd>Speichert einen angegebenen Wert an einer angegebenen Position im Array. Gibt den Wert zurück.</dd>
+ <dt>{{jsxref("Atomics.sub()")}}</dt>
+ <dd>Subtrahiert einen angegebenen Wert von einem Wert an einer angegebenen Position im Array. Gibt den alten Wert an der Position zurück.</dd>
+ <dt>{{jsxref("Atomics.xor()")}}</dt>
+ <dd>Berechnet ein Bitweises XOR mit dem Wert an einer angegebenen Position im Array und einem angegebenen Wert. Gibt den alten Wert an der Position zurück.</dd>
+</dl>
+
+<h3 id="Wait_und_notify">Wait und notify</h3>
+
+<p>Die <code>wait()</code> und <code>notify()</code> Methoden sind auf Linux Futexes ("fast user-space mutex") modelliert und ermöglichen es zu warten, bis eine bestimmte Bedingung <code>true</code> wird, und wird als blockierendes Konstrukt verwendet.</p>
+
+<dl>
+ <dt>{{jsxref("Atomics.wait()")}}</dt>
+ <dd>Überprüft, ob an der angegebenen Position in einem Array einen angegebener Wert enthalten ist und wartet oder bekommt ein Timeout. Es wird <code>"ok"</code>, <code>"not-equal"</code>, oder <code>"timed-out"</code> zurückgegeben. Wenn Warten im ausführenden Agenten nicht erlaubt ist, wird ein Fehler geworfen (die meisten Browser erlauben kein <code>wait()</code> im Browser main Thread).</dd>
+ <dt>{{jsxref("Atomics.notify()")}}</dt>
+ <dd>Benachrichtigt Agenten, die auf die angegebene Arrayposition warten. Gibt die Zahl der benachrichtigten Agenten zurück.</dd>
+ <dt>{{jsxref("Atomics.isLockFree()", "Atomics.isLockFree(size)")}}</dt>
+ <dd>
+ <p>Eine primitive Optimierung, die feststellten kann, ob Locks und atomare Operationen benutzt werden können. Gibt <code>true</code> zurück, wenn atomare Operationen auf einem Array der gegebenen Elementgröße mit einer atomaren Hardwareoperation implementiert ist (im Gegensatz zu einem Lock). Nur für Experten.</p>
+ </dd>
+</dl>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-atomics-object', 'Atomics')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initiale Definition in ES2017.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES8', '#sec-atomics-object', 'Atomics')}}</td>
+   <td>{{Spec2('ES8')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Atomics")}}</p>
+
+<h2 id="Kompatibilitätshinweise">Kompatibilitätshinweise</h2>
+
+<p><span id="result_box" lang="de"><span>Vor Firefox 48 waren die neuesten API-Namen und Semantiken noch nicht implementiert.</span></span> Die Unterschiede zwischen der Firefox Version 46 und der Version 48 sind:</p>
+
+<ul>
+ <li>Die Methoden <code>Atomics.futexWakeOrRequeue()</code> und <code>Atomics.fence()</code> sind vollständig entfernt ({{bug(1259544)}} und {{bug(1225028)}}).</li>
+ <li>Die Methoden {{jsxref("Atomics.wait()")}} and {{jsxref("Atomics.wake()")}} hießen <code>Atomics.futexWait()</code> und <code>Atomics.futexWake()</code> ({{bug(1260910)}}). Hinweis: Die alten Namen wurden in den Version 49 und später entfernt ({{bug(1262062)}}).</li>
+ <li>Die Eigenschaften <code>Atomics.OK</code>, <code>Atomics.TIMEDOUT</code>, <code>Atomics.NOTEQUAL</code> wurden entfernt. die Methode {{jsxref("Atomics.wait()")}} gibt jetzt die Strings <code>"ok"</code>, <code>"timed-out"</code> und <code>"not-equal"</code> zurück ({{bug(1260835)}}).</li>
+ <li>Der <code>count</code> Parameter der {{jsxref("Atomics.wake()")}} Methode wurde geändert: Der Standardwert ist <code>+Infinity</code> und nicht <code>0</code> ({{bug(1253350)}}).</li>
+</ul>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("ArrayBuffer")}}</li>
+ <li><a href="/de/docs/Web/JavaScript/Typed_arrays">JavaScript getypte Arrays</a></li>
+ <li><a href="/de/docs/Web/API/Web_Workers_API">Web Workers</a></li>
+ <li><a href="https://github.com/lars-t-hansen/parlib-simple">parlib-simple </a>– Eine einfache Bibliothek, die Synchronisation und verteilte Abstraktionen ermöglicht.</li>
+ <li><a href="https://github.com/tc39/ecmascript_sharedmem/blob/master/TUTORIAL.md">Geteilter Speicher (Shared Memory) – ein kurzes Tutorial</a></li>
+ <li><a href="https://hacks.mozilla.org/2016/05/a-taste-of-javascripts-new-parallel-primitives/">A Taste of JavaScript’s New Parallel Primitives – Mozilla Hacks</a></li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/atomics/islockfree/index.html b/files/de/web/javascript/reference/global_objects/atomics/islockfree/index.html
new file mode 100644
index 0000000000..61bf90e0bf
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/atomics/islockfree/index.html
@@ -0,0 +1,73 @@
+---
+title: Atomics.isLockFree()
+slug: Web/JavaScript/Reference/Global_Objects/Atomics/isLockFree
+tags:
+  - Atomics
+  - JavaScript
+  - Method
+  - Shared Memory
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/isLockFree
+---
+<div>{{JSRef}}</div>
+
+<p>Die statische <code><strong>Atomics</strong></code><strong><code>.isLockFree()</code></strong> Methode wird benutzt, um festzustellen, ob ein Lock (Sperre) oder eine atomare Operation vorhanden ist. Sie gibt <code>true</code> zurück, wenn die gegebene Größe eine von den in der <a href="/de/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/BYTES_PER_ELEMENT">BYTES_PER_ELEMENT</a> Eigenschften von Integer TypedArray Typen ist.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/atomics-islockfree.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Atomics.isLockFree(size)
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>size</code></dt>
+ <dd>Die größe in Bytes, für die geprüft wird.</dd>
+</dl>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p>Ein {{jsxref("Boolean")}}, der angibt, ob die Operation frei von Locks ist.</p>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<pre class="brush: js">Atomics.isLockFree(1); // true
+Atomics.isLockFree(2); // true
+Atomics.isLockFree(3); // false
+Atomics.isLockFree(4); // true
+Atomics.isLockFree(5); // false
+Atomics.isLockFree(6); // false
+Atomics.isLockFree(7); // false
+Atomics.isLockFree(8); // false</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-atomics.islockfree', 'Atomics.isLockFree')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initiale Definition in ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Atomics.isLockFree")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Atomics")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/atomics/load/index.html b/files/de/web/javascript/reference/global_objects/atomics/load/index.html
new file mode 100644
index 0000000000..07d2c4a477
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/atomics/load/index.html
@@ -0,0 +1,81 @@
+---
+title: Atomics.load()
+slug: Web/JavaScript/Reference/Global_Objects/Atomics/load
+tags:
+  - Atomics
+  - JavaScript
+  - Method
+  - Shared Memory
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/load
+---
+<div>{{JSRef}}</div>
+
+<p>Die statische <code><strong>Atomics</strong></code><strong><code>.load()</code></strong> Methode gibt den Wert an einer gegebenen Position in einem Array zurück.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/atomics-load.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Atomics.load(typedArray, index)
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>typedArray</code></dt>
+ <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd>
+ <dt><code>index</code></dt>
+ <dd>Die Position in <code>typedArray</code>, von der der Wert geladen wird.</dd>
+</dl>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p>Der Wert an der gegebenen Position (<code>typedArray[index]</code>).</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<ul>
+ <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li>
+ <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li>
+ <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li>
+</ul>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+var ta = new Uint8Array(sab);
+
+Atomics.add(ta, 0, 12);
+Atomics.load(ta, 0); // 12</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-atomics.load', 'Atomics.load')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initiale Definition in ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Atomics.load")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Atomics")}}</li>
+ <li>{{jsxref("Atomics.store()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/atomics/or/index.html b/files/de/web/javascript/reference/global_objects/atomics/or/index.html
new file mode 100644
index 0000000000..ec052cadde
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/atomics/or/index.html
@@ -0,0 +1,129 @@
+---
+title: Atomics.or()
+slug: Web/JavaScript/Reference/Global_Objects/Atomics/or
+tags:
+  - Atomics
+  - JavaScript
+  - Method
+  - Shared Memory
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/or
+---
+<div>{{JSRef}}</div>
+
+<p>Die statische <code><strong>Atomics</strong></code><strong><code>.or()</code></strong> Methode berechnet eine bitweises ODER mit einem gegebenen Wert auf einem Wert an einer gegebenen Position im Array und gibt den alten Wert an der Position zurück. Die atomare Operation garantiert, dass kein anderer Schreibprozess während der Operation durchgeführt wird.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/atomics-or.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Atomics.and(typedArray, index, value)
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>typedArray</code></dt>
+ <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd>
+ <dt><code>index</code></dt>
+ <dd>Die Position in <code>typedArray</code>, mit der das bitweise ODER berechnet wird.</dd>
+ <dt><code>value</code></dt>
+ <dd>Die Zahl, mit der das bitweise ODER berechnet wird.</dd>
+</dl>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<ul>
+ <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li>
+ <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li>
+ <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li>
+</ul>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Die bitweise ODER Operation ergibt nur 1, wenn eine Werte, <code>a</code> oder <code>b</code>, 1 ist. Die Wahrheitstabelle für die ODER Operation ist:</p>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th><code>a</code></th>
+   <th><code>b</code></th>
+   <th><code>a | b</code></th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>0</td>
+   <td>0</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>0</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Zum Beispiel resultiert ein bitweises ODER auf <code>5 | 1</code> in <code>0111</code>, was im Dezimalsystem 5 ist.</p>
+
+<pre>5  0101
+1  0001
+   ----
+5  0101</pre>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+var ta = new Uint8Array(sab);
+ta[0] = 2;
+
+Atomics.or(ta, 0, 1); // returns 2, the old value
+Atomics.load(ta, 0);  // 3
+</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-atomics.or', 'Atomics.or')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initiale Definition in ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Atomics.or")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Atomics")}}</li>
+ <li>{{jsxref("Atomics.and()")}}</li>
+ <li>{{jsxref("Atomics.xor()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/atomics/store/index.html b/files/de/web/javascript/reference/global_objects/atomics/store/index.html
new file mode 100644
index 0000000000..6112dc5f62
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/atomics/store/index.html
@@ -0,0 +1,82 @@
+---
+title: Atomics.store()
+slug: Web/JavaScript/Reference/Global_Objects/Atomics/store
+tags:
+  - Atomics
+  - JavaScript
+  - Method
+  - Shared Memory
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/store
+---
+<div>{{JSRef}}</div>
+
+<p>Die statische <code><strong>Atomics</strong></code><strong><code>.store()</code></strong> Methode speichert einen gegebenen Wert an einer gegebenen Position in dem Array und gibt den Wert zurück.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/atomics-store.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Atomics.store(typedArray, index, value)
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>typedArray</code></dt>
+ <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd>
+ <dt><code>index</code></dt>
+ <dd>Die Position in <code>typedArray</code>, an der <code>value</code> gespeichert wird.</dd>
+ <dt><code>value</code></dt>
+ <dd>Die Zahl, die gespeichert wird.</dd>
+</dl>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p>Der Wert, der abgespeichert wurde.</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<ul>
+ <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li>
+ <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li>
+ <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li>
+</ul>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+var ta = new Uint8Array(sab);
+
+Atomics.store(ta, 0, 12); // 12</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-atomics.store', 'Atomics.store')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initiale Definition in ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Atomics.store")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Atomics")}}</li>
+ <li>{{jsxref("Atomics.load()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/atomics/sub/index.html b/files/de/web/javascript/reference/global_objects/atomics/sub/index.html
new file mode 100644
index 0000000000..cce9ae06c6
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/atomics/sub/index.html
@@ -0,0 +1,86 @@
+---
+title: Atomics.sub()
+slug: Web/JavaScript/Reference/Global_Objects/Atomics/sub
+tags:
+  - Atomics
+  - Java
+  - Method
+  - Shared Memory
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/sub
+---
+<div>{{JSRef}}</div>
+
+<p>Die statische <code><strong>Atomics</strong></code><strong><code>.sub()</code></strong> Methode subtrahiert eine gegebenen Wert an einer gegebenen Position im Array und gibt den alten Wert zurück. Diese atomare Operation garantiert, dass keine andere Schreiboperation während der Operation durchgeführt werden kann.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/atomics-sub.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Atomics.add(typedArray, index, value)
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>typedArray</code></dt>
+ <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd>
+ <dt><code>index</code></dt>
+ <dd>Die Position in <code>typedArray</code>, zu der <code>value</code> subtrahiert wird.</dd>
+ <dt><code>value</code></dt>
+ <dd>Die Zahl, die subtrahiert werden soll.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<ul>
+ <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li>
+ <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li>
+ <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li>
+</ul>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+var ta = new Uint8Array(sab);
+ta[0] = 48;
+
+Atomics.sub(ta, 0, 12); // returns 48, the old value
+Atomics.load(ta, 0); // 36</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-atomics.sub', 'Atomics.sub')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initiale Definition in ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Atomics.sub")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Atomics")}}</li>
+ <li>{{jsxref("Atomics.add()")}}</li>
+</ul>
+
+<p> </p>
diff --git a/files/de/web/javascript/reference/global_objects/atomics/wait/index.html b/files/de/web/javascript/reference/global_objects/atomics/wait/index.html
new file mode 100644
index 0000000000..6af6022fc4
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/atomics/wait/index.html
@@ -0,0 +1,95 @@
+---
+title: Atomics.wait()
+slug: Web/JavaScript/Reference/Global_Objects/Atomics/wait
+tags:
+  - Atomics
+  - JavaScript
+  - Method
+  - Shared Memory
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/wait
+---
+<div>{{JSRef}}</div>
+
+<p>Die statische <code><strong>Atomics</strong></code><strong><code>.wait()</code></strong> Methode verifiziert, dass eine gegebene Position in einem {{jsxref("Int32Array")}} ein gegebene Wert ist und dann schläft und entweder aufgeweckt wird oder ein Timeout bekommt. Die Strings <code>"ok"</code>, <code>"not-equal"</code>, und <code>"timed-out"</code> sind alle möglichen Rückgabewerte</p>
+
+<div class="note">
+<p><strong>Hinweis:</strong> Diese Operation funktioniert nur mit einem geteilten<strong> </strong>{{jsxref("Int32Array")}} und ist nicht im Main-Thread erlaubt.</p>
+</div>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Atomics.wait(typedArray, index, value[, timeout])
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>typedArray</code></dt>
+ <dd>Ein geteiltes {{jsxref("Int32Array")}}.</dd>
+ <dt><code>index</code></dt>
+ <dd>Die Position im <code>typedArray</code>, an der gewartet wird.</dd>
+ <dt><code>value</code></dt>
+ <dd>Der wert, mit dem getestet wird.</dd>
+ <dt><code>timeout</code> {{optional_inline}}</dt>
+ <dd>Wartezeit in Millisekunden. {{jsxref("Infinity")}}, wenn keine Zeit angegeben wird.</dd>
+</dl>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p>Ein {{jsxref("String")}} welcher <code>"ok"</code>, <code>"not-equal"</code> oder <code>"timed-out"</code> ist.</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<ul>
+ <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein  {{jsxref("Int32Array")}} ist.</li>
+ <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li>
+</ul>
+
+<h2 id="Beipsiele">Beipsiele</h2>
+
+<p>Gegeben ist ein <code>Int32Array</code>:</p>
+
+<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+var int32 = new Int32Array(sab);
+</pre>
+
+<p>Ein lesender Thread schläft und wartet auf Position 0, ander der Wert 0 erwartet wird. Solange diese gegeben ist, geht es nicht weiter. Immer wenn ein neuer schreibender Thread einen neuen Wert speichert, wacht der Thread. Im Anschluss ist der neue Wert an der Position 0 (123).</p>
+
+<pre class="brush: js">Atomics.wait(int32, 0, 0);
+console.log(int32[0]); // 123</pre>
+
+<p>Ein schreibender Thread speichert einen neuen Wert und wacht den wartenden Thread nach dem Schreiben auf.</p>
+
+<pre class="brush: js">console.log(int32[0]); // 0;
+Atomics.store(int32, 0, 123);
+Atomics.wake(int32, 0, 1);</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-atomics.wait', 'Atomics.wait')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initiale Definition in ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Atomics.wait")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Atomics")}}</li>
+ <li>{{jsxref("Atomics.wake()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/atomics/wake/index.html b/files/de/web/javascript/reference/global_objects/atomics/wake/index.html
new file mode 100644
index 0000000000..5ac06d7adc
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/atomics/wake/index.html
@@ -0,0 +1,93 @@
+---
+title: Atomics.notify()
+slug: Web/JavaScript/Reference/Global_Objects/Atomics/wake
+tags:
+  - Atomics
+  - JavaScript
+  - Method
+  - Shared Memory
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/notify
+---
+<div>{{JSRef}}</div>
+
+<p>Die statische <code><strong>Atomics</strong></code><strong><code>.notify()</code></strong> Methode benachrichtigt Threads, die in einer Warteschlange schlafen.</p>
+
+<div class="note">
+<p><strong>Hinweis:</strong> Diese Operation funktioniert nur mit einem {{jsxref("Int32Array")}}.</p>
+</div>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Atomics.notify(typedArray, index, count)
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>typedArray</code></dt>
+ <dd>Ein geteiltes {{jsxref("Int32Array")}}.</dd>
+ <dt><code>index</code></dt>
+ <dd>Die Position im <code>typedArray</code>, an der aufgewacht wird.</dd>
+ <dt><code>count</code></dt>
+ <dd>Anzahl der aufzuweckenden Threads. Standard ist {{jsxref("Infinity", "+Infinity")}}.</dd>
+</dl>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p>Anzahl an geweckten Threads.</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<ul>
+ <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein  {{jsxref("Int32Array")}} ist.</li>
+ <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li>
+</ul>
+
+<h2 id="Beipsiele">Beipsiele</h2>
+
+<p>Gegeben ist ein <code>Int32Array</code>:</p>
+
+<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+var int32 = new Int32Array(sab);
+</pre>
+
+<p>Ein lesender Thread schläft und wartet auf Position 0, ander der Wert 0 erwartet wird. Solange diese gegeben ist, geht es nicht weiter. Immer wenn ein neuer schreibender Thread einen neuen Wert speichert, wacht der Thread. Im Anschluss ist der neue Wert an der Position 0 (123).</p>
+
+<pre class="brush: js">Atomics.wait(int32, 0, 0);
+console.log(int32[0]); // 123</pre>
+
+<p>Ein schreibender Thread speichert einen neuen Wert und wacht den wartenden Tread nach dem Schreiben auf.</p>
+
+<pre class="brush: js">console.log(int32[0]); // 0;
+Atomics.store(int32, 0, 123);
+Atomics.notify(int32, 0, 1);</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-atomics.notify', 'Atomics.notify')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initiale Definition in ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Atomics.notify")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Atomics")}}</li>
+ <li>{{jsxref("Atomics.wait()")}}</li>
+</ul>
diff --git a/files/de/web/javascript/reference/global_objects/atomics/xor/index.html b/files/de/web/javascript/reference/global_objects/atomics/xor/index.html
new file mode 100644
index 0000000000..913fcc1298
--- /dev/null
+++ b/files/de/web/javascript/reference/global_objects/atomics/xor/index.html
@@ -0,0 +1,130 @@
+---
+title: Atomics.xor()
+slug: Web/JavaScript/Reference/Global_Objects/Atomics/xor
+tags:
+  - Atomics
+  - JavaScript
+  - Method
+  - Shared Memory
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/xor
+---
+<div>{{JSRef}}</div>
+
+<p>Die statische <code><strong>Atomics</strong></code><strong><code>.xor()</code></strong> Methode berechnet eine bitweises XOR mit einem gegebenen Wert auf einem Wert an einer gegebenen Position im Array und gibt den alten Wert an der Position zurück. Die atomare Operation garantiert, dass kein anderer Schreibprozess während der Operation durchgeführt wird.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/atomics-xor.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Atomics.and(typedArray, index, value)
+</pre>
+
+<h3 id="Parameter">Parameter</h3>
+
+<dl>
+ <dt><code>typedArray</code></dt>
+ <dd>Ein geteiltes getrypted Integer Array. Eines von {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}} oder {{jsxref("Uint32Array")}}.</dd>
+ <dt><code>index</code></dt>
+ <dd>Die Position in <code>typedArray</code>, mit der das bitweise XOR berechnet wird.</dd>
+ <dt><code>value</code></dt>
+ <dd>Die Zahl, mit der das bitweise XOR berechnet wird.</dd>
+</dl>
+
+<h3 id="Rückgabewert">Rückgabewert</h3>
+
+<p>Der alte Wert an der gegebenen Position (<code>typedArray[index]</code>).</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<ul>
+ <li>Erzeugt einen {{jsxref("TypeError")}}, wenn <code>typedArray</code> nicht von einem erlaubten Integer Typ ist.</li>
+ <li>Erzeugt eine {{jsxref("TypeError")}}, wenn <code>typedArray</code> kein geteilter Arraytyp ist.</li>
+ <li>Erzeugt ein {{jsxref("RangeError")}}, wenn der <code>index</code> nicht in den Grenzen von <code>typedArray</code> ist.</li>
+</ul>
+
+<h2 id="Beschreibung">Beschreibung</h2>
+
+<p>Die bitweise XOR Operation ergibt nur 1, wenn genau ein Werte, <code>a</code> oder <code>b</code>, 1 ist. Die Wahrheitstabelle für die XOR Operation ist:</p>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th><code>a</code></th>
+   <th><code>b</code></th>
+   <th><code>a &amp; b</code></th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>0</td>
+   <td>0</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>0</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>1</td>
+   <td>0</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Zum Beispiel resultiert ein bitweises XOR auf <code>5 &amp; 1</code> in <code>0100</code>, was im Dezimalsystem 4 ist.</p>
+
+<pre>5  0101
+1  0001
+   ----
+4  0100</pre>
+
+<h2 id="Beispiele">Beispiele</h2>
+
+<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+var ta = new Uint8Array(sab);
+ta[0] = 5;
+
+Atomics.xor(ta, 0, 1); // returns 5, the old value
+Atomics.load(ta, 0);  // 4</pre>
+
+<h2 id="Spezifikationen">Spezifikationen</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Spezifikation</th>
+   <th scope="col">Status</th>
+   <th scope="col">Kommentar</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-atomics.xor', 'Atomics.xor')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initiale Definition in ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browserkompatibilität">Browserkompatibilität</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Atomics.xor")}}</p>
+
+<h2 id="Siehe_auch">Siehe auch</h2>
+
+<ul>
+ <li>{{jsxref("Atomics")}}</li>
+ <li>{{jsxref("Atomics.and()")}}</li>
+ <li>{{jsxref("Atomics.or()")}}</li>
+</ul>
+
+<p> </p>