线程基础知识点

一、概念

进程并不执行任务，只是为线程提供空间和资源，线程才是执行任务的实体。线程仍然是轻量级的进程，所以线程的本质仍然是进程。为了让进程完成工作，进程必须至少包含一个线程。

在硬盘中的程序，在运行过程中就会在内存中开辟一块单独的内存空间。内存空间有自己的内存地址，有自己的堆，上级挂靠单位是操作系统。操作系统是以进程为单位，分配系统资源，所以进程是资源分配的最小单位。线程是操作系统执行的最小单位。

线程是进程的一个实体，是CPU调度和运行的基本单位，它是比进程更小的能独立运行的吉本单位。线程自己不拥有资源，只拥有一点运行必不可少的资源（程序计数器、一组寄存器和栈），但它可以与所属进程的其它线程共享所拥有的全部资源。

进程有自己的地址空间，线程使用进程的地址空间。进程里的资源线程都有权访问。

二、线程特点

1.线程和进程关系

①线程是轻量级的进程，也有PCB，创建线程和进程的底层函数是一样的，都是clone()

②从内核来看，线程和进程是一样的

③进程可以蜕变成线程

不管是创建进程的fork(),还是创建线程的pthread_crate(),底层都是调用同一个内核函数clone()。

• 如果复制对方的地址空间，那么就创建一个进程
• 如果共享对方的地址空间，那么就创建一个线程

Linux内核是不区分线程和进程的，只在用户层面区分。所以，线程所有操作函数 pthread_* 是库函数，而非系统调用。

2 线程共享资源

1) 文件描述符表

2) 每种信号的处理方式

3) 当前工作目录

4) 用户ID和组ID

内存地址空间 (.text/.data/.bss/heap/共享库)

3 线程非共享资源

1) 线程id

2) 处理器现场和栈指针(内核栈)

3) 独立的栈空间(用户空间栈)

4) errno变量

5) 信号屏蔽字

6) 调度优先级

4 线程的优缺点

优点：

Ø 提高程序并发性

Ø 开销小

Ø 数据通信、共享数据方便

缺点：

Ø 库函数，不稳定

Ø 调试、编写困难、gdb不支持

Ø 对信号支持不好

优点相对突出，缺点均不是硬伤。Linux下由于实现方法导致进程、线程差别不是很大。

能用线程实现的程序就用线程，如果不能就用进程。

Q:LWP号是什么？

A：轻量级进程号。

三 线程常用操作

1.线程号

进程号在整个系统中是唯一的，线程号不同，只在当前进程中有效且唯一。

进程号数据类型是pid_t ,线程号数据类型是pthread_t,线程号数据类型的本质都是无符号长整形。

有的系统把pthread_t当作结构体处理，所以在可移植操作系统实现上不能把它当作整形处理。

获取线程号：

#include <pthread.h>

pthread_t pthread_self();

判断线程号是否相等：

int pthread_equal(pthread_t t1, pthread_t t2);
功能：
    判断线程t1和t2是否相等。为了方便移植，尽量使用函数来比较线程ID。
返回值：
    相等： 非0
    不相等：0

2.创建线程

pthread_create函数:

#include <pthread.h>

int pthread_create(pthread_t *thread, 
                    const pthread_attr_t *attr,
                    void *(*start_routine)(void *),
                    void *arg);
功能：
    创建一个线程
参数：
    thread：线程标识符地址
    attr：线程属性结构体地址，通常设置为NULL
    start_routine:线程函数的入口地址
    arg：传给线程函数的参数

由于pthread_create的错误码不保存在errno中，所以不能直接调用perror()打印错误信息，可以先用strerror()把错误转换成错误信息再打印。

创建线程范例：

void *thread_fun(void * arg){
        sleep(1);
        int num = *((int *)arg);
        printf("int the new thread: num = %d\n", num);

        return NULL;
}

int main(){
        pthread_t tid;
        int test = 100;

        int ret = pthread_create(&tid, NULL, thread_fun, (void*)&test);
        if(ret != 0){
                printf("error number:%d\n", ret);
                printf("error information:%s\n", strerror(ret));
        }
        while(1);
        return 0;
}

3.线程资源回收

pthread_join函数：

#include <pthread.h>

int pthread_join(pthread_t pthread, void **retval);
功能：
    等待线程结束（此函数会阻塞），并回收线程资源。类似于进程的wait()。若线程已经结束，此函数会立即返回。

参数：
    thread：被等待的线程号
    retval：用来存储线程退出状态指针的地址

范例程序：

void *thread_fun(void * arg){

        static int num = 123;
        printf("after 2 seconds, thread will return\n");
        sleep(2);

        return #
}

int main(){
        pthread_t tid;
        int ret = 0;
        void *value = NULL;
        int re = pthread_create(&tid, NULL, thread_fun, NULL);
        if(re != 0){
                printf("error number:%d\n", ret);
                printf("error information:%s\n", strerror(ret));
        }
        pthread_join(tid, &value);
        printf("value = %d\n", *((int *)value));
        return 0;
}

调用该函数的线程挂起等待，直到id为thread线程终止。thread线程以不同的方法终止，通过pthread_join得到终止状态是不同的，总结如下：

①如果thread线程通过return返回，retval所指向的单元里存放的是thread线程函数的返回值。

②如果thread线程被别的线程调用pthread_cancel异常终止掉，retval所指向的单元里存放的是常数PTHREAD_CANCELED

③ 如果thread线程是自己调用pthread_exit终止的，retval所指向的单元存放的是传给pthread_exit的参数。

4.线程分离

一般线程终止后，其终止状态一直保留到其它线程调用pthread_join获取它的状态为止。但是线程也可以被置为detach状态，这样的状态一旦终止就立刻回收所占用的资源，不保留终止状态。

不能对一个已经处于detach状态的线程调用pthread_join，这样的调用将返回EINVAL错误。也就是说，如果已经对一个线程调用了pthread_detach就不能再调用pthread_join了。

pthread_detach函数：

#include <pthread.h>

int pthread_detach(pthread_t thread);
功能：
    使调用线程与当前进程分离，分离后不代表此线程不依赖当前进程，而是指若此线程终止后，不由进程回收线程资源，而是交给系统来自动回收线程资源，所以此函数也不会阻塞。

5.线程退出

在进程中我们可以调用exit函数或_exit函数来结束进程，在一个线程中我们可以通过以下三种在不终止整个进程的情况下停止它的控制流。

• 线程从执行函数中返回
• 线程调用pthread_exit退出线程
• 线程可以被同一进程中其它的线程取消

pthread_exit函数：

#include <pthread.h>

void pthread_exit(void *retval);
功能：
    退出调用线程。一个进程中的多个线程是共享该进程的数据段，因此，通常线程退出所占用的资源并不会释放。
参数：retval：存储线程退出状态的指针。

6.线程取消

#include <pthread.h>
int pthread_cancel(pthread_t thread);
功能：取消线程
返回值：
    成功：0
    失败：出错编号

注意，线程取消不是实时的，而是等待某个线程到了某个取消点再取消。

取消点：是线程检查是否被取消，并按请求进行动作的一个位置。通常是一些系统调用creat，open，pause，close，read，write..... 执行命令man 7 pthreads可以查看具备这些取消点的系统调用列表。

可粗略的认为一个系统调用就是一个取消点。

四、线程属性

1.概述

我们对程序有性能上的需求，所以要设置线程属性。比如可以设置线程大小来降低内存的使用，增加最大线程个数。

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

主要结构体成员：

1) 线程分离状态

2) 线程栈大小（默认平均分配）

3) 线程栈警戒缓冲区大小（位于栈末尾）

4) 线程栈最低地址

属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_init，这个函数必须在pthread_create函数之前调用。之后须用pthread_attr_destroy函数来释放资源。

线程属性主要包括如下属性：作用域（scope）、栈尺寸（stack size）、栈地址（stack address）、优先级（priority）、分离的状态（detached state）、调度策略和参数（scheduling policy and parameters）。默认的属性为非绑定、非分离、缺省的堆栈、与父进程同样级别的优先级。

2.线程属性初始化和销毁

#include <pthread.h>

int pthread_attr_init(pthread_attr_t *attr);
功能：
    初始化线程属性函数，注意：应先初始化线程属性，再pthread_crate创建线程。
参数：
    attr：线程属性结构体
返回值：
    成功：0
    失败：错误号

int pthread_attr_destroy(pthread_attr_t *attr);
功能：
    销毁线程属性所占用的资源函数
参数：
    attr：县城属性结构体
返回值：上同

3.线程分离状态

相关函数：

#include <pthread.h>

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
功能：设置线程分离状态
参数：
    attr:已经初始化的线程属性
    detachstate:    分离状态
        PTHREAD_CREATE_DETACHED（分离线程）
        PTHREAD_CREATE_JOINABLE（非分离线程）
    

int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
功能：获取线程分离状态
参数：
    attr：已初始化的线程属性
    detachstate: 分离状态
        PTHREAD_CREATE_DETACHED（分离线程）
        PTHREAD_CREATE_JOINABLE（非分离线程）

注意：如果设置一个线程为分离线程，而这个线程运行又非常快，导致pthread_create没有返回就结束了。这时，线程号和线程资源可能被其它线程利用了，导致pthread_create返回的线程号错误。

要避免这种情况，一般采取线程同步措施，可以在被创建的线程中调用pthread_cond_timedwait函数，让这个线程等一会，留出足够时间让函数pthread_create返回。

注意不要使用wait(),这会让整个进程睡眠，并不能解决线程同步问题。

4.线程栈地址

POSIX.1定义了两个常量来检测系统是否支持栈属性：

• _POSIX_THREAD_ATTR_STACKADDR
• _POSIX_THREAD_ATTR_STACKSIZE

也可以给sysconf函数传递来进行检测：

• _SC_THREAD_ATTR_STACKADDR
• _SC_THREAD_ATTR_STACKSIZE

当进程栈地址空间不够用时，指定新建线程使用由malloc分配的空间作为自己的栈空间。通过pthread_attr_setstack和pthread_attr_getstack两个函数分别设置和获取线程的栈地址。

#include <pthread.h>

int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize);
功能：
    设置线程的栈地址
参数：    
    attr:指向一个线程属性的指针
    stackaddr:内存首地址
    stacksize:返回线程的堆栈大小
返回值：
    成功：0
    失败：错误号

int pthread_attr_getstack(const pthread_attr_t *attr, void **stackaddr, size_t *stacksize);
功能：
    获取线程的栈地址
参数：
    attr：指向一个线程属性的指针
    stackaddr：返回获取的栈地址
    stacksize：返回获取的栈大小
返回值：
    成功：0
    失败：错误号

5.线程栈大小

当系统中有很多线程时，需要减少每个线程栈的默认大小，防止进程的地址空间不够用。

当线程调用的函数会分配很大的局部变量或者函数调用层次很深时，可能需要增大线程的默认大小。

#include <pthread.h>
​
int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
功能：设置线程的栈大小
参数：
    attr：指向一个线程属性的指针
    stacksize：线程的堆栈大小
返回值：
    成功：0
    失败：错误号
​
int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize);
功能：获取线程的栈大小
参数： 
    attr：指向一个线程属性的指针
    stacksize：返回线程的堆栈大小
返回值：
    成功：0
    失败：错误号
​

6.线程使用注意事项

1.主线程退出其他线程不退出，主线程应该调用pthread_exit

2.避免僵尸线程：pthread_join、pthread_detach、pthread_create指定分离属性

3.malloc和mmap申请的内存可以被其他线程释放

4.应避免在多线程模型中调用fork，除非马上exec，子进程中只有调用fork的线程存在，其他线程t在子进程中均pthread_exit

5.信号的复杂语义很难和多线程共存，应避免在多线程引入信号机制

························································································································

续:

头文件：
#include <pthread.h>

函数原型：
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);

函数作用：
该函数用于C函数的多线程编程中，互斥锁的初始化。

pthread_mutex_init() 函数是以动态方式创建互斥锁的，参数attr指定了新建互斥锁的属性。如果参数attr为空(NULL)，则使用默认的互斥锁属性，默认属性为快速互斥锁 。互斥锁的属性在创建锁的时候指定，在LinuxThreads实现中仅有一个锁类型属性，不同的锁类型在试图对一个已经被锁定的互斥锁加锁时表现不同。

pthread_mutexattr_init() 函数成功完成之后会返回零，其他任何返回值都表示出现了错误。
函数成功执行后，互斥锁被初始化为未锁住态。

例子：

 #include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
 
/* 全局变量 */
int gnum = 0;
/* 互斥量 */
pthread_mutex_t mutex;
 
/* 声明线程运行服务程序. */
static void pthread_func_1(void);
static void pthread_func_2(void);
 
int main (void)
{
 /*线程的标识符*/
  pthread_t pt_1 = 0;
  pthread_t pt_2 = 0;
  int ret = 0;
 
  /* 互斥初始化. */
  pthread_mutex_init(&mutex, NULL);
  /*分别创建线程1、2*/
  ret = pthread_create(&pt_1,  //线程标识符指针
                       NULL,  //默认属性
                       (void*)pthread_func_1, //运行函数
                       NULL); //无参数
  if (ret != 0)
  {
     perror ("pthread_1_create");
  }
 
  ret = pthread_create(&pt_2, //线程标识符指针
                       NULL,  //默认属性
                       (void *)pthread_func_2, //运行函数
                       NULL); //无参数
  if (ret != 0)
  {
     perror ("pthread_2_create");
  }
  /*等待线程1、2的结束*/
  pthread_join(pt_1, NULL);
  pthread_join(pt_2, NULL);
 
  printf ("main programme exit!/n");
  return 0;
}
 
/*线程1的服务程序*/
static void pthread_func_1(void)
{
  int i = 0;
 
  for (i=0; i<3; i++) {
    printf ("This is pthread_1!/n");
    pthread_mutex_lock(&mutex); /* 获取互斥锁 */
    /* 注意，这里以防线程的抢占，以造成一个线程在另一个线程sleep时多次访问互斥资源，所以sleep要在得到互斥锁后调用. */
    sleep (1);
    /*临界资源*/
    gnum++;
    printf ("Thread_1 add one to num:%d/n", gnum);
    pthread_mutex_unlock(&mutex); /* 释放互斥锁. */
  }
 
  pthread_exit(NULL);
}
 
/*线程2的服务程序*/
static void pthread_func_2(void)
{
  int i = 0;
 
  for (i=0; i<5; i++)  {
    printf ("This is pthread_2!/n");
    pthread_mutex_lock(&mutex); /* 获取互斥锁. */
    /* 注意，这里以防线程的抢占，以造成一个线程在另一个线程sleep时多次访问互斥资源，所以sleep要在得到互斥锁后调用. */
    sleep(1);
    /* 临界资源. */
    gnum++;
    printf ("Thread_2 add one to num:%d/n",gnum);
    pthread_mutex_unlock(&mutex); /* 释放互斥锁. */
  }
 
  pthread_exit (NULL);
}