linux线程同步方法_shell脚本多线程并发

Linux系统应用开发—多线程同步的几种方法 　　一、互斥锁 　　互斥锁，是一种信号量，常用来防止两个进程或线程在同一时刻访问相同的共享资源。 　　需要的头文件：pthread.h 　　互斥锁标识符：pthread_mutex_t 　　（1）互斥锁初始化： 　　函数原型： int pthread_mutex_init (pthread_mutex_t* mutex,const pthread_mutexattr_t* mutexattr); 　　函数传入值: mutex：互斥锁。 　　mutexattr：PTHREAD_MUTEX_INITIALIZER 创建快速互斥锁。 　　PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP 创建递归互斥锁。 　　PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP 创建检错互斥锁。 　　函数返回值：成功：0；出错：-1 　　（2）互斥操作函数 　　int pthread_mutex_lock(pthread_mutex_t* mutex); //上锁 　　int pthread_mutex_trylock (pthread_mutex_t* mutex); //只有在互斥被锁住的情况下才阻塞 　　int pthread_mutex_unlock (pthread_mutex_t* mutex); //解锁 　　int pthread_mutex_destroy (pthread_mutex_t* mutex); //清除互斥锁 　　函数传入值：mutex：互斥锁。 　　函数返回值：成功：0；出错：-1 　　使用形式： 　　pthread_mutex_t mutex; 　　pthread_mutex_init (&mutex, NULL); /*定义*/ 　　… 　　pthread_mutex_lock(&mutex); /*互斥锁*/ 　　… /*临界资源*/ 　　pthread_mutex_unlock(&mutex); /*释放互斥锁*/ 　　如果一个线程已经给一个互斥量上锁了，后来在操作的过程中又再次调用了该上锁的操作，那么该线程将会无限阻塞在这个地方，从而导致死锁。这就需要互斥量的属性。 　　互斥量分为下面三种： 　　1、快速型。这种类型也是默认的类型。该线程的行为正如上面所说的。 　　2、递归型。如果遇到我们上面所提到的死锁情况，同一线程循环给互斥量上锁，那么系统将会知道该上锁行为来自同一线程，那么就会同意线程给该互斥量上锁。 　　3、错误检测型。如果该互斥量已经被上锁，那么后续的上锁将会失败而不会阻塞，pthread_mutex_lock()操作将会返回EDEADLK。 　　互斥量的属性类型为pthread_mutexattr_t。声明后调用pthread_mutexattr_init()来创建该互斥量。然后调用pthread_mutexattr_settype来设置属性。格式如下：int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind); 　　第一个参数attr，就是前面声明的属性变量；第二个参数kind，就是我们要设置的属性类型。他有下面几个选项： 　　PTHREAD_MUTEX_FAST_NP 　　PTHREAD_MUTEX_RECURSIVE_NP 　　PTHREAD_MUTEX_ERRORCHECK_NP 　　下面给出一个使用属性的简单过程： 　　pthread_mutex_t mutex; 　　pthread_mutexattr_t attr; 　　pthread_mutexattr_init(&attr); 　　pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE_NP); 　　pthread_mutex_init(&mutex,&attr); 　　pthread_mutex_destroy(&attr); 　　前面我们提到在调用pthread_mutex_lock()的时候，如果此时mutex已经被其他线程上锁，那么该操作将会一直阻塞在这个地方。如果我们此时不想一直阻塞在这个地方，那么可以调用下面函数：pthread_mutex_trylock。 　　如果此时互斥量没有被上锁，那么pthread_mutex_trylock将会返回0，并会对该互斥量上锁。如果互斥量已经被上锁，那么会立刻返回EBUSY。 　　——————————————- 例子程序1: linux_mutex_test.c—————————— 　　/*互斥锁测试程序*/ 　　#include<stdio.h> 　　#include<pthread.h> 　　#include<unistd.h> 　　void print_function(char* str) { 　　while (*str != ‘\0’) { 　　putchar(*str); 　　fflush(stdout); // 刷新输出缓冲区 　　str++; 　　usleep(10000); 　　} 　　putchar(‘\n’); 　　} 　　void* thread_func1(void* arg) { 　　char* str = (char*)arg; 　　pthread_mutex_lock(&mutex); 　　print_function(str); 　　pthread_mutex_unlock(&mutex); 　　return NULL; 　　} 　　void* thread_func2(void* arg) { 　　char* str = (char*)arg; 　　pthread_mutex_lock(&mutex); 　　print_function(str); 　　pthread_mutex_unlock(&mutex); 　　return NULL; 　　} 　　int main(int argc, const char* argv[]) { 　　pthread_t tid1, tid2; 　　int ret = -1; 　　char* str1 = “thread task1”; 　　char* str2 = “thread task2”; 　　ret = pthread_mutex_init(&mutex, NULL); // 初始化互斥锁 　　if (0 != ret) { 　　printf(“pthread_mutex_init failure.\n”); 　　return 1; 　　} 　　printf(“pthread_mutex_init OK.\n”); 　　ret = pthread_create(&tid1, NULL, thread_func1, (void*)str1); 　　if (0 != ret) { 　　printf(“thread_func1 create failure!\n”); 　　return 1; 　　} 　　ret = pthread_create(&tid2, NULL, thread_func2, (void*)str2); 　　if (0 != ret) { 　　printf(“thread_func2 create failure!\n”); 　　return 1; 　　} 　　ret = pthread_detach(tid1); 　　if (0 != ret) { 　　printf(“thread_func1 detach failure!.\n”); 　　return 1; 　　} 　　ret = pthread_detach(tid2); 　　if (0 != ret) { 　　printf(“thread_func2 detach failure!\n”); 　　return 1; 　　} 　　sleep(1); 　　// 销毁互斥锁。放在sleep之后，防止主线程执行过快，销毁了正在使用的互斥锁。 　　ret = pthread_mutex_destroy(&mutex); 　　if (0 != ret) { 　　printf(“mutex destroy failure！.\n”); 　　return 1; 　　} 　　printf(“mutex destroy ok！\n”); 　　return 0; 　　} 　　二、条件变量 　　需要的头文件：pthread.h 　　条件变量标识符：pthread_cond_t 　　1、互斥锁的存在问题： 　　互斥锁一个明显的缺点是它只有两种状态：锁定和非锁定。设想一种简单情景：多个线程访问同一个共享资源时，并不知道何时应该使用共享资源，如果在临界区里加入判断语句，或者可以有效，但一来效率不高，二来复杂环境下就难以编写了，这是我们需要一个结构，能在条件成立时触发相应线程，进行变量修改和访问。 　　2、条件变量: 　　条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，它常和互斥锁一起使用。使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开相应的互斥锁并等待条件发生变化。一旦其它的某个线程改变了条件变量，它将通知相应的条件变量唤醒一个或多个正被此条件变量阻塞的线程。这些线程将重新锁定互斥锁并重新测试条件是否满足。 　　3、条件变量的相关函数 　　pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //条件变量结构 　　int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t*cond_attr); 　　int pthread_cond_signal(pthread_cond_t *cond); 　　int pthread_cond_broadcast(pthread_cond_t *cond); 　　int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); 　　int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, 　　const struct timespec *abstime); 　　int pthread_cond_destroy(pthread_cond_t *cond); 　　详细说明： 　　(1)创建和注销 　　条件变量和互斥锁一样，都有静态动态两种创建方式 　　a.静态方式 　　静态方式使用PTHREAD_COND_INITIALIZER常量，如下： 　　pthread_cond_t cond=PTHREAD_COND_INITIALIZER 　　b.动态方式 　　动态方式调用pthread_cond_init()函数，API定义如下： 　　int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr) 　　尽管POSIX标准中为条件变量定义了属性，但在LinuxThreads中没有实现，因此cond_attr值通常为NULL，且被忽略。 　　注销一个条件变量需要调用pthread_cond_destroy()，只有在没有线程在该条件变量上等待的时候才能注销这个条件变量，否则返回EBUSY。因为Linux实现的条件变量没有分配什么资源，所以注销动作只包括检查是否有等待线程。API定义如下：int pthread_cond_destroy(pthread_cond_t *cond) 　　(2)等待和激发 　　a.等待 　　int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) //等待 　　int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, 　　const struct timespec *abstime) //有时等待 　　等待条件有两种方式：无条件等待pthread_cond_wait()和计时等待pthread_cond_timedwait()，其中计时等待方式如果在给定时刻前条件没有满足，则返回ETIMEOUT，结束等待，其中abstime以与time()系统调用相同意义的绝对时间形式出现，0表示格林尼治时间1970年1月1日0时0分0秒。 　　无论哪种等待方式，都必须和一个互斥锁配合，以防止多个线程同时请求pthread_cond_wait()（或 pthread_cond_timedwait()，下同）的竞争条件（Race Condition）。 　　mutex互斥锁必须是普通锁（PTHREAD_MUTEX_TIMED_NP）或者适应锁（PTHREAD_MUTEX_ADAPTIVE_NP），且在调用pthread_cond_wait()前必须由本线程加锁（pthread_mutex_lock()），而在更新条件等待队列以前，mutex保持锁定状态，并在线程挂起进入等待前解锁。 　　在条件满足从而离开 pthread_cond_wait()之前，mutex将被重新加锁，以与进入pthread_cond_wait()前的加锁动作对应。 　　b.激发 　　激发条件有两种形式，pthread_cond_signal()激活一个等待该条件的线程，存在多个等待线程时按入队顺序激活其中一个；而pthread_cond_broadcast()则激活所有等待线程。 　　(3)其他操作 　　pthread_cond_wait ()和pthread_cond_timedwait()都被实现为取消点，因此，在该处等待的线程将立即重新运行，在重新锁定mutex后离开pthread_cond_wait()，然后执行取消动作。也就是说如果pthread_cond_wait()被取消，mutex是保持锁定状态的，因而需要定义退出回调函数来为其解锁。 　　pthread_cond_wait实际上可以看作是以下几个动作的合体: 　　解锁线程锁； 　　等待条件为true； 　　加锁线程锁； 　　使用形式：这两个线程实在一个程序里的,作者给出的模型很好. 　　// 线程一代码 　　pthread_mutex_lock(&mutex); 　　if (条件满足) 　　pthread_cond_signal(&cond); 　　pthread_mutex_unlock(&mutex); 　　// 线程二代码 　　pthread_mutex_lock(&mutex); 　　while (条件不满足) 　　pthread_cond_wait(&cond, &mutex); 　　pthread_mutex_unlock(&mutex); 　　/*线程二中为什么使用while呢？因为在pthread_cond_signal和pthread_cond_wait返回之间，有时间差，假设在这个时间差内，条件改变了，显然需要重新检查条件。也就是说在pthread_cond_wait被唤醒的时候可能该条件已经不成立。*/ 　　——————————————- 例子程序2: linux_cond_test.c—————————— 　　/ pthread_cond 使用方法 / 　　#include <stdio.h> 　　#include <stdlib.h> 　　#include <unistd.h> 　　#include <pthread.h> 　　pthread_mutex_t count_lock; 　　pthread_cond_t count_ready; 　　int count; 　　///// 　　void *thread_consumer(void *arg) 　　{ 　　char *name = (char *)arg; 　　for(;;){ 　　pthread_mutex_lock(&count_lock); 　　printf(“[%s]decrement:waiting, count:%d\n”, name, count); 　　/*等待满足条件，期间互斥量仍然可用*/ 　　if(count == 0){ 　　pthread_cond_wait(&count_ready, &count_lock); 　　} 　　printf(“[%s]decrement:count = %d\n”, name, count); 　　if (count == 1) 　　{ 　　printf(“[%s]action!! count:%d\n”, name, count); 　　} 　　count = 0; 　　pthread_mutex_unlock(&count_lock); 　　} 　　pthread_exit(NULL); 　　} 　　/////// 　　void *thread_producer(void *arg) 　　{ 　　sleep(1); 　　while(1){ 　　pthread_mutex_lock(&count_lock); 　　count = 1; 　　pthread_mutex_unlock(&count_lock); 　　pthread_cond_signal(&count_ready); 　　} 　　pthread_exit(NULL); 　　} 　　///////////////////////////////////////////////////////////////////// 　　int main(void) 　　{ 　　pthread_t tid1,tid2,tid3; 　　const char *tid_name1 = “th_consumer1”; 　　const char *tid_name2 = “th_producer”; 　　const char *tid_name3 = “th_consumer2”; 　　count=0; 　　pthread_mutex_init(&count_lock, NULL); 　　pthread_cond_init(&count_ready, NULL); 　　pthread_create(&tid2, NULL, thread_producer, (void *)tid_name2); 　　pthread_create(&tid1, NULL, thread_consumer, (void *)tid_name1); 　　pthread_create(&tid3, NULL, thread_consumer, (void *)tid_name3); 　　/*等待decrement退出*/ 　　pthread_join(tid2, NULL); 　　printf(“thread_consumer quit\n”); 　　pthread_join(tid3, NULL); 　　pthread_join(tid1, NULL); 　　return 0; 　　} 　　三、信号量 　　sem_init：初始化信号量sem_t，初始化的时候可以指定信号量的初始值，以及是否可以在多进程间共享。 　　sem_wait：一直阻塞等待直到信号量>0。 　　sem_timedwait：阻塞等待若干时间直到信号量>0。 　　sem_post：使信号量加1。 　　sem_destroy：释放信号量。和sem_init对应。 　　信号量其实就是一个计数器，也是一个整数。每一次调用wait操作将会使semaphore值减一，而如果semaphore值已经为0，则wait操作将会阻塞。每一次调用post操作将会使semaphore值加一。 　　需要的头文件：semaphore.h 　　信号量标识符：sem_t 　　主要函数： 　　(1)sem_init 　　功能： 用于创建一个信号量，并初始化信号量的值。 　　函数原型： int sem_init (sem_t* sem, int pshared, unsigned int value); 　　函数传入值： sem：信号量。 　　pshared：决定信号量能否在几个进程间共享。由于目前LINUX还没有实现进程间共享信息量，所以这个值只能取0。 　　value：初始计算器 　　函数返回值： 0：成功；-1：失败。 　　(2)其他函数。 　　//等待信号量 　　int sem_wait (sem_t* sem); 　　int sem_trywait (sem_t* sem); 　　//发送信号量 　　int sem_post (sem_t* sem); 　　//得到信号量值 　　int sem_getvalue (sem_t* sem); 　　//删除信号量 　　int sem_destroy (sem_t* sem); 　　功能：sem_wait和sem_trywait相当于P操作，它们都能将信号量的值减一，两者的区别在于若信号量的值小于零时，sem_wait将会阻塞进程，而sem_trywait则会立即返回。 　　sem_post相当于V操作，它将信号量的值加一，同时发出唤醒的信号给等待的进程（或线程）。 　　sem_getvalue 得到信号量的值。 　　sem_destroy 摧毁信号量。 　　使用形式： 　　sem_t sem; 　　sem_init(&sem, 0, 1); /*信号量初始化*/ 　　… 　　sem_wait(&sem); /*等待信号量*/ 　　… /*临界资源*/ 　　sem_post(&sem); /*释放信号量*/ 　　信号量与线程锁、条件变量相比还有以下几点不同： 　　1)锁必须是同一个线程以及释放，否则会死锁。而条件变量和信号量则不必。 　　2)信号的递增与减少会被系统自动记住，系统内部有一个计数器实现信号量，不必担心会丢失，而唤醒一个条件变量时，如果没有相应的线程在等待该条件变量，这次唤醒将被丢失。 　　——————————————- 例子程序3: linux_sem_test.c—————————— 　　#include <stdio.h> 　　#include <stdlib.h> 　　#include <pthread.h> 　　#include <semaphore.h> 　　static sem_t sem; 　　void* run(void* arg) { 　　int id = *(int*)arg; 　　printf(“Thread %d begin…\n”, id); 　　sem_wait(&sem); 　　printf(“Thread %d get sem…\n”, id); 　　sleep(1); 　　printf(“Thread %d release sem…\n”, id); 　　sem_post(&sem); 　　printf(“Thread %d over…\n”, id); 　　pthread_exit(NULL); 　　} 　　/////////////////////////////////////////////////////////////////////////////// 　　int main() { 　　sem_init(&sem, 0, 3); 　　pthread_t tids[5]; 　　int ids[5]; 　　for (int i = 0; i < 5; i++) { 　　ids[i] = i + 1; 　　pthread_create(&tids[i], NULL, run, &ids[i]); 　　} 　　for (int i = 0; i < 5; i++) { 　　pthread_join(tids[i], NULL); 　　} 　　sem_destroy(&sem); 　　return 0; 　　}