文章目录

Linux线程概念
Linux进程VS线程
- 进程和线程
关于进程线程的问题
死锁

Linux线程概念

什么是线程

线程的优点

线程的缺点

线程异常

单个线程如果出现除零、野指针等问题导致线程崩溃，进程也会随着崩溃
线程是进程的执行分支，线程出异常，就类似进程出异常，进而触发信号机制，终止进程，进程终止，该
进程内的所有线程也就随即退出

线程用途

合理的使用多线程，能提高CPU密集型程序的执行效率
合理的使用多线程，能提高IO密集型程序的用户体验（如生活中我们一边写代码一边下载开发工具，就是多线程运行的一种表现）

Linux进程VS线程

进程和线程

进程的多个线程共享同一地址空间,因此Text Segment、Data Segment都是共享的,如果定义一个函数,在各线程中
都可以调用,如果定义一个全局变量,在各线程中都可以访问到,除此之外,各线程还共享以下进程资源和环境:

进程和线程的关系如下图:

关于进程线程的问题

如何看待之前学习的单进程？具有一个线程执行流的进程

Linux线程控制

POSIX线程库

创建线程

功能：创建一个新的线程
原型
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)
(void*), void *arg);
参数
thread:返回线程ID
attr:设置线程的属性，attr为NULL表示使用默认属性
start_routine:是个函数指针，线程启动后要执行的函数
arg:传给线程启动函数start_routine的参数
返回值：成功返回0；失败返回错误码

错误检查:

#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>

void* pthread_handler(void *arg)
{
    //线程1
  while (1)
  {
    printf("I am thread 1\n");
    sleep(1);
  }

  
}

int main()
{
  pthread_t tid;
  int ret;
    
  //创建线程
  ret = pthread_create(&tid, NULL, pthread_handler, NULL);
  if (ret < 0)
  {
    perror("pthread_creat");
    exit(1);
  }

    //主线程
  while (1)
  {
    printf("I am main thread\n");
    sleep(1);
  }

  return 0;
}

生成可执行文件时，要加-lpthread选项，也可以写成 -pthread，但不推荐。要让编译器知道我们使用的是哪个具体的库。

为什么不加-I和-L选项呢

因为该头文件和库的路径在系统默认路径下

结果：

进程ID和线程ID

可以看出上面a.out进程是多线程的，进程ID为28543，进程内有2个线程，线程ID(LWP的ID)分别为28543，28544

Linux提供了gettid系统调用来返回其线程ID，可是glibc并没有将该系统调用封装起来，在开放接口来共程序员使用。如果确实需要获得线程ID，可以采用如下方法： #include <sys/syscall.h> pid_t tid; tid = syscall(SYS_gettid);

从上面可以看出，a.out进程的ID为28543，下面有一个线程的ID也是28543，这不是巧合。线程组内的第一个线程，在用户态被称为主线程(main thread),在内核中被称为group leader，内核在创建第一个线程时，会将线程组的ID的值设置成第一个线程的线程ID，group_leader指针则指向自身，即主线程的进程描述符。所以线程组内存在一个线程ID等于进程ID，而该线程即为线程组的主线程
```
/* 线程组ID等于线程ID，group_leader指向自身 */
p->tgid = p->pid;
p->group_leader = p;
INIT_LIST_HEAD(&p->thread_group);
```

至于线程组其他线程的ID则由内核负责分配，其线程组ID总是和主线程的线程组ID一致，无论是主线程直接创建线程，还是创建出来的线程再次创建线程，都是这样。

if ( clone_flags & CLONE_THREAD )
	p->tgid = current->tgid;
if ( clone_flags & CLONE_THREAD ) 
{
    P->group_lead = current->group_leader;
    list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);
}

强调一点，线程和进程不一样，进程有父进程的概念，但在线程组里面，所有的线程都是对等关系

线程ID及进程地址空间布局

因为Linux不会创建线程，所以线程是用户创建和管理的，内核中由底层的LWP(执行流)执行
pthread库既然创建了线程，就要负责管理线程：描述(结构体TCB)，组织。
TCB中有一个pid数据标识线程的id，指向轻量级进程(LWP)，LWP帮我们完成线程的执行功能。

进程id，内核线程id，pthread线程id打印：

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/syscall.h>

void* handler(void* arg)
{
  while (1)
  {
    printf("i am thread... 进程id:%d, 线程id:%ld, pthread_id:%ld\n", getpid(), syscall(SYS_gettid), pthread_self());

    sleep(1);
  }
}

int main()
{
  pthread_t tid;
  int ret = 0;

  ret = pthread_create(&tid, NULL, handler, NULL);
  if (ret < 0)
  {
    perror("pthread_create error!");
    return 1;
  }

  //主线程
  while (1)
  {
    printf("i am main thread... 进程id:%d, 线程id:%ld, pthread_id:%ld\n", getpid(), syscall(SYS_gettid), pthread_self());
    sleep(1);
  }

  return 0;
}

线程等待为什么需要线程等待？

功能：等待线程结束
原型
int pthread_join(pthread_t thread, void **value_ptr);
参数
thread:线程ID
value_ptr:它指向一个指针，指针指向线程的返回值
返回值：成功返回0；失败返回错误码

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

void *thread1(void *arg)
{
    printf("thread 1 returning ... \n");
    int *p = (int*)malloc(sizeof(int));
    *p = 1;
    
    return (void*)p;
} 

void *thread2(void *arg)
{
    printf("thread 2 exiting ...\n");
    int *p = (int*)malloc(sizeof(int));
    *p = 2;
    
    pthread_exit((void*)p);
} 

void *thread3(void *arg)
{
    while ( 1 )
    { 
        printf("thread 3 is running ...\n");
        sleep(1);
    } 
    
    return NULL;
}
int main( void)
{
    pthread_t tid;
    void *ret;
    // thread 1 return
    pthread_create(&tid, NULL, thread1, NULL);
    pthread_join(tid, &ret);
    printf("thread return, thread id %X, return code:%d\n", tid, *(int*)ret);
    free(ret);
    
    
    // thread 2 exit
    pthread_create(&tid, NULL, thread2, NULL);
    pthread_join(tid, &ret);
    printf("thread return, thread id %X, return code:%d\n", tid, *(int*)ret);
    free(ret);
    
    
    // thread 3 cancel by other
    pthread_create(&tid, NULL, thread3, NULL);
    sleep(3);
    pthread_cancel(tid);
    pthread_join(tid, &ret);
    if ( ret == PTHREAD_CANCELED )
    	printf("thread return, thread id %X, return code:PTHREAD_CANCELED\n", tid);
    else
    	printf("thread return, thread id %X, return code:NULL\n", tid);
} 

运行结果：
[root@localhost linux]# ./a.out
thread 1 returning ...
thread return, thread id 5AA79700, return code:1
thread 2 exiting ...
thread return, thread id 5AA79700, return code:2
thread 3 is running ...
thread 3 is running ...
thread 3 is running ...
thread return, thread id 5AA79700, return code:PTHREAD_CANCELED

线程终止

如果只需要终止某个线程而不终止整个进程,可以有三种方法:

注意：线程的退出只关心执行结果正不正确，因为当线程异常退出时，进程也退出了。

pthread_exit函数

功能：线程终止
原型
void pthread_exit(void *value_ptr);
参数
value_ptr:value_ptr不需要指向一个局部变量。一般是将结果强转为指针，在读取退出信息时再强转为int/long类型
返回值：无返回值，跟进程一样，线程结束的时候无法返回到它的调用者（自身）

需要注意,pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的,不能在线程函数
的栈上分配,因为当其它线程得到这个返回指针时线程函数已经退出了。

使用示例：

#include<stdio.h>
#include<pthread.h>

void* handle(void*arg)
{
  int i = 0;
  while(1)
  {
    if (5 == i)
      break;

    sleep(1);
    printf("this is a thread: %d\n", pthread_self());
    ++i;
  }

  pthread_exit((void*) 10);//设置线程的退出码为10
}

int main()
{
  pthread_t tid;  

  pthread_create(&tid, NULL, handle, NULL);
  
  void*ptr = NULL;
  pthread_join(tid, &ptr);//主线程等待新线程

    //打印退出码
  printf("exit code:%d\n", (long long)ptr);

  return 0;
}

结果:

pthread_cancel函数

功能：取消一个执行中的线程
原型
int pthread_cancel(pthread_t thread);
参数
thread:线程ID
返回值：成功返回0；失败返回错误码

被取消的线程会返回将宏PTHREAD_CANCELED(值为-1)返回给等待它的线程(等待接下来就讲)

不一定是只由主线程取消，也可以由其他进程取消，当然，也可以自杀(自己取消自己，这种行为很奇怪)

示例：

#include<stdio.h>
#include<pthread.h>

void* handle(void*arg)
{
  int i = 0;
  while(1)
  {
    //if (5 == i)
     // break;

    sleep(1);
    printf("this is a thread: %d\n", pthread_self());
    ++i;
  }

  //pthread_exit((void*) 10);
}

int main()
{
  pthread_t tid;  

  pthread_create(&tid, NULL, handle, NULL);
  
  sleep(10);
  //主线程等10s再取消新线程
  pthread_cancel(tid);
  
  void*ptr = NULL;
  //获取退出码
  pthread_join(tid, &ptr);

  printf("exit code:%d\n", (long long)ptr);

  return 0;
}

结果：

注意：主线程调用pthread_cancel函数，则主线程的状态变更成为Z，其他线程不受影响

分离线程

int pthread_detach(pthread_t thread);

可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离:

pthread_detach(pthread_self());

joinable和分离是冲突的，一个线程不能既是joinable又是分离的

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

void *thread_run( void * arg )
{
    //自己分离
    pthread_detach(pthread_self());
    printf("%s\n", (char*)arg);
    return NULL;
} 

int main( void )
{
    pthread_t tid;
    if ( pthread_create(&tid, NULL, thread_run, "thread1 run...") != 0 ) //创建线程
    {
        printf("create thread error\n");
        return 1;
    } 
    
    int ret = 0;
    
    sleep(1);//很重要，要让线程先分离，再等待
    
    if ( pthread_join(tid, NULL ) == 0 ) 
    {
    	printf("pthread wait success\n");
    	ret = 0;
    } 
    else 
    {
    	printf("pthread wait failed\n");
    	ret = 1;
    } 
    
    return ret;
}

注意：如果分离的线程崩溃了，主线程还是会崩溃，也就是进程还是会跟着遭殃。

Linux线程互斥

进程线程间的互斥相关背景概念

互斥量mutex

首先我们要明白，线程之间的代码和数据都是共享的，不同于进程有写时拷贝，所以一个线程修改了数据，其他线程看到的是同一份数据，因此获取的数据也是被修改的。

// 操作共享变量会有问题的售票系统代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

int ticket = 100;

void *get_ticket(void *arg)
{
    int id = (int)arg;
    while (1) 
    {
    	if ( ticket > 0 ) 
        {
            usleep(1000);
            printf("thread %d sells ticket:%d\n", id, ticket);
            ticket--;
        } 
        else 
        {
            break;
        }
	}
} 

int main( void )
{
    //循环创建进程
    pthread_t arr[4];
    int i = 0;
    for (; i < 4; ++i)//创建四个线程
    {
        //arr+i就是每个元素的地址，所以不用再取地址
        pthread_create(arr + i, NULL, get_ticket, (void*)i);
    }
    
    //抢票等待
    for (i = 0; i < 4; ++i)
    {
        pthread_join(arr[i], NULL);
    }
    
    
    return 0;
} 

一次执行结果：
thread 4 sells ticket:100
...
thread 4 sells ticket:1
thread 2 sells ticket:0
thread 1 sells ticket:-1
thread 3 sells ticket:-2

为什么可能无法获得争取结果？

ticket–的底层汇编实现：

//取出ticket--部分的汇编代码
objdump -d a.out > test.objdump
152 40064b: 8b 05 e3 04 20 00 mov 0x2004e3(%rip),%eax # 600b34 <ticket>
153 400651: 83 e8 01 sub $0x1,%eax
154 400654: 89 05 da 04 20 00 mov %eax,0x2004da(%rip) # 600b34 <ticket>

--操作并不是原子操作，而是对应三条汇编指令：

因此，当多个进程同时进入if时，进行ticket–，如果此时ticket为1，而某个线程对其–了，ticket就为0了，而其他线程还在if里面，于是还会对ticket–，并且会抢票成功，这样即使当ticket为0时，本已经不能抢票了，结果最后还是多抢了几张不存在的票。

要解决以上问题，需要做到三点：

要做到这三点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量

互斥量的接口

初始化互斥量

初始化互斥量有两种方法：

销毁互斥量

销毁互斥量需要注意：

int pthread_mutex_destroy(pthread_mutex_t *mutex)；

互斥量加锁和解锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
返回值:成功返回0,失败返回错误信号

调用pthread_ lock 时，可能会遇到以下情况:

改进上面的售票系统:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>

int ticket = 10000;

pthread_mutex_t mutex;

void *get_ticket(void *arg)
{
    usleep(1000);
    int num = (int)arg;
    while (1) 
    {
        pthread_mutex_lock(&mutex);
    	if ( ticket > 0 ) 
        {
            usleep(1000);
            printf("thread:%d sells ticket:%d\n", num + 1, ticket);
            ticket--;
            pthread_mutex_unlock(&mutex);
        } 
        else 
        {
            pthread_mutex_unlock(&mutex);
            break;
        }
	}
} 

int main( void )
{
    //锁的初始化
    pthread_mutex_init(&mutex, NULL);
    
    //循环创建进程
    pthread_t arr[4];
    int i = 0;
    for (; i < 4; ++i)
    {
        //arr+i就是每个元素的地址，所以不用再取地址
        pthread_create(arr + i, NULL, get_ticket, (void *)i);
    }
    
    //抢票等待
    for (i = 0; i < 4; ++i)
    {
        pthread_join(arr[i], NULL);
    }
    
    //销毁锁
    pthread_mutex_destroy(&mutex);
}

当别的线程已经申请好锁了，期间有其他线程来申请锁，是申请不到的。于是，新线程就要进入阻塞状态。

关于阻塞的补充：将进程/线程对应的PCB投入到等待队列中，将R状态改为S状态。解锁后，一次性唤起一个线程申请锁。

mutex的理解

这样就能保证一次只有一个线程进入临界区，访问临界资源，这就是互斥。

互斥量实现原理探究

我们先思考一个问题：在一个线程执行临界区代码时(已经占用了锁)，线程时间片到了，于是该线程被切换下CPU暂停运行，这样会影响该线程的正常运行吗？

不影响，因为临界资源已经被它锁上了，即使它没有运行，其他线程也无法访问这些临界资源。

经过上面的例子，大家已经意识到单纯的i++或者++i都不是原子的，有可能会有数据一致性问题
为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的总线周期也有先后,一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。现在我们把lock和unlock的伪代码改一下

lock:
		movb $0, %al
		xchgb %al, mutex
		if (al寄存器的内容 > 0)
		{
			return 0;
		}
		else
		{
			挂起等待;
			goto lock;
		}
		
unlock:
		movb $1, mutex
		唤醒等待Mutex的线程

对该段伪代码的理解：

现在我们有一个线程A，它申请对一份临界资源上锁，于是执行 movb $0, %al，al是属于该线程的寄存器，将值0放入该寄存器中，然后执行 xchgb %al, mutex，将寄存器al中的数据与mutex(一个变量，类似上面说的lock)中的数据交换，mutex中的值默认为1，交换后，mutex中的值就变成了0，%al中的值就变成了1。此时，线程A的时间片到了，要切换到线程B运行，线程A退出时，在CPU中属于线程A的寄存器数据(上下文数据)需要被保存，但注意，mutex不属于上下文数据，它是内存中的数据。线程B运行时，也要申请同一份临界资源的锁，于是执行 movb $0, %al，将0值放到寄存器al中，注意，这里al在线程B运行时是属于B的，上下文保存的是进程/线程运行时所使用寄存器中的值，当切换线程/进程时，这些寄存器照样可以被使用，所以当下次线程A再运行时，这些数据又会被返回到对应的寄存器中。所以当线程B执行完 movb $0, %al后，就要执行 xchgb %al, mutex了，此时mutex的值是0，与寄存器%al交换还是0，所以进入下面的判断时，会进入else，从而进入等待。此时线程A从等待队列中出列，将保存的上下文数据返回到%al中，于是%al中就是1了，继续运行，从if开始，进入if，成功申请锁。

通过上面的过程，我们认识到

整个过程中，为1的mutex只有一份
exchange一条汇编完成了寄存器和内存数据的交换
所以pthread_mutex_lock是具有原子性的

当然，解锁也一定是具有原子性的，因为只有已经申请锁成功的线程才有解锁的权利，其他线程不能执行unlock。

关于上下文数据的存放：

以上面的线程A、B为例，线程A、B分别有属于自己的结构体TSS，其中存放着对应所有寄存器的变量。当一个线程/进程时间片到了退出运行时，当前已经占用的寄存器的值会对应放到该结构体中，下次运行时，再将这些数据放入对应的寄存器继续运行。

可重入VS线程安全

概念

常见的线程不安全的情况

常见的线程安全的情况

常见不可重入的情况

常见可重入的情况

可重入与线程安全联系

可重入与线程安全区别

死锁

死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所占不会释放的资源而处于的一种永久等待状态。

也就是线程A占有了一块资源并上了锁，线程B占有了另外一块资源也上了锁，此时线程A和线程B都想再申请对方已经占有并上锁的资源，而双方又不肯释放已经占有的资源，于是两个线程就干耗着。这种现象就称为死锁。

死锁四个必要条件

避免死锁

避免死锁算法

有兴趣的同学可以自己去了解一下

多线程(上)