Comment les threads Linux sont-ils créés ?

Le concept et la mise en œuvre des threads

Un thread est une séquence d'exécution ou un chemin d'exécution au sein d'un processus. Un processus peut contenir plusieurs threads.

• Du point de vue de l'allocation des ressources, le processus est l'unité de base de l'allocation des ressources par le système d'exploitation.

• Du point de vue de la planification des ressources, le thread est la plus petite unité de planification des ressources et la plus petite unité d'exécution du programme

Séquence d'exécution est un ensemble d'instructions ordonnées - une fonction.

Un thread est une séquence d'exécution au sein d'un processus. Un processus a au moins un thread, appelé le thread principal (la séquence d'exécution représentée par la méthode principale. Vous pouvez créer d'autres threads via la bibliothèque de threads (indiquez le thread). une tâche qu'il veut exécuter) fonction), le thread créé est appelé un thread de fonction.

Comment les threads sont implémentés

• Threads au niveau du noyau (les threads sont directement créés et gérés par le noyau. Bien que la surcharge de création soit élevée, les ressources multiprocesseurs peuvent être utilisées)

• Au niveau de l'utilisateur threads (les threads sont créés et gérés directement par le noyau) La bibliothèque crée et gère plusieurs threads. L'implémentation des threads est en mode utilisateur et ne peut pas être détectée par le noyau. La surcharge de création est faible et les ressources des multi-processeurs ne peuvent pas être détectées. utilisé)

• Threads de niveau mixte (implémentés en combinant les deux méthodes ci-dessus, vous pouvez utiliser les ressources du multiprocesseur pour créer plus de threads dans l'espace utilisateur, mappant ainsi les threads dans l'espace du noyau, plusieurs à plusieurs , N:M (N>>M))

Linux La façon dont le système implémente le multi-threading

Le mécanisme Linux d'implémentation des threads est tout à fait unique. Du point de vue du noyau, il n'a pas la notion de threads.

Linux implémente tous les threads en tant que processus. Le noyau ne prépare pas d'algorithmes de planification spéciaux ni ne définit de structures de données spéciales pour représenter les threads.

Au lieu de cela, un thread est simplement considéré comme un processus qui partage certaines ressources avec d'autres processus.

Chaque thread a sa propre task_struct unique, donc dans le noyau, cela ressemble à un processus ordinaire (c'est juste que le thread partage certaines ressources, comme l'espace d'adressage, avec d'autres processus)

Threads et processus La différence

• Le processus est la plus petite unité d'allocation de ressources, et le thread est la plus petite unité d'exécution du programme

• L'efficacité de la commutation entre les threads est supérieure à celle de la commutation entre les processus

• Le processus a son propre espace d'adressage indépendant. Chaque fois qu'un processus est démarré, le système lui alloue un espace d'adressage et établit une table de données pour conserver le segment de code, le segment de pile et le segment de données. Un thread n'a pas d'espace d'adressage indépendant qu'il utilise. le même espace d'adressage pour partager des données ;

• Créer un fil Moins de surcharge qu'un processus

• Les threads occupent beaucoup moins de ressources que les processus.

• La communication entre les threads est plus pratique. Dans le cadre du même processus, les threads partagent des variables globales, des variables statiques et d'autres données. La communication entre les processus doit être effectuée via la communication (IPC) ; L'exclusion mutuelle est un point difficile)

• Les programmes multi-processus sont plus sûrs et plus vitaux. La mort d'un processus n'affectera pas l'autre processus (en raison de l'espace d'adressage indépendant, les programmes multi-thread sont plus difficiles à maintenir). .Un thread Si le processus meurt, le processus entier meurt (en raison de l'espace d'adressage partagé) ;

• Le processus a des exigences élevées en matière de protection des ressources, des frais généraux élevés et une efficacité relativement faible. la surcharge est faible et l'efficacité est élevée Commutation fréquente

Trois concepts de base du développement multithread

• Thread [créer, quitter, attendre]

• Verrouillage Mutex [créer, détruire, verrouiller] , déverrouiller]

• Conditions [Créer, détruire, déclencher, diffuser, attendre]

Utilisation de la bibliothèque de fils de discussion

1. Créer un fil

#include<phread.h>

int pthread_create(pthread_t *id , pthread_attr_t *attr, void(*fun)(void*), void *arg);

• id : Réussir l'adresse d'une variable de type pthread_t, Une fois la création réussie, elle est utilisée pour obtenir le TID du thread nouvellement crééid ：传递一个pthread_t类型的变量的地址，创建成功后，用来获取新创建的线程的TID

• attr：指定线程的属性 默认使用NULL

• fun：线程函数的地址

• arg：传递给线程函数的参数

• 返回值，成功返回0，失败返回错误码

多线程代码示例

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<unistd.h>

#include<pthread.h>

//声明一个线程函数
void *fun(void *);

int main()
{
	printf("main start\n");

	pthread_t id;
	//创建函数线程，并且指定函数线程要执行的函数
	int res = pthread_create(&id,NULL,fun,NULL);
	assert(res == 0);

	//之后并发运行
	int i = 0;	
	for(; i < 5; i++)
	{
		printf("main running\n");
		sleep(1);
	}

	printf("main over\n");
	exit(0);
}

//定义线程函数
void* fun(void *arg)
{
	printf("fun start\n");

	int i = 0;
	for(; i < 3;i++)
	{
		printf("fun running\n");
		sleep(1);
	}

	printf("fun over\n");
}

gcc编译代码时报`undifined reference to xxxxx错误，都是因为程序中调用了一些方法，但是没有连接该方法所在的文件，例如下面的情况：

连接库文件编译成功并执行，这一点在帮助手册中也有提示：Compile and link with -pthread

🎜🎜attr : L'attribut du thread spécifié utilise NULL par défaut 🎜🎜🎜🎜fun : L'adresse de la fonction thread 🎜🎜🎜🎜arg : paramètres passés à la fonction thread 🎜🎜🎜🎜🎜 valeur de retour 🎜, le succès renvoie 0 , l'échec renvoie le code d'erreur 🎜🎜🎜🎜🎜Exemple de code multithread 🎜🎜

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<unistd.h>

#include<pthread.h>

void *fun(void *);

int main()
{
	printf("main start\n");

	int a = 10;
	
	pthread_t id;
	int res = pthread_create(&id,NULL,fun,(void*)a);
	assert(res == 0);

	int i = 0;	
	for(; i < 5; i++)
	{
		printf("main running\n");
		sleep(1);
	}

	printf("main over\n");
	exit(0);
}


void* fun(void *arg)
{
	int b = (int)arg;
	printf("b == %d\n",b);
}

🎜gcc Lors de la compilation du code, une erreur de « référence indifiée à xxxxx » se produit car certaines méthodes sont appelées dans le programme, mais dans le fichier dans lequel se trouve le fichier. La méthode est localisée n'est pas connectée. Par exemple, la situation suivante : 🎜🎜🎜🎜Le fichier de la bibliothèque de connexion est compilé et exécuté avec succès. Ceci est également noté dans le manuel d'aide : Compiler et lier avec -pthread🎜

比较两次运行的结果发现前三条执行语句时一样的

结论

• 创建线程并执行线程函数，和调用函数是完全不同的概念。

• 主线程和函数线程是并发执行的。

• 线程提前于主线程结束时，不会影响主线程的运行

• 主线程提前于线程结束时，整个进程都会结束，其他线程也会结束

• 创建函数线程后，哪个线程先被执行是有操作系统的调度算法和机器环境决定。

函数线程在主线程结束后也随之退出，原因：主线程结束时使用的是exit方法，这个方法结束的是进程。

然而修改代码为：pthread_exit(NULL);此时主线程结束，函数线程会继续执行直至完成。即便如此，我们还是不推荐大家手动结束主线程，我们更喜欢让主线程等待一会。

给线程函数传参

①值传递

将变量的值直接转成void*类型进行传递

因为线程函数接受的是一个void*类型的指针，只要是指针，32位系统上都是4个字节，值传递就只能传递小于或等于4字节的值。

代码示例

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<unistd.h>

#include<pthread.h>

void *fun(void *);

int main()
{
	printf("main start\n");

	int a = 10;
	
	pthread_t id;
	int res = pthread_create(&id,NULL,fun,(void*)a);
	assert(res == 0);

	int i = 0;	
	for(; i < 5; i++)
	{
		printf("main running\n");
		sleep(1);
	}

	printf("main over\n");
	exit(0);
}


void* fun(void *arg)
{
	int b = (int)arg;
	printf("b == %d\n",b);
}

②地址传递

将变量（所有类型）的地址强转成void*类型进行传递，就和在普通函数调用传递变量的地址相似。

主线程和函数线程通过这个地址就可以共享地址所指向的空间。

一个进程内的所有线程是共享这个进程的地址空间。

多线程下进程的4G虚拟地址空间

一个进程内的所有线程对于全局数据，静态数据，堆区空间都是共享的。

线程之间传递数据很简单，但是随之带来的问题就是线程并发运行时无法保证线程安全。

代码示例

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<unistd.h>

#include<pthread.h>

int gdata = 10; //.data

void *fun(void *);

int main()
{
	int *ptr = (int *)malloc(4);//.heap
    *ptr = 10;
	
	pthread_t id;
	int res = pthread_create(&id,NULL,fun,(void*)ptr);
	assert(res == 0);

    sleep(2);//等待两秒，保证函数线程已经讲数据修改

	printf("main : gdata == %d\n",gdata);
    printf("main : *ptr = %d\n",*ptr);

	exit(0);
}


void *fun(void *arg)
{
	int *p = (int*)arg;

    gdata = 20000;
    *p = 20;

	printf("fun over\n");
}

线程库中的其他方法

线程退出的三种方式：

• 线程从执行函数返回，返回值是线程的退出码；

• 线程被同一进程的其他线程取消；

• 调用pthread_exit（）函数退出；

等待线程终止

int pthread_join(pthread_t thread, void **retval);
args:
    pthread_t thread: 被连接线程的线程号，该线程必须位于当前进程中，而且不得是分离线程
    void **retval :该参数不为NULL时，指向某个位置 在该函数返回时，将该位置设置为已终止线程的退出状态
    return:
    线程连接的状态，0是成功，非0是失败

当A线程调用线程B并 pthread_join() 时，A线程会处于阻塞状态，直到B线程结束后，A线程才会继续执行下去。当 pthread_join() 函数返回后，被调用线程才算真正意义上的结束，它的内存空间也会被释放（如果被调用线程是非分离的）。

这里有三点需要注意：

• 系统仅释放系统空间，你需要手动清除程序分配的空间，例如由 malloc() 分配的空间。

• 2.一个线程只能被一个线程所连接。

• 3.被连接的线程必须是非分离的，否则连接会出错。所以可以看出pthread_join()有两种作用：1-用于等待其他线程结束：当调用 pthread_join() 时，当前线程会处于阻塞状态，直到被调用的线程结束后，当前线程才会重新开始执行。2-对线程的资源进行回收：如果一个线程是非分离的（默认情况下创建的线程都是非分离）并且没有对该线程使用 pthread_join() 的话，该线程结束后并不会释放其内存空间，这会导致该线程变成了“僵尸线程”。

等待指定的子线程结束

• 等待thread（）指定的线程退出，线程未退出时，该方法阻塞

• result接收thread线程退出时，指定退出信息

int pthread_join(pthread_t id,void **result)//调用这个方法的线程会阻塞，直到等待线程结束

代码演示：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<unistd.h>

#include<pthread.h>

int main()
{
	printf("main start\n");

	pthread_t id;
	int res = pthread_create(&id,NULL,fun,NULL);
	assert(res == 0);

	//之后并发运行
	int i = 0;	
	for(; i < 5; i++)
	{
		printf("main running\n");
		sleep(1);
	}
	
	char *s = NULL;
	pthread_join(id,(void **)&s);
	printf("join : s = %s\n",s);
	
	exit(0);
}

//定义线程函数
void* fun(void *arg)
{
	printf("fun start\n");

	int i = 0;
	for(; i < 10;i++)
	{
		printf("fun running\n");
		sleep(1);
	}

	printf("fun over\n");

	pthread_exit("fun over");//将该字符常量返回给主线程
}

此时，主线程完成五次输出，就会等待子线程结束，阻塞等待，子线程结束后，最后，主线程打印join：s = fun over

关于exit和join的一些详细说明：

• 线程自己运行结束，或者调用pthread_exit结束，线程都会释放自己独有的空间资源；

• 若线程是非分离的，线程会保留线程ID号，直到其他线程通过joining这个线程确认其已经死亡，join的结果是joining线程得到已终止线程的退出状态，已终止线程将消失；

• 若线程是分离的，不需要使用pthread_exit（），线程自己运行结束，线程结束就会自己释放所有空间资源（包括线程ID号）；

• 子线程最终一定要使用pthread_join（）或者设置为分离线程来结束线程，否则线程的资源不会被完全释放（使用取消线程功能也不能完全释放）；

• 主线程运行pthrea_exit()，会结束主线程，但是不会结束子线程；

• 主线程结束，则整个程序结束，所以主线程最好使用pthread_join函数等待子线程结束，使用该函数一个线程可以等待多个线程结束；

• 使用pthread_join函数的线程将会阻塞，直到被join的函数线程结束，该函数返回，但是它对被等待终止的线程运行没有影响；

• 如果子线程使用exit()则可以结束整个进程；

线程属性

线程具有的属性可以在线程创建的时候指定；

——pthread_create()函数的第二个参数(pthread_attr_t *attr)表示线程的属性，在以前的例子中将其值设为NULL,也就是采用默认属性，线程的多项属性都是可以修改的，这些属性包括绑定属性，分离属性，堆栈属性，堆栈大小，优先级。

系统默认的是非绑定，非分离，缺省1M的堆栈以及父子进程优先级相同

线程结构如下：

typedef struct
{
    int             detachstate;     //线程的分离状态
    int             schedpolicy;    //线程调度策略
    struct sched_param  schedparam; //线程的调度参数
    int             inheritsched;   //线程的继承性
    int             scope;      //线程的作用域
    size_t          guardsize;  //线程栈末尾的警戒缓冲区大小
    int             stackaddr_set; //线程的栈设置
    void*           stackaddr;  //线程栈的位置
    size_t          stacksize;  //线程栈的大小
} pthread_attr_t;

每一个属性都有对应的一些函数，用于对其进行查看和修改，下面分别介绍：

线程属性初始化

初始化和去初始化分别对应于如下的两个函数：

#include <pthread.h>

①int pthread_attr_init(pthread_attr_t *attr);
②it pthread_attr_destroy(pthread_attr_t *attr);

①功能：

• 初始化线程属性函数，注意：应先初始化线程属性，再pthread_create创建线程

参数：

• attr：线程属性结构体

返回值：

• 成功：0

• 失败：-1

②功能：

• 销毁线程属性所占用的资源函数

参数：

• attr：线程属性结构体

返回值：

• 成功：0

• 失败：-1

线程分离

线程的分离状态决定一个线程以什么样的方式来终止自己，这个在之前我们也说过了。

• 默认状态下，线程是非分离状态，意味着原有的线程会等待所创建的线程结束。只有在pthread_join()函数返回后，才能释放创建的线程占用的系统资源，也才能视作该线程终止。

• 若线程运行结束且无其他线程阻塞等待，则该线程处于分离状态，此时系统资源将立即被释放。应该根据自己的需要，选择适当的分离状态。

相关API如下：

#include <pthread.h>

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

功能：设置线程分离状态

参数：

• attr：已初始化的线程属性

• detachstate： 分离状态

PTHREAD_CREATE_DETACHED（分离线程）

PTHREAD_CREATE_JOINABLE（非分离线程）

返回值：

• 成功：0

• 失败：非0

int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);

功能：获取线程分离状态

参数：

• attr：已初始化的线程属性detachstate： 分离状态

PTHREAD_CREATE_DETACHED（分离线程）

PTHREAD _CREATE_JOINABLE（非分离线程）

返回值：

• 成功：0

• 失败：非0

注意：

Lorsqu'un thread est défini comme thread détaché, en supposant que la vitesse d'exécution du thread est très rapide à ce moment-là, il est susceptible de se terminer avant le retour de pthread_create après la fin, le numéro de thread et les ressources système sont transférés à d'autres threads ; , de sorte que l'appel de create obtiendra un mauvais numéro de thread, donc certaines mesures de synchronisation doivent être prises. Vous pouvez appeler la fonction pthread_cond_timedwait dans le thread créé, laisser le thread attendre un moment, laisser suffisamment de temps pour que la fonction pthread_create revienne, et définissez un temps d'attente Méthodes couramment utilisées dans la programmation des threads. Évitez d'utiliser des fonctions comme wait() car elles mettent l'ensemble du processus en veille et ne résolvent pas les problèmes de synchronisation des threads.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!