揭秘高并发背后的系统崩溃始末：还原现场，直击痛点！

后端

2023-10-28 10:13:13

高并发：一把双刃剑

前言

在互联网的汪洋大海中，高并发现象已成为一种常态，既是网站和应用程序的荣耀，也是它们面临的严峻考验。在这篇文章中，我们将深入探究高并发背后的原理、潜在风险和应对策略，为企业和开发者提供在高并发时代生存和壮大的指南。

高并发：机遇与挑战并存

高并发是指在短时间内对系统或应用程序的大量并发访问。这种现象通常是由突发流量或高峰时段造成的。对于网站或应用程序而言，高并发既是受欢迎程度和影响力的象征，也是考验其技术实力和稳定性的试金石。

高并发引发的系统崩溃：蝴蝶效应

当并发访问量超过系统处理能力时，就会产生高并发风险。就像多米诺骨牌效应，一个微小的故障会迅速蔓延到整个系统，导致系统崩溃。以下是一些常见的高并发引发系统崩溃的原因：

服务器资源不足： 并发访问量超过服务器处理能力，导致服务器资源枯竭，进而崩溃。
网络拥塞： 并发访问量过大，导致网络无法及时处理请求，造成网络拥塞，降低系统响应速度，甚至导致崩溃。
数据库压力过大： 并发访问量过大，导致数据库无法及时处理查询，产生数据库压力，降低系统响应速度，甚至导致崩溃。
缓存失效： 缓存失效时，系统需要从数据库中重新加载数据，导致系统性能下降，甚至崩溃。

应对高并发挑战的策略：分而治之

面对高并发带来的巨大挑战，业界已开发出多种有效的应对策略，帮助系统抵御高并发洪流，避免系统崩溃。这些策略包括：

负载均衡： 负载均衡将请求合理分配到多个服务器上，减轻单个服务器压力，提升系统整体处理能力。

from random import choice
from socket import *

# 创建一个包含服务器地址列表的元组
servers = (('192.168.1.1', 80), ('192.168.1.2', 80), ('192.168.1.3', 80))

# 创建一个套接字对象
s = socket()

while True:
    # 从服务器列表中随机选择一个服务器
    server = choice(servers)

    # 连接到服务器
    s.connect(server)

    # 发送请求
    s.send('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n'.encode('utf-8'))

    # 接收响应
    data = s.recv(1024)

    # 关闭套接字
    s.close()

分布式系统： 分布式系统将系统分解为多个独立组件，每个组件负责处理一部分请求，提升系统整体处理能力。

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

public class DistributedSystem {

    private static final int NUM_THREADS = 4;

    public static void main(String[] args) {
        // 创建一个线程池，包含指定数量的线程
        ExecutorService executorService = Executors.newFixedThreadPool(NUM_THREADS);

        // 提交任务到线程池
        for (int i = 0; i < 100; i++) {
            executorService.submit(new Task(i));
        }

        // 等待所有任务完成
        executorService.shutdown();
        while (!executorService.isTerminated()) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static class Task implements Runnable {

        private final int id;

        public Task(int id) {
            this.id = id;
        }

        @Override
        public void run() {
            // 处理任务
            System.out.println("任务 " + id + " 已处理。");
        }
    }
}

缓存： 缓存将数据临时存储在内存中，当用户请求数据时，系统首先从缓存中读取数据，提升系统响应速度，减轻数据库压力。

<?php

// 创建一个缓存对象
$cache = new Cache();

// 设置缓存键值对
$cache->set('key', 'value');

// 获取缓存值
$value = $cache->get('key');

// 检查缓存值是否存在
if ($value !== false) {
    // 使用缓存值
    echo $value;
} else {
    // 从数据库中获取值并更新缓存
    $value = $database->get('key');
    $cache->set('key', $value);

    // 使用数据库值
    echo $value;
}

?>

微服务： 微服务将系统分解为多个小型、独立的服务，每个服务负责处理一部分功能，提升系统可扩展性和灵活性。

require 'sinatra'

get '/' do
  'Hello world!'
end

run!

弹性计算： 弹性计算根据系统负载动态调整资源分配，降低系统运行成本，提升系统可靠性。

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
    "runtime"
    "strconv"
)

func main() {
    // 获取 CPU 核心数
    numCPUs := runtime.NumCPU()

    // 设置最大线程数
    runtime.GOMAXPROCS(numCPUs)

    // 启动 HTTP 服务器
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // 处理请求

        // 获取当前线程数
        numThreads := runtime.NumGoroutine()

        // 输出线程数
        fmt.Fprintf(w, "当前线程数：%d\n", numThreads)
    })

    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    log.Printf("监听端口 %s", port)
    if err := http.ListenAndServe(":"+port, nil); err != nil {
        log.Fatal(err)
    }
}