Il flusso di sequenza singola di un processo può essere definito un thread. I fili sono spesso indicati come "processi leggeri" poiché hanno alcune caratteristiche con i processi. Una classe è rappresentare thread di esecuzione distinti. Un singolo thread di esecuzione è rappresentato dal thread di classe. Più funzioni possono essere eseguite contemporaneamente a causa dei thread. Quando viene creato un oggetto thread, inizia immediatamente a eseguire (soggetto a eventuali ritardi di pianificazione del sistema operativo) che iniziano alla funzione più alta specificata come costruttore di funzioni. Il valore definito del metodo viene ignorato e std :: terminare viene invocato se esce aumentando un errore.

Tipi di thread

Il particolare flusso di serie di un processo viene definito thread. I thread sono indicati come procedure insostituzionali in quanto sono simili ai processi in molti modi. Sebbene i thread siano gestiti in sequenza, sembrano funzionare contemporaneamente. Ci sono vari stati per ogni thread.

• un contatore elettronico
• un insieme di registri
• una zona di scaffale

Processi

In sostanza, i processi sono i programmi che vengono inviati dallo stato pronto e programmati per l'esecuzione nella CPU. Il concetto di processo è detenuto da PCB (blocco di controllo del processo). Un processo potrebbe produrre ciò che viene definito "processi per bambini" o nuovi processi. Il processo richiede più tempo per il completamento perché è isolato, il che significa che non condivide una memoria con altri processi. Uno dei seguenti stati per il processo potrebbe essere presente: nuovo, pronto, in esecuzione, attesa, terminato o sospeso.

Discussioni

Un thread è un modulo di un processo. Un processo può avere diversi thread e tutti questi thread sono contenuti all'interno del metodo. Esistono tre stati per un thread: in esecuzione, pronto e bloccato. Il thread termina più velocemente del processo ma non si isola come fa il processo.

Le caratteristiche comuni tra thread e processi includono

• Solo un thread o un processo può essere operativo contemporaneamente.
• Esecuzione successiva all'interno del processo.
• La capacità di generare bambini.

Le distinzioni tra processi e thread

• I processi sono autoregolanti; i thread non lo sono.
• Mentre i processi possono o meno aiutarsi a vicenda, i thread sono progettati per farlo.

Discussione a livello dell'utente

Viene messo in pratica nella libreria a livello di utente; Le chiamate di sistema non vengono utilizzate per costruirle. La commutazione del thread non richiede una chiamata del sistema operativo o un interrupt del kernel. Il kernel li gestisce come se fossero processi a thread singolo poiché non è a conoscenza del thread a livello di utente.

Benefici

• Gli unici attributi che un thread ha sono uno spazio dello stack, un puntatore dello stack e un registro a turni.
• Poiché il kernel non fa regolamenti, la creazione è semplice.
• A causa dell'assenza di chiamate del sistema operativo, la commutazione del thread è rapida.
• È compatibile con i sistemi operativi che proibiscono.

Un thread a livello del kernel

I thread sono gestiti dal kernel. Inoltre, il kernel tiene anche traccia dei processi utilizzando la tabella di processo convenzionale. Il kernel del sistema operativo ha richieste di sistema per la gestione e la creazione di thread.

Benefici

• Dato che il kernel ha informazioni complete sui thread del sistema.
• Lo scheduler può decidere di fornire processi con un numero elevato di thread in più.
• Buono per bloccare regolarmente i programmi.

Multi-threading:

Un altro nome per un thread è un processo leggero. Rompendo un processo in diversi thread, il parallelismo è destinato a essere raggiunto. Ad esempio, molte schede in un browser potrebbero rappresentare vari thread. Più thread vengono utilizzati da MS Word, incluso uno per l'elaborazione degli input e un altro per la formattazione del testo.

Definire una funzione thread ()

Un thread di classe si riferisce a un particolare thread di implementazione. In C ++, il termine "classe thread" si riferisce alla classe STD :: Thread. Una volta creato l'oggetto thread collegati, il metodo di alto livello fornito come parte dell'accordo di costruttore della funzione è dove inizia l'esecuzione del thread. Il codice di implementazione che deve essere invocato riceverà un nuovo oggetto thread che è stato creato per avviare un thread.

Come è stato detto in precedenza, il thread std :: è necessario per avviare un nuovo thread e anche il thread deve essere richiamabile. Un callabile è un programma che deve essere eseguito quando il thread è attivo. In altre parole, se è richiesto un nuovo thread, una callone deve essere fornita come argomento al costruttore di un oggetto per std :: thread. Successivamente, inizia il thread appena generato e viene eseguita la funzione Callable fornita.

Processi vs thread

La distinzione principale è che mentre i processi funzionano in diverse aree di memoria, thread all'interno di un singolo processo di memoria condivisa. Poiché i thread non sono completamente indipendenti l'uno dall'altro come i processi, condividono le loro risorse del sistema operativo, la sezione del codice e la sezione dati con altri thread.

I thread hanno vantaggi rispetto ai processi

• Reattività: se un processo viene suddiviso in numerosi thread, l'output di ogni thread può essere restituito non appena ha finito di funzionare.
• Switch di contesto più rapido: gli interruttori di contesto tra i thread si verificano più rapidamente degli interruttori di contesto all'interno di un processo. La CPU deve fare più sovraccarico a causa di cambiamenti di contesto di processo.
• Utilizzo efficace del sistema multiprocessore: se un processo contiene molti thread, possiamo programmare quei thread su diversi processori. Di conseguenza, sarebbe un'esecuzione di processo più rapida.
• La comunicazione è facilitata dal fatto che diversi thread condividono uno spazio degli indirizzi. Mentre in corso, dobbiamo aderire a un particolare metodo di comunicazione per la comunicazione a due processi.
• Condivisione delle risorse: tutti i thread all'interno di un processo possono condividere risorse come codice, dati e file.
• Capacità del sistema potenziata: quando un'attività viene separata in più thread, ogni operazione di thread viene trattata come una funzione, aumentando il numero di metodi eseguiti in un determinato periodo di tempo migliora la capacità del sistema.

Funzione del filo in C++

In un sistema operativo, forniscono (thread POSIX) per le funzioni, quelle funzioni relative alle funzioni. Possiamo fare molti thread in questo modo per supportare il flusso di processo simultaneo. Funziona meglio su sistemi con diversi processori o core, in cui la velocità di esecuzione può essere raggiunta implementando thread a livello di kernel. I guadagni possono anche essere effettuati nei sistemi con un singolo processore sfruttando IO o altri servizi di sistema che tendono a mettere in pausa i processi.

Crea () funzione

pthread_create: creazione di nuovi thread

Parametri

• Discussione: un puntatore a un valore intero non firmato che contiene l'ID thread del thread più recente che è stato avviato.
• ATTR: Attributi di un thread, come il suo stato distaccato, la strategia di programmazione, l'indirizzo dello stack, ecc., sono definiti da una struttura chiamata attr. Per le proprietà del thread predefinite, imposta su NULL.
• Inizia la routine: un puntatore alla subroutine iniziale di un thread. La funzione ha un solo attributo ma è necessario utilizzare una struttura se è necessario fornire più di un valore.
• Arg: un puntatore a un vuoto che contiene un puntatore ai parametri della funzione forniti dall'argomento precedente.

Funzione Exit ()

pThread_exit: usato per smettere di usare un thread

Parametri
Rivelare, un puntatore a un numero intero che contiene lo stato di ritorno del thread è un parametro richiesto per questa procedura. Qualsiasi thread in attesa di aderire a questo thread deve essere in grado di visualizzare lo stato di ritorno perché l'ambito di questa variabile deve essere globale.

Funzione join ()

PThread_Join: usato per uscire dal thread in attesa

Parametri

• TH: Il thread sta aspettando l'identificatore del thread.
• Ritorno del thread: un puntatore alla posizione in cui viene salvato il thread descritto nello stato di uscita.

Funzione uguale ()

pthread_equal: determina se due thread sono simili. La funzione restituisce un numero diverso da zero se i due thread sono uguali, altrimenti zero.

ST :: Creazione del thread

In C ++, i thread sono costruiti utilizzando la classe STD :: Thread. Un thread è un flusso di esecuzione unico; è simile ad avere un aiuto di un compito mentre ne raggiungi un altro contemporaneamente. Una volta che tutto il codice del thread è stato eseguito, si ferma. Quando si stabilisce un thread, deve essere superato qualcosa per essere eseguito su di esso. Gli oggetti elencati di seguito possono essere passati a un thread.

Tipi di membri

ID: ID thread (pubblico)
Nativo_handle_type: native_handle_type (pubblico)

Il thread consente l'esecuzione simultanea di più attività. In C ++, il termine "classe thread" si riferisce alla classe STD :: Thread. Un nuovo oggetto thread deve essere generato per avviare un thread e deve essere fornito al codice di esecuzione che deve essere chiamato. Il metodo di alto livello fornito come parte dell'accordo di costruttore della funzione è dove l'esecuzione del thread inizia dopo che l'oggetto thread collegati è stato creato.

Callabile che utilizza l'oggetto

Un oggetto potrebbe essere reso callbile utilizzando questo metodo. Per questo, è richiesta una classe e l'operatore () deve essere sovraccarico all'interno di quella classe. Il software che deve essere eseguito quando si forma il thread è incluso nei metodi sovraccarichi.

Callabile utilizzando puntatore

Un puntatore verrà reso richiamabile usando questo metodo. Nell'oggetto thread, l'elenco di parametri o argomenti inviati al metodo appare accanto al nome della funzione.

Callabile usando il puntatore della funzione

Dandolo all'oggetto thread per l'esecuzione raggiunge il risultato desiderato. Il costruttore della funzione dell'oggetto thread riceve un'espressione di lambda denominata "LM" come primo argomento prima di ricevere i suoi argomenti come secondo argomento.

Discutiamo diversi esempi di funzioni di thread std ::.

Esempio 1

In questo caso, utilizzeremo un thread con un puntatore.

#includere
#includere
Test di classe

pubblico:
void esecute (std :: comando string)

per (int i = 0; i < 8; i++)

std :: cout<

;
int main ()

Test * testptr = new test ();
std :: thread th (& test :: Execute, testptr, "valori");
th.giuntura();
Elimina testptr;
restituzione 0;

Innanzitutto, includiamo i file di intestazioni e nel programma. Creiamo la classe e specifichiamo il suo nome "test". Quindi, utilizziamo il metodo pubblico ed eseguiamo il comando stringa. Dopo aver eseguito il comando String, faremo domanda per loop e incremento (da 0 a 8). Qui, impieghiamo la dichiarazione "cout". Successivamente, chiamiamo la funzione principale (). Insieme a questo, chiamiamo il "test" di classe e usiamo un puntatore. Successivamente, il thread passa il puntatore. Quindi, abbiamo utilizzato la funzione join (), eliminare il puntatore di prova e inserire 'return 0'.

Esempio 2

In questo caso, utilizzeremo un thread senza un puntatore.

#includere
#includere
nome della classe

pubblico:
test void statico (comando std :: string)

per (int i = 0; i < 3; i++)

std :: cout<

;
int main ()

std :: thread th (& name :: test, "name");
th.giuntura();
restituzione 0;

Usa i file di intestazione e . Crea una classe e il titolo della classe è "nome". Utilizziamo il metodo pubblico e la riga successiva utilizza una funzione membro statica e qui passiamo la stringa. Usa il ciclo "per" e quindi inizializza i valori da 0 a 3. L'istruzione "cout" viene utilizzata per rappresentare il valore. Nella riga successiva, invochiamo la funzione principale (), utilizziamo il thread e passiamo i valori senza usare un puntatore. Successivamente, utilizziamo la funzione join () e inseriamo 'return 0'.

Esempio 3

Qui applicheremo l'operatore vuoto.

#includere
#includere
Utilizzo dello spazio dei nomi std;
Class Lab
pubblico:
void operatore () (int a)

per (int i = 0; i < a; i++)
cout << "Number of threads :" << i << "\n";

;
int main ()

Thread T2 (Lab (), 6);
T2.giuntura();
restituzione 0;

In questo codice, integriamo i file di intestazione richiesti , . Utilizziamo lo spazio dei nomi standard come std. Aggiungiamo una classe denominata "Lab" e utilizziamo il suo metodo pubblico. Quindi, impiega l'operatore vuoto e inizializza una variabile 'A' in esso. Qui impiegheremo il ciclo "per" da 0 al valore della variabile "A". Inoltre, stamperemo un'istruzione "Numero di thread" utilizzando l'istruzione 'cout'. Invochiamo la funzione principale (). All'interno di questo, verrà dichiarato un thread con il valore 6. Quando un thread riceve una chiamata, esegue un codice e visualizza il messaggio sullo schermo.

Conclusione

In questa guida, abbiamo parlato del thread nelle funzioni C ++. Quindi, osserviamo diverse funzioni di thread in c++. Abbiamo definito il thread e anche i suoi tipi. Inoltre, abbiamo menzionato diversi parametri del thread. Abbiamo eseguito numerosi tipi di codici. Nel primo codice, abbiamo usato un thread con un puntatore, è una funzione membro non statica. In secondo luogo, nel codice utilizziamo il thread senza puntatore, è una funzione membro statica. Terzo e ultimo codice, abbiamo usato l'operatore vuoto e quando un thread ha ottenuto il valore ha mostrato il messaggio sullo schermo.