Bagaimanakah benang Linux dicipta?

Konsep dan pelaksanaan utas

Benang ialah urutan pelaksanaan atau laluan pelaksanaan dalam satu proses.

• Dari perspektif peruntukan sumber, proses ialah unit asas peruntukan sumber oleh sistem pengendalian.

• Dari perspektif penjadualan sumber, urutan ialah unit terkecil penjadualan sumber dan unit terkecil pelaksanaan program

Pelaksanaan Urutan ialah satu set arahan tersusun - fungsi.

Urutan ialah urutan pelaksanaan dalam proses Suatu proses mempunyai sekurang-kurangnya satu utas, yang dipanggil utas utama (urutan pelaksanaan yang diwakili oleh kaedah utama boleh). dicipta melalui pustaka benang ( Tentukan fungsi untuk utas untuk dilaksanakan), dan panggil utas yang dicipta sebagai utas fungsi.

Cara melaksanakan benang

• Benang peringkat kernel (benang dicipta dan diuruskan terus oleh kernel. Walaupun overhed penciptaan adalah besar, Boleh menggunakan sumber berbilang pemproses)

• Benang peringkat pengguna (benang berbilang dicipta dan diuruskan oleh pustaka benang. Benang dilaksanakan dalam mod pengguna dan tidak dapat dikesan oleh kernel. Overhed penciptaan agak tinggi, tidak dapat menggunakan sumber berbilang pemproses)

• Benang peringkat hibrid (dilaksanakan dengan menggabungkan dua kaedah di atas, anda boleh menggunakan sumber berbilang pemproses untuk mencipta lebih banyak utas dalam ruang pengguna Benang, dengan itu dipetakan ke utas dalam ruang kernel, banyak-ke-banyak, N: M (N>>M))

Pelaksanaan sistem Linux Multi-threading

Mekanisme Linux untuk melaksanakan thread adalah sangat unik. Dari perspektif kernel, ia tidak mempunyai konsep benang.

Linux melaksanakan semua urutan sebagai proses. Kernel tidak menyediakan algoritma penjadualan khas atau mentakrifkan struktur data khas untuk mewakili benang.

Sebaliknya, urutan dilihat hanya sebagai proses yang berkongsi sumber tertentu dengan proses lain.

Setiap utas mempunyai task_struct tersendiri, jadi dalam kernel, ia kelihatan seperti proses biasa (hanya benang itu berkongsi sumber tertentu, seperti ruang alamat, dengan beberapa proses lain)

Perbezaan antara utas dan proses

• Proses ialah unit terkecil peruntukan sumber dan utas ialah unit terkecil pelaksanaan program;

  Thread Kecekapan bertukar antara proses adalah lebih tinggi daripada antara proses

• Proses mempunyai ruang alamat bebasnya sendiri Setiap kali proses dimulakan, sistem akan memperuntukkan alamat ruang untuknya dan sediakan jadual data untuk mengekalkannya segmen kod, segmen tindanan dan segmen data, utas tidak mempunyai ruang alamat bebas, mereka menggunakan ruang alamat yang sama untuk berkongsi data; >Membuat utas adalah lebih murah daripada satu proses;

• Adalah lebih mudah untuk berkomunikasi antara utas Di bawah proses yang sama, utas berkongsi pembolehubah global, pembolehubah statik dan data lain Komunikasi antara proses perlu dijalankan melalui komunikasi (IPC). ; ( Walau bagaimanapun, adalah sukar untuk program berbilang benang untuk mengendalikan penyegerakan dan pengecualian bersama dengan baik)

• Program berbilang proses adalah lebih selamat dan lebih penting Kematian satu proses tidak akan menjejaskan proses lain (daripada (dengan ruang alamat bebas), program berbilang benang lebih sukar untuk diselenggara. Jika satu utas mati, keseluruhan proses akan mati (kerana ruang alamat dikongsi);

• Proses ini mempunyai keperluan yang tinggi untuk perlindungan sumber , overhed tinggi, kecekapan yang agak rendah, keperluan perlindungan sumber benang rendah, tetapi overhed rendah, kecekapan tinggi, dan boleh ditukar dengan kerap

• Tiga konsep asas pembangunan berbilang benang

• Benang [buat, keluar, tunggu]

• Kunci Mutex [buat, musnah, kunci], buka kunci]

Syarat [buat, musnah, cetus, siarkan, tunggu]

• Penggunaan pustaka benang

• 1. Cipta benang

#include<phread.h>

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

: Lulus alamat pembolehubah jenis pthread_t Selepas penciptaan berjaya, ia digunakan untuk mendapatkan TID yang baru tercipta benang

: Atribut benang yang ditentukan menggunakan NULL secara lalai

• : Alamat fungsi utas id

• : dihantar ke benang Parameter fungsi attr

• nilai pulangan fun, kejayaan mengembalikan 0, kegagalan mengembalikan kod ralat

• argContoh kod berbilang benang

#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 menyusun kod dan melaporkan `rujukan tidak bersatu kepada ralat xxxxx beberapa kaedah dipanggil dalam program, tetapi fail di mana kaedah terletak tidak disambungkan Contohnya, situasi berikut:

Fail perpustakaan sambungan berjaya disusun dan. dilaksanakan. Ini juga dinyatakan dalam manual bantuan:

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

结论

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

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

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

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

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

函数线程在主线程结束后也随之退出，原因：主线程结束时使用的是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

注意：

Apabila utas ditetapkan sebagai utas tertanggal, dengan mengandaikan bahawa kelajuan pelaksanaan utas adalah sangat pantas pada masa ini, ia berkemungkinan akan ditamatkan sebelum pthread_create kembali selepas penamatan, nombor utas dan sumber sistem diserahkan kepada benang lain untuk digunakan, jadi panggilan buat mendapat nombor utas yang salah, jadi beberapa langkah penyegerakan mesti diambil Anda boleh memanggil fungsi pthread_cond_timedwait dalam utas yang dibuat, biarkan benang menunggu seketika, biarkan masa yang cukup untuk fungsi pthread_create kembali. , dan tetapkan masa menunggu, ya Kaedah yang biasa digunakan dalam pengaturcaraan berbilang benang. Elakkan menggunakan fungsi seperti wait() kerana ia meletakkan keseluruhan proses untuk tidur dan tidak menyelesaikan masalah penyegerakan benang.

Atas ialah kandungan terperinci Bagaimanakah benang Linux dicipta?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!