Linux C 线程(一)

1.线程和互斥锁
<1> 相关函数
   int pthread_create(pthread_t*restrict tidp,const pthread_attr_t *restrict_attr,void*（*start_rtn)(void*),void *restrict arg);
   int pthread_join(pthread_t thread, void **retval);// 阻塞当前线程，让pthread_t 代表的线程执行完毕
   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_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);
   int pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *cond_attr); //条件变量初始化    
   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);// 阻塞线程，有时间限制
   int pthread_cond_destroy(pthread_cond_t *cond);  //销毁条件变量
   int pthread_cond_signal(pthread_cond_t *cond);// 解除一个线程的阻塞
   int pthread_cond_broadcast(pthread_cond_t *cond);  //解除所有线程的阻塞
<2>线程创建 pthread_create,总共需要四个参数
   第一个参数，线程标识符指针： pthread_t *restrict
   第二个参数，线程属性：pthread_attr_t
   第三个参数，函数指针 start_rtn：作为线程的入口函数。
   第四个参数，函数参数，这个参数是作为线程的入口函数的参数。
    eg void *thread1(void *args){
     }
    pthread_t id;
    int result;
     result=pthread_create(&id,NULL,thread1,NULL);
    如果result等于0，那么就进入 thread1函数中执行相关代码
<3> 线程加入 pthread_join
    主要用于等待线程结束。pthread_join(id,NULL)
<3> 互斥锁
    pthread_mutex_t 锁变量，一般是一个外部变量，让程序共享。
    对于公共资源，锁变量能够保证，在某一段时间内，只有一个线程能够访问公共资源。公共资源的访问模式如下：
     pthread_mutex_lock(&mutex)
     访问公共资源
     pthread_mutex_unlock(&mutex)
    也就是说访问公共资源前，必须对锁变量上锁。
    线程1对锁变量上锁后，在线程1对锁变量解锁前，任何线程都无法对锁变量上锁,如果线程上锁失败，就会阻塞在那里，如果使用pthread_mutex_trylock,则会快速返回错误原因。
    也就是说程序的公共资源就像一栋房子，房子上有锁，线程先进入房子，把房子锁住，在线程从房子里出来解锁前，其他线程都无法进入这个房子。
<4> 条件变量。
    互斥锁的缺点在于，一旦锁变量被锁住，其他线程都无法访问公共资源。如果锁变量因为异常原因，始终无法解锁，那么程序将陷入无限的等待中。条件变量的作用在于让线程有条件的阻塞和唤醒。在执行任务的过程中，在线程1中，如果条件不满足，就让线程1阻塞，在线程2中，当条件满足时，再让线程1重新唤醒。
    条件变量一般和互斥锁一起结合使用
    条件变量 pthread_cond_t
    pthread_cond_init //初始化 条件变量
    pthread_cond_wait(&pthread_cond_t,&pthread_mutex_t)// 通过pthread_cond_t 让线程阻塞
    pthread_cond_signal(&pthread_cond_t)// 将第一个因为pthread_cond_t 而阻塞的线程唤醒，同时 让 pthread_mutex_t 上锁
    现在更新一下，公共资源的访问模式：
     线程1：
     pthread_mutex_lock(&mutex)
     if(条件不满足）
      pthread_cond_wait //阻塞线程 将线程休眠，同时 将mutex 解锁
     访问公共资源
     pthread_mutex_lock (&mutex)
     线程2：
     pthread_mutex_lock(&mutex)
     if(条件满足）
       pthread_cond_signal//唤醒线程 将第一个因为pthread_cond_t 而阻塞的线程唤醒，同时让mutex_t 上锁
     访问公共资源
     pthread_mutex_lock (&mutex)

代码实例
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
int count=0;
pthread_mutex_t mutex;
pthread_cond_t con;
struct student{
char name[20];
int age;
};
void *increament(void *args){
  printf("increate\n");
  pthread_mutex_lock(&mutex);
 
  count+=1;
  if(count>0){
    printf("con signal\n");
    pthread_cond_signal(&con);
  }
  printf("add\n");

 
  pthread_mutex_unlock(&mutex);
 
}
void *decrement(void *args){
  printf("decreament\n");
  pthread_mutex_lock(&mutex);
  struct student *stu1=(struct student *)args;
  strcpy(stu1->name,"test123");
  stu1->age=28;
  if(count==0){
 
    printf("decrement thread sleep\n");
    pthread_cond_wait(&con,&mutex);
  }
  printf("decre\n");
  count-=1;
 
  pthread_mutex_unlock(&mutex);
}

int main(void){
pthread_mutex_init(&mutex,NULL);
pthread_cond_init(&con,NULL);
pthread_t id1,id2;
int result=0;
struct student stu={"test",27};
pthread_mutex_unlock(&mutex);
result=pthread_create(&id1,NULL,(void *)decrement,&stu);
if(result!=0){
printf("create increament thread fail\n");
return -1;
}
result=pthread_create(&id2,NULL,(void *)increament,NULL);
if(result!=0){
printf("create decrement thread \n");
return -1;
}
printf("..................student name=%s\n",stu.name);
printf("..................student age=%d\n",stu.age);
pthread_join(id1,NULL);
pthread_join(id2,NULL);
return 1;
}