// -- main.js --
const worker = new Worker("./worker.js", { type: "module" });Agent communication and coordination / notebook
Agent communication and coordination
Runnable notebook: every JavaScript, HTML and CSS example on this page executes in a sandboxed local frame. Nothing leaves the browser.
<script src="main.js" type="module"></script>// -- main.js --
const worker = new Worker("./worker.js", { type: "module" });
const { port1, port2 } = new MessageChannel();
// We'll explain the [port2] parameter soon
worker.postMessage({ hereIsYourPort: port2 }, [port2]);
// Mark the port as ready for receiving messages
port1.start();// -- worker.js --
// Use top-level await (only available inside modules) so code following it
// only evaluates when the port is received
const port = await new Promise((resolve, reject) => {
self.addEventListener(
"message",
(e) => {
const port = e.data.hereIsYourPort;
if (!(port instanceof MessagePort)) {
reject(new Error("I'm expecting a dedicated port"));
return;
}
resolve(port);
},
{ once: true },
);
});
// Mark the port as ready for receiving messages
port.start();const { port1, port2 } = new MessageChannel();
const worker1 = new Worker("./worker1.js", { type: "module" });
const worker2 = new Worker("./worker2.js", { type: "module" });
worker1.postMessage({ hereIsYourPort: port1 }, [port1]);
worker2.postMessage({ hereIsYourPort: port2 }, [port2]);// -- main.js --
const secretNumber = 63;
port1.addEventListener("message", (e) => {
const workerGuess = e.data;
console.log("Worker guessed:", workerGuess);
if (workerGuess < secretNumber) {
port1.postMessage("Too low");
} else if (workerGuess > secretNumber) {
port1.postMessage("Too high");
} else {
port1.postMessage("Correct");
console.log("Worker successfully guessed the secret number!");
}
});// -- worker.js --
let low = 0;
let high = 100;
let lastGuess = Math.floor((low + high) / 2);
// First guess submitted immediately after initialization
port.postMessage(lastGuess);
port.addEventListener("message", (e) => {
const feedback = e.data;
if (feedback === "Correct") {
console.log("Yay");
return;
}
if (feedback === "Too low") {
low = lastGuess + 1;
} else if (feedback === "Too high") {
high = lastGuess - 1;
}
if (low > high) {
throw new Error(
"Sorry, the feedback from main.js is inconsistent and I suspect main is cheating",
);
}
lastGuess = Math.floor((low + high) / 2);
port.postMessage(lastGuess);
});
port.start();worker.postMessage({ hereIsYourPort: port2 }, [port2]);const buffer1 = new ArrayBuffer(1024);
console.log(buffer1.detached); // false
console.log(buffer1.byteLength); // 1024
const buffer2 = buffer1.transfer();
console.log(buffer1.detached); // true
console.log(buffer1.byteLength); // 0
console.log(buffer2.byteLength); // 1024console.log(window.crossOriginIsolated); // true
console.log("SharedArrayBuffer" in window); // trueconst sab = new SharedArrayBuffer(1024);const int8 = new Int8Array(sab);
int8[0] = 63;const sab2 = sab.slice();
// Entire sab is copied
const int82 = new Int8Array(sab2);
console.log(int82[0]); // 63const sabResizable = new SharedArrayBuffer(1024, { maxByteLength: 2048 });
console.log(sabResizable.byteLength); // 1024
sabResizable.grow(2000);
console.log(sabResizable.byteLength); // 2000worker.postMessage({ hereIsYourPort: port2 }, [port2]);const sab = new SharedArrayBuffer(1024);
worker.postMessage({ hereIsYourPort: port2, andHereIsOurSAB: sab }, [port2]);const { port, sab } = await new Promise((resolve, reject) => {
self.addEventListener(
"message",
(e) => {
const port = e.data.hereIsYourPort;
if (!(port instanceof MessagePort)) {
reject(new Error("I'm expecting a dedicated port"));
return;
}
const sab = e.data.andHereIsOurSAB;
if (!(sab instanceof SharedArrayBuffer)) {
reject(new Error("I'm expecting a shared array buffer"));
return;
}
resolve({ port, sab });
},
{ once: true },
);
});// -- main.js --
const int8 = new Int8Array(sab);
port1.addEventListener("message", (e) => {
console.log(int8[0]); // 63
});// -- worker.js --
const int8 = new Int8Array(sab);
int8[0] = 63;
port.postMessage("I've modified the memory. Please check");const promise = Promise.resolve();
let i = 0;
promise.then(() => {
i += 1;
console.log(i);
});
promise.then(() => {
i += 1;
console.log(i);
});// -- main.js --
const i = new Int32Array(sab, 0, 1);
port1.addEventListener("message", ({ data }) => {
if (data === "started") {
for (let n = 0; n < 10_000_000; n++) {
i[0] += 1;
}
} else if (data === "finished") {
console.log(i[0]); // Usually less than 20000000
}
});// -- worker.js --
const i = new Int32Array(sab, 0, 1);
port.postMessage("started");
for (let n = 0; n < 10_000_000; n++) {
i[0] += 1;
}
port.postMessage("finished");// -- main.js --
const a = new Int32Array(sab);
a[0] = 63;
console.log("Main:", a[1]);// -- worker.js --
const a = new Int32Array(sab);
a[1] = 15;
console.log("Worker:", a[0]);// -- main.js --
const a = new Int32Array(sab);
Atomics.store(a, 0, 63);
console.log("Main:", Atomics.load(a, 1));// -- worker.js --
const a = new Int32Array(sab);
Atomics.store(a, 1, 15);
console.log("Worker:", Atomics.load(a, 0));// -- main.js --
a[0] = 63;
// Set a "Ready" flag in a[1]; assume initially it's not 1.
Atomics.store(a, 1, 1);// -- worker.js --
// Spin until a[1] receives the "Ready" flag
while (Atomics.load(a, 1) !== 1);
console.log(a[0]); // 63// -- main.js --
const i = new Int32Array(sab, 0, 1);
port1.addEventListener("message", ({ data }) => {
if (data === "started") {
for (let n = 0; n < 10_000_000; n++) {
Atomics.add(i, 0, 1);
}
} else if (data === "finished") {
console.log(i[0]); // Guaranteed 20000000
}
});// -- worker.js --
const i = new Int32Array(sab, 0, 1);
port.postMessage("started");
for (let n = 0; n < 10_000_000; n++) {
Atomics.add(i, 0, 1);
}
port.postMessage("finished");const oldValue = array[index];
if (oldValue === expectedValue) {
array[index] = newValue;
}
return oldValue;function atomicMultiply(array, index, multiplier) {
let oldValue = Atomics.load(array, index);
while (true) {
const observed = Atomics.compareExchange(
array,
index,
oldValue,
oldValue * multiplier,
);
if (observed === oldValue) {
return oldValue;
}
oldValue = observed;
}
}const oldValue = array[index];
array[index] = newValue;
return oldValue;// -- worker.js --
while (true) {
Atomics.add(a, 0, 1);
}// -- main.js --
const ticksSinceLastCheck = Atomics.exchange(a, 0, 0);
// ticksSinceLastCheck records how many times the worker has spun.// -- worker.js --
while (Atomics.load(a, 1) !== 1) {
Atomics.pause();
}// -- worker.js --
Atomics.wait(a, 1, 0);
console.log(a[0]);// -- main.js --
a[0] = 63;
Atomics.store(a, 1, 1);
Atomics.notify(a, 1);// -- worker.js --
const result = Atomics.wait(a, 1, 0, 100); // Wait about 100ms
if (result === "timed-out") {
// Decide what to do here: wait again? Throw an error?
// Change to an asynchronous wait instead?
} else {
// result can be either "not-equal" - i.e., a[1] is already "Ready"
// without waiting or "ok" - i.e., some other thread notified it
console.log(a[0]);
}// -- main.js --
const result = Atomics.waitAsync(a, 1, 0, 100); // Wait about 100ms
if (!result.async) {
// Already ready
// (Note: because timeout is not 0, result.value is always "not-equal")
console.log(a[0]);
} else {
const resultValue = await result.value;
if (resultValue === "ok") {
console.log(a[0]);
} else {
// resultValue is "timed-out" here; decide what to do
}
}const sab = new SharedArrayBuffer(8);
const shared = new Int32Array(sab);
shared[0] = 1;function lock() {
while (Atomics.compareExchange(shared, 0, 1, 0) !== 1) {
Atomics.wait(shared, 0, 0);
}
}
function unlock() {
Atomics.store(shared, 0, 1);
Atomics.notify(shared, 0, 1);
}lock();
try {
shared[1] *= 2;
shared[1] += 1;
} finally {
unlock();
}function lock() {
while (Atomics.compareExchange(shared, 0, 1, 0) !== 1) {
Atomics.pause();
}
}
function unlock() {
Atomics.store(shared, 0, 1);
}const sab = new SharedArrayBuffer(4);
const permits = new Int32Array(sab);
permits[0] = 3;const permits = new Int32Array(sab);
function acquire() {
while (true) {
const available = Atomics.load(permits, 0);
if (available === 0) {
Atomics.wait(permits, 0, 0);
} else if (
Atomics.compareExchange(permits, 0, available, available - 1) ===
available
) {
return;
}
}
}
function release() {
Atomics.add(permits, 0, 1);
Atomics.notify(permits, 0, 1);
}
acquire();
try {
// Perform a task that requires one permit.
} finally {
release();
}// -- a.js --
lockX.lock();
try {
lockY.lock(); // Waiting for lockY.unlock() in b.js...
try {
// Work requiring both locks
} finally {
lockY.unlock();
}
} finally {
lockX.unlock();
}// -- b.js --
lockY.lock();
try {
lockX.lock(); // Waiting for lockX.unlock() in a.js...
try {
// Work requiring both locks
} finally {
lockX.unlock();
}
} finally {
lockY.unlock();
}const firstByte = uint8[0]; // uint8 is the same memory span viewed as Uint8Array
const secondByte = uint8[1];
const value = firstByte + (secondByte << 8);Atomics.isLockFree(4); // true: required for 4-byte atomic operations
Atomics.isLockFree(7); // false: not a supported atomic element sizefunction atomicMultiply(array, index, multiplier) {
let oldValue = Atomics.load(array, index);
while (true) {
const observed = Atomics.compareExchange(
array,
index,
oldValue,
oldValue * multiplier,
);
if (observed === oldValue) {
return oldValue;
}
oldValue = observed;
}
}const sab = new SharedArrayBuffer(8);
const shared = new Int32Array(sab);// -- producer.js --
function produce(value) {
while (Atomics.load(shared, 0) !== 0) {
Atomics.wait(shared, 0, 1);
}
shared[1] = value;
Atomics.store(shared, 0, 1);
Atomics.notify(shared, 0, 1);
}
produce(63);
produce(64);// -- consumer.js --
function consume() {
while (Atomics.load(shared, 0) !== 1) {
Atomics.wait(shared, 0, 0);
}
const value = shared[1];
Atomics.store(shared, 0, 0);
Atomics.notify(shared, 0, 1);
return value;
}
console.log(consume()); // 63
console.log(consume()); // 64// -- main.js --
const worker = new Worker("./worker.js", { type: "module" });
const sab = new SharedArrayBuffer(8);
const shared = new Int32Array(sab);
const secretNumber = 63;
// The turn flag is initially 0, so the worker takes the first turn
worker.postMessage(sab);
// Wait until the worker has started. The browser may not start the
// worker until the main thread returns to the event loop.
await new Promise((resolve) => {
worker.addEventListener("message", resolve, { once: true });
});
while (true) {
// Wait until the worker finishes its turn
while (Atomics.load(shared, 0) !== 1) {
// We use busy waiting here because we expect the worker to come
// back very quickly and the main thread can't use Atomics.wait().
// In more complex scenarios, you probably want to use Atomics.waitAsync()
// to avoid blocking the main thread.
Atomics.pause();
}
const workerGuess = shared[1];
console.log("Worker guessed:", workerGuess);
const feedback =
workerGuess < secretNumber ? -1 : workerGuess > secretNumber ? 1 : 0;
shared[1] = feedback;
Atomics.store(shared, 0, 0);
Atomics.notify(shared, 0, 1);
if (feedback === 0) {
console.log("Worker successfully guessed the secret number!");
break;
}
}// -- worker.js --
const sab = await new Promise((resolve) => {
self.addEventListener("message", (e) => resolve(e.data), { once: true });
});
const shared = new Int32Array(sab);
let low = 0;
let high = 100;
// Tell the main thread that the worker has started
self.postMessage("ready");
while (true) {
const lastGuess = Math.floor((low + high) / 2);
// Worker initiates the handoff here by making a guess
shared[1] = lastGuess;
Atomics.store(shared, 0, 1);
Atomics.notify(shared, 0, 1);
// Wait until the main agent writes the feedback
while (Atomics.load(shared, 0) !== 0) {
Atomics.wait(shared, 0, 1);
}
const feedback = shared[1];
if (feedback === 0) {
console.log("Yay");
break;
}
if (feedback === -1) {
low = lastGuess + 1;
} else if (feedback === 1) {
high = lastGuess - 1;
}
if (low > high) {
throw new Error(
"Sorry, the feedback from main.js is inconsistent and I suspect main is cheating",
);
}
}