Grundlegende Thread-Programmierung
1. Einführung in Threads
Um die Leerlaufzeit des Prozessors weiter zu reduzieren, Multiprozessoren zu unterstützen und den Aufwand für die Kontextumschaltung zu verringern, erscheint im Prozess des Evolutionsthreads ein anderes Konzept. Es ist eine unabhängige Lauflinie innerhalb des Prozesses, die kleinste Einheit der Prozessorplanung, und wird auch als leichter Prozess bezeichnet. Aufgrund der hohen Effizienz und Manövrierfähigkeit von Threads werden sie häufig in der Entwicklung eingebetteter Systeme verwendet.
Zu den Ressourcen, die von mehreren Threads in einem Prozess gemeinsam genutzt werden, gehören: ausführbare Anweisungen, statische Daten, im Prozess geöffnete Dateideskriptoren, aktuelles Arbeitsverzeichnis, Benutzer-ID und Benutzergruppen-ID
. Zu den für jeden Thread privaten Ressourcen gehören: Thread-ID (TID) ), PC (Programmzähler) und zugehörige Register, Stapel, Fehlernummer, Priorität, Ausführungsstatus und Attribute
2. Programmieranweisungen
Unter Linux ist die allgemeine pthread-Thread-Bibliothek eine Reihe allgemeiner Thread-Bibliotheken, die von POSIX vorgeschlagen werden und eine gute Portabilität aufweisen. Die pthread-Thread-Bibliothek bietet die folgenden grundlegenden Operationen:
- Thread erstellen: Bestimmen Sie den Einstiegspunkt für den Aufruf der Thread-Funktion und verwenden Sie die Funktion pthread_create ()
- Thread recyceln: Geben Sie die vom Thread belegten Ressourcen nach dem Beenden frei. Verwenden Sie die Funktion pthread_join ()
- Thread beenden: Thread beenden ist das aktive Verhalten des Threads. Verwenden Sie die Funktion pthread_exit ()
- Beenden Sie einen anderen Thread in einem Thread: Verwenden Sie die Funktion pthread_cancel ()
3. Funktionseinführung
pthread_create ()
/*****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；失败：返回错误码
pthread_join ()
/*****pthread_join()函数*****/
函数原型：int pthread_join(pthread_t th,void **thread_return)
传 入 值：th 等待线程的标识符
thread_return 用户定义的指针，用来存储被等待线程结束时的返回值（不为NULL时）
返 回 值：成功：返回0；失败：返回错误码
pthread_exit ()
/*****pthread_exit()函数*****/
函数原型：void pthread_exit(void *retval)
传 入 值：retval 线程结束时的返回值，可由其他函数如pthread_join()来获取
pthread_cancel ()
/*****pthread_cancel()函数*****/
函数原型：int pthread_cancel(pthread_t th)
传 入 值：th 要取消的线程的标识符
返 回 值：成功：返回0；失败：返回错误码
4. Programmierbeispiele
Im folgenden Beispiel werden 3 Threads erstellt. Um die parallele Ausführung zwischen Threads besser zu beschreiben, lassen Sie die 3 Threads eine Ausführungsfunktion gemeinsam nutzen. Jeder Thread hat 5 Zyklen, jeder Zyklus wartet zufällig 1 bis 10 Sekunden, was bedeutet, dass die Ankunftszeit jeder Aufgabe simuliert wird und es keine spezifische Regel gibt
/*****thread.c*****/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define THREAD_NUMBER 3 //线程数
#define REPEAT_NUMBER 5 //每个线程中的小任务数
#define DELAY_TIME_LEVELS 10.0 //小任务之间的最大时间间隔
void *thrd_func(void *arg){
int thrd_num = (int)arg;
int delay_time = 0;
int count = 0;
printf("Thread %d is starting\n",thrd_num);
for(count = 0;count < REPEAT_NUMBER;count++){
delay_time = (int)(rand()*DELAY_TIME_LEVELS/(RAND_MAX)) + 1;
sleep(delay_time);
printf("\tThread %d: job %d delay = %d\n",thrd_num,count,delay_time);
}
printf("Thread %d finished\n",thrd_num);
pthread_exit(NULL);
}
int main(){
pthread_t thread[THREAD_NUMBER];
int no = 0,res;
void * thrd_ret;
srand(time(NULL));
for(no = 0;no < THREAD_NUMBER;no++){
res = pthread_create(&thread[no],NULL,thrd_func,(void*)no);
if(res != 0){
printf("Create thread %d failed\n",no);
exit(res);
}
}
printf("Create thread sucess\nWaiting for threads to finish...");
for(no = 0;no < THREAD_NUMBER;no++){
res = pthread_join(thread[no],&thrd_ret);
if(!res)
printf("Thread %d joined\n",no);
else
printf("Thread %d join failed\n",no);
}
return 0;
}
Das Folgende ist das laufende Ergebnis. Es ist ersichtlich, dass das Laufen und das Ende jedes Threads ungeordnet, unabhängig und parallel sind
linux@linux-virtual-machine:~/andy/proc$ ./thread
Create threads sucess
Waiting for threads to finish...
Thread 0 is starting
Thread 1 is starting
Thread 2 is starting
Thread 1: job 0 delay = 6
Thread 2: job 0 delay = 6
Thread 0: job 0 delay = 9
Thread 1: job 0 delay = 6
Thread 2: job 0 delay = 8
Thread 0: job 0 delay = 8
Thread 2 finished
Thread 1: job 2 delay = 10
Thread 1: job 3 delay = 4
Thread 1: job 4 delay = 1
Thread 1 finished
Thread 0: job 3 delay = 9
Thread 0: job 4 delay = 2
Thread 0 finished
Thread 0 joined
Thread 1 joined
Thread 2 joined