Linux进程同步：怎样避免资源冲突 - 问答

在Linux系统中，为了避免多个进程同时访问共享资源而导致的资源冲突，可以采用以下几种进程同步机制：

1. 互斥锁（Mutex）

互斥锁是一种简单的同步机制，用于确保同一时间只有一个进程可以访问共享资源。

#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* thread_func(void* arg) {
    pthread_mutex_lock(&mutex);
    // 访问共享资源
    pthread_mutex_unlock(&mutex);
    return NULL;
}

2. 信号量（Semaphore）

信号量是一种更高级的同步机制，可以用来控制对共享资源的访问。

二进制信号量（Binary Semaphore）

类似于互斥锁，但更通用。

#include <semaphore.h>

sem_t semaphore;

void init_semaphore() {
    sem_init(&semaphore, 0, 1);
}

void* thread_func(void* arg) {
    sem_wait(&semaphore);
    // 访问共享资源
    sem_post(&semaphore);
    return NULL;
}

计数信号量（Counting Semaphore）

可以用来控制对一组资源的访问。

#include <semaphore.h>

sem_t semaphore;

void init_semaphore(int count) {
    sem_init(&semaphore, 0, count);
}

void* thread_func(void* arg) {
    sem_wait(&semaphore);
    // 访问共享资源
    sem_post(&semaphore);
    return NULL;
}

3. 条件变量（Condition Variable）

条件变量用于进程间的同步，允许一个或多个进程等待某个条件的发生。

#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void* producer(void* arg) {
    pthread_mutex_lock(&mutex);
    // 生产数据
    pthread_cond_signal(&cond); // 通知消费者
    pthread_mutex_unlock(&mutex);
    return NULL;
}

void* consumer(void* arg) {
    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond, &mutex); // 等待生产者通知
    // 消费数据
    pthread_mutex_unlock(&mutex);
    return NULL;
}

4. 屏障（Barrier）

屏障用于同步多个进程，确保它们在某个点上同时继续执行。

#include <pthread.h>

#define NUM_THREADS 4

pthread_barrier_t barrier;

void* thread_func(void* arg) {
    // 做一些工作
    pthread_barrier_wait(&barrier);
    // 继续执行
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    pthread_barrier_init(&barrier, NULL, NUM_THREADS);

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

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

    pthread_barrier_destroy(&barrier);
    return 0;
}

5. 文件锁（File Locking）

文件锁是一种通过操作系统提供的机制来同步对文件的访问。

#include <fcntl.h>
#include <unistd.h>
#include <sys/file.h>

int fd = open("file.txt", O_RDWR);
if (fd == -1) {
    perror("open");
    return 1;
}

// 获取排他锁
if (flock(fd, LOCK_EX) == -1) {
    perror("flock");
    close(fd);
    return 1;
}

// 访问文件

// 释放锁
if (flock(fd, LOCK_UN) == -1) {
    perror("flock");
    close(fd);
    return 1;
}

close(fd);

总结

选择合适的同步机制取决于具体的应用场景和需求。互斥锁和信号量适用于简单的资源保护，条件变量和屏障适用于更复杂的同步需求，而文件锁则适用于需要跨进程同步的场景。合理使用这些同步机制可以有效避免资源冲突。

0 赞

0 踩