1
// 多线程环境下典型的竞态条件
2
public class Counter {
3
    private int count = 0;
4

5
    public void increment() {
6
        count++;  // 非原子操作！
7
    }
8
}

1
// 线程 1：删除节点
2
document.getElementById("container").remove();
3

4
// 线程 2：同时操作同一个节点
5
document.getElementById("container").appendChild(child);

1
console.log("1. 开始");
2

3
setTimeout(() => {
4
  console.log("2. setTimeout");
5
}, 0);
6

7
Promise.resolve().then(() => {
8
  console.log("3. Promise");
9
});
10

11
console.log("4. 结束");
12

13
// 输出顺序：1, 4, 3, 2

1
// 不使用微任务
2
function processData(data) {
3
  console.log("处理数据");
4
  // 问题是：这会阻塞后续代码
5
  notifyUsers(data);
6
  updateUI(data);
7
  logAnalytics(data);
8
}
9

10
// 使用微任务
11
function processData(data) {
12
  console.log("处理数据");
13
  // 将非关键操作推迟到微任务
14
  queueMicrotask(() => notifyUsers(data));
15
  queueMicrotask(() => updateUI(data));
16
  queueMicrotask(() => logAnalytics(data));
17
}

1
async function fetchUser(id) {
2
  const response = await fetch(`/api/users/${id}`);
3
  const user = await response.json();
4
  return user;
5
}
6

7
// 等价于
8
function fetchUser(id) {
9
  return fetch(`/api/users/${id}`)
10
    .then(response => response.json())
11
    .then(user => user);
12
}

1
// 主线程
2
const worker = new Worker("compute.js");
3

4
worker.postMessage({ data: largeData });
5

6
worker.onmessage = e => {
7
  console.log("计算结果:", e.data);
8
};
9

10
// compute.js (Worker 线程)
11
self.onmessage = e => {
12
  const result = heavyComputation(e.data);
13
  self.postMessage(result);
14
};

1
// Java 多线程示例
2
public class Counter {
3
    private int count = 0;
4
    private final Object lock = new Object();
5

6
    public void increment() {
7
        synchronized (lock) {
8
            count++;
9
        }
10
    }
11
}
12

13
// 创建多个线程
14
for (int i = 0; i < 10; i++) {
15
    new Thread(() -> {
16
        counter.increment();
17
    }).start();
18
}

1
import threading
2

3
# 多线程在 CPU 密集任务中无法并行
4
def cpu_bound():
5
    sum(range(10000000))
6

7
threads = [threading.Thread(target=cpu_bound) for _ in range(4)]
8
# 这不会比单线程更快！

1
func main() {
2
    var wg sync.WaitGroup
3

4
    for i := 0; i < 1000; i++ {
5
        wg.Add(1)
6
        go func(n int) {
7
            defer wg.Done()
8
            fmt.Println(n)
9
        }(i)
10
    }
11

12
    wg.Wait()
13
}

1
// 阻塞式（传统服务器）
2
const data = fs.readFileSync("file.txt"); // 阻塞
3
processData(data);
4
handleOtherRequests(); // 等待读取完成后才能处理
5

6
// 非阻塞式（Node.js）
7
fs.readFile("file.txt", (err, data) => {
8
  processData(data); // 回调执行
9
});
10
handleOtherRequests(); // 立即执行，不等待

1
const cluster = require("cluster");
2
const os = require("os");
3

4
if (cluster.isMaster) {
5
  const cpuCount = os.cpus().length;
6
  for (let i = 0; i < cpuCount; i++) {
7
    cluster.fork();
8
  }
9
} else {
10
  // Worker 进程
11
  require("./server");
12
}