面试题：C语言Linux多线程负载均衡中的资源竞争处理

Question

在实现Linux C语言多线程负载均衡过程中，不可避免会出现资源竞争问题。假设你有一个共享资源，多个线程会同时对其进行读写操作，描述你会采用哪些机制（如互斥锁、信号量等）来解决这个问题，并说明在代码中如何具体实现。

Answer 1

1. 互斥锁（Mutex）

• 原理：互斥锁用于保证在同一时刻只有一个线程能够访问共享资源，就像一把锁，线程获取锁才能访问资源，访问完释放锁。
• 代码实现（示例）：

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

// 共享资源
int shared_variable = 0;
// 互斥锁
pthread_mutex_t mutex;

// 线程函数
void* thread_function(void* arg) {
    // 加锁
    pthread_mutex_lock(&mutex);
    // 访问共享资源
    shared_variable++;
    printf("Thread incremented shared_variable to %d\n", shared_variable);
    // 解锁
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main() {
    pthread_t thread;
    // 初始化互斥锁
    pthread_mutex_init(&mutex, NULL);
    // 创建线程
    pthread_create(&thread, NULL, thread_function, NULL);
    // 等待线程结束
    pthread_join(thread, NULL);
    // 销毁互斥锁
    pthread_mutex_destroy(&mutex);
    return 0;
}

2. 读写锁（Read-Write Lock）

• 原理：读写锁区分读操作和写操作。允许多个线程同时进行读操作，但只允许一个线程进行写操作，且写操作时不允许读操作。这样在读多写少的场景下，能提高并发性能。
• 代码实现（示例）：

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

// 共享资源
int shared_variable = 0;
// 读写锁
pthread_rwlock_t rwlock;

// 读线程函数
void* read_thread_function(void* arg) {
    // 加读锁
    pthread_rwlock_rdlock(&rwlock);
    // 读共享资源
    printf("Read thread read shared_variable as %d\n", shared_variable);
    // 解锁
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

// 写线程函数
void* write_thread_function(void* arg) {
    // 加写锁
    pthread_rwlock_wrlock(&rwlock);
    // 写共享资源
    shared_variable++;
    printf("Write thread incremented shared_variable to %d\n", shared_variable);
    // 解锁
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

int main() {
    pthread_t read_thread, write_thread;
    // 初始化读写锁
    pthread_rwlock_init(&rwlock, NULL);
    // 创建读线程
    pthread_create(&read_thread, NULL, read_thread_function, NULL);
    // 创建写线程
    pthread_create(&write_thread, NULL, write_thread_function, NULL);
    // 等待读线程结束
    pthread_join(read_thread, NULL);
    // 等待写线程结束
    pthread_join(write_thread, NULL);
    // 销毁读写锁
    pthread_rwlock_destroy(&rwlock);
    return 0;
}

3. 信号量（Semaphore）

• 原理：信号量可以控制同时访问共享资源的线程数量。通过初始化信号量的值来设定允许访问的线程数，线程获取信号量（值减1）才能访问资源，释放信号量（值加1）。
• 代码实现（示例）：

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

// 共享资源
int shared_variable = 0;
// 信号量
sem_t semaphore;

// 线程函数
void* thread_function(void* arg) {
    // 获取信号量
    sem_wait(&semaphore);
    // 访问共享资源
    shared_variable++;
    printf("Thread incremented shared_variable to %d\n", shared_variable);
    // 释放信号量
    sem_post(&semaphore);
    return NULL;
}

int main() {
    pthread_t thread;
    // 初始化信号量，允许一个线程访问
    sem_init(&semaphore, 0, 1);
    // 创建线程
    pthread_create(&thread, NULL, thread_function, NULL);
    // 等待线程结束
    pthread_join(thread, NULL);
    // 销毁信号量
    sem_destroy(&semaphore);
    return 0;
}