Linux多线程的学习
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录
- 前言
- 一、线程是什么？
- 1.线程和进程的区别
- 2.多线程的优势
- 二、线程的API介绍
- 1.线程的自身API介绍
- a.线程创建pthread_create
- b.线程退出pthread_exit
- c.线程等待pthread_join
- 2.线程的互质锁API
- a.创建及销毁互斥锁
- b.加锁及解锁
- 3.与条件变量相关API
- 1. 创建及销毁条件变量
- 2. 等待
- 3. 触发
- 二、创建简单的线程示例
- a.创建一个线程实列
- b.实验多线程共享空间
- c.使用互斥锁结合上一问
- d.使用条件变量
- 总结
前言
进程——资源分配的最小单位，线程——程序执行的最小单位
提示：以下是本篇文章正文内容，下面案例可供参考
一、线程是什么？
1.线程和进程的区别
进程： 是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。
线程： 是操作系统能够进行运算调度的最小单位。线程包含了表示进程内执行环境必须的信息，其中包括进程中表示线程的线程ID、一组寄存器值、栈、调度优先级和策略、信号屏蔽字、errno常量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本、程序的全局内存和堆内存、栈以及文件描述符。
进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。
线程有自己的堆栈和局部变量，但线程没有单独的地址空间，
一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。
但对于一些要求同时进行并且又要共享某些变量的并发操作，
只能用线程，不能用进程。
2.多线程的优势
a.多线程是一种非常"节俭"的多任务操作方式。在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计，总的说来，一个进程的开销大约是一个线程开销的30倍左右`，当然，在具体的系统上，这个数据可能会有较大的区别。
b.线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。
二、线程的API介绍
1.线程的自身API介绍
a.线程创建pthread_create
#include <pthread.h>
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。(pthread_t,在使用printf打印时,应转换为u类型unsigned long。)
attr: 参数用于定制各种不同的线程属性，暂可以把它设置为NULL，以创建默认属性的线程。
start_rtn: 新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg。如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把这个结构体的地址作为arg参数传入。
b.线程退出pthread_exit
单个线程可以通过以下三种方式退出，在不终止整个进程的情况下停止它的控制流：
1）线程只是从启动例程中返回，返回值是线程的退出码。
2）线程可以被同一进程中的其他线程取消。
3）线程调用pthread_exit：
#include <pthread.h>
int pthread_exit(void *rval_ptr);
(这里需要注意：给rval_ptr在函数中传的值必须使用static来进行变量赋值否则值将会消失)
c.线程等待pthread_join
#include <pthread.h>
int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号
如果对线程的返回值不感兴趣，可以把rval_ptr置为NULL。在这种情况下，调用pthread_join函数将等待指定的线程终止，但并不获得线程的终止状态。
感兴趣就可以设置一个指针然后将其地址给予这个参数，后面取出就可以看到其值。
2.线程的互质锁API
互斥量（mutex）从本质上来说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程将会被阻塞直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以对互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用。在这种方式下，每次只有一个线程可以向前运行。
在设计时需要规定所有的线程必须遵守相同的数据访问规则。只有这样，互斥机制才能正常工作。操作系统并不会做数据访问的串行化。如果允许其中的某个线程在没有得到锁的情况下也可以访问共享资源，那么即使其它的线程在使用共享资源前都获取了锁，也还是会出现数据不一致的问题。
互斥变量用pthread_mutex_t数据类型表示。在使用互斥变量前必须对它进行初始化，可以把它置为常量PTHREAD_MUTEX_INITIALIZER（只对静态分配的互斥量），也可以通过调用pthread_mutex_init函数进行初始化。如果动态地分配互斥量（例如通过调用malloc函数），那么在释放内存前需要调用pthread_mutex_destroy。
a.创建及销毁互斥锁
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t mutex);
// 返回：若成功返回0，否则返回错误编号
要用默认的属性初始化互斥量，只需把attr设置为NULL。
b.加锁及解锁
#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);//加锁
int pthread_mutex_trylock(pthread_mutex_t* mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);//解锁
// 返回：若成功返回0，否则返回错误编号
3.与条件变量相关API
条件变量是线程另一可用的同步机制。条件变量给多个线程提供了一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。
条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其他线程在获得互斥量之前不会察觉到这种改变，因为必须锁定互斥量以后才能计算条件。
条件变量使用之前必须首先初始化，pthread_cond_t数据类型代表的条件变量可以用两种方式进行初始化，可以把常量PTHREAD_COND_INITIALIZER赋给静态分配的条件变量，但是如果条件变量是动态分配的，可以使用pthread_cond_destroy函数对条件变量进行去除初始化（deinitialize）。
1. 创建及销毁条件变量
#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t cond);
// 返回：若成功返回0，否则返回错误编号
除非需要创建一个非默认属性的条件变量，否则pthread_cont_init函数的attr参数可以设置为NULL。
2. 等待
#include <pthread.h>
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);//一般直接用第一个即可
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, cond struct timespec *restrict timeout);
// 返回：若成功返回0，否则返回错误编号
pthread_cond_wait等待条件变为真。如果在给定的时间内条件不能满足，那么会生成一个代表一个出错码的返回变量。传递给pthread_cond_wait的互斥量对条件进行保护，调用者把锁住的互斥量传给函数。函数把调用线程放到等待条件的线程列表上，然后对互斥量解锁，这两个操作都是原子操作。这样就关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道，这样线程就不会错过条件的任何变化。pthread_cond_wait返回时，互斥量再次被锁住。
pthread_cond_timedwait函数的工作方式与pthread_cond_wait函数类似，只是多了一个timeout。timeout指定了等待的时间，它是通过timespec结构指定。
3. 触发
#include <pthread.h>
int pthread_cond_signal(pthread_cond_t cond);
int pthread_cond_broadcast(pthread_cond_t cond);
// 返回：若成功返回0，否则返回错误编号
这两个函数可以用于通知线程条件已经满足。pthread_cond_signal函数将唤醒等待该条件的某个线程，而pthread_cond_broadcast函数将唤醒等待该条件的所有进程。
注意一定要在改变条件状态以后再给线程发信号。
二、创建简单的线程示例
a.创建一个线程实列
这里是创建线程传入了多个参数，将结构体传入后再创建一个结构体指针对其进行赋值就可完成操作。
#include <pthread.h>
#include<stdio.h>
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
/*当pthread_create成功返回时，由tidp指向的内存单元被设置为新创建线程的线程ID。attr参数用于定制各种不同的线程属性，暂可以把它设置为NULL，以创建默认属性的线程。
新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg。如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg参数传入。*/
//int pthread_join(pthread_t thread, void **rval_ptr);
//int pthread_exit(void *rval_ptr);
pthread_t pth_ID;
struct all
{
int *agg;
int kiki;
};
void *func1(void * age)
{
struct all *S1=age;
static int canshu=999;//；这里必须是有static否则会指向一个乱七八糟数值
//int *pat=S1->agg;
printf("t1线程中的pid=%u\n",(unsigned int)pthread_self());
printf("t1中的age=%d\n",*(S1->agg));
printf("t1中的kiki=%d\n",S1->kiki);
pthread_exit((void *)&canshu);
}
int main()
{
int cnt;
int *canshu;
int pat=100;
struct all S1;
S1.agg=&pat;
S1.kiki=pat*2;
cnt=pthread_create(&pth_ID,NULL,func1,&S1);
if(cnt!=0)
{
printf("创建func1线程出错\n");
}
printf("main线程中号：%u\n",(unsigned int)pthread_self());
pthread_join(pth_ID,(void **)&canshu);
printf("此时的线程回收值为%d\n",*canshu);
return 0;
}
结果展示：
xsn@xsn-virtual-machine:~/桌面/test/pthread$ ./a.out
main线程中号：4039448384
t1线程中的pid=4039444224
t1中的age=100
t1中的kiki=200
此时的线程回收值为999
b.实验多线程共享空间
本实验就是通过一个全局变量在main的线程中进行赋值，看在其他线程中的结果。
代码示例：
#include<stdio.h>
#include <pthread.h>
#include <unistd.h>
/
pthread_t pth_ID;
unsigned int cmt=0;
struct all
{
int *agg;
int kiki;
};
void *func1(void * age)
{
struct all *S1=age;
static int canshu=999;//；这里必须是有static否则会指向一个乱七八糟数值
//int *pat=S1->agg;
while(1){
printf(" \n");
printf("t1线程中的pid=%u\n",(unsigned int)pthread_self());
printf("t1中cnt的值为%d\n",cmt);
printf("t1中的age=%d\n",*(S1->agg));
printf(" \n");
sleep(1);
}
//printf("t1中的age=%d\n",*(S1->agg));
// printf("t1中的kiki=%d\n",S1->kiki);
//pthread_exit((void *)&canshu);
}
void *func2(void * age)
{
//struct all *S1=age;
//static int canshu=999;//；这里必须是有static否则会指向一个乱七八糟数值
//int *pat=S1->agg;
while(1){
printf(" \n");
printf("t2线程中的pid=%u\n",(unsigned int)pthread_self());
printf("t2中cmt的值为%d\n",cmt);
printf("t2中age的值为%d\n",*(int *)age);
printf(" \n");
sleep(1);
}
// printf("t1中的age=%d\n",*(S1->agg));
// printf("t1中的kiki=%d\n",S1->kiki);
//pthread_exit((void *)&canshu);
}
int main()
{
int cnt,cnt1;
int *canshu;
int pat=100;
struct all S1;
S1.agg=&pat;
S1.kiki=pat*2;
pthread_t pth_ID2;
cnt=pthread_create(&pth_ID,NULL,func1,&S1);
cnt1=pthread_create(&pth_ID2,NULL,func2,&pat);
if(cnt!=0)
{
printf("创建func1线程出错\n");
}
if(cnt1!=0)
{
printf("创建func2线程出错\n");
}
while(1)
{
cmt++;
printf(" \n");
printf("main线程中号：%u\n",(unsigned int)pthread_self());
printf("main线程中cmt=%d\n",cmt);
printf(" \n");
sleep(1);
}
// pthread_join(pth_ID,(void **)&canshu);
//printf("此时的线程回收值为%d\n",*canshu);
return 0;
}
结果展示：
main线程中号：3259029312
main线程中cmt=1
t2线程中的pid=3250632448
t2中cmt的值为1
t2中age的值为100
t1线程中的pid=3259025152
t1中cnt的值为1
t1中的age=100
main线程中号：3259029312
main线程中cmt=2
t1线程中的pid=3259025152
t1中cnt的值为2
t1中的age=100
t2线程中的pid=3250632448
t2中cmt的值为2
t2中age的值为100
t1线程中的pid=3259025152
t1中cnt的值为3
t1中的age=100
t2线程中的pid=3250632448
main线程中号：3259029312
main线程中cmt=3
t2中cmt的值为3
t2中age的值为100
main线程中号：3259029312
main线程中cmt=4
t2线程中的pid=3250632448
t2中cmt的值为4
t2中age的值为100
t1线程中的pid=3259025152
t1中cnt的值为4
t1中的age=100
main线程中号：3259029312
main线程中cmt=5
t2线程中的pid=3250632448
t2中cmt的值为5
t2中age的值为100
t1线程中的pid=3259025152
t1中cnt的值为5
t1中的age=100
main线程中号：3259029312
main线程中cmt=6
t1线程中的pid=3259025152
t1中cnt的值为6
t1中的age=100
t2线程中的pid=3250632448
t2中cmt的值为6
t2中age的值为100
^Z
[1]+ 已停止 ./a.out
当然从结果能看出到有一些bug，t2线程中有一次被main的主线程打断了这里就需要用到互斥锁。
c.使用互斥锁结合上一问
从上述的b列子中，可以看到一个bug三个线程都有可能会被打断，想要修改这个bug需要用到互斥锁，在每个线程开始时加一个取锁，在结束时放回锁即可。
代码示例：
#include<stdio.h>
#include <pthread.h>
#include <unistd.h>
/
pthread_t pth_ID;
unsigned int cmt=0;
pthread_mutex_t mutex,mutex2;
struct all
{
int *agg;
int kiki;
};
void *func1(void * age)
{
struct all *S1=age;
static int canshu=999;//；这里必须是有static否则会指向一个乱七八糟数值
//int *pat=S1->agg;
while(1){
pthread_mutex_lock(&mutex);
printf(" \n");
printf("t1线程中的pid=%u\n",(unsigned int)pthread_self());
printf("t1中cnt的值为%d\n",cmt);
printf("t1中的age=%d\n",*(S1->agg));
printf(" \n");
pthread_mutex_unlock(&mutex);
sleep(1);
}
//printf("t1中的age=%d\n",*(S1->agg));
// printf("t1中的kiki=%d\n",S1->kiki);
//pthread_exit((void *)&canshu);
}
void *func2(void * age)
{
//struct all *S1=age;
//static int canshu=999;//；这里必须是有static否则会指向一个乱七八糟数值
//int *pat=S1->agg;
while(1){
pthread_mutex_lock(&mutex);
printf(" \n");
printf("t2线程中的pid=%u\n",(unsigned int)pthread_self());
printf("t2中cmt的值为%d\n",cmt);
printf("t2中age的值为%d\n",*(int *)age);
printf(" \n");
pthread_mutex_unlock(&mutex);
sleep(1);
}
// printf("t1中的age=%d\n",*(S1->agg));
// printf("t1中的kiki=%d\n",S1->kiki);
//pthread_exit((void *)&canshu);
}
int main()
{
int cnt,cnt1;
int *canshu;
int pat=100;
struct all S1;
S1.agg=&pat;
S1.kiki=pat*2;
pthread_t pth_ID2;
// int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
/*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_init(&mutex, NULL);
pthread_mutex_init(&mutex2, NULL);
cnt=pthread_create(&pth_ID,NULL,func1,&S1);
cnt1=pthread_create(&pth_ID2,NULL,func2,&pat);
if(cnt!=0)
{
printf("创建func1线程出错\n");
}
if(cnt1!=0)
{
printf("创建func2线程出错\n");
}
while(1)
{
pthread_mutex_lock(&mutex);
cmt++;
printf(" \n");
printf("main线程中号：%u\n",(unsigned int)pthread_self());
printf("main线程中cmt=%d\n",cmt);
printf(" \n");
pthread_mutex_unlock(&mutex);
sleep(1);
}
// pthread_join(pth_ID,(void **)&canshu);
//printf("此时的线程回收值为%d\n",*canshu);
return 0;
}
结果展示：
main线程中号：4213958464
main线程中cmt=1
t2线程中的pid=4205561600
t2中cmt的值为1
t2中age的值为100
t1线程中的pid=4213954304
t1中cnt的值为1
t1中的age=100
main线程中号：4213958464
main线程中cmt=2
t2线程中的pid=4205561600
t2中cmt的值为2
t2中age的值为100
t1线程中的pid=4213954304
t1中cnt的值为2
t1中的age=100
main线程中号：4213958464
main线程中cmt=3
t2线程中的pid=4205561600
t2中cmt的值为3
t2中age的值为100
t1线程中的pid=4213954304
t1中cnt的值为3
t1中的age=100
main线程中号：4213958464
main线程中cmt=4
t2线程中的pid=4205561600
t2中cmt的值为4
t2中age的值为100
t1线程中的pid=4213954304
t1中cnt的值为4
t1中的age=100
main线程中号：4213958464
main线程中cmt=5
t2线程中的pid=4205561600
t2中cmt的值为5
t2中age的值为100
t1线程中的pid=4213954304
t1中cnt的值为5
t1中的age=100
main线程中号：4213958464
main线程中cmt=6
t2线程中的pid=4205561600
t2中cmt的值为6
t2中age的值为100
t1线程中的pid=4213954304
t1中cnt的值为6
t1中的age=100
main线程中号：4213958464
main线程中cmt=7
t2线程中的pid=4205561600
t2中cmt的值为7
t2中age的值为100
t1线程中的pid=4213954304
t1中cnt的值为7
t1中的age=100
main线程中号：4213958464
main线程中cmt=8
t2线程中的pid=4205561600
t2中cmt的值为8
t2中age的值为100
t1线程中的pid=4213954304
t1中cnt的值为8
t1中的age=100
^Z
[5]+ 已停止
d.使用条件变量
使用条件变量让线程一在全局变量等于3的时候去调用。
代码示例：
#include<stdio.h>
#include <pthread.h>
#include <unistd.h>
pthread_t pth_ID;
unsigned int cmt=0;
pthread_mutex_t mutex,mutex2;
pthread_cond_t cond;
struct all
{
int *agg;
int kiki;
};
void *func1(void * age)
{
struct all *S1=age;
static int canshu=999;//；这里必须是有static否则会指向一个乱七八糟数值
//int *pat=S1->agg;
while(1){
pthread_cond_wait(&cond, &mutex);
cmt=0;
printf("======func1 run===================\n");
printf("t1线程中的pid=%u\n",(unsigned int)pthread_self());
printf("t1中cmt的值为%d\n",cmt);
printf("t1中的age=%d\n",*(S1->agg));
printf("======func1 quite===================\n");
printf(" \n");
sleep(1);
}
//printf("t1中的age=%d\n",*(S1->agg));
// printf("t1中的kiki=%d\n",S1->kiki);
//pthread_exit((void *)&canshu);
}
void *func2(void * age)
{
//struct all *S1=age;
//static int canshu=999;//；这里必须是有static否则会指向一个乱七八糟数值
//int *pat=S1->agg;
while(1){
pthread_mutex_lock(&mutex);
cmt++;
if(cmt==3){pthread_cond_signal(&cond); }
printf("========func2 run=======================\n");
printf("t2线程中的pid=%u\n",(unsigned int)pthread_self());
printf("t2中cmt的值为%d\n",cmt);
printf("t2中age的值为%d\n",*(int *)age);
printf("========func2 quite=======================\n");
printf(" \n");
pthread_mutex_unlock(&mutex);
sleep(1);
}
// printf("t1中的age=%d\n",*(S1->agg));
// printf("t1中的kiki=%d\n",S1->kiki);
//pthread_exit((void *)&canshu);
}
int main()
{
int cnt,cnt1;
int *canshu;
int pat=100;
struct all S1;
S1.agg=&pat;
S1.kiki=pat*2;
pthread_t pth_ID2;
// int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
/*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_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
pthread_cond_init(&cond,NULL);
pthread_mutex_init(&mutex, NULL);
pthread_mutex_init(&mutex2, NULL);
cnt=pthread_create(&pth_ID,NULL,func1,&S1);
cnt1=pthread_create(&pth_ID2,NULL,func2,&pat);
if(cnt!=0)
{
printf("创建func1线程出错\n");
}
if(cnt1!=0)
{
printf("创建func2线程出错\n");
}
while(1);
/*{
pthread_mutex_lock(&mutex);
cmt++;
printf(" \n");
printf("main线程中号：%u\n",(unsigned int)pthread_self());
printf("main线程中cmt=%d\n",cmt);
printf(" \n");
pthread_mutex_unlock(&mutex);
sleep(1);
}*/
// pthread_join(pth_ID,(void **)&canshu);
//printf("此时的线程回收值为%d\n",*canshu);
return 0;
}
结果展示：
xsn@xsn-virtual-machine:~/桌面/test/pthread$ ./a.out
========func2 run=======================
t2线程中的pid=798971648
t2中cmt的值为1
t2中age的值为100
========func2 quite=======================
========func2 run=======================
t2线程中的pid=798971648
t2中cmt的值为2
t2中age的值为100
========func2 quite=======================
========func2 run=======================
t2线程中的pid=798971648
t2中cmt的值为3
t2中age的值为100
========func2 quite=======================
======func1 run===================
t1线程中的pid=807364352
t1中cmt的值为0
t1中的age=100
======func1 quite===================
========func2 run=======================
t2线程中的pid=798971648
t2中cmt的值为1
t2中age的值为100
========func2 quite=======================
========func2 run=======================
t2线程中的pid=798971648
t2中cmt的值为2
t2中age的值为100
========func2 quite=======================
========func2 run=======================
t2线程中的pid=798971648
t2中cmt的值为3
t2中age的值为100
========func2 quite=======================
======func1 run===================
t1线程中的pid=807364352
t1中cmt的值为0
t1中的age=100
======func1 quite===================
^Z
[6]+ 已停止 ./a.out