正文

解锁操作系统进程同步难题，实战练习题大揭秘！

/0 浏览量
0323

引言

在操作系统的设计中，进程同步是一个至关重要的概念。它确保了多个进程能够有序地执行，避免了竞争条件和死锁等问题。本文将深入探讨操作系统进程同步的难题，并提供一系列实战练习题，帮助读者理解和掌握这一复杂主题。

进程同步基础

1. 线程与进程

在操作系统中，线程是进程中的一个实体，被系统独立调度和分派的基本单位。进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。

2. 同步机制

为了实现进程同步，操作系统提供了多种同步机制，包括：

  • 互斥锁（Mutex）：确保一次只有一个线程可以访问共享资源。
  • 信号量（Semaphore）：用于控制对共享资源的访问，可以是一个计数信号量或二进制信号量。
  • 条件变量：允许线程在某些条件成立之前挂起，直到其他线程改变这些条件。

实战练习题

练习题 1：互斥锁的使用

题目描述：编写一个程序，使用互斥锁保护一个共享资源，确保同一时间只有一个线程可以访问该资源。

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

pthread_mutex_t lock;
int shared_resource = 0;

void* thread_function(void* arg) {
    pthread_mutex_lock(&lock);
    // 临界区代码
    shared_resource++;
    printf("Thread %d: Shared resource value is now %d\n", *(int*)arg, shared_resource);
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main() {
    pthread_t threads[10];
    int thread_ids[10];

    pthread_mutex_init(&lock, NULL);

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

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

    pthread_mutex_destroy(&lock);
    return 0;
}

练习题 2：信号量的使用

题目描述：使用信号量实现一个生产者-消费者问题，其中生产者生产数据，消费者消费数据。

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

#define BUFFER_SIZE 10
int buffer[BUFFER_SIZE];
int in = 0, out = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t not_full = PTHREAD_COND_INITIALIZER;
pthread_cond_t not_empty = PTHREAD_COND_INITIALIZER;

void producer() {
    pthread_mutex_lock(&mutex);
    while (1) {
        while (in == out) {
            pthread_cond_wait(&not_full, &mutex);
        }
        // 生产数据
        buffer[in] = rand() % 100;
        in = (in + 1) % BUFFER_SIZE;
        pthread_cond_signal(&not_empty);
        pthread_mutex_unlock(&mutex);
    }
}

void consumer() {
    pthread_mutex_lock(&mutex);
    while (1) {
        while (in == out) {
            pthread_cond_wait(&not_empty, &mutex);
        }
        // 消费数据
        int data = buffer[out];
        out = (out + 1) % BUFFER_SIZE;
        pthread_cond_signal(&not_full);
        pthread_mutex_unlock(&mutex);
    }
}

int main() {
    pthread_t prod, cons;

    pthread_create(&prod, NULL, producer, NULL);
    pthread_create(&cons, NULL, consumer, NULL);

    pthread_join(prod, NULL);
    pthread_join(cons, NULL);

    return 0;
}

练习题 3：条件变量的使用

题目描述：使用条件变量实现一个简单的线程池，其中线程池可以接受任务，并且任务在完成后会被线程池中的线程执行。

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

#define THREAD_POOL_SIZE 4
#define QUEUE_SIZE 10

typedef struct {
    int task;
} task_t;

task_t task_queue[QUEUE_SIZE];
int head = 0, tail = 0;

pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t queue_not_empty = PTHREAD_COND_INITIALIZER;
pthread_cond_t queue_not_full = PTHREAD_COND_INITIALIZER;

void* thread_function(void* arg) {
    while (1) {
        pthread_mutex_lock(&queue_mutex);
        while (head == tail) {
            pthread_cond_wait(&queue_not_empty, &queue_mutex);
        }
        // 执行任务
        task_t task = task_queue[tail];
        tail = (tail + 1) % QUEUE_SIZE;
        pthread_cond_signal(&queue_not_full);
        pthread_mutex_unlock(&queue_mutex);
        // 模拟任务执行
        sleep(1);
    }
}

int main() {
    pthread_t threads[THREAD_POOL_SIZE];

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

    for (int i = 0; i < 20; i++) {
        pthread_mutex_lock(&queue_mutex);
        while (head == tail) {
            pthread_cond_wait(&queue_not_full, &queue_mutex);
        }
        task_queue[head].task = i;
        head = (head + 1) % QUEUE_SIZE;
        pthread_cond_signal(&queue_not_empty);
        pthread_mutex_unlock(&queue_mutex);
    }

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

    return 0;
}

总结

本文深入探讨了操作系统进程同步的难题，并通过三个实战练习题展示了互斥锁、信号量和条件变量的使用。通过这些练习，读者可以更好地理解和掌握进程同步的概念，并在实际编程中应用这些机制。

-- 展开阅读全文 --