系统小窝欢迎您

电脑公司 深度技术
当前位置:系统小窝 > 系统教程 > Linux教程 >

线程同步的方法有哪些?Linux下实现线程同步的三种方法

时间:2021-04-09 来源:大神到 人气:

线程同步的方法有哪些?在linux下,系统提供了很多种方式来实现线程同步,其中最常用的便是互斥锁、条件变量和信号量这三种方式,可能还有很多伙伴对于这三种方法都不熟悉,下面就给大家详细介绍下。

Linux下实现线程同步的三种方法:

一、互斥锁(mutex)

通过锁机制实现线程间的同步。

1、初始化锁。在Linux下,线程的互斥量数据类型是pthread_mutex_t。在使用前,要对它进行初始化。

静态分配:pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

动态分配:int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutex_attr_t *mutexattr);

2、加锁。对共享资源的访问,要对互斥量进行加锁,如果互斥量已经上了锁,调用线程会阻塞,直到互斥量被解锁。

int pthread_mutex_lock(pthread_mutex *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

3、解锁。在完成了对共享资源的访问后,要对互斥量进行解锁。

int pthread_mutex_unlock(pthread_mutex_t *mutex);

4、销毁锁。锁在是使用完成后,需要进行销毁以释放资源。

int pthread_mutex_destroy(pthread_mutex *mutex);

#include lt;cstdio #include lt;cstdlib #include lt;unistd.h #include lt;pthread.h #include ;iostream; using namespace std; pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; int tmp; void* thread(void *arg) { cout lt;lt; ;thread id is ; lt;lt; pthread_self() lt;lt; endl; pthread_mutex_lock(mutex); tmp = 12; cout lt;lt; ;Now a is ; lt;lt; tmp lt;lt; endl; pthread_mutex_unlock(mutex); return NULL; } int main() { pthread_t id; cout lt;lt; ;main thread id is ; lt;lt; pthread_self() lt;lt; endl; tmp = 3; cout lt;lt; ;In main func tmp = ; lt;lt; tmp lt;lt; endl; if (!pthread_create(id, NULL, thread, NULL)) { cout lt;lt; ;Create thread success!; lt;lt; endl; } else { cout lt;lt; ;Create thread failed!; lt;lt; endl; } pthread_join(id, NULL); pthread_mutex_destroy(mutex); return 0; } //编译:g++ -o thread testthread.cpp -lpthread

二、条件变量(cond)

与互斥锁不同,条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程,直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。条件变量分为两部分: 条件和变量。条件本身是由互斥量保护的。线程在改变条件状态前先要锁住互斥量。条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制,主要包括两个动作:一个线程等待;条件变量的条件成立;而挂起;另一个线程使;条件成立;(给出条件成立信号)。条件的检测是在互斥锁的保护下进行的。如果一个条件为假,一个线程自动阻塞,并释放等待状态改变的互斥锁。如果另一个线程改变了条件,它发信号给关联的条件变量,唤醒一个或多个等待它的线程,重新获得互斥锁,重新评价条件。如果两进程共享可读写的内存,条件变量可以被用来实现这两进程间的线程同步。

1、初始化条件变量。

静态态初始化,pthread_cond_t cond = PTHREAD_COND_INITIALIER;

动态初始化,int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);

2、等待条件成立。释放锁,同时阻塞等待条件变量为真才行。timewait()设置等待时间,仍未signal,返回ETIMEOUT(加锁保证只有一个线程wait)

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,const timespec *abstime);

4、激活条件变量。pthread_cond_signal,pthread_cond_broadcast(激活所有等待线程)

int pthread_cond_signal(pthread_cond_t *cond);

int pthread_cond_broadcast(pthread_cond_t *cond); //解除所有线程的阻塞

5、清除条件变量。无线程等待,否则返回EBUSY

int pthread_cond_destroy(pthread_cond_t *cond);

[cpp] view plain copy #include lt;stdio.h #include lt;pthread.h #include ;stdlib.h; #include ;unistd.h; pthread_mutex_t mutex; pthread_cond_t cond; void hander(void *arg) { free(arg); (void)pthread_mutex_unlock(mutex); } void *thread1(void *arg) { pthread_cleanup_push(hander, mutex); while(1) { printf(;thread1 is running ;); pthread_mutex_lock(mutex); pthread_cond_wait(cond, mutex); printf(;thread1 applied the condition ;); pthread_mutex_unlock(mutex); sleep(4); } pthread_cleanup_pop(0); } void *thread2(void *arg) { while(1) { printf(;thread2 is running ;); pthread_mutex_lock(mutex); pthread_cond_wait(cond, mutex); printf(;thread2 applied the condition ;); pthread_mutex_unlock(mutex); sleep(1); } } int main() { pthread_t thid1,thid2; printf(;condition variable study! ;); pthread_mutex_init(mutex, NULL); pthread_cond_init(cond, NULL); pthread_create(thid1, NULL, thread1, NULL); pthread_create(thid2, NULL, thread2, NULL); sleep(1); do { pthread_cond_signal(cond); }while(1); sleep(20); pthread_exit(0); return 0; } #include lt;pthread.h #include lt;unistd.h #include ;stdio.h; #include ;stdlib.h; static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t cond = PTHREAD_COND_INITIALIZER; struct node { int n_number; struct node *n_next; }*head = NULL; static void cleanup_handler(void *arg) { printf(;Cleanup handler of second thread./n;); free(arg); (void)pthread_mutex_unlock(mtx); } static void *thread_func(void *arg) { struct node *p = NULL; pthread_cleanup_push(cleanup_handler, p); while (1) { //这个mutex主要是用来保证pthread_cond_wait的并发性 pthread_mutex_lock(mtx); while (head == NULL) { //这个while要特别说明一下,单个pthread_cond_wait功能很完善,为何 //这里要有一个while (head == NULL)呢?因为pthread_cond_wait里的线 //程可能会被意外唤醒,如果这个时候head != NULL,则不是我们想要的情况。 //这个时候,应该让线程继续进入pthread_cond_wait // pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx, //然后阻塞在等待对列里休眠,直到再次被唤醒(大多数情况下是等待的条件成立 //而被唤醒,唤醒后,该进程会先锁定先pthread_mutex_lock(mtx);,再读取资源 //用这个流程是比较清楚的 pthread_cond_wait(cond, mtx); p = head; head = head-n_next; printf(;Got %d from front of queue/n;, p-n_number); free(p); } pthread_mutex_unlock(mtx); //临界区数据操作完毕,释放互斥锁 } pthread_cleanup_pop(0); return 0; } int main(void) { pthread_t tid; int i; struct node *p; //子线程会一直等待资源,类似生产者和消费者,但是这里的消费者可以是多个消费者,而 //不仅仅支持普通的单个消费者,这个模型虽然简单,但是很强大 pthread_create(tid, NULL, thread_func, NULL); sleep(1); for (i = 0; i lt; 10; i++) { p = (struct node*)malloc(sizeof(struct node)); p-n_number = i; pthread_mutex_lock(mtx); //需要操作head这个临界资源,先加锁, p-n_next = head; head = p; pthread_cond_signal(cond); pthread_mutex_unlock(mtx); //解锁 sleep(1); } printf(;thread 1 wanna end the line.So cancel thread 2./n;); //关于pthread_cancel,有一点额外的说明,它是从外部终止子线程,子线程会在最近的取消点,退出 //线程,而在我们的代码里,最近的取消点肯定就是pthread_cond_wait()了。 pthread_cancel(tid); pthread_join(tid, NULL); printf(;All done -- exiting/n;); return 0; }

三、信号量(sem)

如同进程一样,线程也可以通过信号量来实现通信,虽然是轻量级的。信号量函数的名字都以;sem_;打头。线程使用的基本信号量函数有四个。

1、信号量初始化。

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

这是对由sem指定的信号量进行初始化,设置好它的共享选项(linux 只支持为0,即表示它是当前进程的局部信号量),然后给它一个初始值VALUE。

2、等待信号量。给信号量减1,然后等待直到信号量的值大于0。

int sem_wait(sem_t *sem);

3、释放信号量。信号量值加1。并通知其他等待线程。

int sem_post(sem_t *sem);

4、销毁信号量。我们用完信号量后都它进行清理。归还占有的一切资源。

int sem_destroy(sem_t *sem);

#include lt;stdlib.h #include lt;stdio.h #include lt;unistd.h #include lt;pthread.h #include lt;semaphore.h #include lt;errno.h #define return_if_fail(p) if((p) == 0){printf (;[%s]:func error!/n;, __func__);return;} typedef struct _PrivInfo { sem_t s1; sem_t s2; time_t end_time; }PrivInfo; static void info_init (PrivInfo* thiz); static void info_destroy (PrivInfo* thiz); static void* pthread_func_1 (PrivInfo* thiz); static void* pthread_func_2 (PrivInfo* thiz); int main (int argc, char** argv) { pthread_t pt_1 = 0; pthread_t pt_2 = 0; int ret = 0; PrivInfo* thiz = NULL; thiz = (PrivInfo* )malloc (sizeof (PrivInfo)); if (thiz == NULL) { printf (;[%s]: Failed to malloc priv./n;); return -1; } info_init (thiz); ret = pthread_create (pt_1, NULL, (void*)pthread_func_1, thiz); if (ret != 0) { perror (;pthread_1_create:;); } ret = pthread_create (pt_2, NULL, (void*)pthread_func_2, thiz); if (ret != 0) { perror (;pthread_2_create:;); } pthread_join (pt_1, NULL); pthread_join (pt_2, NULL); info_destroy (thiz); return 0; } static void info_init (PrivInfo* thiz) { return_if_fail (thiz != NULL); thiz-end_time = time(NULL) + 10; sem_init (thiz-s1, 0, 1); sem_init (thiz-s2, 0, 0); return; } static void info_destroy (PrivInfo* thiz) { return_if_fail (thiz != NULL); sem_destroy (thiz-s1); sem_destroy (thiz-s2); free (thiz); thiz = NULL; return; } static void* pthread_func_1 (PrivInfo* thiz) { return_if_fail(thiz != NULL); while (time(NULL) lt; thiz-end_time) { sem_wait (thiz-s2); printf (;pthread1: pthread1 get the lock./n;); sem_post (thiz-s1); printf (;pthread1: pthread1 unlock/n;); sleep (1); } return; } static void* pthread_func_2 (PrivInfo* thiz) { return_if_fail (thiz != NULL); while (time (NULL) lt; thiz-end_time) { sem_wait (thiz-s1); printf (;pthread2: pthread2 get the unlock./n;); sem_post (thiz-s2); printf (;pthread2: pthread2 unlock./n;); sleep (1); } return; }

以上便是Linux下实现线程同步常用的三种方法,大家都知道,线程的最大的亮点便是资源共享性,而资源共享中的线程同步问题却是一大难点,希望小编的归纳能够对大家有所帮助!

相关文章

发表评论

验证码: 看不清?点击更换

注:网友评论仅供其表达个人看法,并不代表本站立场。