【操作系统】线程的使用

半生瓜的blog

发布于 2023-05-13 14:17:06

4340

发布于 2023-05-13 14:17:06

文章被收录于专栏：半生瓜のblog

线程

为什么使用线程?

使用fork创建进程以执行新的任务，该方式的代价很高——子进程将父进程的所有资源都复制一遍。
多个进程之间不会直接共享内存。
进程是系统分配资源的基本单位，线程是进程的基本执行单元，一个进程的所有任务都在线程中执行，进程想要执行任务，必须得有线程，进程至少要有一条线程，程序启动会默认开启一条线程，这条线程被称为主线程或UI线程。

什么是线程？

线程是进程内部的一个控制序列。
类比:
- 创建一个进程，就类似于克隆一个家庭，新的"家庭"与原来的家庭完全相同，但是新"家庭"和原来的家庭完全独立。
- 进程包含一个或多个线程，就像一个家庭中包含一个或多个家庭成员。
- 家庭内的各个成员同时做各自的事情，而对于家庭外部的人来说，就是这个家庭同时在做多件事情。
- 家庭内的每个成员，就是一个线程。每个家庭成员都有自己的个人资源，即线程有自己的局部变量。
- 所有的家庭成员都能共享这个家庭的资源，即同一个进程内的各个线程，都能共享当前这个进程中的全局变量，除了线程自己的局部变量外，其它资源都共享。
注意:
- 在单核处理器上，同一个时刻，只能运行一个线程。但是对于用户而言，感觉像是执行了多个线程一样，是因为各个线程在单核CPU上不断进行切换。

线程的优缺点

优点:创建线程比创建进程开销要小。
缺点:
- 多线程编程要多加小心，很容易发生错误。
- 多线程调试很困难。
补充:
- 把一个任务划分为两部分，如果在单核处理器上运行，速度不一定更快。除非能确定这个任务运行在多核处理器上，即两部分可以同时执行。

线程的应用场合

需要让用户感觉同时在做多件事情时。
- 比如:处理文档的进程，一个线程处理用户编辑，一个线程同时统计用户字数。
当一个应用程序，需要同时处理输入、计算、输出时。
- 可开3个线程，分别处理输入、计算、输出。
综上所述，即高并发编程。

线程的使用

线程的创建

pthread_create
功能:创建一个新线程。
- 同时指定该线程的属性、执行函数、执行函数的参数。
函数原型:

int  pthread_create (
  pthread_t *thread,
  pthread_attr_t *attr,
  void *(*start_routine)(void*), 
  void *arg
);

参数:
- thread:指向新的线程标识符。
- attr:用来设置新线程的属性。
  - 一般取默认属性，即该参数取NULL。
- start_routine:该线程的处理函数。
  - 该函数的返回类型和参数类型都是void*。
- arg:线程处理函数start_routine的参数。
返回值:
- 成功:返回0。
- 失败:返回错误代码。(错误代码，这里略过，其它函数也是如此。)
注意:
- 使用fork创建进程后，进程马上就启动，执行的是fork后面的代码。
- 使用pthread_create创建线程后，新线程马上就启动，执行对应的线程处理函数。

线程的终止

pthread_exit
功能:在线程函数内部调用该函数，对本线程进行终止，返回值通过参数retval指定。
函数原型:void pthread_exit (void *retval)
参数：
- retval：它指向的数据为线程退出时的返回值，如果不需要接收该线程的返回值，设置NULL即可。
参考补充:
- pthread_join(3) — Linux manual page

等待指定线程结束

pthread_join
功能:等待指定线程结束，并获取该线程的返回值。
函数原型:int pthread_join (pthread_t th,void ** thread_return);
参数:
- th:线程标识符，指定要的等待的线程。
- thread_return:指向(接收)当前线程的返回值。参数类型为void**。
返回值
- 成功:返回0。
- 失败:返回错误号。

使用线程程序的编译

定义宏:_REENTRANT——可重入
- 即:gcc -D_REENTRANT
功能:告诉编译器，编译时需要可重用功能。
- 即，在编译时，编译部分函数的可重入版本。将共享的资源给本线程独享。
注意:
- 在单线程程序中，整个程序都是顺序执行的，一个函数在同一时刻只能被一个函数调用，但是在多线程中，由于并发性，一个函数可能同时被多个函数调用，此时这个函数就成了临界资源，很容易造成调用函数时，处理结果的相互影响。
- 如果一个函数在多线程并发的环境中，每次被调用产生的结果是不确定的，我们就说这个函数是不可重入的/线程不安全的。
编译时，指定线程库。
- 即:gcc xxx -lpthread
  - 功能:使用系统默认的NPTL线程库。
    - 即，在默认路径中寻找库文件libpthread.so。默认路径为/usr/lib和usr/local/lib
一般使用如下形式即可:
- gcc mythread.c -o mythread -D_REENTRANT -lpthread

示例:

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

int my_global;
void* my_thread_handle(void* arg){
    int val;
    val =  *((int*)arg);
    printf("new thread begin,arg=%d\n",val);
    my_global += val;
    sleep(3);
    pthread_exit(&my_global);
    //下面一行不再执行
    printf("new thread end\n");
}

int main(void){
    pthread_t mythread;
    int arg;
    int ret;
    void *thread_return;
    
    arg = 100;
    my_global = 1000;
    printf("my_global=%d\n", my_global);
	printf("ready create thread...\n");
    ret = pthread_create(&mythread,0,my_thread_handle,&arg);
    if (ret != 0) {
		printf("create thread failed!\n");
		exit(1);
	}
    printf("wait thread finished...\n");
    ret = pthread_join(mythread,&thread_return);
    if (ret != 0) {
		printf("pthread_join failed!\n");
		exit(1);
	}
    printf("wait thread end, return value is %d\n", *((int*)thread_return));
    printf("my_global=%d\n", my_global);
	printf("create thread finished!\n");
    return 0;
}

线程的同步与互斥

线程的互斥:
- 指某一资源同一时间只允许一个访问者对其进行访问，具有唯一性和排它性。
- 但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
线程的同步:
- 指在互斥的基础上(大多数情况)，通过其它机制实现访问者对资源的有序访问。

问题 :同一个进程内的各个线程，共享该进程的全局变量，如果多个线程同时对某个全局变量进行访问时，就可能导致竞态。
有关竞态:多线程对共享资源的访问。
- Linux内核分析（七）----并发与竞态
- 在并发编程中我们常说的“竞态”是什么？
解决办法:对临界区使用信号量、或互斥量。
信号量和互斥量的选择:对于同步和互斥，使用信号量和互斥量都可以实现。使用时选择更符合情况的:
- 如果要求最多只允许一个线程进入临界区，则使用互斥量。
- 如果要求多个线程之间的执行顺序满足某个约束，则使用信号量。

信号量

什么是信号量？

此时所指的"信号量"是指用于同一个进程内多个线程之间的信号量。即POSIX信号量，而不是System V信号量。(用于进程之间的信号量)。
用于线程的信号量原理与用于进程之间的信号量原理相同。都有P、V操作。
信号量的表示:sem_t类型。

信号量的初始化

sem_init
功能:对信号量进行初始化。
函数原型:int sem_init (sem_t *sem， int pshared, unsigned int value);
参数:
- sem:指向要被初始化的信号量。
- pshared：
  - 0表示该信号量是该进程内使用的"局部信号量",不再被其它进程共享。
  - 非0表示该信号量可被其它进程共享，Linux不支持这种信号量。
- value:信号量的初值。>=0
返回值:
- 成功:返回0。
- 失败:返回错误码。

信号量的P操作

sem_wait
功能:信号量的P操作。-1
函数原型:int sem_wait (sem_t *sem);
参数:
- sem:要操作的信号量。
返回值:
- 成功:返回0。
- 失败:返回错误码。

信号量的V操作

sem_post
功能:信号量的V操作。+1
函数原型:int sem_post (sem_t *sem);
参数:
- sem:要操作的信号量。
返回值:
- 成功:返回0。
- 失败:返回错误码。

信号量的删除

sem_destroy
功能:删除信号量。
函数原型:int sem_destroy (sem_t *sem);
参数:
- sem:要操作的信号量。
返回值:
- 成功: 返回0。
- 失败:返回错误码。

示例:

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

#define BUFF_SIZE 80

char buff[BUFF_SIZE];
sem_t sem;

static void* str_thread_handle(void *arg) 
{
	while(1) {
		//P(sem) -1
		if (sem_wait(&sem) != 0) {
			printf("sem_wait failed!\n");
			exit(1);
		}
		
		printf("string is: %slen=%d\n", buff, strlen(buff));
		if (strncmp(buff, "end", 3) == 0) {
			break;
		}
	}
}

int main(void)
{
	int ret;
	pthread_t  str_thread;
	void *thread_return;


	ret = sem_init(&sem, 0, 0);
	if (ret != 0) {
		printf("sem_init failed!\n");
		exit(1);
	}

	ret = pthread_create(&str_thread, 0, str_thread_handle, 0);
	if (ret != 0) {
		printf("pthread_create failed!\n");
		exit(1);
	}

	while (1) {
		fgets(buff, sizeof(buff), stdin);

		//V(sem) +1 
		if (sem_post(&sem) != 0) {
			printf("sem_post failed!\n");
			exit(1);
		}
		
		if (strncmp(buff, "end", 3) == 0) {
			break;
		}
	}

	ret = pthread_join(str_thread, &thread_return);
	if (ret != 0) {
		printf("pthread_join failed!\n");
		exit(1);
	}

	ret = sem_destroy(&sem);
	if (ret != 0) {
		printf("sem_destroy failed!\n");
		exit(1);
	}

	return 0;
}

互斥量

什么是互斥量?

效果等同于初始值为1的信号量。

互斥量的初始化

pthread_mutex_init
功能:初始化互斥量。
函数原型:int pthread_mutex_init(pthread_mutex_t *mutex,pthread_mutexattr_t *attr);
参数:
- mutex:指向被初始化的互斥量。
- attr:互斥量的属性，一般取默认属性。
返回值:
- 成功:返回0。
- 失败:返回错误码。

互斥量的获取

pthread_mutex_lock
功能:获取互斥量。
函数原型:int pthread_mutex_lock (pthread_mutex_t *mutex);
参数:
- mutex:指向要操作的互斥量。
返回值:
- 成功:返回0。
- 失败:返回错误码。

互斥量的删除

pthread_mutex_destroy
功能:删除互斥量。
函数原型:int pthread_mutex_destroy (pthread_mutex_t *mutex);
参数:
- mutex:指向要操作的互斥量。
返回值:
- 成功:返回0。
- 失败:返回错误码。

示例:

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

#define BUFF_SIZE 80

int global_value = 1000;
pthread_mutex_t  lock;

static void* str_thread_handle(void *arg) 
{
	int i = 0;

	for (i=0; i<10; i++) {
		pthread_mutex_lock(&lock);

		if (global_value  > 0) {
			// work
			sleep(1);
			printf("soled ticket(%d) to ChildStation(%d)\n",
				global_value, i+1);
		}
		global_value--;
		
		pthread_mutex_unlock(&lock);
		sleep(1);
	}
}

int main(void)
{
	int ret;
	pthread_t  str_thread;
	void *thread_return;
	int i;

	

	ret = pthread_mutex_init(&lock, 0);
	if (ret != 0) {
		printf("pthread_mutex_init failed!\n");
		exit(1);
	}

	ret = pthread_create(&str_thread, 0, str_thread_handle, 0);
	if (ret != 0) {
		printf("pthread_create failed!\n");
		exit(1);
	}

	for (i=0; i<10; i++) {
		pthread_mutex_lock(&lock);
		
		if (global_value  > 0) {
			// work
			sleep(1);
			printf("soled ticket(%d) to MainStation(%d)\n",
				global_value, i+1);
		}
		global_value--;
		
		
		pthread_mutex_unlock(&lock);
		sleep(1);
	}

	ret = pthread_join(str_thread, &thread_return);
	if (ret != 0) {
		printf("pthread_join failed!\n");
		exit(1);
	}

	ret = pthread_mutex_destroy(&lock);
	if (ret != 0) {
		printf("pthread_mutex_destroy failed!\n");
		exit(1);
	}

	return 0;
}

线程的条件变量

什么是条件变量？

与互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直到某种情况发生为止，通常条件变量和互斥锁一起使用。
条件变量使我们可以睡眠来等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作:
线程因等待"条件变量的条件成立"而被挂起；
线程使"条件成立"(给出条件成立信号)。
条件的检测是在互斥锁的保护下进行的。如果条件为假，一个线程自动阻塞(挂起)，并释放等待状态改变的互斥锁。
如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。
如果两个进程共享可读写的内存，条件变量可以被用来实现这两个进程间的线程同步。

条件变量初始化

pthread_cond_init
功能:初始化条件变量
函数原型:int pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *attr);
参数:
- cond:要操作的条件变量。
- attr:设置条件变量属性。
返回值:
- 成功:返回0。
- 失败:返回错误码。

唤醒一个等待线程

pthread_cond_signal
功能:通知条件变量，唤醒一个等待者。
函数原型: int pthread_cond_signal (pthread_cond_t *cond);
参数:
- cond:要操作的条件变量(条件变量指针)。
返回值:
- 成功:返回0。
- 失败:返回错误码。

唤醒所有等待该条件变量的线程

pthread_cond_broadcast
功能:广播条件变量。
函数原型: int pthread_cond_broadcast (pthread_cond_t *cond);
参数:
- cond:要操作的条件变量。
返回值:
- 成功:返回0。
- 失败:返回错误码。

等待条件变量/超时被唤醒

pthread_cond_timedwait
功能:等待条件变量cond被唤醒，直到由一个信号或广播，或到绝对超时时间abstime，才唤醒该线程。
函数原型:int pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
参数：
- cond:要操作的条件变量:
- mutex:互斥量。
返回值:
- 成功:返回0。
- 失败:返回错误码。

等待条件变量被唤醒

pthread_cond_wait
功能:等待条件变量cond被唤醒(由一个信号或广播)。
函数原型:int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex);
参数:
- cond:要操作的条件变量。
- mutex:互斥量。
返回值:
- 成功:返回0。
- 失败:返回错误码。

释放/销毁条件变量

pthread_cond_destroy
功能:销毁条件变量。
函数原型:int pthread_cond_destroy (pthread_cond_t *cond);
参数:
- cond:要销毁的条件变量。
返回值:
- 成功:返回0。
- 失败:返回错误码。

示例：

个人理解，条件变量会为临界资源创建两道防线，第一道防线为进入等待唤醒前，第二道为进入临界区前。
条件变量与互斥量的结合。
进入到第一道防线时，pthread_mutex_lock对互斥量加锁(P操作)。
进入到第一道防线后，也就是等待被唤醒前，pthread_cond_wait首先会先将当前线程挂起，然后解锁互斥量(V操作)。
被唤醒时，pthread_cond_wait首先对互斥量加锁，然后线程才被唤醒(第二道防线也突破)，执行完临界区中的代码后，再次解锁。
如下图示中，注意:
我们默认该进程有两个额外创建的线程，线程1首先执行。
图中仅示例线程1和线程2分别执行一次。

#include <stdio.h>
#include <pthread.h>
pthread_mutex_t mutex;//互斥量
pthread_cond_t cond;//条件变量
void *thread1(void *arg){

	while (1) {
		printf("thread1 is running\n");
		pthread_mutex_lock(&mutex);//加锁
		pthread_cond_wait(&cond, &mutex);//等待时挂起，然后开锁，被唤醒时，先加锁，然后再唤醒(即执行下方代码)。。
		printf("thread1 applied the condition\n");
		pthread_mutex_unlock(&mutex);//开锁
		sleep(4);
	}
}
void *thread2(void *arg){
	while (1) {
		printf("thread2 is running\n");
		pthread_mutex_lock(&mutex);//加锁
		pthread_cond_wait(&cond, &mutex);//等待时挂起，然后开锁，被唤醒时，先加锁，然后再唤醒(即执行下方代码)。
		printf("thread2 applied the condition\n");
		pthread_mutex_unlock(&mutex);//开锁
		sleep(2);
	}
}
int main(){
	pthread_t thid1, thid2;
	printf("condition variable study!\n");
	pthread_mutex_init(&mutex, NULL);//互斥量初始化
	pthread_cond_init(&cond, NULL);//条件变量初始化
	pthread_create(&thid1, NULL, (void *)thread1, NULL);//线程1创建
	pthread_create(&thid2, NULL, (void *)thread2, NULL);//线程2创建
	do {
		pthread_cond_signal(&cond);//唤醒一个等待线程
       sleep(1);
	} while (1);
	return 0;
}