linux 高并发编程

基础概念

Linux高并发编程是指在Linux操作系统环境下，设计和实现能够同时处理大量并发请求的程序。高并发编程涉及多线程、多进程、异步I/O等多种技术，旨在提高系统的吞吐量和响应速度。

优势

提高资源利用率：通过并发处理，可以充分利用多核CPU的计算能力。
提升系统性能：并发编程可以显著提高系统的吞吐量和响应速度。
增强系统稳定性：通过合理的并发控制，可以有效避免单点故障，提高系统的稳定性。

类型

多线程编程：通过创建多个线程来实现并发处理。
多进程编程：通过创建多个进程来实现并发处理。
异步I/O编程：通过非阻塞I/O和事件驱动的方式来实现并发处理。

应用场景

Web服务器：如Nginx、Apache等，需要处理大量并发请求。
数据库系统：如MySQL、PostgreSQL等，需要处理大量的并发读写操作。
实时通信系统：如WebSocket服务器，需要处理大量的实时消息。
分布式系统：如ZooKeeper、Kafka等，需要处理大量的并发请求。

常见问题及解决方法

1. 竞态条件（Race Condition）

问题描述：多个线程或进程同时访问和修改共享资源，导致结果不可预测。

解决方法：

使用互斥锁（Mutex）来保护共享资源。
使用信号量（Semaphore）来控制并发访问的数量。

示例代码：

#include <stdio.h>
#include <pthread.h>

int counter = 0;
pthread_mutex_t mutex;

void* increment(void* arg) {
    pthread_mutex_lock(&mutex);
    counter++;
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main() {
    pthread_t threads[10];
    pthread_mutex_init(&mutex, NULL);

    for (int i = 0; i < 10; i++) {
        pthread_create(&threads[i], NULL, increment, NULL);
    }

    for (int i = 0; i < 10; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("Counter: %d\n", counter);
    pthread_mutex_destroy(&mutex);
    return 0;
}

参考链接：

pthread_mutex_lock

2. 死锁（Deadlock）

问题描述：两个或多个线程或进程互相等待对方释放资源，导致程序无法继续执行。

解决方法：

使用资源分配图来检测和避免死锁。
使用银行家算法来避免死锁。
按照固定的顺序获取资源。

示例代码：

#include <stdio.h>
#include <pthread.h>

pthread_mutex_t mutex1, mutex2;

void* thread1_func(void* arg) {
    pthread_mutex_lock(&mutex1);
    pthread_mutex_lock(&mutex2);
    // do something
    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);
    return NULL;
}

void* thread2_func(void* arg) {
    pthread_mutex_lock(&mutex1);
    pthread_mutex_lock(&mutex2);
    // do something
    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    pthread_mutex_init(&mutex1, NULL);
    pthread_mutex_init(&mutex2, NULL);

    pthread_create(&thread1, NULL, thread1_func, NULL);
    pthread_create(&thread2, NULL, thread2_func, NULL);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    pthread_mutex_destroy(&mutex1);
    pthread_mutex_destroy(&mutex2);
    return 0;
}

参考链接：

pthread_mutex_lock

3. 性能瓶颈

问题描述：在高并发场景下，程序的性能出现瓶颈，无法满足需求。

解决方法：

使用性能分析工具（如perf、gprof）来定位性能瓶颈。
优化代码逻辑，减少不必要的计算和内存分配。
使用线程池或进程池来复用资源，减少创建和销毁的开销。

示例代码：

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>

typedef struct {
    int* data;
    int size;
} ThreadData;

void* process_data(void* arg) {
    ThreadData* data = (ThreadData*)arg;
    for (int i = 0; i < data->size; i++) {
        // do something with data->data[i]
    }
    return NULL;
}

int main() {
    int data_size = 1000000;
    int* data = (int*)malloc(data_size * sizeof(int));
    pthread_t threads[4];
    ThreadData thread_data[4];

    for (int i = 0; i < 4; i++) {
        thread_data[i].data = data + (data_size / 4) * i;
        thread_data[i].size = data_size / 4;
        pthread_create(&threads[i], NULL, process_data, &thread_data[i]);
    }

    for (int i = 0; i < 4; i++) {
        pthread_join(threads[i], NULL);
    }

    free(data);
    return 0;
}

参考链接：