linux mutex 和 sem

    在Linux系统中，互斥锁(mutex)和信号量(sem)是常用的同步机制，但它们有什么区别呢？本文将从概念、实现、使用场景等多个方面进行详细分析，希望能够帮助读者更好地理解和应用这两种同步机制。

    一、概念

    1.互斥锁(mutex)

    互斥锁是一种保护共享资源的机制，它能够确保同一时间只有一个线程访问共享资源。当一个线程需要访问共享资源时，它必须先获得互斥锁，如果该锁已经被其他线程占用，则当前线程将会被阻塞。当占用该锁的线程释放锁时，等待该锁的线程将会被唤醒，并尝试重新获取锁。

    2.信号量(sem)

    信号量是一种计数器，用于协调多个线程对共享资源的访问。每个信号量都有一个整数值，在对它进行操作时可以增加或减少该值。当一个线程需要访问共享资源时，它必须先对信号量进行P操作（减少计数器的值），如果计数器的值为0，则当前线程将会被阻塞。当占用共享资源的线程释放资源时，它必须对信号量进行V操作（增加计数器的值），以唤醒等待该资源的线程。

    二、实现

    1.互斥锁(mutex)

    在Linux系统中，互斥锁的实现主要依靠pthread_mutex_t类型。该类型是一个结构体指针，定义如下：

    typedefstruct{

    int__spinlock;

    int__owner;

    }pthread_mutex_t;

    其中__spinlock表示自旋锁，用于保护锁本身，__owner表示当前持有锁的线程ID。当一个线程需要获得互斥锁时，它会尝试获取__spinlock，并判断__owner是否为0（表示未被占用），如果满足这两个条件，则将__owner设置为自己的线程ID，并返回。否则，当前线程将会进入等待队列，并阻塞。

    2.信号量(sem)

    在Linux系统中，信号量的实现主要依靠sem_t类型。该类型是一个结构体指针，定义如下：

    typedefstruct{

    unsignedint__val;

    }sem_t;

    其中__val表示计数器的值。当一个线程需要对信号量进行P操作时，它会尝试将__val减1，并判断是否小于0（表示当前没有可用资源），如果满足这个条件，则将当前线程加入等待队列，并阻塞。当占用共享资源的线程释放资源时，它会将__val加1，并唤醒一个等待该资源的线程。

    三、使用场景

    1.互斥锁(mutex)

    互斥锁主要用于保护共享资源，适合于多个线程对同一数据结构进行读写操作的场景。例如，在一个多线程服务器中，多个客户端可能同时访问同一份数据，为了避免数据混乱或者丢失，可以使用互斥锁来保护这份数据。

    2.信号量(sem)

    信号量主要用于协调多个线程对共享资源的访问，适合于生产者-消费者模型或者限制并发数的场景。例如，在一个Web服务器中，为了避免过多的客户端同时访问服务器而导致服务器崩溃，可以使用信号量来控制并发数。

    四、案例分析

    下面通过两个案例来说明互斥锁和信号量的具体使用方法。

    1.使用互斥锁实现多线程计算器

    假设有一个计算器程序需要支持多线程并发操作，但是由于计算器内部存储了结果，因此需要使用互斥锁来保护该数据结构。以下是一个基于互斥锁的多线程计算器的示例代码：

    c

    #include<stdio.h>

    #include<pthread.h>

    pthread_mutex_tmutex;

    intresult=0;

    void*add(void*arg){

    inti;

    for(i=0;i<1000000;i++){

    pthread_mutex_lock(&mutex);

    result++;

    pthread_mutex_unlock(&mutex);

    }

    returnNULL;

    }

    intmain(){

    inti;

    pthread_tthreads[10];

    pthread_mutex_init(&mutex,NULL);

    for(i=0;i<10;i++){

    pthread_create(&threads[i],NULL,add,NULL);

    }

    for(i=0;i<10;i++){

    pthread_join(threads[i],NULL);

    }

    printf("result=%d\n",result);

    return0;

    }

    在上面的代码中，首先定义了一个互斥锁mutex和一个全局变量result，然后创建了10个线程，在每个线程中执行1000000次加1操作。由于加1操作需要访问全局变量result，因此在每次访问前需要获取互斥锁，并在访问结束后释放锁。最后，主线程打印出计算结果。

    2.使用信号量实现生产者-消费者模型

    假设有一个生产者-消费者模型的问题需要解决，其中生产者可以不断地生产产品，而消费者则可以从队列中取出产品进行消费。但是由于队列的容量有限，因此需要使用信号量来控制生产者和消费者的操作。以下是一个基于信号量的生产者-消费者模型的示例代码：

    c

    #include<stdio.h>

    #include<pthread.h>

    #include<semaphore.h>

    #defineMAX_SIZE10

    sem_tsem_producer,sem_consumer;

    intqueue[MAX_SIZE];

    intfront=0,rear=0;

    void*producer(void*arg){

    inti;

    for(i=0;i<100;i++){

    sem_wait(&sem_producer);

    queue[rear]=i;

    rear=(rear+1)%MAX_SIZE;

    printf("producer:%d\n",i);

    sem_post(&sem_consumer);

    }

    returnNULL;

    }

    void*consumer(void*arg){

    inti,data;

    for(i=0;i<100;i++){

    sem_wait(&sem_consumer);

    data=queue[front];

    front=(front+1)%MAX_SIZE;

    printf("consumer:%d\n",data);

    sem_post(&sem_producer);

    }

    returnNULL;

    }

    intmain(){

    pthread_tthreads[2];

    sem_init(&sem_producer,0,MAX_SIZE);

    sem_init(&sem_consumer,0,0);

    pthread_create(&threads[0],NULL,producer,NULL);

    pthread_create(&threads[1],NULL,consumer,NULL);

    pthread_join(threads[0],NULL);

    pthread_join(threads[1],NULL);

    return0;

    }

    在上面的代码中，首先定义了两个信号量sem_producer和sem_consumer，初始值分别为队列的容量和0。然后创建了两个线程，其中一个线程是生产者，另一个线程是消费者。在生产者线程中，每次生产一个产品时需要获取sem_producer信号量，并将产品加入队列中，然后释放sem_consumer信号量以唤醒消费者线程。在消费者线程中，每次从队列中取出一个产品时需要获取sem_consumer信号量，并将产品从队列中删除，然后释放sem_producer信号量以唤醒生产者线程。

    五、总结

    本文从概念、实现、使用场景等多个方面对Linux互斥锁(mutex)和信号量(sem)进行了详细分析。互斥锁主要用于保护共享资源，适合于多个线程对同一数据结构进行读写操作的场景；信号量主要用于协调多个线程对共享资源的访问，适合于生产者-消费者模型或者限制并发数的场景。无论是互斥锁还是信号量，在使用时都需要考虑到竞态条件和死锁等问题。因此，在实际应用中需要根据具体情况选择合适的同步机制，并且要注意对其正确使用和处理异常情况。

tokenpocket最新版：https://cjge-manuscriptcentral.com/software/3775.html