以下内容参考自《Linux线程介绍》，作者峰子_仰望阳光
线程概述——与进程的区别、优势
“进程——资源分配的最小单位，线程——程序执行的最小单位”
典型的Unix进程可看成只有一个控制线程，同一时刻一个进程只做一件事。当有了多个控制线程之后，就可以设计并发处理程序了，每个线程各自处理独立任务
首先来看进程和线程有什么不同：
- 进程是程序一次执行的实例，是系统资源（CPU、内存、网络等）分配的基本单位，因此，各个进程之间相互独立，互不影响，在面向线程设计的系统中，线程是程序执行的基本单位，进程就相当于是线程的容器。程序本身只是编写好的代码，经过编译生成后的一条条指令，进程才是程序的真正运行实例。通常，使用
fork()函数创建进程
- 线程则是操作系统所能进行运算调度的最小单位。线程被包含在进程中，是进程的实际运作单位。一条线程的实质是进程中一个单一顺序的控制流，一个进程中可以包含多个线程，每条线程并行执行不同的任务。由于所有线程共享内存资源，虽然有自己的堆栈和局部变量，但是线程只是一个进程中的不同执行路径，没有独立的地址空间，因此一个线程内存出问题死掉，整个进程就会退出，同进程的其他线程自然也就死掉了。通常，使用
clone()函数创建线程
从上面的概念不难看出，多进程的健壮性要强于多线程。但进程的使用，无论是资源分配上还是进程间通信上，耗费都比较大，而多线程的设计，由于共享地址空间，所以线程切换和线程通信代价要小得多。在一些要求同时进行并且又要共享某些变量的并发操作，多线程相较于多进程具有无法替代的优越性。
因此，我们可以总结使用多线程而不是多进程的两点理由：
- 理由一：相比多进程，多线程是非常“节俭”的多任务操作方式。启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计，总的说来，一个进程的开销大约是一个线程开销的30倍左右
- 理由二：线程间的通信机制十分方便。由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。
此外，抛开和进程的对比，从多线程的本身来看，还具有如下优点：
- 提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time consuming）置于一个新的线程，可以避免这种尴尬的情况。
- 使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。
- 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。
线程创建、等待及退出
在Linux中，线程的全部操作都已经集成到pthread库中，涉及的多线程开发的最基本概念主要包含三点：线程，互斥锁，条件。
其中，线程操作又分线程的创建，退出，等待 3 种。
互斥锁则包括 4 种操作，分别是创建，销毁，加锁和解锁。
条件操作有 5 种操作：创建，销毁，触发，广播和等待。
其他的一些线程扩展概念，如信号灯等，都可以通过上面的三个基本元素的基本操作封装出来。在使用pthread库时，我们只需引入头文件#include<pthread.h>并在编译时链接pthread库：gcc code.c -lpthread
关于线程最基本操作：创建、等待及退出的api：
| 操作 |
原型 |
备注 |
| pthread_create() |
int pthread_create(pthread_t *restrict tidp,
const pthread_attr_t *restrict attr,
void *(*start_rtn)(void *), void *restrict arg);
// 若成功返回0，否则返回错误编号 |
当pthread_create成功返回时，由tidp指向的内存单元被设置为新创建线程的线程ID。
attr参数用于定制各种不同的线程属性，暂可以把它设置为NULL，以创建默认属性的线程。
新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg。
如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg参数传入。 |
| pthread_join() |
int pthread_join(pthread_t thread, void **rval_ptr);
// 若成功返回0，否则返回错误编号 |
单个线程可以通过以下三种方式退出，在不终止整个进程的情况下停止它的控制流：
1.线程只是从启动例程中返回，返回值是线程的退出码。
2.线程可以被同一进程中的其他线程取消。
3.线程调用pthread_exit |
| pthread_exit() |
int pthread_exit(void *rval_ptr); |
rval_ptr是一个无类型指针，与传给启动例程的单个参数类似。进程中的其他线程可以通过调用pthread_join函数访问到这个指针。 |
线程的创建需要预先定义一个函数，使得线程创建后从该函数开始执行。在这个自定义函数中，我们可以先写一些简单的输出语句。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| #include <stdio.h>
#include <pthread.h>
void *func1(void *arg)
{
printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
printf("t1:param is %d\n",*((int *)arg));
}
int main()
{
int ret;
int param = 100;
pthread_t t1;
ret = pthread_create(&t1, NULL, func1,(void *)¶m);
if(ret == 0){
printf("main:create t1 success\n");
}
printf("main:%ld\n",(unsigned long)pthread_self());
return 0;
}
|
编译运行上面的代码，你会发现main函数能够打印出“main:create t1 success”，但看不到线程的输出“thread is created”，为什么呢？这是因为，默认情况下线程的创建是非阻塞的，在上面代码中main函数创建线程成功并输出自身信息后直接就return 0;了，关闭了终端，自然也就看不到线程输出。我们可以使主线程等待子线程退出后再结束。这就用到pthread_join()函数，它将使调用的线程一直阻塞到指定线程调用pthread_exit()才继续执行后面的代码。
进一步，如果想要在线程退出的时候传递一些消息，可以这样做：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| #include <stdio.h>
#include <pthread.h>
void *func1(void *arg)
{
static char *p = "t1 is existing,bye";
printf("t1:%ld thread is created\n",(unsigned long)pthread_self());
printf("t1:param is %d\n",*((int *)arg));
pthread_exit((void *)p);
}
int main()
{
int ret;
int param = 100;
pthread_t t1;
char *pret = NULL;
ret = pthread_create(&t1, NULL, func1,(void *)¶m);
if(ret == 0){
printf("main:create t1 success\n");
}
printf("main:%ld\n",(unsigned long)pthread_self());
pthread_join(t1,(void **)&pret);
printf("main: t1 quit: %s\n",pret);
return 0;
}
|
需要注意的是func1函数中的局部变量必须声明为static类型，否则返回时将出错。
线程共享内存空间的编程验证
在前面提到过，同一进程的所有线程共享该进程的资源，包括全局变量、内存地址等。这一小节就通过编程验证这一特点。
实现思路就是定义一个全局变量，创建两个线程均对该变量进行递增操作，看是否会出现值重复的情况：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
| #include <stdio.h>
#include <pthread.h>
int g_data = 0;
void *func1(void *arg)
{
printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
printf("t1:param is %d\n",*((int *)arg));
while(1){
printf("t1: %d\n",g_data++);
sleep(1);
if(g_data == 3){
pthread_exit(NULL);
}
}
}
void *func2(void *arg)
{
printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
printf("t2:param is %d\n",*((int *)arg));
while(1){
printf("t2: %d\n",g_data++);
sleep(1);
}
}
int main()
{
int ret;
int param = 100;
pthread_t t1;
pthread_t t2;
ret = pthread_create(&t1, NULL, func1,(void *)¶m);
if(ret == 0){
printf("main:create t1 success\n");
}
ret = pthread_create(&t2, NULL, func2,(void *)¶m);
if(ret == 0){
printf("main:create t2 success\n");
}
printf("main:%ld\n",(unsigned long)pthread_self());
while(1){
printf("main: %d\n",g_data++);
sleep(1);
}
pthread_join(t1,NULL);
pthread_join(t2,NULL);
return 0;
}
|
如下图所示，程序启动运行以后，main、t1和t2三个线程均让g_data加一，并没有出现重复数值的情况，可见内存的确实共享的，各线程可读取、操作全局变量并将其保存。
线程同步之互斥量加锁解锁
在上面的例子中，各个线程都可以随意操作全局变量，并且从程序运行结果来看，各线程之间存在竞争关系，可能这个线程输出一条语句，下一次就会被另一个个线程打断，输出其他的信息。如果我们想要对线程的运行顺序进行控制，或者至少控制各线程之间的操作是连贯不混乱的，那么我们只需要使用互斥量控制即可
互斥量（mutex）从本质上来说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程将会被阻塞直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以对互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用。在这种方式下，每次只有一个线程可以向前运行。
在设计时需要规定所有的线程必须遵守相同的数据访问规则。只有这样，互斥机制才能正常工作。操作系统并不会做数据访问的串行化。如果允许其中的某个线程在没有得到锁的情况下也可以访问共享资源，那么即使其它的线程在使用共享资源前都获取了锁，也还是会出现数据不一致的问题。
互斥变量用pthread_mutex_t数据类型表示。在使用互斥变量前必须对它进行初始化，可以把它置为常量PTHREAD_MUTEX_INITIALIZER（只对静态分配的互斥量），也可以通过调用pthread_mutex_init函数进行初始化。如果动态地分配互斥量（例如通过调用malloc函数），那么在释放内存前需要调用pthread_mutex_destroy。
相关API
与互斥量相关的api分为两类，一类是互斥锁的创建及销毁，一类是加锁及解锁
有如下函数原型：
1
2
3
4
5
6
7
8
| int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t mutex);
int pthread_mutex_lock(pthread_mutex_t mutex);
int pthread_mutex_trylock(pthread_mutex_t mutex);
int pthread_mutex_unlock(pthread_mutex_t mutex);
|
互斥量加锁有两个函数都可以使用：pthread_mutex_lock与pthread_mutex_trylock，区别是后者不会使线程阻塞住。如果使用前者，当线程尝试加锁而互斥量已经加锁的情况下，线程会阻塞在原处指导锁被其他线程解开。下面是在上一节代码的基础上做的应用，运行程序后会发现线程ti和t2之间的输出是连贯独立的，不会打乱。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
| #include <stdio.h>
#include <pthread.h>
int g_data = 0;
pthread_mutex_t mutex;
void *func1(void *arg)
{
int i;
pthread_mutex_lock(&mutex);
for(i=0;i<5;i++){
printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
printf("t1:param is %d\n",*((int *)arg));
sleep(1);
}
pthread_mutex_unlock(&mutex);
}
void *func2(void *arg)
{
pthread_mutex_lock(&mutex);
printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
printf("t2:param is %d\n",*((int *)arg));
pthread_mutex_unlock(&mutex);
}
void *func3(void *arg)
{
pthread_mutex_lock(&mutex);
printf("t3:%ld thread is create\n",(unsigned long)pthread_self());
printf("t3:param is %d\n",*((int *)arg));
pthread_mutex_unlock(&mutex);
}
int main()
{
int ret;
int param = 100;
pthread_t t1;
pthread_t t2;
pthread_t t3;
pthread_mutex_init(&mutex, NULL);
ret = pthread_create(&t1, NULL, func1,(void *)¶m);
if(ret == 0){
printf("main:create t1 success\n");
}
ret = pthread_create(&t2, NULL, func2,(void *)¶m);
if(ret == 0){
printf("main:create t2 success\n");
}
ret = pthread_create(&t3, NULL, func3,(void *)¶m);
printf("main:%ld\n",(unsigned long)pthread_self());
pthread_join(t1,NULL);
pthread_join(t2,NULL);
pthread_mutex_destroy(&mutex);
return 0;
}
|
互斥锁限制共享资源的访问
实现效果：当func1拿到互斥量锁的权限时，一直对资源加锁并不释放，达到临界条件后退出线程
看代码学习
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
| #include <stdio.h>
#include <pthread.h>
int g_data = 0;
pthread_mutex_t mutex;
void *func1(void *arg)
{
printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
printf("t1:param is %d\n",*((int *)arg));
pthread_mutex_lock(&mutex);
while(1){
printf("t1: %d\n",g_data++);
sleep(1);
if(g_data == 3){
pthread_mutex_unlock(&mutex);
printf("t1 quit================================\n");
exit(0);
}
}
}
void *func2(void *arg)
{
printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
printf("t2:param is %d\n",*((int *)arg));
while(1){
printf("t2: %d\n",g_data);
pthread_mutex_lock(&mutex);
g_data++;
pthread_mutex_unlock(&mutex);
sleep(1);
}
}
int main()
{
int ret;
int param = 100;
pthread_t t1;
pthread_t t2;
pthread_mutex_init(&mutex,NULL);
ret = pthread_create(&t1, NULL, func1,(void *)¶m);
if(ret == 0){
printf("main:create t1 success\n");
}
ret = pthread_create(&t2, NULL, func2,(void *)¶m);
if(ret == 0){
printf("main:create t2 success\n");
}
printf("main:%ld\n",(unsigned long)pthread_self());
while(1){
printf("main: %d\n",g_data);
sleep(1);
}
pthread_join(t1,NULL);
pthread_join(t2,NULL);
pthread_mutex_destroy(&mutex);
return 0;
}
|
什么情况造成死锁
死锁的造成，简单来说就是一个线程在持有一把锁的同时等待其他线程释放一把锁，而那把锁的持有者也在等待该线程释放掉这把锁的权限。两把锁一直握在两个线程手里，谁都不肯先释放，这样就导致进程一直停滞下去，造成空耗。
在下面的示例中，创建了两个线程t1与t2，分别持有mutex和mutex1两把锁，人为造成死锁：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
| #include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int g_data = 0;
pthread_mutex_t mutex;
pthread_mutex_t mutex2;
void *func1(void *arg)
{
int i;
pthread_mutex_lock(&mutex);
sleep(1);
pthread_mutex_lock(&mutex2);
for(i=0;i<5;i++){
printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
printf("t1:param is %d\n",*((int *)arg));
sleep(1);
}
pthread_mutex_unlock(&mutex);
}
void *func2(void *arg)
{
pthread_mutex_lock(&mutex2);
sleep(1);
pthread_mutex_lock(&mutex);
printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
printf("t2:param is %d\n",*((int *)arg));
pthread_mutex_unlock(&mutex);
}
int main()
{
int ret;
int param = 100;
pthread_t t1;
pthread_t t2;
pthread_t t3;
pthread_mutex_init(&mutex, NULL);
pthread_mutex_init(&mutex2, NULL);
ret = pthread_create(&t1, NULL, func1,(void *)¶m);
if(ret == 0){
printf("main:create t1 success\n");
}
ret = pthread_create(&t2, NULL, func2,(void *)¶m);
if(ret == 0){
printf("main:create t2 success\n");
}
printf("main:%ld\n",(unsigned long)pthread_self());
pthread_join(t1,NULL);
pthread_join(t2,NULL);
pthread_mutex_destroy(&mutex);
pthread_mutex_destroy(&mutex2);
return 0;
}
|
线程条件控制实现线程同步
实现需求：一个线程通过对互斥锁的控制，实现对另一个线程运行的同步控制，比如，A线程每执行3次特定操作，B线程执行1次特定操作，当特定条件（比如某变量阈值）达到后，退出程序。
在下面的示例代码中，通过fun2，每当data达到3的时候激活func1，将cnt加一，如果cnt达到10，退出程序。示例中线程的休眠和信号激活，我们分别通过pthread_cond_wait和pthread_cond_signal函数实现。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
| #include <stdio.h>
#include <pthread.h>
int g_data = 0;
pthread_mutex_t mutex;
pthread_cond_t cond;
void *func1(void *arg)
{
printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
printf("t1:param is %d\n",*((int *)arg));
static int cnt = 0;
while(1){
pthread_cond_wait(&cond,&mutex);
printf("t1 run================================\n");
printf("t1: %d\n",g_data);
g_data = 0;
sleep(1);
if(cnt++ == 10){
exit(1);
}
}
}
void *func2(void *arg)
{
printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
printf("t2:param is %d\n",*((int *)arg));
while(1){
printf("t2: %d\n",g_data);
pthread_mutex_lock(&mutex);
g_data++;
if(g_data == 3){
pthread_cond_signal(&cond);
}
pthread_mutex_unlock(&mutex);
sleep(1);
}
}
int main()
{
int ret;
int param = 100;
pthread_t t1;
pthread_t t2;
pthread_mutex_init(&mutex,NULL);
pthread_cond_init(&cond,NULL);
pthread_create(&t1, NULL, func1,(void *)¶m);
pthread_create(&t2, NULL, func2,(void *)¶m);
pthread_join(t1,NULL);
pthread_join(t2,NULL);
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
return 0;
}
|
互斥量的初始化，除了我们常用的pthred\_mutex\_init和pthred\_cond\_init，我们还可以使用宏定义：
1
2
3
|
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
|