Linux线程同步必知，常用方法揭秘！

一、为什么要线程同步

在Linux 多线程编程中，线程同步是一个非常重要的问题。如果线程之间没有正确地同步，就会导致程序出现一些意外的问题，例如：

竞态条件（Race Condition）：多个线程同时修改同一个共享变量，可能会导致不可预测的结果，因为线程的执行顺序是不确定的。
死锁（Deadlock）：当两个或多个线程互相等待对方释放资源时，可能会导致死锁，这会导致程序无法继续执行。
活锁（Livelock）：当多个线程相互响应对方的动作，而没有任何进展时，可能会导致活锁，这也会导致程序无法继续执行。

活锁对话

两个人在走路时需要相互让路，两个人都想让对方先通过，但最终还是没有人通过，这就是一种活锁情况

接下来将介绍互斥锁、条件变量、信号量、读写锁这几种线程同步方法，并使用C语言代码示例说明其使用方法。

Linux线程同步必知，常用方法揭秘！

二、互斥锁

互斥锁是一种用于线程同步的锁，用于保护共享资源。只有拥有该锁的线程才能访问共享资源，其他线程需要等待锁被释放后才能继续执行。

在Linux环境下，我们可以使用pthread库提供的互斥锁函数来实现互斥锁机制。以下是一些常用的互斥锁函数：

函数名	描述
`pthread_mutex_init`	初始化互斥锁
`pthread_mutex_lock`	加锁互斥锁
`pthread_mutex_trylock`	尝试加锁互斥锁
`pthread_mutex_unlock`	解锁互斥锁
`pthread_mutex_destroy`	销毁互斥锁

初始化互斥锁

在使用互斥锁之前，需要先初始化互斥锁。pthread_mutex_init函数用于初始化一个互斥锁。函数原型如下：

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

其中，mutex参数是一个指向pthread_mutex_t结构体的指针，用于指定要初始化的互斥锁；attr参数是一个指向pthread_mutexattr_t结构体的指针，用于指定互斥锁的属性，通常设置为NULL。

以下是一个初始化互斥锁的例子：

#include <pthread.h>

pthread_mutex_t mutex;

int main()
{
    // 初始化互斥锁
    pthread_mutex_init(&mutex, NULL);
    
    // ...
    
    // 销毁互斥锁
    pthread_mutex_destroy(&mutex);
    
    return 0;
}

加锁互斥锁

加锁互斥锁用于保证同一时刻只有一个线程能够访问共享资源。pthread_mutex_lock函数用于加锁一个互斥锁。函数原型如下：

int pthread_mutex_lock(pthread_mutex_t *mutex);

其中，mutex参数是一个指向pthread_mutex_t结构体的指针，用于指定要加锁的互斥锁。

以下是一个加锁互斥锁的例子：

#include <pthread.h>

pthread_mutex_t mutex;

void* thread_func(void* arg)
{
    // 加锁互斥锁
    pthread_mutex_lock(&mutex);
    
    // 访问共享资源
    // ...
    
    // 解锁互斥锁
    pthread_mutex_unlock(&mutex);
    
    return NULL;
}

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

尝试加锁互斥锁

尝试加锁互斥锁与加锁互斥锁的主要区别在于，如果互斥锁已经被其他线程锁定了，尝试加锁互斥锁将不会阻塞当前线程，而是会立即返回一个错误代码。函数原型如下：

int pthread_mutex_trylock(pthread_mutex_t *mutex);

其中，mutex参数是一个指向pthread_mutex_t结构体的指针，用于指定要尝试加锁的互斥锁。

以下是一个尝试加锁互斥锁的例子：

#include <pthread.h>

pthread_mutex_t mutex;

void* thread_func(void* arg)
{
    // 尝试加锁互斥锁
    int ret = pthread_mutex_trylock(&mutex);
    if (ret == 0) {
        // 访问共享资源
        // ...
        
        // 解锁互斥锁
        pthread_mutex_unlock(&mutex);
    } else {
        // 互斥锁已经被其他线程锁定了
        // ...
    }
    
    return NULL;
}

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

解锁互斥锁

解锁互斥锁用于释放已经锁定的互斥锁。pthread_mutex_unlock函数用于解锁一个互斥锁。函数原型如下：

int pthread_mutex_unlock(pthread_mutex_t *mutex);

其中，mutex参数是一个指向pthread_mutex_t结构体的指针，用于指定要解锁的互斥锁。

以下是一个解锁互斥锁的例子：

#include <pthread.h>

pthread_mutex_t mutex;

void* thread_func(void* arg)
{
    // 加锁互斥锁
    pthread_mutex_lock(&mutex);
    
    // 访问共享资源
    //
	// 解锁互斥锁
	pthread_mutex_unlock(&mutex);

	return NULL;
}

销毁互斥锁

在不再需要使用互斥锁时，需要将互斥锁销毁。pthread_mutex_destroy函数用于销毁一个互斥锁。函数原型如下：

int pthread_mutex_destroy(pthread_mutex_t *mutex);

其中，mutex参数是一个指向pthread_mutex_t结构体的指针，用于指定要销毁的互斥锁。

以下是一个销毁互斥锁的例子：

#include <pthread.h>

pthread_mutex_t mutex;

int main()
{
    // 初始化互斥锁
    pthread_mutex_init(&mutex, NULL);
    
    // ...
    
    // 销毁互斥锁
    pthread_mutex_destroy(&mutex);
    
    return 0;
}

示例程序

下面是一个简单的示例程序，演示了如何使用互斥锁来同步两个线程的访问。

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

pthread_mutex_t mutex;
int shared_data = 0;

void *thread_func(void *arg)
{
    int i;
    for (i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&mutex);
        shared_data++;
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main()
{
    pthread_t thread1, thread2;
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&thread1, NULL, thread_func, NULL);
    pthread_create(&thread2, NULL, thread_func, NULL);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_mutex_destroy(&mutex);
    printf("Shared data: %d\n", shared_data);
    return 0;
}

在这个程序中，thread_func函数是两个线程执行的函数，它会对shared_data变量进行1000000次加一操作。

为了确保多个线程不会同时访问shared_data变量，我们使用了一个互斥锁。当一个线程要访问shared_data变量时，它会调用pthread_mutex_lock函数来加锁。如果锁已经被其他线程持有，那么这个线程就会被阻塞，直到锁被释放为止。当线程完成对shared_data变量的操作后，它会调用pthread_mutex_unlock函数来释放锁。

在这个程序执行完毕后，我们可以通过打印shared_data变量的值来检查程序是否正确地同步了两个线程的访问。如果程序正确地同步了线程的访问，那么shared_data变量的值应该是2000000。

? 在使用互斥锁时，需要确保每个线程都在必要的时候释放锁。如果一个线程忘记释放锁，那么其他线程就会被永久地阻塞，程序就会死锁。另外，过度使用互斥锁也会降低程序的性能。

?因为加锁和释放锁的过程需要消耗一定的时间和系统资源，所以在设计程序时需要尽可能减少加锁和释放锁的次数。

三、条件变量

条件变量是Linux线程的另一种同步机制。它用于自动阻塞线程，直到某个特定事件发生或某个条件满足为止，通常情况下，条件变量是和互斥锁一起搭配使用的。使用条件变量主要包括两个动作：

一个线程等待某个条件满足而被阻塞；
另一个线程中，条件满足时发出“信号”

初始化条件变量

在使用条件变量之前，需要先对其进行初始化。以下是一个初始化条件变量的示例：

#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

等待条件变量

线程可以通过等待条件变量来暂停执行，并在条件变量被唤醒后继续执行。以下是一个等待条件变量的示例：

#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void *thread_func(void *arg)
{
    // 等待条件变量
    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond, &mutex);
    pthread_mutex_unlock(&mutex);

    return NULL;
}

在上面的示例中，线程会在pthread_cond_wait函数处等待条件变量cond。

在等待之前，线程必须先获取互斥锁mutex。等待函数会自动释放互斥锁，并在条件变量被唤醒后重新获取互斥锁。

唤醒等待条件变量的线程

线程可以通过发送信号来唤醒等待条件变量的线程。以下是一个发送信号的示例：

#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void *thread_func(void *arg)
{
    // 等待条件变量
    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond, &mutex);
    pthread_mutex_unlock(&mutex);

    return NULL;
}

int main()
{
    // 唤醒等待条件变量的线程
    pthread_mutex_lock(&mutex);
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);

    return 0;
}

在上面的示例中，主线程通过发送信号来唤醒等待条件变量的线程。在发送信号之前，主线程必须先获取互斥锁mutex。

广播唤醒等待条件变量的线程

有时候需要唤醒多个等待条件变量的线程，此时可以使用广播机制。以下是一个广播唤醒等待条件变量的线程的示例：

#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void *thread_func(void *arg)
{
    // 等待条件变量
    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond, &mutex);
    pthread_mutex_unlock(&mutex);

    return NULL;
}

int main()
{
    // 广播唤醒等待条件变量的线程
    pthread_mutex_lock(&mutex);
    pthread_cond_broadcast(&cond);
    pthread_mutex_unlock(&mutex);

    return 0; 
}

在上面的示例中，主线程通过广播机制来唤醒等待条件变量的线程。在广播之前，主线程必须先获取互斥锁mutex。

等待特定条件的条件变量

有时候需要等待特定条件的条件变量，此时可以在等待函数中加入判断条件。以下是一个等待特定条件的条件变量的示例：

#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int condition = 0;

void *thread_func(void *arg)
{
    // 等待特定条件的条件变量
    pthread_mutex_lock(&mutex);
    while (condition == 0) {
        pthread_cond_wait(&cond, &mutex);
    }
    pthread_mutex_unlock(&mutex);

    return NULL;
}

int main()
{
    // 设置特定条件并唤醒等待条件变量的线程
    pthread_mutex_lock(&mutex);
    condition = 1;
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);

    return 0;
}

在上面的示例中，线程会在while循环中等待特定条件的条件变量cond。在等待之前，线程必须先获取互斥锁mutex。

主线程通过设置特定条件并发送信号来唤醒等待条件变量的线程。

销毁条件变量

在不需要使用条件变量时，需要将其销毁以释放资源。以下是一个销毁条件变量的示例：

#include <pthread.h>

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int main()
{
    // 销毁条件变量
    pthread_cond_destroy(&cond);

    return 0;
}

在上面的示例中，通过调用pthread_cond_destroy函数来销毁条件变量cond。

示例程序

下面是一个简单的示例程序，演示了如何使用条件变量来实现线程间的同步。

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

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int shared_data = 0;

void *thread_func1(void *arg)
{
    printf("Thread 1 started\n");
    pthread_mutex_lock(&mutex);
    while (shared_data < 10) {
        pthread_cond_wait(&cond, &mutex);
    }
    printf("Thread 1 read shared_data: %d\n", shared_data);
    pthread_mutex_unlock(&mutex);
    printf("Thread 1 finished\n");
    return NULL;
}

void *thread_func2(void *arg)
{
    printf("Thread 2 started\n");
    for (int i = 0; i < 10; i++) {
        pthread_mutex_lock(&mutex);
        shared_data++;
        printf("Thread 2 wrote shared_data: %d\n", shared_data);
        if (shared_data == 10) {
            pthread_cond_signal(&cond);
        }
        pthread_mutex_unlock(&mutex);
    }
    printf("Thread 2 finished\n");
    return NULL;
}

int main()
{
    pthread_t thread1, thread2;
    pthread_create(&thread1, NULL, thread_func1, NULL);
    pthread_create(&thread2, NULL, thread_func2, NULL);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

在这个程序中，我们创建了两个线程，分别执行thread_func1和thread_func2函数。

thread_func1函数等待shared_data变量的值达到10后再继续执行，并输出到控制台上。

thread_func2函数将shared_data变量的值加1，并在shared_data变量的值等于10时，发送一个信号通知thread_func1函数可以继续执行。

需要注意的是，我们在thread_func1函数中使用了pthread_cond_wait函数来等待条件变量，而在thread_func2函数中使用了pthread_cond_signal函数来发送条件变量。

当一个线程等待条件变量时，它会释放掉与条件变量相关的锁，并进入睡眠状态。当另一个线程发送条件变量时，它会唤醒等待条件变量的线程，并重新获取与条件变量相关的锁。

四、信号量

信号量是一种计数器，用于同步和互斥访问共享资源。它是一个整数变量，可以使用原子操作来访问。

当多个线程需要同时访问共享资源时，它们必须先获取一个信号量，然后访问资源，并在访问完成后释放信号量。

如果信号量的计数器值为零，则线程会被阻塞，直到有其他线程释放信号量。

在Linux中，信号量的API是sem_init、sem_wait、sem_post和sem_destroy。

初始化信号量

int sem_init(sem_t *sem, int pshared, unsigned int value);

sem_init() 函数用于初始化信号量。它接受三个参数：

sem：指向信号量的指针
pshared：指示信号量是进程共享还是线程共享的标志。如果为 0，则信号量被限制在当前进程的线程中；否则，信号量可以被多个进程共享。
value：信号量的初始值。如果为 0，则调用线程将等待，直到其他线程释放信号量。

等待信号量

int sem_wait(sem_t *sem);

sem_wait() 函数用于等待信号量。

如果信号量的值大于 0，则将该值减 1 并返回。否则，调用线程将被阻塞，直到其他线程释放信号量为止。

释放信号量

int sem_post(sem_t *sem);

sem_post() 函数用于释放信号量。它将信号量的值加 1，并通知等待该信号量的线程或进程。

销毁信号量

int sem_destroy(sem_t *sem);

sem_destroy() 函数用于销毁信号量。它将释放信号量使用的资源，并将其重置为未初始化状态。但是，只有在没有线程等待信号量时才能销毁它。

示例程序

下面是一个简单的示例程序，演示了如何使用信号量来实现生产者消费者模式。

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

#define BUFFER_SIZE 10

sem_t empty, full;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int buffer[BUFFER_SIZE];
int buffer_index = 0;

void *producer(void *arg)
{
    printf("Producer started\n");
    for (int i = 0; i < BUFFER_SIZE * 2; i++) {
        sem_wait(&empty);
        pthread_mutex_lock(&mutex);
        buffer[buffer_index] = i;
        buffer_index++;
        printf("Produced: %d\n", i);
        pthread_mutex_unlock(&mutex);
        sem_post(&full);
    }
    printf("Producer finished\n");
    return NULL;
}

void *consumer(void *arg)
{
    printf("Consumer started\n");
    for (int i = 0; i < BUFFER_SIZE * 2; i++) {
        sem_wait(&full);
        pthread_mutex_lock(&mutex);
        buffer_index--;
        printf("Consumed: %d\n", buffer[buffer_index]);
        pthread_mutex_unlock(&mutex);
        sem_post(&empty);
    }
    printf("Consumer finished\n");
    return NULL;
}

int main()
{
    sem_init(&empty, 0, BUFFER_SIZE);
    sem_init(&full, 0, 0);
    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);
    sem_destroy(&empty);
    sem_destroy(&full);
    pthread_mutex_destroy(&mutex);
    return 0;
}

在这个程序中，我们使用了两个信号量，一个是empty，用于表示缓冲区中的空闲空间数量，另一个是full，用于表示缓冲区中已经存储的数据数量。

在生产者线程中，当需要向缓冲区中添加数据时，它会先等待empty信号量，以确保缓冲区中有足够的空间来存储数据。

一旦empty信号量的计数器值大于零，生产者线程会使用pthread_mutex_lock来保护缓冲区，然后向缓冲区中添加数据，并发送一个full信号量的信号，以通知消费者线程可以从缓冲区中获取。

五、读写锁

Linux读写锁（Read-Write Lock）是一种用于多线程并发控制的同步机制，它允许多个线程同时读取共享资源，但在写入操作时，只允许一个线程进行，以避免数据竞争和不一致性。

初始化读写锁

int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);

其中rwlock为读写锁指针，attr为读写锁属性指针。如果attr为NULL，则使用默认属性。成功返回0，失败返回错误码。

销毁读写锁

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

其中rwlock为读写锁指针。成功返回0，失败返回错误码。

加读锁

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

其中rwlock为读写锁指针。如果当前有写锁或正在等待写锁，则阻塞等待。成功返回0，失败返回错误码。

加写锁

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

其中rwlock为读写锁指针。如果当前有读锁或写锁或正在等待读锁或写锁，则阻塞等待。成功返回0，失败返回错误码。

解锁

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

其中rwlock为读写锁指针。成功返回0，失败返回错误码。

示例程序

下面是一个简单的使用读写锁的例子，用于演示读写锁的使用方法。

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

pthread_rwlock_t rwlock;
int count = 0;

void *write_thread(void *arg)
{
    while(1) {
        pthread_rwlock_wrlock(&rwlock);
        count++;
        printf("write thread: count=%d\n", count);
        pthread_rwlock_unlock(&rwlock);
        sleep(1);
    }
    return NULL;
}

void *read_thread(void *arg)
{
    while(1) {
        pthread_rwlock_rdlock(&rwlock);
        printf("read thread: count=%d\n", count);
        pthread_rwlock_unlock(&rwlock);
        sleep(1);
    }
    return NULL;
}

int main()
{
    pthread_t tid1, tid2;
    pthread_rwlock_init(&rwlock, NULL);

    pthread_create(&tid1, NULL, write_thread, NULL);
    pthread_create(&tid2, NULL, read_thread, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    pthread_rwlock_destroy(&rwlock);

    return 0;
}

该例子中，我们定义了两个线程write_thread和read_thread。

其中write_thread对共享变量count进行写操作，read_thread对共享变量count进行读操作。

我们使用pthread_rwlock_init函数初始化读写锁，然后使用pthread_rwlock_wrlock函数和pthread_rwlock_rdlock函数对共享变量进行加锁，保证写线程和读线程互斥访问共享变量。

在加锁后，线程对共享变量进行操作，然后使用pthread_rwlock_unlock函数进行解锁。最后，我们使用pthread_rwlock_destroy函数销毁读写锁。

当我们运行这个程序时，会发现write_thread线程每隔一秒钟就会增加共享变量count的值，并打印出来。

而read_thread线程每隔一秒钟就会读取并打印共享变量count的值。

由于读写锁的存在，这两个线程可以安全地并发访问共享变量，避免了数据竞争和不一致性的问题。

小结

了解这些同步机制可以帮助我们写出高效且正确的多线程应用程序。不同的同步机制适用于不同的情况，选择适当的同步机制也是非常重要的。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：Linux线程同步必知，常用方法揭秘！ - Python技术站

Linux线程同步必知，常用方法揭秘！

一、为什么要线程同步

二、互斥锁

初始化互斥锁

加锁互斥锁

尝试加锁互斥锁

解锁互斥锁

销毁互斥锁

示例程序

三、条件变量

初始化条件变量

等待条件变量

唤醒等待条件变量的线程

广播唤醒等待条件变量的线程

等待特定条件的条件变量

销毁条件变量

示例程序

四、信号量

初始化信号量

等待信号量

释放信号量

销毁信号量

示例程序

五、读写锁

初始化读写锁

销毁读写锁

加读锁

加写锁

解锁

示例程序

小结

相关文章