Linux线程浅析[初识线程]

Linux线程浅析[初识线程]

1. 线程的基本概念
2. Linux线程的实现
3. 线程的创建和终止
4. 线程的互斥和同步
5. 互斥锁
6. 读写锁
7. 条件变量
8. 线程信号量
9. 死锁

线程的基本概念

进程是资源管理的最小单位，线程是程序执行的最小单位 ，
每个进程有自己的数据段，代码段和堆栈段。线程通常叫做轻型的进程，它包含独立的栈和CPU寄存器状态，线程是进程的一条执行路径，每个线程共享其所附属进程的所有资源，包括打开的文件，内存页面，信号标识及动态内存分配(线程是共享附属进程的资源)

因为线程和进程比起来很小，所以相对来说，线程花费更少的CPU资源
在操作系统设计上，从进程演化出线程，最主要的目的就是更好的支持多处理器，并且见效进程上下文切换的开销

进程与线程的包含关系：
线程与进程之间的关系是：线程是属于进程的，线程是运行在进程空间内部，同一个进程的所有线程共享同一用户内存空间，当进程推出的时候，该进程所产生的线程也会强制退出并且清除，一个进程至少需要一个线程作为它的指令执行体，进程管理资源(如cpu,内存，文件，)而将线程分配到某个cpu上面去
一般情况下，首先需要让进程进入runing状态，进程再去为线程分配资源，让线程处于runing状态
一个进程在默认情况之下只存在一个线程(主控线程)
一个进程可以创建出很多个子线程

线程的分类：

线程按照调度者可以分为用户级线程和内核级线程两种

用户级别的线程：主要是解决上下文切换的问题，其调度过程由用户决定
内核级别线程：由内核调度机制决定    

一般情况下现在大多数操作系统采用用户级线程和内核级别线程并存的方法

用户级别线程要绑定内核级别线程运行，一个进程中的内核级别线程会分配到固定的时间片，用户级线程分配的时间片以内核级线程为准

默认情况下用户级别线程和内核级别线程是一对一，也可以多对一，这样实时性及比较差

当cpu分配给线程的时间片用完后但线程没有执行完毕，此时线程会从运行状态返回到就绪状态，将cpu让给其他线程

Linux线程的实现

线程的使用：
以下的线程均为用户级别的线程，在linux中，一般采用pthread线程库函数，实现线程的访问和控制，由POSIX提出，具有很好的可移植性。
Linux标准下的pthread需要在编译的时候去链接pthread

 gcc -o bin/demo -lpthread src/demo.c

每个进程内部的不同线程都有自己的唯一标识ID

线程标识只在它所属的进程环境中有效果
线程标识是pthread_t数据类型
#include
int pthread_equal(pthread_t,pthread_t);
返回:相等返回非0,否则返回0
pthread_t pthread_self(void)
返回:调用线程的线程ID

线程特征的结构体:

typedef struct{
    int etachstate; //线程的分离状态
    int schedpolicy; //线程的调度策略
    structsched schedparam;//线程的调度参数
    int inheritsched; //线程的继承性
    int scope; //线程的作用域
    size_t guardsize; //线程栈末尾的警戒缓冲区大小
    int stackaddr_set; //线程栈的设置
    void* stackaddr; //线程栈的启始位置
    size_t stacksize; //线程栈大小
}pthread_attr_t;

线程的创建和终止

线程创建:

#include
int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict attr,void*(start_rtn)(void*),
void *restrict arg
)；
返回：成功返回0,失败返回错误编号
参数:
tidp :线程标识符指针
attr：线程属性指针
start_rtn:线程运行函数的起始地址(线程运行函数，函数指针)
arg:传递给线程运行函数的参数(一般情况下我们都是将参数做成一个结构体，然后将结构体指针传进去)
新创建的线程从start_rtn函数的地址开始运行
不能保证新线程和调用线程的执行顺序

龟兔赛跑的案例，只传递简单的参数类型

/*
 * ===========================================================================
 *
 *       Filename:  pthread_create1.c
 *    Description:  i
 *        Version:  1.0
 *        Created:  2017年03月26日 09时25分59秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

#include
#include
#include

void* th_function(void *argv){
  //在获取参数的时候，其实拿到的就是这样的一个地址，但是这个地址是一个整形，而不是我们经常使用的二进制的0x123456等
  //在指针变量中存储的数据不是地址，而是返回的参数５０或者６０
  //以下两种写法都是可以的
  //int *arg = (int *)argv;
  int arg = (int)argv;
  int i = 0;
  for(i = 0;i < arg;i++){
    printf("thread id:%lx,run distance:%d\n",pthread_self(),i);
    sleep(1);
  }
   pthread_exit((void*)0);//正常的线程退出方式
  //return (void*)0;正常退出
}

int main(int argc,char *argv[]){
  int result;
  pthread_t turtle,rabbit;
  if((result = pthread_create(&turtle,NULL,th_function,(void*)50))!=0){
      perror("create error\n");
  }
  /* 
   * 参数是讲６０转化成一个void *类型的指针，也就是把其看成了一个地址类型
   * */
  if((result = pthread_create(&rabbit,NULL,th_function,(void*)60))!=0){
     perror("create error\n");
  }
  //pthread_join调用者被阻塞住了，所以只有当两个线程同事执行完毕之后才会执行printf语句 
  pthread_join(rabbit,NULL);
  pthread_join(turtle,NULL);
  printf("thread id:%lx\n",pthread_self());

  return 0;
}

　创建的代码线程部分的经典案例,传递的是复杂的结构体：龟兔赛跑:

/*
 * ===========================================================================
 *
 *       Filename:  pthread_create.c
 *    Description:  关于线程的经典案例:龟兔赛跑
 *        Version:  1.0
 *        Created:  2017年03月25日 21时25分44秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */
#include
#include
#include

/* *
 *创建参数类型的结构体
 * */
typedef struct{
  char pthread_name[20];
  long sleep_time;
  int start;
  int end;
}Arg;

/**
 * 线程的执行函数
 */
void* function(void *arg){
  Arg *r = (Arg *)arg;
  char *pthread_name = r ->pthread_name;
  long sleep_time = r -> sleep_time;
  int start = r -> start;
  int end = r->end;
  for(; start//pthread_self(),这是去获取线程的id
    printf("thread_name:%s thead_id:%lx,distance:%ld\n",pthread_name,pthread_self(),start);
    //毫秒级的睡眠时间
    usleep(sleep_time);
  }

  return (void*)0;
}


int main(int argc,char *argv[]){
  pthread_t turtle,rabbit;
  Arg turtle_arg = {"turtle",drand48()*10000000,0,50};
  Arg rabbit_arg = {"rabbit",drand48()*10000000,0,40};

  int result;
  /* 
   * x线程创建函数pthread_create().成功返回０，失败返回错误编码
   * */
  if((result = pthread_create(&turtle,NULL,function,(void *)&turtle_arg))!=0){
    perror("turtle pthread create error");
  }

  if((result = pthread_create(&rabbit,NULL,function,(void*)&rabbit_arg))!=0){
    perror("rabbit pthread create error");
  }
  //线程的等待函数join，谁调用了join后，谁就被阻塞了，等待其指定的线程执行完毕后再去执行
  pthread_join(turtle,NULL);
  pthread_join(rabbit,NULL);
  printf("main thread:%lx\n",pthread_self());
  printf("the main process is ended\n");
  return 0;
}

线程终止

主动终止：

线程的执行函数中调用return语句
调用pthread_exit()

被动终止：

线程可以被同一进程的其他线程取消，其它线程调用
pthread_cancel(pthid);

　终止函数：

    #include
    int pthread_cancel(pthread_t tid);
    void pthread_exit(void *retval);
    int pthread_join(pthread_t th,void **thread_return);
    返回值：成功返回0,失败返回错误编号
    pthread_exit((void*)0);

    pthread_cancel
    线程可以被同一进程的其他线程取消，tid为被终止的线程标识符

    pthread_exit
retval:pthread_exit调用者线程的返回值，可由其他函数和pthread_join来检测获取
线程退出时使用pthread_exit是线程的主动行为

由于一个进程中的多个线程共享数据段，因此通常在线程退出后，
退出线程所占用的资源并不会随线程结束而释放，所以需要pthread_join函数来等待线程结束，类似与wait或者waitpid系统调用

pthread_join(谁调用，谁就会阻塞，直到所等待的线程执行完毕后，其才会执行,而且调用之后会去释放掉子线程的资源，所以切记要在主控线程中去调用，等待子线程执行完毕后去回收子线程的资源，如果没调用的话，那么在子线程结束后，资源并不会去回收)

th:被等待线程的标识符
thread_return:用户定义指针，用来存储被等待线程的返回值(注意Ｃ语言中的线程join后是可以接受到线程的返回值的)

//使用pthread_join接收线程返回的参数

/*
 * ===========================================================================
 *
 *       Filename:  pthread_create2.c
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年03月26日 10时02分09秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */

#include
#include
#include

typedef struct{
  int num1;
  int num2;
  int num3;
}Arg;

void* th_function(void *argv){
  Arg * agv = (Arg *)argv;
  int result = agv->num1 +agv->num2 +agv->num3;
  printf("caculate_result:%d\n",result);
//  pthread_exit((void*)result);
  return (void*)result;
}

int main(int argc,char * argv[]){
  pthread_t caculate;
  int result;
  Arg agv = {10,11,12};
  if((result = pthread_create(&caculate,NULL,th_function,(void *)&agv))!=0){
    perror("create thread error");
  }
  //使用pthead_join接收线程返回参数方法一:
  //
  //int result_two;
  //pthread_join(caculate,(void *)&result_two);
  //printf("main thread id:%lx,result:%d\n",pthread_self(),(int)result_two);

  //使用pthread_join接受线程返回参数方法二
  int *result_two;
  pthread_join(caculate,(void **)&result_two);
  printf("main thread id:%lx result:%d\n",pthread_self(),(int)result_two);
  return 0;
}

注意在接收函数返回参数的时候，参数类型是怎么填写的．具体其实很好理解．在以往指针的使用过程中，指针变量中存储的都是一个地址．但是在这里，**其实指针变量存储的并不是一个地址．而是返回参数的数值．**

　这些都是很简单的例子．有兴趣的拷贝一下

欢迎持续访问博客