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

博客 动态
0 155
羽尘
羽尘 2023-04-01 08:26:49
悬赏：0 积分 收藏

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

一、为什么要线程同步

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

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

活锁对话

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

让路

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

二、互斥锁

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

在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的值。

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

小结

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

posted @ 2023-04-01 08:21  知微之见  阅读(0)  评论(0)  编辑  收藏  举报
上一篇：普冉PY32系列(七)SOP8,SOP10和SOP16封装的PY32F003/PY32F002A管脚复用
下一篇：Terraform系列-Terraform项目的典型文件布局
回帖
    羽尘

    羽尘 （王者 段位）

    2335 积分 (2)粉丝 (11)源码

     

    温馨提示

    亦奇源码

    最新会员