线程学习之互斥锁

互斥锁

  当一个进程中存在两个及以上（一个进程本来就有一个线程）的线程时，线程间会互相争夺共享资源，导致单个线程中的执行秩序会被打乱。所以需要用到互斥量来进行秩序控制，保证单个线程中的程序先执行完毕。
  所以互斥锁的作用就是使上锁与解锁之间的代码完整的、不受别的线程“打扰”的执行完。而另一个线程必须等到这个锁解开了，才能执行自己的代码。注意互斥锁不能控制多线程的执行顺序，也就是我们加了锁之后，并不知道先执行那个线程.

相关API

(1)创建互斥锁pthread_mutex_init();

函数原型; int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
参数说明：
  1. *mutex :互斥量的索引（名称），为指针变量；
  2. *attr :互斥量的属性，通常为 NULL。
返回值： 成功返回0；失败返回错误编码。
我们在使用的时候，应该把 *mutex定义为全局变量，这样所有的线程都能使用。

（2）销毁互斥锁pthread_mutex_destroy();

函数原型; int pthread_mutex_destroy(pthread_mutex_t *mutex);
参数说明：
     *mutex :互斥锁的索引（名称），注意这里同样是指针变量。
返回值： 成功返回0；失败返回错误编码；
我们在所有线程都执行完毕后，应该销毁互斥锁。
用法：

#include <pthread.h>
pthread_mutex_t mutex;//定义互斥锁的索引
int main()
{
	int ret;
	ret=pthread_mutex_init(&mutex,NULL);//创建互斥锁
	............
	pthread_mutex_destroy(&mutex);//销毁互斥锁
	return 0;
}

(3）上锁pthread_mutex_lock();

函数原型; int pthread_mutex_lock(pthread_mutex_t *mutex);
参数说明：
    *mutex: 互斥锁的索引（名称），注意这里同样是指针变量。
返回值： 成功返回0；失败返回错误编码；
用法结合解锁函数pthread_mutex_unlock来介绍。

（4）解锁pthread_mutex_unlock();

函数原型; int pthread_mutex_unlock(pthread_mutex_t *mutex);
参数说明：
    *mutex :互斥锁的索引（名称），注意这里同样是指针变量。
返回值： 成功返回0；失败返回错误编码；
用法结合上锁函数pthread_mutex_lock来介绍。
例子：

void fun1(void *s){
        pthread_mutex_lock(&mutex);//上锁
        for(i=0;i<3;i++){
                printf("fun1:%d\n",data++);
                        sleep(1);
        }
        pthread_mutex_unlock(&mutex);//解锁
        pthread_exit(NULL);
}

补充：视频中涉及的shell脚本可用c语言system（）代替；

test.sh的内容为：

执行结果就是：a.out被执行了3次。

关于死锁

   两个子线程使用不同的互斥锁，当它们在各自还没有释放锁的(pthread_mutex_unlock)时候，获取对方的锁，导致程序一直卡在pthread_mutex_lock 处，这种情况就是死锁。我们编程的时候，因为代码量大，可能不经意间就出现死锁。（即在未解锁的情况下两次获取同一把锁（pthread_mutex_lock），第二次lock锁的时候会阻塞。）
**

条件信号（conditional）

   在进程里，如果没有条件信号去控制线程的话，我们无法确定进程会先执行哪个线程，但是使用条件信号的话，我们可以去控制线程的执行顺序。
条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其他线程在获得互斥量之前不会察觉到这种改变，因为必须锁定互斥量以后才能计算条件。
　　条件变量使用之前必须首先初始化，pthread_cond_t数据类型代表的条件变量可以用两种方式进行初始化，可以把常量PTHREAD_COND_INITIALIZER赋给静态分配的条件变量。

1.相关API

（1）创建条件信号pthread_cond_init();

函数原型; int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
参数说明：
  1. *cond ：条件信号的索引（名称），为指针变量；
  2. *attr ：条件的属性，通常为 NULL。
返回值： 成功返回0；失败返回错误编码。
我们在使用的时候，应该把 *cond定义为全局变量，这样所有的线程都能使用。
用法:

#include <pthread.h>
pthread_cond_t cond;//定义条件信号的索引
int main()
{
	int ret;
	ret=pthread_mutex_init(&cond,NULL);//创建条件信号
	return 0;
}	

（2）销毁条件信号pthread_cond_destroy();

函数原型; int pthread_cond_destroy(pthread_cond_t *cond);
参数说明：
    *cond ：条件信号的索引（名称），为指针变量；
返回值： 成功返回0；失败返回错误编码。
另外在所有线程都是执行完毕后，也需要把条件信号销毁。
用法:
#include <pthread.h>
pthread_cond_t cond;//定义条件信号的索引

int main()
{
	int ret;
	ret=pthread_cond_init(&cond,NULL);//创建条件信号
	........
	pthread_cond_destroy(&cond);//销毁条件信号
	return 0;
}	
1

（3）等待条件信号pthread_cond_wait();

函数原型; int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t * mutex);
参数说明：
  1. *cond ：条件信号的索引（名称），为指针变量，需要等待条件信号；
  2. *mutex ：为互斥锁，在mutex这个锁里等待条件信号。
返回值： 成功返回0；失败返回错误编码。
用法: 配合条件信号发送函数pthread_cond_signal（触发方式，也叫点播方式）来介绍。

（4）发送条件信号pthread_cond_signal();

函数原型; int pthread_cond_signal(pthread_cond_t *restrict cond);
参数说明：
    *cond ：条件信号的索引（名称），为指针变量，需要发送的条件信号；
返回值： 成功返回0；失败返回错误编码。
用法: 配合条件信号发送函数pthread_cond_wait（触发方式，也叫点播方式）来介绍。

#include <pthread.h>
pthread_cond_t cond;//定义条件信号的索引
pthread_mutex_t mutex;//定义互斥锁的索引
void *T1_T（void* arg）
{
	ptread_mutex_lock(&mutex);
	........
	pthread_cond_signal(&cond);//达到某个条件之后，发送信号
	pthread_mutex_unlock(&mutex);
}
void *T2_T（void* arg）
{
	pthread_cond_wait(&cond,&mutex);//达到某个条件之后，发送信号
	.........
}
int main()
{
	int ret;
	pthread_t T1;
	pthread_t T2;
	pthread_create(&T1,NULL,void(*)T1_T,NULL);//创建线程T1
	pthread_create(&T2,NULL,void(*)T2_T,NULL);//创建线程T1
	ret=pthread_cond_init(&cond,NULL);//创建条件信号
	pthread_mutex_init(&mutex,NULL);//创建一个互斥锁
	........
	pthread_cond_destroy(&cond);//销毁条件信号
	pthread_mutex_destroy(&mutex);//销毁互斥锁
	return 0;
}

具体例子：

编程遇到的问题：

现象：程序运行后运行完main函数和fun1函数后就没反应了。。
原因：由于在条件语句外没写使data++的语句，满足不了（data3）的条件；使pthread_cond_signal()执行不了。使程序阻塞了。

#include<stdio.h>
#include <pthread.h>
#include <stdlib.h>
int data=0;
int i;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;//静态初始化
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
void fun1(void *s){
        pthread_mutex_lock(&mutex);
        while(1){
                if(data==3){
                        pthread_cond_signal(&cond);
                        pthread_mutex_unlock(&mutex);
                        sleep(1);
                }
                printf("fun1:%d\n",data++);//让data++使之达到3
        }
        pthread_exit(NULL);
}
void fun2(void *s){
        pthread_cond_wait(&cond,&mutex);
        while(1){
                printf("fun2=========%d\n",data++);
                exit(0);
   }
}
int main(){
        pthread_t threadid;
        pthread_t threadid1;
        int *val;
        int ret;
        int s=1;
        pthread_cond_init(&cond,NULL);//在main函数中初始化是动态初始化 用宏就是静态初始化。
        pthread_mutex_init(&mutex,NULL);
        ret=pthread_create(&threadid,NULL,(void*)fun1,(void*)&s);
        if(ret==0)
                printf("thread create success\n");
        ret=pthread_create(&threadid1,NULL,(void*)fun2,(void*)&s);
        if(ret==0)
                printf("thread1 create success\n");
        printf("man thread id =%ld\n",(unsigned long)pthread_self());
        pthread_join(threadid,NULL);
        pthread_join(threadid1,NULL);
        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);
        return 0;
}                                                    

补充
将运行结果输入到txt文件中

a.out中代码：

#include<stdio.h>
int main(int argc,char**argv){
        int i;
        for(i=0;i<atoi(argv[1]);i++){
                system("./2.5");
        }
        return 0;
}