Penyegerakan dan mekanisme pengecualian bersama dalam Linux

在多进程或多线程的操作系统环境中，同步和互斥是关键的概念，用于确保共享资源的正确访问。下面是同步和互斥的设计原理以及

在 Linux 中的实现方式：

Penyegerakan

Mekanisme penyegerakan ialah proses menyelaraskan pelaksanaan berbilang urutan atau proses pelaksanaan untuk memastikan ia dilaksanakan dalam susunan tertentu atau menunggu dalam keadaan tertentu. Mekanisme penyegerakan biasa termasuk semaphore, pembolehubah keadaan, halangan, dsb.

Prinsip reka bentuk

1. Kendalian Atom: Operasi atom merujuk kepada operasi tidak boleh dibahagikan, sama ada kesemuanya dilaksanakan atau tiada satu pun daripadanya dilaksanakan. Dalam penyegerakan, operasi atom adalah elemen penting untuk memastikan pelaksanaan yang selamat bagi benang atau proses.

2. Pengecualian Bersama: Matlamat utama penyegerakan adalah untuk memastikan akses yang saling eksklusif kepada sumber yang dikongsi, iaitu, hanya satu urutan atau proses boleh mengakses sumber yang dikongsi pada masa yang sama untuk mengelakkan keadaan perlumbaan.

3. Keadaan Menunggu: Mekanisme penyegerakan biasanya perlu menyokong menunggu bersyarat, iaitu, utas atau proses menunggu sehingga syarat tertentu dipenuhi, dan utas atau proses lain memberitahu utas menunggu untuk meneruskan pelaksanaan apabila syarat dipenuhi untuk mencapai penyelarasan pelaksanaan benang antara.

4. Pemeliharaan Pesanan: Penyegerakan juga mungkin melibatkan kawalan susunan pelaksanaan untuk memastikan urutan atau proses dilaksanakan dalam susunan yang dijangkakan, dengan itu memastikan ketepatan dan kebolehpercayaan program.

Pelaksanaan dalam Linux

• Semaphore: Melalui semaphore, sumber boleh dikira untuk memastikan bahawa hanya sebilangan utas atau proses yang terhad boleh mengakses sumber yang dikongsi pada masa yang sama. Di Linux, semaphore biasanya dikendalikan menggunakan fungsi seperti sem_init、sem_wait 和 sem_post.
• Pembolehubah keadaan: Pembolehubah keadaan membenarkan urutan menunggu sehingga syarat tertentu dipenuhi, dan dimaklumkan untuk meneruskan pelaksanaan apabila syarat dipenuhi. Di Linux, pembolehubah keadaan biasanya dimanipulasi menggunakan fungsi seperti pthread_cond_init、pthread_cond_wait 和 pthread_cond_signal.

Mutex

Pengecualian bersama ialah mekanisme yang digunakan untuk memastikan akses yang saling eksklusif kepada sumber yang dikongsi. Dalam persekitaran berbilang benang atau berbilang proses, kunci mutex ialah mekanisme pengecualian bersama yang paling biasa.

Prinsip reka bentuk

1. Kunci mutex: Kunci mutex ialah kunci yang digunakan untuk memastikan hanya satu utas boleh mengakses sumber yang dikongsi pada masa yang sama. Apabila satu benang memperoleh kunci mutex, benang lain mesti menunggu.
2. Bahagian Kritikal: Bahagian kritikal ialah bahagian kod yang boleh mengakses sumber yang dikongsi, dan hanya satu urutan boleh masuk pada masa yang sama. Kunci Mutex sering digunakan untuk melindungi bahagian kritikal.
3. Pengelak jalan buntu: Semasa mereka bentuk mekanisme mutex, anda perlu mempertimbangkan pengelakan kebuntuan untuk memastikan sistem tidak terjebak dalam penantian yang tidak lega kerana penggunaan kunci mutex.

Pelaksanaan dalam Linux

• Mutex (Mutex): Di Linux, kunci mutex biasanya dikendalikan melalui fungsi seperti pthread_mutex_init、pthread_mutex_lock 和 pthread_mutex_unlock. Mereka membenarkan benang masuk dan keluar dari bahagian kritikal dengan selamat.
• Spinlock: Spinlock ialah kunci yang tidak melepaskan CPU tetapi terus menyemak dalam gelung sementara menunggu mutex. Di Linux, spinlock biasanya dikendalikan melalui spin_lock 和 spin_unlock.

Di atas ialah beberapa mekanisme biasa untuk mencapai penyegerakan dan pengecualian bersama dalam Linux. Pilihan khusus bergantung pada keperluan aplikasi dan pertukaran antara prestasi dan kebolehselenggaraan.

Dalam kod sampel di bawah, saya akan menunjukkan penggunaan mutex dan pembolehubah keadaan untuk melaksanakan mekanisme penyegerakan yang mudah. Fungsi berkaitan pustaka benang POSIX digunakan di sini.

#include 
#include 
#include 

#define BUFFER_SIZE 5

int buffer[BUFFER_SIZE];
int count = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_producer = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_consumer = PTHREAD_COND_INITIALIZER;

void *producer(void *arg) {
    for (int i = 0; i while (count == BUFFER_SIZE) {
            // 缓冲区满，等待消费者消费
            pthread_cond_wait(&cond_producer, &mutex);
        }

        buffer[count++] = i;
        printf("Produced: %d\n", i);

        // 通知消费者可以消费了
        pthread_cond_signal(&cond_consumer);
        pthread_mutex_unlock(&mutex);
    }

    pthread_exit(NULL);
}

void *consumer(void *arg) {
    for (int i = 0; i while (count == 0) {
            // 缓冲区空，等待生产者生产
            pthread_cond_wait(&cond_consumer, &mutex);
        }

        int item = buffer[--count];
        printf("Consumed: %d\n", item);

        // 通知生产者可以生产了
        pthread_cond_signal(&cond_producer);
        pthread_mutex_unlock(&mutex);
    }

    pthread_exit(NULL);
}

int main() {
    pthread_t producer_thread, consumer_thread;

    // 创建生产者和消费者线程
    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);

    // 等待线程结束
    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);

    // 销毁互斥锁和条件变量
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond_producer);
    pthread_cond_destroy(&cond_consumer);

    return 0;
}

这个简单的示例演示了一个生产者-消费者问题，其中生产者线程负责往缓冲区中生产数据，而消费者线程负责从缓冲区中消费数据。互斥锁 mutex 用于确保对共享资源的互斥访问，而条件变量 cond_producer 和 cond_consumer 用于在缓冲区满或空时进行等待和通知。

请注意，实际应用中的同步和互斥可能更加复杂，具体的设计取决于应用的需求。

下面是一个简单的示例代码，演示了如何使用 Linux 中的 pthread_mutex_t 来实现互斥锁。这个示例中，两个线程共享一个计数器，通过互斥锁确保对计数器的互斥访问。

#include 
#include 

// 共享的计数器
int counter = 0;

// 互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// 线程函数，增加计数器的值
void* increment_counter(void* arg) {
    for (int i = 0; i main() {
    // 创建两个线程
    pthread_t thread1, thread2;
    pthread_create(&thread1, NULL, increment_counter, NULL);
    pthread_create(&thread2, NULL, increment_counter, NULL);

    // 等待线程结束
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    // 销毁互斥锁
    pthread_mutex_destroy(&mutex);

    // 输出最终的计数器值
    printf("Final Counter Value: %d\n", counter);

    return 0;
}

在这个例子中，两个线程并发地增加 counter 变量的值。由于两个线程共享同一个变量，存在竞争条件。互斥锁 mutex 用来确保对 counter 的互斥访问，一个线程在访问 counter 时先上锁，完成后再解锁，这样另一个线程才能进入。

要使用互斥锁，需要注意以下几点：

1. Mulakan mutex: Gunakan PTHREAD_MUTEX_INITIALIZER 或者 pthread_mutex_init untuk memulakan mutex.
2. Kunci dan Buka Kunci: Gunakan pthread_mutex_lock 来上锁，使用 pthread_mutex_unlock untuk membuka kunci. Akses kepada sumber yang dikongsi dalam bahagian kritikal hendaklah antara mengunci dan membuka kunci.
3. Memusnahkan mutex: Gunakan pthread_mutex_destroy untuk memusnahkan mutex apabila ia tidak diperlukan lagi.

Kod di atas menunjukkan cara menggunakan kunci mutex untuk memastikan akses selamat kepada sumber yang dikongsi dan mencegah keadaan perlumbaan.

Atas ialah kandungan terperinci Penyegerakan dan mekanisme pengecualian bersama dalam Linux. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!