Inhaltsverzeichnis
2. Eigenschaften mehrerer Threads in einem Prozess
2.1 Gemeinsam genutzte Thread-Ressourcen
3. Thread-bezogene API-Funktionen
Der Code zum Erstellen einer Thread-Instanz lautet wie folgt:
Was besondere Aufmerksamkeit erfordert, ist:
Der Unterschied zwischen -lpthread und -pthread
3.2 Übergeben Sie Parameter an die Thread-Funktion
Der Beispielcode für die Parameterübergabe lautet wie folgt:
Der Beispielcode zum Sammeln von Leichen lautet wie folgt:
2. Beschreibung der Thread-Statusübergangsfunktion
1. Initialisierungsbedingung Schlaf
2. Bedingter Ruhezustand, Thread anhalten
4.Stornierungsstatus festlegen
5. Legen Sie die Stornierungsmethode fest
3. Thread-Statusübergangsbild (im Bild deutlich sichtbar)
Vorwort
Thread bezieht sich auf die kleinste Einheit der unabhängigen Ausführung in einem Prozess. Einfach ausgedrückt ist ein Thread ein Ausführungsfluss in einem Prozess, der als Ausführungspfad des ausführenden Programms verstanden werden kann. In diesem Artikel werden Threads ausführlich erläutert.
1. Thread-Grundlagen
1. Konzept
(1) Thread: Wird im Prozessraum ausgeführt und ist ebenfalls ein dynamischer Prozess.
(2) Ein Prozess entspricht einem Programm und ein Thread entspricht einer Funktion im Programm.
(3) Ein Thread ist ein Ausführungsprozess dieser Funktion, und diese Funktion wird als Thread-Funktion bezeichnet.
2. Eigenschaften mehrerer Threads in einem Prozess
2.1 Gemeinsam genutzte Thread-Ressourcen
(1) Ausführbare Anweisungen (.text)
(2) Statische Daten (.data/.bss/.heap)
( 3) Im Prozess geöffnete Dateideskriptoren
(4) Signalverarbeitungsfunktion
(5) Aktuelles Arbeitsverzeichnis
(6 )Benutzer-ID
(7)Benutzergruppen-ID
2.2 Private Thread-Ressourcen
(1) Thread-ID (TID)
(2) PC (Programmzähler) und zugehörige Register
(3) Stapel
(4) Lokale Variablen
(5) Rücksendeadresse
(6) Fehlernummer (errno)
(7) Signalmaske und Priorität
(8) Ausführungsstatus und Attribute
3. Thread-bezogene API-Funktionen
3.1 Thread erstellen
Kopfdatei:
#include <pthread.h>
Kompilieren und verknüpfen mit -pthread.int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
//Parameter 1 ----- Die Adresse der Variablen, die die Thread-ID speichert
//Parameter 2 ----- Thread-Attribut, normalerweise NULL, das die Verwendung des Standardwerts angibt Attribut
//Parameter 3 ----- Thread-Funktionszeiger, muss im folgenden Format vorliegen:
{ //Rückgabewert---- Erfolg: 0, Fehler: Fehlercode
Der Code zum Erstellen einer Thread-Instanz lautet wie folgt:
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
void* fun(void* arg)
{
int i;
for(i = 0; i < 7; i++){
printf("我是fun\n");
sleep(1);
}
return 0;
}
int main(void)
{
int i;
pthread_t tid;
//fun();
if(pthread_create(&tid,NULL,fun,NULL)){
perror("pthread_create");
exit(1);
}
for(i = 0; i < 7; i++){
printf("我是主函数\n");
sleep(1);
}
return 0;
}Was besondere Aufmerksamkeit erfordert, ist:
Beim Kompilieren müssen Sie die Thread-Bibliothek verknüpfen
gcc pthread_create.c -o pthread_create -lpthread
Der Unterschied zwischen -lpthread und -pthread
Bei beiden Optionen handelt es sich um Optionen zur Verknüpfung mit der pthread-Bibliothek, sie weisen jedoch einige subtile Unterschiede auf.
-lpthread weist den Linker an, eine Verbindung zur pthread-Bibliothek herzustellen. Dies ist eine Standard-Link-Option, die zum Verknüpfen jeder Bibliothek verwendet werden kann.
-pthread teilt dem Compiler mit, dass er beim Kompilieren die pthread-Bibliothek verwenden muss. Dies ist eine nicht standardmäßige Kompilierungsoption, die nur auf Compilern verwendet werden kann, die sie unterstützen.
In den meisten Fällenist die Verwendung von -lpthread die bessere Wahl, da es sich um eine Standard-Link-Option handelt und auf verschiedene Weise von Compilern verwendet werden kann und Betriebssysteme. Und -pthread kann nur auf Compilern verwendet werden, die es unterstützen.
3.2 Übergeben Sie Parameter an die Thread-Funktion
Der Beispielcode für die Parameterübergabe lautet wie folgt:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
typedef struct{
int sno;
char name[20];
float score;
}St;
void* fun(void* arg)
{
St *p = (St*)arg;
//printf("%d\n",*(int*)arg);
//printf("%s\n",(char*)arg);
printf("%d %s %.2f\n",p->sno,p->name,p->score);
return 0;
}
int main(void)
{
pthread_t tid;
//int a = 120;
//char str[] = "hello world";
St s = {1001,"peter",98.56};
if(pthread_create(&tid,NULL,fun,&s)){
perror("pthread_create");
exit(1);
}
sleep(1);
return 0;
}3.3 Bereinigen Sie den Thread
int pthread_join(pthread_t thread, void **retval);
//Parameter 1 ---- Thread-ID
//Parameter 2 - --- Die Adresse der Zeigervariablen, die den Thread-Rückgabewert speichert
//Rückgabewert---- Erfolg: 0, Fehler: Fehlercode
Der Beispielcode zum Sammeln von Leichen lautet wie folgt:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
typedef struct{
int sno;
char name[20];
float score;
}St;
void* fun(void* arg)
{
static int a = 112200;
St *p = (St*)arg;
//printf("%d\n",*(int*)arg);
//printf("%s\n",(char*)arg);
printf("%d %s %.2f\n",p->sno,p->name,p->score);
return &a;
}
int main(void)
{
pthread_t tid;
int *p;
//int a = 120;
//char str[] = "hello world";
St s = {1001,"peter",98.56};
//创建子线程
if(pthread_create(&tid,NULL,fun,&s)){
perror("pthread_create");
exit(1);
}
//给指定线程收尸，如果子线程没有结束，则主线程阻塞
//if(pthread_join(tid,NULL)){
if(pthread_join(tid,(void**)&p)){
perror("pthread_join");
exit(1);
}
printf("*p = %d\n",*p);
return 0;
}
2. Beschreibung der Thread-Statusübergangsfunktion
1. Initialisierungsbedingung Schlaf
Header-Datei: #include <pthread.h>
int pthread_cond_init (pthread_cond_t * __cond,const pthread_condattr_t * __cond_attr)
* Funktion: Initialisierungsbedingung Sleep
* Parameter:
pthread_cond_t * __cond – zeigt auf die initialisierte Bedingungsvariable
const pthread_condattr_t * __cond_attr- zeigt auf das Attribut der Bedingungsvariablen, wobei der Standardwert NULL verwendet wird
* Rückgabewert:
Fehler: negative Zahl, absoluter Wert ist Fehlercode
2. Bedingter Ruhezustand, Thread anhalten
Header-Datei: #include <pthread.h>
int pthread_cond_wait (pthread_cond_t * __cond, pthread_mutex_t *__mutex);
* Funktion: bedingter Ruhezustand, Thread anhalten (der Thread, der diese Funktion aufruft, ist blockiert, die Funktion kehrt nicht zurück und Ruhezustand)
* Parameter:
pthread_cond_t * __cond – zeigt auf die Bedingungsvariable
pthread_mutex_t *__mutex- zeigt auf den Mutex lock Fehler: negative Zahl, absoluter Wert ist Fehlercode
* Rückgabewert:
3. Wecken Sie den Thread auf
Header-Datei: #include <pthread.h>
int pthread_cond_signal (pthread_cond_t *__cond);
* Funktion: Thread aufwecken (rufen Sie diese Funktion auf, um den durch pthread_cond_wait blockierten Thread aufzuwecken)
* Parameter:
pthread_cond_t * __cond – zeigt auf die Bedingungsvariable
* Rückgabewert:
Fehler: negative Zahl, absolut Wert ist Fehlercode a>
4.Stornierungsstatus festlegen
Header-Datei: #include <pthread.h>
int pthread_setcancelstate (int __state, int *__oldstate);
* Funktion: Abbruchstatus festlegen
* Parameter:
int __state – Aktiviert, aber nicht aktiviert
Thread-Abbruch aktivieren, PTHREAD_CANCEL_ENABLE
int *__oldstate- Den alten Status speichern
* Rückgabewert:
Fehler – der Absolutwert einer negativen Zahl ist ein Fehlercode
5. Legen Sie die Stornierungsmethode fest
Header-Datei: #include <pthread.h>
int pthread_setcanceltype (int __type, int *__oldtype);
* Funktion: Abbruchmethode festlegen
* Parameter:
int __type – Abbruchmethode
PTHREAD_CANCEL_ASYNCHRONOUS – asynchroner Abbruch
PTHREAD_CANCEL_DEFERRED – Abbruchverzögerung
int *__oldtype- save Der alte Weg
* Rückgabewert:
Fehler – der absolute Wert einer negativen Zahl ist ein Fehlercode
6. Thread abbrechen
Header-Datei: #include <pthread.h>
int pthread_cancel (pthread_t __th);
/*
* Funktion: Thread abbrechen
* Parameter:
pthread_t __th – Thread-ID Fehler – der absolute Wert einer negativen Zahl ist ein Fehlercode
* Rückgabewert:
3. Thread-Statusübergangsbild (im Bild deutlich sichtbar)
Zusammenfassen
In diesem Artikel werden C/C++-Threads ausführlich erläutert. Ich hoffe, er kann allen helfen!
In Zukunft werde ich Ihnen weitere wichtige Grundkenntnisse über eingebettete und C-Sprache zeigen. Vielen Dank für die Unterstützung von Lazy King!
Ich hoffe, dass dieser Blog allen meinen Freunden helfen kann. Schließlich werden Freunde, die von Lazy King eingeladen wurden, Ihre wertvollen Kommentare und Ihre Aufmerksamkeit hinterlassen. Vielen Dank!