Un thread è una singola unità di esecuzione in un programma. Un programma ordinario è singolo, in cui le istruzioni nel programma eseguono successivamente fino alla risoluzione.
D'altra parte, Multi-threading consente al programma di creare più thread in cui le istruzioni in un programma possono eseguire contemporaneamente. Offre un'eccellente utilizzo di risorse di sistema come CPU e memoria.
In Ruby, usiamo i thread con l'aiuto della classe dei threads. I thread in Ruby non sono pesanti delle risorse, rendendoli efficienti per impiegare la concorrenza nei programmi.
I thread sono implementati all'interno dell'interprete di Ruby per Ruby versione 1.9 e sotto. A partire dalla versione 1.9 e oltre, il threading è implementato sul sistema operativo.
Usando questa guida, imparerai come implementare thread nella programmazione di Ruby.
Punto di nota: L'interprete di Matz (MRI) ha un blocco dell'interprete globale che impedisce a più thread di eseguire contemporaneamente. Tuttavia, questo non si applica agli interpreti di Jruby e Rubinius.
Creazione di un thread
Come accennato, possiamo lavorare con i thread usando la classe thread. Per creare un nuovo thread, chiamare il thread.nuovo metodo.
La sintassi è:
Filo.Nuovo blocco # thread va qui
Assicurati di includere il codice che si desidera eseguire dal thread all'interno della coppia di bretelle.
Ecco un esempio:
Filo.Nuovo pura "ciao, mondo!"
Prendiamo un semplice programma che calcola l'area di un cerchio.
area def
pi = 3.14159
rad = 7.3
return (pi * rad * rad)
FINE
Filo.nuovo
la zona()
mette "correre all'interno del thread!"
mette "l'esecuzione completa!"
Se esegui l'esempio sopra, noterai che non otteniamo l'area del cerchio. Questo perché Ruby non attende che i thread creati finiscano l'esecuzione. Per garantire il completamento dei thread, dobbiamo chiamare il metodo.
Il metodo di join metterà in pausa l'esecuzione del thread principale e attenderà i thread specificati nel metodo di join da completare.
Quello che segue è il codice di esempio sopra con il metodo di join implementato.
area def
pi = 3.14159
rad = 7.3
return (pi * rad * rad)
FINE
thread = thread.nuovo
mette "L'area del cerchio è #area () cm2"
mette "correre all'interno del thread!"
filo.giuntura
mette "l'esecuzione completa!"
In questo esempio, otteniamo l'output del thread come mostrato di seguito:
L'area del cerchio è 167.41533109999997 cm2
In esecuzione all'interno del thread!
Esecuzione completa!
Terminare un thread
Ruby fornisce vari modi per terminare un thread. Uno di questi modo è usare il metodo di uccisione.
La sintassi è:
Filo.uccidere (thread)
Specificare il nome del thread per terminare all'interno della parentesi.
Eccezioni del thread
Noterai che se viene visualizzata un'eccezione all'interno di un thread, l'esecuzione del programma non si ferma.
Per esempio:
def error_me
sollevare "Errore!"
FINE
Filo.nuovo errore_me
mette "corro ancora"
Nell'esempio sopra, solleviamo un'eccezione all'interno della funzione passata al thread. Noterai due cose:
- Il thread non visualizzerà il messaggio di errore
- Il codice dopo il thread è ancora in esecuzione.
In alcuni casi, potresti voler interrompere l'esecuzione se si presenta un'eccezione all'interno di un thread. Possiamo farlo usando l'abort_on_execption.
Per esempio:
Filo.abort_on_exception = true
throppy = thread.Nuovo do
mette "corro prima dell'eccezione"
sollevare "Eccezione si è verificata!"
FINE
Prima.giuntura
mette "scusa, non corro!"
Nell'esempio sopra, il programma terminerà se quando si verifica un esecuzione all'interno del thread. Ecco un esempio di esempio:
Corro prima dell'eccezione
# terminato con eccezione (report_on_exception è vero):
Discussioni.RB: 4: in 'blocco in': Eccezione si è verificata! (RuntimeError)
Discussioni.RB: 4: in 'blocco in
': Eccezione si è verificata! (RuntimeError) Variabili del filo
Le variabili create in un thread obbediscono alle regole dell'ambito di rubino. Sono accessibili solo nell'ambito del thread in cui vengono creati.
Discussione
È possibile recuperare lo stato di un determinato thread usando il metodo di stato. Puoi anche usare Alive per verificare se il thread è in esecuzione e fermarti per verificare se il thread è morto.
Esistono cinque valori di restituzione per il metodo di stato:
- Corsa - Restituisce la corsa
- Sonno - ritorna a dormire
- Abortire - Restituisce l'aborte
- Terminato con eccezione - Restituisce zero
- Terminare normalmente - restituisce falso.
Conclusione
In questa guida, abbiamo discusso delle basi del lavoro con i thread nel linguaggio di programmazione Ruby.
È bene notare che c'è di più di quello che abbiamo discusso in questa guida. Considera la documentazione per saperne di più.
Grazie per aver letto!
