学习笔记——Linux线程

石子君

已于 2022-07-15 20:30:22 修改

阅读量158

点赞数

分类专栏：关于嵌入式文章标签： linux 学习运维

于 2022-06-22 00:33:19 首次发布

本文链接：https://blog.csdn.net/qq_44333320/article/details/125400809

版权

关于嵌入式专栏收录该内容

68 篇文章 18 订阅

订阅专栏

什么是线程

线程是进程内部的一条执行序列，一个进程至少有一条线程，称之为主线程（main方法代表的执行序列），可以通过线程库创建其他线程（给线程制定一个它要执行的函数），将创建的线程称之为函数线程。

LWP：light weight process 轻量级的进程，本质仍是进程(在Linux环境下)
进程：独立地址空间，拥有PCB
线程：也有PCB，但没有独立的地址空间(共享)
区别：在于是否共享地址空间。独居(进程)；合租(线程)。
Linux下： 线程：最小的执行单位，调度的基本单位。
进程：最小分配资源单位，可看成是只有一个线程的进程。

优点： 1. 提高程序并发性 2. 开销小 3. 数据通信、共享数据方便
缺点： 1. 库函数，不稳定 2. 调试、编写困难、gdb不支持 3. 对信号支持不好
优点相对突出，缺点均不是硬伤。Linux下由于实现方法导致进程、线程差别不是很大。

进程有独立的空间，而线程只是共享进程里面的空间，一个进程可以有多个线程，这些线程共享同一个进程的空间，一旦线程exit，那么进程也会结束。

线程和进程的区别

进程是资源分配最小单位，线程是程序执行的最小单位。
线程间的切换效率相比进程间的切换要高。
进程有自己独立的地址空间，每启动一个进程，系统都会为其分配地址空间，建立数据表来维护代码段、堆栈段和数据段，线程没有独立的地址空间，它使用相同的地址空间共享数据。
创建一个线程比进程开销小。
线程占用的资源要⽐进程少很多。
线程之间通信更方便，同一个进程下，线程共享全局变量，静态变量等数据，进程之间的通信需要以通信的方式（IPC）进行；（但多线程程序处理好同步与互斥是个难点）。
多进程程序更安全，生命力更强，一个进程死掉不会对另一个进程造成影响（源于有独立的地址空间），多线程程序更不易维护，一个线程死掉，整个进程就死掉了（因为共享地址空间）。
进程对资源保护要求高，开销大，效率相对较低，线程资源保护要求不高，但开销小，效率高，可频繁切换。

线程API详解

多线程开发在 Linux 平台上已经有成熟的 pthread 库支持。其涉及的多线程开发的最基本概念主要包含三点：线程，互斥锁，条件。其中，线程操作又分线程的创建，退出，等待 3 种。互斥锁则包括 4 种操作，分别是创建，销毁，加锁和解锁。条件操作有 5 种操作：创建，销毁，触发，广播和等待。其他的一些线程扩展概念，如信号灯等，都可以通过上面的三个基本元素的基本操作封装出来。详细请见下表：

在这里插入图片描述

与线程相关的API

线程创建

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

// 返回：若成功返回0，否则返回错误编号

当pthread_create成功返回时，由tidp指向的内存单元被设置为新创建线程的线程ID。attr参数用于定制各种不同的线程属性，暂可以把它设置为NULL，以创建默认属性的线程。

新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg。如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg参数传入。

线程退出

单个线程可以通过以下三种方式退出，在不终止整个进程的情况下停止它的控制流：

1）线程只是从启动例程中返回，返回值是线程的退出码。

2）线程可以被同一进程中的其他线程取消。

3）线程调用pthread_exit：

#include <pthread.h>
int pthread_exit(void *rval_ptr);

rval_ptr是一个无类型指针，与传给启动例程的单个参数类似。进程中的其他线程可以通过调用pthread_join函数访问到这个指针。

线程等待

#include <pthread.h>
int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号

调用这个函数的线程将一直阻塞，直到指定的线程调用pthread_exit、从启动例程中返回或者被取消。如果例程只是从它的启动例程返回i，rval_ptr将包含返回码。如果线程被取消，由rval_ptr指定的内存单元就置为PTHREAD_CANCELED。

可以通过调用pthread_join自动把线程置于分离状态，这样资源就可以恢复。如果线程已经处于分离状态，pthread_join调用就会失败，返回EINVAL。

如果对线程的返回值不感兴趣，可以把rval_ptr置为NULL。在这种情况下，调用pthread_join函数将等待指定的线程终止，但并不获得线程的终止状态。

线程脱离

一个线程或者是可汇合（joinable，默认值），或者是脱离的（detached）。当一个可汇合的线程终止时，它的线程ID和退出状态将留存到另一个线程对它调用pthread_join。脱离的线程却像守护进程，当它们终止时，所有相关的资源都被释放，我们不能等待它们终止。如果一个线程需要知道另一线程什么时候终止，那就最好保持第二个线程的可汇合状态。

pthread_detach函数把指定的线程转变为脱离状态。

#include <pthread.h>
int pthread_detach(pthread_t thread);
// 返回：若成功返回0，否则返回错误编号

本函数通常由想让自己脱离的线程使用，就如以下语句：

pthread_detach(pthread_self());

线程ID获取及比较

#include <pthread.h>
pthread_t pthread_self(void);
// 返回：调用线程的ID

对于线程ID比较，为了可移植操作，我们不能简单地把线程ID当作整数来处理，因为不同系统对线程ID的定义可能不一样。我们应该要用下边的函数：

#include <pthread.h>
int pthread_equal(pthread_t tid1, pthread_t tid2);
// 返回：若相等则返回非0值，否则返回0

对于多线程程序来说，我们往往需要对这些多线程进行同步。同步（synchronization）是指在一定的时间内只允许某一个线程访问某个资源。而在此时间内，不允许其它的线程访问该资源。我们可以通过互斥锁（mutex），条件变量（condition variable）和读写锁（reader-writer lock）来同步资源。在这里，我们暂不介绍读写锁。

demo示例1

#include <pthread.h>
#include <stdio.h>
/*
	int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
        int pthread_join(pthread_t thread, void **retval);
        void pthread_exit(void *retval);
        pthread_t pthread_self(void);

*/

void *function(void *arg){
	static int ret = 100;
	printf("t1: t1id is %ld,t1 create success\n",(unsigned long)pthread_self());
	printf("t1: param is %d\n",*((int *)arg));
	
	pthread_exit((void *)&ret);
}

int main(){
	int ret;
	pthread_t t1;
	int param = 10;
	int *pret = NULL;
	ret = pthread_create(&t1,NULL,function,(void *)&param);
 //第四个参数可以是int或者char，结构体等，这里用的是int，转为void*
	if(ret == 0){
		printf("main:thread t1 create success!\n");
	}

//	while(1);
	pthread_join(t1,(void **)&pret);	
	printf("main: mianid is %ld,pret is %d\n",(unsigned long)pthread_self,*((int *)pret));
	
//join函数会接收function的ret，通过强转int*取内容读取打印
	return 0;
}

运行结果如下：
在这里插入图片描述

demo示例2

#include <pthread.h>
#include <stdio.h>
/*
	int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
        int pthread_join(pthread_t thread, void **retval);
        void pthread_exit(void *retval);
        pthread_t pthread_self(void);

*/
int addnum = 0;

void *func1(void *arg){
	printf("t1: t1id is %ld,t1 create success\n",(unsigned long)pthread_self());
	printf("t1: param is %d\n",*((int *)arg));
	while(1){
		if(addnum == 3){	
			pthread_exit(NULL);
		}
		printf("t1: addnum is %d\n",addnum++);
//		sleep(1);
	}
}

void *func2(void *arg){
	printf("t2: t1id is %ld,t1 create success\n",(unsigned long)pthread_self());
	printf("t2: param is %d\n",*((int *)arg));
	
	while(1){
		printf("t2: addnum is %d\n",addnum);
		sleep(2);
		addnum++;
	}
}

int main(){
	int ret;
	int param = 10;

	pthread_t t1;
	pthread_t t2;
	ret = pthread_create(&t1,NULL,func1,(void *)&param);
	if(ret == 0){
		printf("main:thread t1 create success!\n");
	}

	ret = pthread_create(&t2,NULL,func2,(void *)&param);
	if(ret == 0){
		printf("main:thread t2 create success!\n");
	}
	while(1){
		printf("main: addnum is %d\n",addnum);
		sleep(2);
		addnum++;
	}
	pthread_join(t1,NULL);	
	pthread_join(t2,NULL);	
	return 0;
}

运行结果如下：

在这里插入图片描述

与互斥锁相关的API

互斥量（mutex）从本质上来说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程将会被阻塞直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以对互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用。在这种方式下，每次只有一个线程可以向前运行。

在设计时需要规定所有的线程必须遵守相同的数据访问规则。只有这样，互斥机制才能正常工作。操作系统并不会做数据访问的串行化。如果允许其中的某个线程在没有得到锁的情况下也可以访问共享资源，那么即使其它的线程在使用共享资源前都获取了锁，也还是会出现数据不一致的问题。

互斥变量用pthread_mutex_t数据类型表示。在使用互斥变量前必须对它进行初始化，可以把它置为常量PTHREAD_MUTEX_INITIALIZER（只对静态分配的互斥量），也可以通过调用pthread_mutex_init函数进行初始化。如果动态地分配互斥量（例如通过调用malloc函数），那么在释放内存前需要调用pthread_mutex_destroy。

创建及销毁互斥锁

#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。

加锁及解锁

#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，否则返回错误编号

如果线程不希望被阻塞，它可以使用pthread_mutex_trylock尝试对互斥量进行加锁。如果调用pthread_mutex_trylock时互斥量处于未锁住状态，那么pthread_mutex_trylock将锁住互斥量，不会出现阻塞并返回0，否则pthread_mutex_trylock就会失败，不能锁住互斥量，而返回EBUSY。

demo示例3

#include <pthread.h>
#include <stdio.h>
/*
	int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
        int pthread_join(pthread_t thread, void **retval);
        void pthread_exit(void *retval);
        pthread_t pthread_self(void);

	int pthread_mutex_lock(pthread_mutex_t mutex);
	int pthread_mutex_trylock(pthread_mutex_t mutex);
	int pthread_mutex_unlock(pthread_mutex_t mutex);
	int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
	int pthread_mutex_destroy(pthread_mutex_t mutex);
*/
pthread_mutex_t mutex;

void *func1(void *arg){
	int i = 0;	
	pthread_mutex_lock(&mutex);
	for(;i<5;i++){	
		printf("t1111111111\n");
	}
	pthread_mutex_unlock(&mutex);
}

void *func2(void *arg){
	int i = 0;	
	pthread_mutex_lock(&mutex);
	for(;i<5;i++){	
		printf("t2222222222\n");
	}
	pthread_mutex_unlock(&mutex);
}

void *func3(void *arg){
	int i = 0;	
	pthread_mutex_lock(&mutex);
	for(;i<5;i++){	
		printf("t3333333333\n");
	}
	pthread_mutex_unlock(&mutex);
}

int main(){
/*      int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
        int pthread_mutex_destroy(pthread_mutex_t mutex);
*/
	int ret;
	int param = 10;
	
	pthread_mutex_init(&mutex,NULL);
	
	pthread_t t1;
	pthread_t t2;
	pthread_t t3;
	ret = pthread_create(&t1,NULL,func1,(void *)&param);
	if(ret == 0){
		printf("main:thread t1 create success!\n");
	}

	ret = pthread_create(&t2,NULL,func2,(void *)&param);
	if(ret == 0){
		printf("main:thread t2 create success!\n");
	}

	ret = pthread_create(&t3,NULL,func3,(void *)&param);
	if(ret == 0){
		printf("main:thread t3 create success!\n");
	}
	pthread_join(t1,NULL);	
	pthread_join(t2,NULL);	
	pthread_join(t3,NULL);	

//	while(1);
	pthread_mutex_destroy(&mutex);
	return 0;
}

运行结果如下：
在这里插入图片描述

下面的demo是说明死锁的情况

demo示例4

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

pthread_mutex_t mutex;
pthread_mutex_t mutex2;

void *func1(void *arg){
	int i = 0;	
//	sleep(1);
	pthread_mutex_lock(&mutex);
	sleep(1);
	pthread_mutex_lock(&mutex2);
	for(;i<5;i++){	
		printf("t1111111111\n");
	}
	pthread_mutex_unlock(&mutex);
}

void *func2(void *arg){
	int i = 0;	
	pthread_mutex_lock(&mutex2);
	sleep(1);
	pthread_mutex_lock(&mutex);
	for(;i<5;i++){	
		printf("t2222222222\n");
	}
	pthread_mutex_unlock(&mutex);
}

int main(){
	int ret;
	int param = 10;
	
	pthread_mutex_init(&mutex,NULL);
	pthread_mutex_init(&mutex2,NULL);
	
	pthread_t t1;
	pthread_t t2;

	ret = pthread_create(&t1,NULL,func1,(void *)&param);
	if(ret == 0){
		printf("main:thread t1 create success!\n");
	}

	ret = pthread_create(&t2,NULL,func2,(void *)&param);
	if(ret == 0){
		printf("main:thread t2 create success!\n");
	}

	pthread_join(t2,NULL);	
	pthread_join(t1,NULL);	

//	while(1);
	pthread_mutex_destroy(&mutex);
	pthread_mutex_destroy(&mutex2);
	return 0;
}

当线程1拿到mutex锁的同时，线程2拿到了mutex2锁，但是线程1必须拿到mutex2锁才可以执行下面的代码，访问共享资源。同理，线程2也必须拿到mutex锁才行，这样的话双方就一直僵着，谁也动弹不了，没办法进行下一步的拿锁，更别提谁放锁了，由此造成了死锁，也就是demo示例4的代码所示

与条件相关的API

条件变量是线程另一可用的同步机制。条件变量给多个线程提供了一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。

条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其他线程在获得互斥量之前不会察觉到这种改变，因为必须锁定互斥量以后才能计算条件。

条件变量使用之前必须首先初始化，pthread_cond_t数据类型代表的条件变量可以用两种方式进行初始化，可以把常量PTHREAD_COND_INITIALIZER赋给静态分配的条件变量，但是如果条件变量是动态分配的，可以使用pthread_cond_destroy函数对条件变量进行去除初始化（deinitialize）。

创建及销毁条件变量

#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。

等待

#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结构指定。

触发

#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函数将唤醒等待该条件的所有进程。

注意一定要在改变条件状态以后再给线程发信号。

demo示例5

#include <pthread.h>
#include <stdio.h>
/*
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t cond);	
int pthread_cond_timedwait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex,const struct timespec *restrict abstime);
int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex);
int pthread_cond_signal(pthread_cond_t cond);
int pthread_cond_broadcast(pthread_cond_t cond);
*/
int idata = 0;
pthread_mutex_t mutex;
pthread_cond_t cond;

void *func1(void *arg){
	while(1){
		pthread_cond_wait(&cond,&mutex);
		printf("t1 run=============\n");
		printf("t1:%d\n",idata);
		idata = 0;
		sleep(1);
	}
}
void *func2(void *arg){
	while(1){
		printf("t2:%d\n",idata);
		pthread_mutex_lock(&mutex);
		idata++;
		if(idata == 3){
			pthread_cond_signal(&cond);
//			printf("debug\n");
		}
//		sleep(1);
		pthread_mutex_unlock(&mutex);
		sleep(1);
	}
}

int main(){
	int param = 10;
	
	pthread_mutex_init(&mutex,NULL);
	pthread_cond_init(&cond,NULL);

	pthread_t t1;
	pthread_t t2;
	pthread_create(&t1,NULL,func1,(void *)&param);
	pthread_create(&t2,NULL,func2,(void *)&param);
	pthread_join(t1,NULL);	
	pthread_join(t2,NULL);	

	pthread_mutex_destroy(&mutex);
	pthread_cond_destroy(&cond);
	return 0;
}

注：
在demo5示例中，当在unlock之前写sleep时，会导致线程1拿不到资源，进而不能执行。得知idata为3时，发送信号，然后休眠1秒（lock和unlock的执行是一气呵成的），此时线程1接到信号发现互斥锁还在锁定状态，又进入wait休眠等待时间，这样导致一直在执行线程2。

pthread_mutex_lock()调用时,通常会允许它立即锁定互斥锁,即使有一个线程正在等待(并且实现可以知道它).当线程2在此之后唤醒时,它会发现互斥锁已经锁定并重新进入休眠状态。
最好的解决方案是不要长时间持有互斥锁

运行结果如下：
在这里插入图片描述

补充考点

并行和并发的区别
并发(concurrency)

在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。其中两种并发关系分别是同步和互斥。（并发是指同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上有多个进程被同时执行的效果–宏观上并行，针对单核处理器）

互斥：进程间相互排斥的使用临界资源的现象，就叫互斥。
同步(synchronous)：进程之间的关系不是相互排斥临界资源的关系，而是相互依赖的关系。进一步的说明：就是前一个进程的输出作为后一个进程的输入，当第一个进程没有输出时第二个进程必须等待。具有同步关系的一组并发进程相互发送的信息称为消息或事件。（彼此有依赖关系的调用不应该同时发生，而同步就是阻止那些“同时发生”的事情）
其中并发又有伪并发和真并发，伪并发是指单核处理器的并发，真并发是指多核处理器的并发。

并行(parallelism)

在单处理器中多道程序设计系统中，进程被交替执行，表现出一种并发的外部特种；在多处理器系统中，进程不仅可以交替执行，而且可以重叠执行。在多处理器上的程序才可实现并行处理。从而可知，并行是针对多处理器而言的。并行是同时发生的多个并发事件，具有并发的含义，但并发不一定并行，也亦是说并发事件之间不一定要同一时刻发生。（同一时刻，有多条指令在多个处理器上同时执行–针对多核处理器）

同步和异步的区别

同步(synchronous)：进程之间的关系不是相互排斥临界资源的关系，而是相互依赖的关系。进一步的说明：就是前一个进程的输出作为后一个进程的输入，当第一个进程没有输出时第二个进程必须等待。具有同步关系的一组并发进程相互发送的信息称为消息或事件。
异步(asynchronous)：异步和同步是相对的，同步就是顺序执行，执行完一个再执行下一个，需要等待、协调运行。异步就是彼此独立,在等待某事件的过程中继续做自己的事，不需要等待这一事件完成后再工作。线程就是实现异步的一个方式。异步是让调用方法的主线程不需要同步等待另一线程的完成，从而可以让主线程干其它的事情。

大幅改自：https://www.cnblogs.com/xiehongfeng100/p/4620852.html#autoid-2-2-0
https://blog.csdn.net/qq_22847457/article/details/89371217

石子君

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
学习笔记——Linux线程

线程是进程内部的一条执行序列，一个进程至少有一条线程，称之为主线程（main方法代表的执行序列），可以通过线程库创建其他线程（给线程制定一个它要执行的函数），将创建的线程称之为函数线程。LWP：light weight process 轻量级的进程，本质仍是进程(在Linux环境下)进程：独立地址空间，拥有PCB线程：也有PCB，但没有独立的地址空间(共享)区别：在于是否共享地址空间。独居(进程)；合租(线程)。Linux下：线程：最小的执行单位，调度的基本单位。进程：最小分配资源单位，可看成
复制链接

扫一扫