线程

1. 线程概述

1.1 从进程到线程

在经过之前课程的学习之后，我们已经了解进程的基本概念：进程是正在执行的程序，并且是系统资源分配的基本单位。

当用户需要在一台计算机上去完成多个独立的工作任务时，可以使用多进程的方式，为每个独立的工作任务分配一个进程。多进程的管理则由操作系统负责——操作系统调度进程，合理地在多个进程之间分配资源，包括CPU资源、内存、文件等等。除此以外，即便是一个单独的应用，采用多进程的设计也可以提升其吞吐量，改善其响应时间。假如在处理任务的过程中，其中一个进程因为死循环或者等待IO之类的原因无法完成任务时，操作系统可以调度另一个进程来完成任务或者响应用户的请求。比如在文本处理程序当中，可以并发地处理用户输入和保存已完成文件的任务。随着进程进入大规模使用，程序员在分析性能的时候发现计算机花费了大量的时间在切换不同的进程上面。当一个进程在执行过程中，CPU的寄存器当中需要保存一些必要的信息，比如堆栈、代码段等，这些状态称作上下文。上下文切换这里涉及到大量的寄存器和内存之间的保存和载入工作。除此以外，Linux操作系统还支持虚拟内存，所以每个用户进程都拥有自己独立的地址空间，这在实现上就要求每个进程有自己独立的页目录表(页目录表: 映射虚拟地址到物理地址)(TLB是是一个页目录表的缓存，来存储最近使用的物理和虚拟地址映射)。所以，具体到Linux操作系统，进程切换包括两步：首先是切换页目录表，以支持一个新的地址空间；然后是进入内核态，将硬件上下文，即CPU寄存器的内容以及内核态栈切换到新的进程。

为了缩小切换进程的开销，线程的概念便诞生了。线程又被称为轻量级进程 (Light Weight Process,LWP)，我们将一个进程分解成多个线程，每个线程是独立的运行中程序实体，线程之间并发运行，这样线程就取代进程成为CPU时分配和调度的最小单位，在Linux操作系统当中，每个线程都拥有自己独立的 task_struct 结构体，当然，在属于同一个进程多个线程中， task_struct 中大量的字段是相同的或者是共享的。注意到在Linux操作系统中，线程并没有脱离进程而存在。而计算机的内存、文件、IO设备等资源依然还是按进程为单位进行分配，属于同一个进程的多个线程会共享进程地址空间，每个线程在执行过程会在地址空间中有自己独立的栈，而堆、数据段、代码段、文件描述符和信号屏蔽字等资源则是共享的。

因为属于同一个进程的多个线程是共享地址空间的，所以线程切换的时候不需要切换页目录表，而且上下文的内容中需要切换的部分也很少，只需要切换栈和PC指针以及其他少量控制信息即可，数据段、代码段等信息可以保持不变。因此，切换线程的花费要小于切换进程的。

同一个进程的多个线程各自拥有自己的栈，这些栈虽然是独立的，但是都位于同一个地址空间中，所以一个线程可以通过地址去访问另一个线程的栈区。

了解:

在Linux文件系统中，路径 /proc 挂载了一个伪文件系统，通过这个伪文件系统用户可以采用访问普通文件的方式（使用read系统调用等），来访问操作系统内核的数据结构。其中，在 /proc/[num] 目录中，就包含了pid为num的进程的大量的内核数据。而在 /proc/[num]/task 就包含本进程中所有线程的内核数据。我们之前的编写进程都可以看成是单线程进程。

xxxxxxxxxx
3
1
man ps
2
ps -elf
3
ps aux

1.2 用户级线程和内核级线程

在Linux2.4以及以前版本，因为还没有线程的概念，Linux内核不知道什么是线程。而后来随着技术发展，因为创建进程开销的资源更多，且进程间的切换相比线程更慢，线程带来的好处被大家所认识。于是我们希望Linux能实现多线程编程，然而要修改一个操作系统并不是件容易的事情，于是采用的办法是写函数来实现，而不是去修改操作系统的内核。而这些函数也就是最初的线程库，由于在Linux内核中没有线程的概念，因此这种线程是用进程来模拟的。因此这种线程也被称为用户级线程。

虽然当时的线程库已经和POSIX的标准非常接近了，但是在Linux的线程实现版本和POSIX标准之间还是存在着细微的差别，最明显的是关于信号处理部分，这些差别中的大部分都受底层Linux内核的限制，而不是函数所能改变的。许多项目都在研究如何才能改善Linux对线程的支持，这其中大部分工作集中在了如何将用户级的线程映射到内核级的线程。

其中IBM公司的NGPT(Next Generation POSIX Threads),和Redhat公司的NPTL(Native POSIX Thread Library)通过修改Linux内核来支持新的线程库，两者都极大地提升了性能。在2002年，NGPT项目组宣布，由于不希望分化团队，所以停止为NGPT添新功能。也因此NPTL成为了Linux线程的新标准。在NPTL中, 内核会处理每个线程堆栈所使用的内存的回收工作。它甚至还通过在清除父线程之前进行等待，从而实现对所有线程结束的管理。

目前使用最广泛的线程库名为NPTL (Native POSIX Threads Library)，在Linux内核2.6版本之后，它取代了传统的LinuxThreads线程库。NPTL支持了POSIX的线程标准库，在早期，NPTL只支持用户级线程，随着内核版本的迭代，现在每一个用户级线程都对应一个内核态线程，这样NPTL线程本质就成为了内核级线程，可被操作系统调度

xxxxxxxxxx
4
1
man 7 pthreads
2
(Linux implementations of POSIX threads
3
     LinuxThreads: 并不完全兼容POSIX标准
4
     NPTL:   Native POSIX Thread Library)

用户级线程和内核级线程在实现方式、运行状态、切换方式、调度方式、对系统资源的访问、创建和销毁等方面存在明显的差异

用户级线程和内核级线程的主要区别体现在以下方面：

1. 实现方式：用户级线程是在用户程序中实现的，而内核级线程是由操作系统内核创建和管理的。

2. 运行状态：用户级线程运行在用户态下，而内核级线程可以访问操作系统的所有资源。

3. 切换方式：用户级线程的切换由应用程序自己控制，而内核级线程的切换需要操作系统的支持。

4. 调度方式：用户级线程的调度由应用程序自己控制，而内核级线程的调度由操作系统内核负责。

5. 等...

xxxxxxxxxx
2
1
闲聊: (线程源码参考)
2
/usr/src/linux-source-4.15.0/linux-source-4.15.0/arch/h8300/include/asm/thread_info.h

1.3 线程的创建

使用线程的思路其实和使用进程的思路类似，用户需要去关心线程的创建、退出和资源回收等行为，初学者可以参考之前学习进程的方式对比学习线程对应的库函数。下面是常用的线程库函数和之前的进程中的对应关系。

1.3.1 pthread_create

函数定义

线程创建使用的函数是 pthread_create ，这个函数的函数原型如下( man pthread_create )

xxxxxxxxxx
8
1
#include <pthread.h>
2
int pthread_create(
3
  pthread_t *thread, // 不同线程独立唯一的线程id 
4
  const pthread_attr_t *attr, // 线程的属性 (attr属性),  暂时使用NULL填充
5
  void *(*start_routine) (void *), // 线程的启动函数
6
  void *arg // 线程的传参 
7
);
8
// 返回值： 0成功， 其它失败可暂时忽略or参见1.3.2错误处理

xxxxxxxxxx
4
1
ps: 在使用线程相关的函数之后，在链接时需要加上 -lpthread 选项以显式链接线程库
2
ps: 在一个进程当中的不同线程都拥有自己独立唯一的线程id（thread id），NPTL使用pthread_t类型来保存线程id，在不同的操作系统中，pthread_t底层实现不同，具体到Linux是一个无符号整型数 (也可以使用函数 pthread_self 获取本线程的id)。
3
ps: 在操作系统中，当一个新进程被创建时（例如，通过执行一个程序），操作系统会自动创建一个线程(作为这个进程的主线程)。
4
ps: 主线程终止时（例如通过返回main()或调用exit()），这会导致整个进程终止，包括它创建的所有子线程也会随着进程的终止而消亡。（除非主线程是通过调用pthread_exit()来终止的, 这不会导致进程终止，这种情况下进程内的其他线程可以继续依赖进程存活）。

代码示例

xxxxxxxxxx
15
1
//下面是一个不传递参数的版本
2
void * threadFunc(void *arg){
3
   printf("I am child thread, \n" );
4
   return NULL;
5
}
6
int main()
7
{
8
   pthread_t tid;
9
   pthread_create(&tid,NULL,threadFunc,NULL);
10

11
   printf("I am main thread \n") 
12
   sleep(1);
13
   //usleep(20);
14
   return 0;
15
}

注意事项

A: 主线程的消亡,引发的一些问题

在上面的例子当中，如果主线程不sleep, 或者将 sleep(1) 改成 usleep(20)或者别的 (设个时间也取决于系统的cpu核心和执行效率)，线程并发执行的特点会导致一些看上去非常奇怪的结果：在某次执行的时候，标准输出上有一定的几率显示两条相同的语句。

产生这种问题的原因是这样的，stdout缓冲区在多个线程之间是共享，当执行 printf 时，会首先将stdout的内容拷贝到内核态的文件对象中，再清空缓冲区，当主线程终止导致所有线程终止时，可能子线程已经将数据拷贝到了内核态（此时第一份语句已经打印了），但是stdout的内容并未清空，此时进程终止，会把所有缓冲区清空，清空缓冲区的行为会将留存在缓冲区的内容直接清空并输出到标准输出中，此时就会出现内容的重复打印了。

B: 链接 -lpthread

在使用线程相关的函数之后，在链接时需要加上 -lpthread 选项以显式链接线程库

C: 了解

在一个进程当中的不同线程都拥有自己独立唯一的线程id（thread id），NPTL使用pthread_t类型来保存线程id，在不同的操作系统中，pthread_t底层实现不同，具体到Linux是一个无符号整型数 (也可以使用函数 pthread_self 获取本线程的id)。

1.3.2 线程函数错误处理

之前的POSIX系统调用和库函数在调用出错的时候，通常会把全局变量 errno (按进程隔离)设置为一个特别的数值以指示报错的类型，这样就可以调用 perror 以显示符合人阅读需求的报错信息。但是在多线程编程之中，全局变量是各个线程的共享资源，很容易被并发地读写，所以pthread系列的函数优化了检错方式，它会根据pthread系列的函数不同的返回值, 让strerror 函数根据这个错误返回值，使用 strerror 函数可以根据返回值显示报错字符串。(man strerror)

xxxxxxxxxx
3
1
char *strerror(int errnum);
2

3
#define THREAD_ERROR_CHECK(ret,msg) {if(ret!=0){fprintf(stderr,"%s:%s\n",msg,strerror(ret));}}

xxxxxxxxxx
14
1
void * threadFunc(void *arg){
2
   printf("I am child thread, \n" );
3
   return NULL;
4
}
5
int main()
6
{
7
   pthread_t tid;
8
   int ret = pthread_create(&tid,NULL,threadFunc,NULL);
9
    THREAD_ERROR_CHECK(ret,"pthread_create");
10
   printf("I am main thread \n") 
11
   sleep(1);
12
   //usleep(20);
13
   return 0;
14
}

xxxxxxxxxx
23
1
// 创建最大的线程数
2
void * threadFunc(void *arg){
3
   sleep(3);
4
   return NULL;
5
}
6
int main()
7
{
8
   int count = 1;
9
   whlie(1){
10

11
       pthread_t tid;
12
       int ret = pthread_create(&tid,NULL,threadFunc,NULL);
13
        THREAD_ERROR_CHECK(ret,"pthread_create");
14

15
       count++;
16
       if(ret != 0){
17
           printf("sum thread count=%d \n", count);
18
           break;
19
       }
20
   }
21

22
   return 0;
23
}

1.4 线程和数据共享

1.4.1 共享全局变量 (数据段)

多个线程是共享一片地址空间的，所以各个线程可以并发地访问的同一个数据段、堆空间和其他位置。

下面是一个共享数据段的例子：

xxxxxxxxxx
22
1
//多线程共享数据段
2
#include <func.h>
3
int global= 100;
4

5
void * threadFunc(void *arg){
6
   printf("I am child thread \n" );
7
   printf("child thread, global = %d\n", global);
8
   return NULL;
9
}
10
int main()
11
{
12
   pthread_t tid;
13
   int ret = pthread_create(&tid,NULL,threadFunc,NULL);
14
   THREAD_ERROR_CHECK(ret,"pthread_create");
15
   printf("I am main thread \n" );
16

17
   global = 200;
18
   printf("main thread, global = %d\n", global);
19

20
   sleep(1);
21
   return 0;
22
}

1.4.2 共享堆空间

堆空间自然也是可以共享的，我们通过会将堆空间的首地址作为参数在创建线程的时候进行传递，无论是子线程还是主线程访问的区域都是同一片空间。

eg:

xxxxxxxxxx
29
1
//多线程共享堆空间
2
void * threadFunc(void *arg){
3

4
   char *pHeap = (char *)arg;
5
   printf("I am child thread \n" );
6

7
   strcpy(pHeap,"world"); // 复制字符串
8
   printf("child thread, %s\n",pHeap);
9

10
   return NULL;
11
}
12
int main()
13
{
14

15
   char *pHeap = (char *)malloc(20);
16
   strcpy(pHeap,"hello");
17

18
   pthread_t tid;
19
   int ret = pthread_create(&tid,NULL,threadFunc,(void *)pHeap);
20
   THREAD_ERROR_CHECK(ret,"pthread_create");
21

22
   printf("I am main thread \n" );
23

24
   sleep(1);
25
   printf("parent thread, %s\n",pHeap);
26
   free(pHeap);
27

28
   return 0;
29
}

1.4.3 访问栈数据

需要注意的是，虽然各个线程执行的过程中拥有自己独立的栈区，但是这些所有的栈区都是在同一个地址空间当中，所以一个线程完全可以访问到另一个线程栈帧内部的数据。(如果将主线程栈帧数据的地址作为参数传递给各个子线程，就一定要注意并发访问的情况，有可能另一个线程的执行会修改掉原本想要传递数据的内容)

xxxxxxxxxx
23
1
void * threadFunc(void *arg){
2
   printf("I am child thread \n" );
3

4
   int * pval = (int *)arg;
5
   *pval = 1002;
6
   printf("child, val = %d\n",*pval);
7

8
   return NULL;
9
}
10
int main(){
11

12
   pthread_t tid;
13
   int val = 1001;
14
   int ret = pthread_create(&tid,NULL,threadFunc,(void *)&val);
15
   THREAD_ERROR_CHECK(ret,"pthread_create");
16

17
   printf("I am main thread \n" );
18

19
   sleep(1);
20
   //虽然栈帧是私有的，但是其他线程依然有权限读写
21
   printf("main, val = %d\n",val);
22
   return 0;
23
}

1..4.4 其它

注意: long作为8字节参数

虽然说 arg 是一个 void* 类型的参数，这暗示着用户可以使用该参数来传递一个数据的地址，但是有些情况下我们只需要传递一个整型数据，在这种情况，除了传递参数地址以外, 用户可以直接把 void* 类型的参数当成是一个8字节的普通数据(比如long)进行传递。

传递地址

xxxxxxxxxx
27
1
void * threadFunc(void *arg){
2

3
int *intnum = (int *)arg;
4
  printf("I am child thread \n" );
5
   //把参数当成是普通的8字节整型
6
   printf("child, val = %d\n", *intnum);
7
   return NULL;
8
}
9
int main(){
10

11
int val = 1001;
12

13
   pthread_t tid;
14
  int ret = pthread_create(&tid,NULL,threadFunc,&val);
15
   THREAD_ERROR_CHECK(ret,"pthread_create");
16

17
   //sleep(1);
18

19
   val = 1002;
20
  ret = pthread_create(&tid,NULL,threadFunc, &val);
21
   THREAD_ERROR_CHECK(ret,"pthread_create");
22

23
   printf("I am main thread \n" );
24
  sleep(1);
25

26
   return 0;
27
}

传递8字节数据

xxxxxxxxxx
26
1
void * threadFunc(void *arg){
2

3
printf("I am child thread \n" );
4
  //把参数当成是普通的8字节整型
5
   printf("child, val = %ld\n",(long)arg);
6
   return NULL;
7
}
8
int main(){
9

10
long val = 1001;
11

12
   pthread_t tid;
13
  int ret = pthread_create(&tid,NULL,threadFunc,(void *)val);
14
   THREAD_ERROR_CHECK(ret,"pthread_create");
15

16
   //sleep(1);
17

18
   val = 1002;
19
  ret = pthread_create(&tid,NULL,threadFunc,(void *)val);
20
   THREAD_ERROR_CHECK(ret,"pthread_create");
21

22
   printf("I am main thread \n" );
23
  sleep(1);
24

25
   return 0;
26
}

注意: 栈数据共享的释放

共享栈数据，一定要注意内存的释放顺序

EgCode：

xxxxxxxxxx
25
1
void * threadFunc(void *arg){
2
   sleep(1);
3

4
   int *intnum = (int *)arg;
5
   printf("I am child thread \n" );
6
   //把参数当成是普通的8字节整型
7
   printf("child, val = %d\n", *intnum);
8
   return NULL;
9
}
10
void func(){
11
   int val = 1001;
12

13
   pthread_t tid;
14
   int ret = pthread_create(&tid,NULL,threadFunc,&val);
15
   THREAD_ERROR_CHECK(ret,"pthread_create");
16

17
   printf("function over \n" );
18
}
19
int main(){
20
   func(); // 调用函数
21

22
   printf("I am main thread \n" );
23
   sleep(2);
24
   return 0;
25
}

1.5 获取线程的退出状态

我们可以通过pthread_join()方法捕获线程的退出和退出状态。

1.5.0 补充: ps -elLf

补充

xxxxxxxxxx
2
1
ps -elLf
2
# 我们可以在在shell中使用ps -elLf命令， 列出所有线程

运行如下代码，在代码运行中，并通过ps -elLf命令查看所有线程状态，观察线程变化

EgCode：

xxxxxxxxxx
13
1
#include <testfun.h> 
2
void * fun1(void * arg){
3
   // while(1){};
4
   sleep(10);
5
}
6
int main()
7
{
8
   pthread_t pid;
9
   int ret = pthread_create(&pid, NULL, fun1, NULL);
10
    THREAD_ERROR_CHECK(ret,"pthread_create");
11
    sleep(20);
12
    return 0;
13
}    

1.5.1 pthread_join

函数定义

使用 pthread_join() 捕获线程的退出和退出状态。

xxxxxxxxxx
13
1
#include <pthread.h>
2
// join with a terminated thread
3
int pthread_join( 
4
    pthread_t thread, // 要捕获线程目标的线程id
5
    void **retval // 目标线程的退出状态(指向线程的退出时携带参数)
6
);
7
// 返回值int标识捕获状态:  0代表成功 (别的仅作了解: 死锁,不可捕获,被别的线程捕获, 不识别的线程id)
8

9

10
ps1: pthread_join可以使本线程处于等待状态/阻塞,直到指定的thread终止, 就结束等待/结束阻塞,并且捕获到的线程终止状态存入retval指针所指向的内存空间中。
11
ps2: pthread_join可以捕获一个线程,一个线程的退出也可以由另一个线程使用pthread_join捕获,需要注意的是,另一个线程的选择是任意的,不需要是被捕获线程创建者。
12
ps3: 一个线程的退出,可以被多个线程通过pthread_join"试图"捕获(多个线程调用该函数获取同一个线程的执行结果),但是只有一个pthread_join能捕获成功。别的都将失败。
13
ps4: 指针retval捕获线程函数内部的局部数据, 可能会存在问题。

代码示例

xxxxxxxxxx
17
1
#include <testfun.h>
2

3
void *funThread(void *arg){
4
    return 0;
5
} 
6
int main()
7
{
8
   pthread_t threadId;
9
   int ret = pthread_create(&threadId, NULL, funThread, NULL);
10
   THREAD_ERROR_CHECK(ret, "pthread_create");
11

12
   int ret_join = pthread_join(threadId, NULL );// NULL代表不接收join线程返回状态
13
   THREAD_ERROR_CHECK(ret_join, "pthread_join");
14

15
   printf("child thread join status = %d \n",  ret_join);
16
   return 0;
17
}

注意事项

A. 注意: 阻塞线程

pthread_join 可以使本线程处于等待/阻塞状态,直到指定的 thread 终止, 就结束等待,并且捕获到的线程终止状态(返回参数)存入 retval 指针所指向的内存空间中。

EgCode:

xxxxxxxxxx
22
1
#include <testfun.h>
2

3
void *funThread(void *arg){
4
   sleep(10);
5

6
   // return 100;
7
   return (void *)100;
8
} 
9

10
int main()
11
{
12
   pthread_t threadId;
13
   int ret = pthread_create(&threadId, NULL, funThread, NULL);
14
   THREAD_ERROR_CHECK(ret, "pthread_create");
15

16
   void * retThread;
17
   int ret_join = pthread_join(threadId, &retThread );
18
   THREAD_ERROR_CHECK(ret_join, "pthread_join");
19

20
   printf("child thread retval = %ld \n",  (long)retThread);
21
   return 0;
22
}

B. 注意: 捕获和被捕获线程的关系

ps2: pthread_join可以捕获一个线程,一个线程的退出也可以由另一个线程使用pthread_join捕获,需要注意的是,另一个线程的选择是任意的,不需要是被捕获线程创建者。 ps3: 一个线程的退出,可以被多个线程通过pthread_join试图捕获(多个线程调用该函数获取同一个线程的执行结果),但是只有一个pthread_join能捕获成功。别的都将失败。

C. 注意: 局部变量问题

指针retval捕获线程函数内部的局部数据, 可能会存在问题(比如局部变量)。

xxxxxxxxxx
24
1
// 如下代码报错: Segmentation fault (core dumped), 
2
// 原因是: funThread 函数中定义了一个局部变量 num。 函数返回时，它返回了一个指向 num 的指针。一旦 funThread 函数执行完毕，num 所占用的栈内存将不再有效，因此返回的指针指向一个已经被回收的内存区域。当主线程尝试通过这个指针访问 num 的值时，它访问了一个无效的内存地址，从而引发了 "Segmentation fault"
3
#include <testfun.h>
4

5
void *funThread(void *arg){
6
    sleep(5);
7

8
    int num = 10;
9
    return &num;
10
} 
11

12
int main()
13
{
14
    pthread_t threadId;
15
    int ret = pthread_create(&threadId, NULL, funThread, NULL);
16
    THREAD_ERROR_CHECK(ret, "pthread_create");
17

18
    void *retThread;
19
    int ret_join = pthread_join(threadId, &retThread );
20
    THREAD_ERROR_CHECK(ret_join, "pthread_join");
21

22
    printf("child thread retval = %d \n", *(int *)retThread);
23
    return 0;
24
}

xxxxxxxxxx
32
1
// 假设返回的堆上数据没有问题
2
#include <testfun.h>
3

4
void *funcThread(void *arg){
5
    sleep(5);
6

7
    int *num = malloc(sizeof(int));
8
    *num = 10;
9

10
    //return num;
11
    return (void *)num;
12
}
13
int main()
14
{
15
    pthread_t pid;
16
    int ret = pthread_create(&pid, NULL, funcThread, NULL);
17
    THREAD_ERROR_CHECK(ret, "pthread_create");
18

19
    void *retThread;
20
    int ret_join = pthread_join(pid, &retThread);
21
    THREAD_ERROR_CHECK(ret_join, "pthread_join");
22
    printf("child thread retval = %d \n", *(int *)retThread);
23
    free(retThread);
24

25
    //void **retThread;
26
    //int ret_join = pthread_join(pid, retThread);
27
    //THREAD_ERROR_CHECK(ret_join, "pthread_join");
28
    //printf("child thread retval = %d \n", *(int *)(*retThread));
29
    //free(*retThread);
30

31
    return 0;
32
}

1.6 线程的主动退出

1.6.1 线程的return退出

1, 当存在一个线程， 这个线程正常运行结束， 其入口调用函数通过return运行结束。 此线程将正常退出。

2, 我们可以通过pthread_join捕获到线程return退出, 以及退出时返回数据.

EgCode： （可配合 ps -elLf命令， 查看子线程的结束时机。）

xxxxxxxxxx
23
1
#include <testfun.h> 
2
void *fun2(){
3
   sleep(5);
4
   printf("fun2 sleep over \n");
5
   return NULL;
6
}
7
void * fun1(void * arg){
8
   fun2();
9
   sleep(5);
10
   printf("fun1 sleep over \n");
11
   // 需要注意的是,要通过return结束线程
12
   // 是要在线程的入口的函数中return(类似主线程的main方法return)
13
   // 而非是在更深层次的非线程的入口函数(调用函数)中return
14
   return NULL;
15
}
16
int main()
17
{
18
   pthread_t pid;
19
   int ret = pthread_create(&pid, NULL, fun1, NULL);
20
   THREAD_ERROR_CHECK(ret,"pthread_create");
21
   sleep(20);
22
   return 0;
23
}

通过pthread_join捕获正常return线程

xxxxxxxxxx
19
1
#include <testfun.h> 
2

3
void * fun1(void * arg){ 
4
   sleep(5);
5
   return (void *)11;
6
}
7
int main()
8
{
9
   pthread_t pid;
10
   int ret = pthread_create(&pid, NULL, fun1, NULL);
11
   THREAD_ERROR_CHECK(ret, "pthread_cetate");
12

13
   void *numP;
14
   int ret_join = pthread_join(pid, &numP);
15
   THREAD_ERROR_CHECK(ret_join, "pthread_join");
16

17
   printf("catch from child thread return value = %ld \n",  (long)numP);
18
   return 0;
19
}

1.6.2 通过pthread_exit退出

函数定义

使用 pthread_exit 函数可以主动退出线程。

无论这个函数是否是在 start_routine(主调函数/线程入口函数) 中被调用(其行为类似于进程退出的 exit), 都将退出该线程 。

xxxxxxxxxx
12
1
#include <pthread.h>
2
// terminate calling thread
3
void pthread_exit( 
4
    void *retval // 该参数描述了线程的退出状态
5
             // ( 即它指向的数据将作为线程退出时的返回值。
6
             //   如果线程不需要返回任何数据，将retval参数置为NULL即可。)
7
);
8

9
ps: 指针retval建议不要指向该退出线程函数内部的局部数据。
10
ps: 在正常return结束的线程中, 其start_routine的最终返回值, 等价于pthread_exit退出线程的携带retval,等待捕获程结束的pthread_join()函数都可以接收到线程的返回值, 对于pthread_join来说,并不认为两者有什么异同
11
ps: 如果子线程通过return 0, 或者 pthread_exit(NULL) 或者 pthread_exit(0) 结束, 那么pthread_join()捕获的线程退出状态可以表示为0
12
ps: pthread_exit()可以自动调用线程清理程序(参考pthread_cleanup_push()),return 则不具备这个能力。

代码示例

EgCode: pthread_exit 函数可以主动退出线程

xxxxxxxxxx
21
1
#include <testfun.h>
2

3
void *funThread(void *arg){
4
   // 退出线程的参数要求是void*类型 
5
   pthread_exit((void *) 11);
6
   printf("this scene well not be print \n");
7
} 
8

9
int main()
10
{
11
   pthread_t threadId;
12
   int ret = pthread_create(&threadId, NULL, funThread, NULL);
13
   THREAD_ERROR_CHECK(ret, "pthread_create");
14

15
   void *numP;
16
   int ret_join = pthread_join(threadId, &numP);
17
   THREAD_ERROR_CHECK(ret_join, "pthread_join");
18

19
   printf("catch child thread by pthread_exit value = %ld \n", (long)numP);
20
   return 0;
21
}

EgCode: 无论这个函数是否是在start_routine函数中被调用, 都将退出该线程 。

xxxxxxxxxx
21
1
#include <testfun.h>
2

3
void funTHreadDeep(){
4
   printf("this is deep funaction \n");
5
   // 次数调用退出线程, 依旧会导致该方法所在线程退出
6
   // 即使当前方法不是线程的入口函数
7
   pthread_exit(NULL);
8
   printf("this scene2 well not be print \n");
9
}
10
void *funThread(void *arg){
11
   funTHreadDeep();// 调用另一个方法
12
   printf("this scene1 well not be print \n");
13
} 
14
int main()
15
{
16
   pthread_t threadId;
17
   int ret = pthread_create(&threadId, NULL, funThread, NULL);
18
   THREAD_ERROR_CHECK(ret, "pthread_create");
19
   sleep(20);
20
   return 0;
21
}       

其它注意

A. 注意

ps: 指针retval建议不要指向该退出线程函数内部的局部数据。

ps: 在正常return结束的线程中, 其start_routine的最终返回值, 等价于pthread_exit退出线程的携带retval,等待捕获程结束的pthread_join()函数都可以接收到线程的返回值, 对于pthread_join来说,并不认为两者有什么异同。

ps: pthread_join()函数的第二个参数线程的返回值的位置, 可以用NULL填充, 表示不捕获线程返回值。

B. 了解

ps: 如果子线程通过pthread_exit(NULL) 退出, 那么pthread_join()捕获的线程退出状态和 return 0以及pthread_exit(0) 结束线程一样,捕获返回结果为0。

xxxxxxxxxx
20
1
#include <testfun.h>
2

3
void *funThread(void *arg){
4
   //pthread_exit(NULL);
5
   //pthread_exit(0);
6
   return 0;    
7
} 
8
int main()
9
{
10
   pthread_t threadId;
11
   int ret = pthread_create(&threadId, NULL, funThread, NULL);
12
   THREAD_ERROR_CHECK(ret, "pthread_create");
13

14
   void *numP;
15
   int ret_join = pthread_join(threadId, &numP);
16
   THREAD_ERROR_CHECK(ret_join, "pthread_join");
17

18
   printf("catch child thread by pthread_exit value = %ld \n", (long)numP);
19
   return 0;
20
}

C. 一个stdout的特殊情况

每个线程开辟了一个独属于自己的栈, 而堆/数据段/代码段/..是共享的。 同时也共享一个进程的stdout(标准输出)。

xxxxxxxxxx
18
1
#include <testfun.h>
2

3
void *funThread(void *arg){
4
printf("i am child thread"); // 这句话并未立即输出,而是等了一会 才输出
5
// 退出线程的参数要求是void*类型 or NULL
6
pthread_exit((void *) 11);
7
printf("this scene well not be print \n");
8
} 
9

10
int main()
11
{
12
pthread_t threadId;
13
int ret = pthread_create(&threadId, NULL, funThread, NULL);
14
THREAD_ERROR_CHECK(ret, "pthread_create");
15
sleep(10);
16
printf("i am main thread \n");
17
return 0;
18
}

D. 注意

pthread_exit()可以自动调用线程清理程序(参考pthread_cleanup_push()),return 则不具备这个能力。

1.7 线程的被动退出

我们在上面分别介绍了: 通过代码正常运行return结束, 以及通过执行pthread_exit函数退出线程; 而这两种方式都是由执行线程触发的主动退出方式。

除了上述线程自己主动退出的情况, 那线程有没有可能被另一个线程通过某些方式强制终止(即被动退出)的情况那?

xxxxxxxxxx
1
1
ps: 不过首先值得注意的是，和进程的'被动退出'情况不同, 我们可以通过'信号'让进程被动退出/终止,  但是我们不能轻易地在多线程程序使用信号，因为多线程是共享代码段的，从而'信号处理的回调函数'也是共享的，当产生一个信号到进程时，进程中用于递送信号的线程是随机的，很有可能会出现主线程因递送信号而终止从而导致所有线程异常退出的情况

1.7.1 线程的取消

而多线程程序中，一个线程可以借助 pthread_cancel() 函数向另一个线程发送终止执行的信息, 从而实现在一个线程中去终止另一个线程的操作, 从而使被通知的线程被动退出。

函数原理

线程的被动取消流程， 如图所示:

需要注意的是， 当线程A向线程B发送取消线程执行信息的时候， 线程B并不是立即终止执行， 线程B是要先运行到一个叫取消点的位置才终止线程。

 

取消点

xxxxxxxxxx
7
1
// 什么是取消点？
2
当一个线程调用 pthread_cancel 去取消另一个线程的时候，另一个线程会将本线程的取消标志位设置为真，当这个线程执行一些函数之时，线程就会退出。这些会导致已取消未终止的线程终止的函数称为取消点。
3
// 那些常见的取消点函数？
4
a. 几乎所有会引发阻塞的函数：  eg：sleep()， select(), wait() ....
5
b. I/O操作： open(), close(), read(), write(), fopen(), fclose(), printf()....
6

7
ps: 可以通过(man 7 pthreads)查看取消点函数(cancellation points)

函数定义

通过pthread_cancel() 取消一个执行中的线程

xxxxxxxxxx
6
1
#include <pthread.h>
2
// send a cancellation request to a thread
3
int pthread_cancel( 
4
     pthread_t thread, // 不同线程的线程id 
5
);
6
// 返回值int标识捕获状态:  0代表成功， ESRCH代表参数错误(没找到这个线程id)

代码示例

EgCode： 没有取消点无法取消示例

xxxxxxxxxx
22
1
#include <testfun.h>
2

3
void * func(void *arg){
4
while(1){
5
}
6
return NULL;
7
}
8
int main()
9
{
10
pthread_t  pid;
11
int res = pthread_create(&pid, NULL, func, NULL);
12
THREAD_ERROR_CHECK(res, "pthread_create");
13

14
int res_cancel = pthread_cancel(pid);
15
THREAD_ERROR_CHECK(res_cancel, "pthread_cancel");
16

17
printf("main use cancel \n");    
18
int res_join = pthread_join(pid, NULL);
19
THREAD_ERROR_CHECK(res_join, "pthread_join");
20

21
return 0;
22
}

EgCode： 正常取消示例

xxxxxxxxxx
25
1
#include <testfun.h>
2

3
void * func(void *arg){
4
while(1){
5
   printf("child thread printf \n");
6
}
7
return NULL;
8
}
9
int main()
10
{
11
pthread_t  pid;
12
int res = pthread_create(&pid, NULL, func, NULL);
13
THREAD_ERROR_CHECK(res, "pthread_create");
14

15
sleep(10);
16

17
printf("main use cancel \n");
18
int res_cancel = pthread_cancel(pid);
19
THREAD_ERROR_CHECK(res_cancel, "pthread_cancel");
20

21
int res_join = pthread_join(pid, NULL);
22
THREAD_ERROR_CHECK(res_join, "pthread_join");
23

24
return 0;
25
}

注意事项: 了解, 不重要

当线程被动取消， 通过pthread_join捕获的结束状态： PTHREAD_CANCELED （参考 man pthread_join 的 description）

（了解：PTHREAD_CANCELED 是一个由pthread.h定义的， 本质值为-1 ）

（了解：当线程主动退出：pthread_exit(PTHREAD_CANCELED)退出，pthread_join捕获的结束状态也是PTHREAD_CANCELED ）

xxxxxxxxxx
32
1
#include <testfun.h>
2

3
void * func(void *arg){
4
   while(1){
5
       sleep(1);
6
       printf("child thread printf \n");
7
   }
8
   return NULL;
9
}
10
int main()
11
{
12
   pthread_t  pid;
13
   int res = pthread_create(&pid, NULL, func, NULL);
14
   THREAD_ERROR_CHECK(res, "pthread_create");
15

16
   sleep(10);
17

18
   int res_cancel = pthread_cancel(pid);
19
   THREAD_ERROR_CHECK(res_cancel, "pthread_cancel");
20

21
   void *ret_catch ;
22
   int res_join = pthread_join(pid, &ret_catch);
23
   THREAD_ERROR_CHECK(res_join, "pthread_join");
24

25
   if(ret_catch == PTHREAD_CANCELED){
26
       printf("catch value = %ld \n", (long)ret_catch); // -1
27
   }else{
28
       printf("other value = %ld \n", (long)ret_catch);
29
   }
30

31
   return 0;
32
}

1.7.2 手打取消点

从上述的的被动取消过程中， 我们知道pthread_cancel函数是依赖于被取消线程的取消点这一关键标志位； 但是有一种可能，要被取消线程代码中（试图被动取消的代码片段位置）没有取消点， 那么我们该怎么办那？

我们可以通过pthread_testcancel方法， 手动添加一个取消点。

函数定义

通过pthread_testcancel方法， 手动添加一个取消点。

xxxxxxxxxx
4
1
#include <pthread.h>
2
// request delivery of any pending cancellation request 
3
void pthread_testcancel(void);
4
// 无参数和返回值

代码示例

EgCode:

xxxxxxxxxx
23
1
#include <testfun.h>
2

3
void * func(void *arg){
4
   while(1){
5
      pthread_testcancel();// 没有这句代码， 将一直 循环无法取消
6
   }
7
   return NULL;
8
}
9
int main()
10
{
11
   pthread_t  pid;
12
   int res = pthread_create(&pid, NULL, func, NULL);
13
   THREAD_ERROR_CHECK(res, "pthread_create");
14

15
   printf("main use cancel \n");
16
   int res_cancel = pthread_cancel(pid);
17
   THREAD_ERROR_CHECK(res_cancel, "pthread_cancel");
18

19
   int res_join = pthread_join(pid, NULL);
20
   THREAD_ERROR_CHECK(res_join, "pthread_join");
21

22
   return 0;
23
}

1.7.3 总结补充

了解线程取消的先后顺序流程是很重要的，尤其是在复杂的多线程应用中。当调用 pthread_cancel 来取消一个线程时，以下是线程取消的大致步骤和流程：

xxxxxxxxxx
5
1
// 1, 首先在某个线程中调用'pthread_cancel', 并传入要取消的目标线程ID。系统根据线程ID找到要取消的目标线程， 给这个线程的内部取消标记设置为真。
2
// 2， 被取消线程在程序的执行的时候， 当执行到取消点函数， 则去检测标志位。
3
// 3,  取消点函数一旦检测到线程为取消状态时，在终止线程之前， 将执行清理函数： pthread_cleanup_push, 用于释放占用资源、解锁互斥锁等。。。 
4
// 4,  完成数据清理后， 线程执行退出操作。而操作系统和线程库负责销毁thread local数据， 比如栈空间
5
// 5,  pthread_join被返回， 接受线程取消状态， eg：PTHREAD_CANCELED。

1.8 资源清理

在引入线程取消之后，程序员在管理资源回收的难度上会急剧提升。

EgCode：

xxxxxxxxxx
28
1
#include <testfun.h>
2

3
void * func(void *arg){
4
   void *p1 = malloc(4);
5
   void *p2 = malloc(4);
6

7
   int fd = open("file1", O_RDWR);
8
   // ... 其它代码
9
   close(fd); // 有没有可能代码在这个， 被取消了？这决定了p1, p2的空间会不会被释放？
10

11
   free(p2);
12
   free(p1);
13
   return NULL;
14
}
15
int main()
16
{
17
   pthread_t  pid;
18
   int res = pthread_create(&pid, NULL, func, NULL);
19
   THREAD_ERROR_CHECK(res, "pthread_create");
20

21
   int res_cancel = pthread_cancel(pid);// 取消线程
22
   THREAD_ERROR_CHECK(res_cancel, "pthread_cancel");
23

24
   int res_join = pthread_join(pid, NULL);
25
   THREAD_ERROR_CHECK(res_join, "pthread_join");
26

27
   return 0;
28
}

在上述代码中， 我们遇到了什么问题？

xxxxxxxxxx
1
1
和我们前面通过return或者pthread_exit主动退出线程不同(是可控行为)， 当我们通过pthread_cancel被动退出线程， 有可能导致被退出的线程中有些资源没有回收， 从而导致内存泄漏。

为了解决这个问题， 线程库引入了 pthread_cleanup_push 和 pthread_cleanup_pop函数来管理线程主动或者被动终止时所申请资源（比如文件、堆空间、锁等等）。

1.8.1 pthread_cleanup

函数原理

当线程开始执行时，会创建一个清理栈（thread's stack of thread-cancellation），用于存储注册的清理函数和参数。

而我们可以通过 pthread_cleanup_push 和 pthread_cleanup_pop通过向这个清理栈中添加清理函数，以及pop出清理函数执行。从而确保线程的正确终止和资源回收。

函数定义

xxxxxxxxxx
6
1
#include <pthread.h>
2
// push thread cancellation clean-up handlers
3
void pthread_cleanup_push( 
4
    void (*routine)(void *),// 指向清理函数的指针，该函数将在线程取消时被调用
5
    void *arg // 传递给清理函数的参数
6
);

xxxxxxxxxx
5
1
#include <pthread.h>
2
// pop thread cancellation clean-up handlers
3
void pthread_cleanup_pop( 
4
    int execute // 设置参数0代表弹出栈顶函数并且'不执行'这个函数， 非0代表代表弹出栈顶函数并且'执行'这个函数
5
);

xxxxxxxxxx
8
1
ps：pthread_cleanup_push()和pthread_cleanup_pop()必须在同一个作用域中要成对出现 。
2
（此处可参考: /usr/include/pthread.h 对这两个方法的定义 
3
   -> 可以发现push和pop的宏定义不是语义完全的，它们必须在同一作用域中成对出现才能使花括号成功匹配。）
4
ps：线程运行到pthread_cleanup_pop()方法,当execute参数0代表弹出栈顶函数并且'不执行'这个函数， 
5
                                 当execute参数非0代表代表弹出栈顶函数并且'执行'这个函数。
6
ps: 通过pthread_cancel取消线程， 线程取消，所有入栈的清理函数将按照顺序依次弹栈并执行。
7
ps: 调用pthread_exit主动退出线程， 所有入栈的清理函数将按照顺序依次弹栈并执行。
8
ps: 当线程因为在start_routine中因为return结束线程， 清理函数栈将不会弹栈。（这取决于操作系统）

代码示例

EgCode:

xxxxxxxxxx
42
1
#include <testfun.h>
2

3
void cleanheap(void *argp){
4
   printf("cleanheap is runing \n");
5
   free(argp);
6
}
7
void cleanfile(void *filep){
8
   printf("cleanfile is runing \n");
9
   int *fdP = (int *)filep;
10
   close(*fdP);
11
}
12
void * func(void *arg){
13
   void *p1 = malloc(4);
14
   pthread_cleanup_push(cleanheap, p1);
15
   void *p2 = malloc(4);
16
   pthread_cleanup_push(cleanheap, p2);
17

18
   int fd = open("file1", O_RDWR); // ps： 注意，代码未必能执行到这个位置
19
   pthread_cleanup_push(cleanfile, &fd);
20

21
   // sleep(2);
22

23
   pthread_cleanup_pop(1);
24
   pthread_cleanup_pop(1);
25
   pthread_cleanup_pop(1);
26
}
27
int main()
28
{
29
   pthread_t  pid;
30
   int res = pthread_create(&pid, NULL, func, NULL);
31
   THREAD_ERROR_CHECK(res, "pthread_create");
32

33
   // sleep(1);
34
   int res_cancel = pthread_cancel(pid);
35
   THREAD_ERROR_CHECK(res_cancel, "pthread_cancel");
36

37
   int res_join = pthread_join(pid, NULL);
38
   THREAD_ERROR_CHECK(res_join, "pthread_join");
39

40
   return 0;
41
}
42

注意事项

ps：pthread_cleanup_push()和pthread_cleanup_pop()必须在同一个作用域中要成对出现 。 （此处可参考: /usr/include/pthread.h 对这两个方法的定义 -> 可以发现push和pop的宏定义不是语义完全的，它们必须在同一作用域中成对出现才能使花括号成功匹配。）

ps：线程运行到pthread_cleanup_pop()方法: 当execute参数0代表弹出栈顶函数并且'不执行'这个函数， 当execute参数非0代表代表弹出栈顶函数并且'执行'这个函数。

ps: 通过pthread_cancel取消线程， 线程取消，所有入栈的清理函数将按照顺序依次弹栈并执行。

ps: 调用pthread_exit主动退出线程， 所有入栈的清理函数将按照顺序依次弹栈并执行。

ps: 当线程因为在start_routine中因为return结束线程， 清理函数栈将不会弹栈。（这取决于操作系统）

2. 线程的同步和互斥

由于多线程之间不存在隔离，共享同一个地址在提高运行效率的同时也给用户带来了巨大的困扰。在并发执行的情况下，大量的共享资源成为竞争条件(竞争条件是指多个线程并发访问和修改共享资源时可能出现的问题)，导致程序执行的结果往往和预期的内容大相径庭。

EgCode: 两个线程操作一个共享变量, "每个线程每次加一, 加一百万次"

xxxxxxxxxx
27
1
#include <testfun.h>
2
// 两个线程对同一个共享变量分别加一百万次
3
#define TIMES 1000000
4
int global = 0;
5

6
void * func(void *arg){
7
printf("child thread is runing \n");
8
for(int i = 0; i<TIMES; i++){
9
   global++;
10
}
11
printf("child thread stop \n");
12
}
13
int main(int argc,char*argv[])
14
{
15
pthread_t pid;
16
pthread_create(&pid,NULL,func,NULL);
17

18
printf("main thread is runing \n");
19
for(int i = 0; i<TIMES; i++){
20
   global++;
21
}
22
printf("main thread stop \n");
23

24
pthread_join(pid, NULL);
25
printf("all over, global = %d \n", global);
26
return 0;
27
}

我们发现结果并不是我们期望的二百万。原因是什么那?

xxxxxxxxxx
4
1
// 以某次逻辑为例
2
1, 当主线程在读取共享变量时，假设它的值为x, 那么主线程把它从内存读到寄存器, 把x自增变成x+1再写回内存。
3
2, 在主线程完成上述操作的过程中，假设在写回内存之前, 子线程可能也已经读取了共享变量的值, 即未被主线程写回更新之前的x。 子线程的运行也是把自己读取到寄存器的x自增变成x+1再写回内存。
4
// 综上, 虽然两个线程都进行了一次逻辑自增执行,但是实际结果产生了覆盖, 最终只增加了1. 

如果一个程序的结果是不正确的，那么再高的效率也毫无意义。在基于之前进程对并发的研究之上，线程库也提供了专门用于正确地访问共享资源的机制--> 锁。

2.1 互斥锁

在多线程编程中，用来控制共享资源的最简单有效也是最广泛使用的机制就是 mutex(MUTual EXclusion)，即互斥锁。锁的本质是一个全局的标志位，线程可以对锁进行原子性修改，即所谓的加锁/解锁。当一个线程持有锁的时候，其余线程再尝试加锁时(包括自己再次加锁)，都会使自己陷入阻塞状态，直到这把锁 -> 被持有该锁的线程解锁, 其它线程才能拿到这个锁, 拿到锁之后并且解除之前的阻塞状态恢复运行。所以锁在某个时刻永远不能被两个线程同时持有。

2.1.1 锁的基本情况

锁

xxxxxxxxxx
2
1
互斥锁（Mutex，全称为Mutual Exclusion）是一种用于多线程编程的同步机制。
2
它可以保证在任意时刻只有一个线程能够访问共享资源，从而避免了多个线程同时对共享资源进行操作, 确保线程之间的互斥执行。

锁的状态

xxxxxxxxxx
5
1
(锁的本身是一个, 通过原子性操作的全局的标志位.)
2
// 未锁
3
此时没有线程拥有该锁, 任意线程都可以试图来占有/获取该锁。
4
// 已锁
5
该锁被某一个线程持有, 其它线程在获取该锁的时候阻塞。

锁的行为

xxxxxxxxxx
5
1
// 加锁(原子操作)
2
查看锁的状态, 如果未锁, 则加锁/占有锁; 
3
查看锁的状态, 如果已锁, 则阻塞;
4
// 解锁(原子操作)
5
让锁处于未锁状态;

锁的要求

xxxxxxxxxx
2
1
1, 同时只有一个线程获取锁
2
2, 谁加锁, 谁解锁 (锁的使用纷繁复杂，如果不按照规范行事，很容易出现错误，而且随意解锁会导致代码的无可读性)

临界区/临界资源

xxxxxxxxxx
2
1
加锁和解锁是成对出现的操作, 在加锁之后和解锁之前的这一段代码, 我们称为临界区.
2
在临界区中的这段代码，我们可以对共享资源进行操作。因为将临界区的代码块用互斥锁包裹，由于锁的互斥性, 则可以确保同一时间内只有一个线程能够进入该代码块，从而保证了共享资源的安全性。

饥饿

xxxxxxxxxx
3
1
饥饿是指线程由于某种原因无法获得所需的锁，导致该线程长时间无法执行。
2
当多个线程竞争同一把锁时，如果某个线程经常无法获得所需的锁，那么它可能会长时间处于阻塞状态，即饥饿状态; 另外, 临界区范围过大, 也可能导致饥饿。
3
饥饿现象可能会导致程序性能下降等问题

死锁: 重要

xxxxxxxxxx
2
1
死锁是指线程在执行过程中，由于竞争资源使用不当造成的一种永久阻塞的现象，若无外力作用，某些逻辑将再阻塞状态下无法向下推进。
2
使用互斥锁的时候必须小心谨慎，如果是需要持续多个锁的情况，加锁和解锁之间必须要维持一定的顺序。即使是只有一把锁，如果使用不当，也会导致死锁。

xxxxxxxxxx
11
1
常见的死锁的情况
2
1, 情况一
3
// 存在线程1:  先持有锁A, 再持有锁B
4
// 存在线程2:  先持有锁B, 再持有锁A
5

6
// 如果上述两个线程, 1先持有了A锁, 2持有了B锁;  在这种状态下1又试图去获取B锁, 2又试图获取A锁都会产生死锁
7
2, 情况二
8
// 持有锁的线程在未释放锁的情况下, 线程终止了, 造成锁未释放; 
9
// 而另外的线程试图获取这个未释放的锁 
10
3, 情况三
11
// 某个线程在对A锁进行加锁, 当持有了A锁之后, 在未释A放锁的情况下, 重复对A进行加锁