从线程池到负载均衡：高并发场景下的系统优化实战

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 创建固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(10);

        // 提交任务
        for (int i = 0; i < 100; i++) {
            executor.submit(() -> {
                System.out.println("Task executed by " + Thread.currentThread().getName());
            });
        }

        // 关闭线程池
        executor.shutdown();
    }
}

from concurrent.futures import ProcessPoolExecutor

def task(n):
    return n * n

if __name__ == "__main__":
    with ProcessPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(task, range(10)))
    print("Results:", results)

const fs = require('fs').promises;

async function readFiles() {
    const file1 = await fs.readFile('file1.txt', 'utf8');
    const file2 = await fs.readFile('file2.txt', 'utf8');
    console.log(file1, file2);
}

readFiles();

servers = ['Server1', 'Server2', 'Server3']
current = 0

def round_robin():
    global current
    server = servers[current]
    current = (current + 1) % len(servers)
    return server

# 模拟请求分发
for _ in range(10):
    print(round_robin())

servers = [('Server1', 3), ('Server2', 2), ('Server3', 1)]  # (服务器, 权重)
current = 0

def weighted_round_robin():
    global current
    total_weight = sum(weight for _, weight in servers)
    server_index = current % total_weight
    for server, weight in servers:
        if server_index < weight:
            selected_server = server
            break
        server_index -= weight
    current += 1
    return selected_server

# 模拟请求分发
for _ in range(10):
    print(weighted_round_robin())

servers = {'Server1': 0, 'Server2': 0, 'Server3': 0}  # 服务器: 连接数

def least_connections():
    selected_server = min(servers, key=servers.get)
    servers[selected_server] += 1
    return selected_server

# 模拟请求分发
for _ in range(10):
    print(least_connections())