Linux线程同步必知,常用方法揭秘!
2023/4/1 11:22:05
本文主要是介绍Linux线程同步必知,常用方法揭秘!,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
一、为什么要线程同步
在Linux 多线程编程中,线程同步是一个非常重要的问题。如果线程之间没有正确地同步,就会导致程序出现一些意外的问题,例如:
- 竞态条件(Race Condition):多个线程同时修改同一个共享变量,可能会导致不可预测的结果,因为线程的执行顺序是不确定的。
- 死锁(Deadlock):当两个或多个线程互相等待对方释放资源时,可能会导致死锁,这会导致程序无法继续执行。
- 活锁(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的值。
由于读写锁的存在,这两个线程可以安全地并发访问共享变量,避免了数据竞争和不一致性的问题。
小结
了解这些同步机制可以帮助我们写出高效且正确的多线程应用程序。不同的同步机制适用于不同的情况,选择适当的同步机制也是非常重要的。
这篇关于Linux线程同步必知,常用方法揭秘!的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!
- 2024-12-18git仓库有更新,jenkins 自动触发拉代码怎么配置的?-icode9专业技术文章分享
- 2024-12-18Jenkins webhook 方式怎么配置指定的分支?-icode9专业技术文章分享
- 2024-12-13Linux C++项目实战入门教程
- 2024-12-13Linux C++编程项目实战入门教程
- 2024-12-11Linux部署Scrapy教程:新手入门指南
- 2024-12-11怎么将在本地创建的 Maven 仓库迁移到 Linux 服务器上?-icode9专业技术文章分享
- 2024-12-10Linux常用命令
- 2024-12-06谁看谁服! Linux 创始人对于进程和线程的理解是…
- 2024-12-04操作系统教程:新手入门及初级技巧详解
- 2024-12-04操作系统入门:新手必学指南