‫Ben tornato.
‫In questo video, vorrei parlare di join ed è vivo, quindi join è un metodo che la minaccia o la classe di
‫minaccia ha e che possiamo usare ed è vivo è una proprietà che ha.
‫Quindi creiamo una minaccia qui o addirittura alle minacce.
‫E ho anche creato due metodi.
‫La minaccia, una funzione e la minaccia di funzionare.
‫E quello che fanno è solo dire che hanno iniziato.
‫Quindi la terza funzione è stata avviata e ha cercato di funzionare.
‫Quindi ora puoi andare avanti e semplicemente copiarlo o costruirlo da solo molto velocemente e poi puoi andare avanti.
‫Quindi qui, dirò solo che il thread del dominio è iniziato e alla fine dirà che il thread principale è terminato.
‫Finora niente di nuovo.
‫Se iniziamo con il controllo cinque, ad esempio, la console rimane attiva, il thread principale viene avviato e il thread principale
‫viene terminato.
‫Premere un tasto qualsiasi per continuare.
‫OK, quindi puoi vedere che è iniziato e finito e che è successo molto, molto velocemente.
‫Quindi non sta succedendo molto qui.
‫Quindi ora cambiamo questo.
‫Creiamo alcuni thread lì dentro.
‫Quindi creiamo un nuovo thread chiamato Thread One.
‫Quindi Filo.
‫E per utilizzare il thread, dobbiamo implementare l'utilizzo del threading di sistema.
‫Quindi ora possiamo usare i thread.
‫E chiamerò quel thread uno.
‫E quello che farà sarà semplicemente un nuovo thread che chiamerà la funzione thread uno o thread
‫una funzione.
‫Quindi eseguirò questo codice qui.
‫Li chiamerà semplicemente il metodo.
‫E poi, un altro thread.
‫Chiamerò il thread due, che sarà anche un thread e qui thread per funzionare.
‫Quindi, come puoi vedere, ci sono più thread di Overlord, inizio thread con parametri e avvio
‫thread.
‫Quindi quello che facciamo è solo un inizio di thread.
‫Quindi inizia con un delegato di avvio del thread che rappresenta i metodi da richiamare quando il thread inizia
‫l'esecuzione.
‫Quindi questo sarà il nostro metodo, quindi.
‫Quindi questa terza o terza funzione, che non è realmente un metodo, è una funzione perché
‫non è all'interno di una classe orientata agli oggetti, ma in modi che vanno avanti e creano quella funzione.
‫Come puoi vedere, non hai bisogno delle parentesi qui perché in realtà non lo chiamiamo delegato qui.
‫Tutto bene.
‫Quindi, ciò che dobbiamo fare è semplicemente avviare quei thread.
‫Quindi facciamo quel thread all'inizio di un punto e thread a quell'inizio.
‫E sto solo andando a premere controllo, ne ho cinque per avviarlo e vedere il thread principale avviato, il thread principale
‫terminato il thread.
‫Una funzione è stata avviata e ha provato a funzionare.
‫Quindi non sono finiti perché non abbiamo ancora implementato alcun messaggio di fine.
‫Quindi ora andiamo avanti e usiamo il metodo congiunto su quelle due minacce o minacce, uno che si unisce e controlliamo cosa
‫ci ha unito blocchi congiunti, la minaccia chiamante fino a quando la minaccia rappresentata da questa istanza non
‫termina mentre continua a eseguire il messaggio standard vieni e inviato pompaggio.
‫Quindi quello che faremo è semplicemente venire o unirci a queste due minacce.
‫Quindi questa minaccia con la minaccia principale, questo è ciò che fa questo metodo congiunto e blocca la minaccia principale per
‫quel momento.
‫Così è chiamato dalla minaccia principale.
‫Ecco perché blocca la minaccia principale.
‫Quindi è generalmente chiamato bloccare la minaccia chiamante.
‫E nel nostro caso, la minaccia principale è la minaccia principale perché siamo all'interno della minaccia principale quando la
‫chiamiamo.
‫OK, allora quello che facciamo è anche unirci alla seconda minaccia.
‫Così ci siamo uniti a noi due.
‫E scriviamo qualcosa sulla console, CW e diciamo thread una funzione, Don.
‫E facciamo lo stesso per il secondo, quindi eseguiamolo di nuovo e non accadrà molto in realtà premi il controllo
‫alle cinque, quindi la mia console rimane sveglia, il thread principale è iniziato la terza funzione
‫ha iniziato a funzionare e qui dovrebbe essere chiamato minaccia di funzione.
‫Tutto bene.
‫Quindi siamo ora che dice, OK, terzo, introduci fatto e dopo viene fatta solo la minaccia principale.
‫Quindi non è niente di speciale e niente di nuovo.
‫Esegue semplicemente quella roba passo dopo passo.
‫Quindi è così che sembra qui.
‫Ma allora facciamo qualcosa di interessante.
‫Aggiungiamo un sonno qui.
‫Quindi, in realtà, facciamo addormentare la minaccia per tre secondi.
‫Quindi minaccia il sonno.
‫Tremila millisecondi.
‫E quello che farà è che questo metodo dirà semplicemente il metodo, il thread è iniziato e
‫poi aspetterà tre secondi.
‫Quindi ora eseguiamolo di nuovo ed effettivamente eseguiamolo di nuovo con il controllo alle cinque.
‫Quindi qui sono iniziate le funzioni.
‫E poi, dopo aver pensato un po', lancia una funzione, Dunn ha effettivamente riprodotto quella funzione molto velocemente in modo che uno
‫e due iniziassero e dopo tre secondi puoi vedere quella funzione.
‫Dunn ha cercato di funzionare, Dunn e la minaccia principale sono finite.
‫Quindi il thread principale e attendi fino al completamento del principale o del terzo.
‫E questo sta accadendo perché ci uniamo qui.
‫Quindi ci uniamo alla minaccia uno e diciamo, OK, per favore aspetta finché non abbiamo finito.
‫Ora, se guardiamo al metodo congiunto, ci sono altre cose interessanti da considerare.
‫Ci sono più sovraccarichi.
‫Quindi, come puoi vedere, c'è solo uno o abbiamo zero parametri qui o argomenti che abbiamo dato, ma ce
‫ne sono più.
‫Quindi possiamo aggiungere un altro argomento qui, che è il tempo che vogliamo aspettare prima di andare avanti.
‫Quindi qui, userò solo una minaccia IV che in realtà thread uno che si unisce richiede una quantità specifica di tempo e,
‫come puoi vedere, timeout di millisecondi.
‫Quindi diciamo che aspettiamo un secondo e daremo a questa minaccia un secondo per terminare.
‫E se lo fa entro il tempo, diciamo thread una funzione eseguita e altrimenti diciamo qualcosa come minaccia.
‫Una funzione non è stata eseguita entro un secondo.
‫Tutto bene.
‫Quindi liberiamoci di questo giunto qui e sostituiamo effettivamente tutto quel
‫codice per questo.
‫Quindi ora eseguiamolo di nuovo.
‫Controlla un cinque.
‫Quindi la funzione frontale, una minaccia non è stata eseguita entro un secondo, la minaccia per ridurre la minaccia principale è terminata.
‫Quindi, come puoi vedere, non è stato fatto entro il periodo di tempo specificato.
‫Ma ora aggiungiamo un altro codice qui, perché non abbiamo mai visto questa minaccia, una funzione eseguita.
‫Quindi aggiungiamo qualcosa come thread, una funzione che torna a main.
‫Quindi questo significa che è praticamente finito o forse non principale.
‫Ma il chiamante, eseguiamolo di nuovo con il controllo di cinque.
‫Quindi la minaccia alla funzione è iniziata, fammi effettivamente chiamarla ancora una volta, quindi, ok, la minaccia principale è terminata e poi vedi
‫solo dopo quel tempo, quindi solo dopo tre secondi ha detto che la funzione della minaccia uno torna a
‫colore.
‫Quindi la minaccia principale era già stata fatta e solo allora tornava al chiamante, che era la minaccia principale.
‫Solo allora è arrivato, beh, alla linea 30 o addirittura dopo.
‫Quindi è stato fatto con il metodo principale e solo allora questo codice qui è stato eseguito.
‫Quindi, come puoi vedere, ha bloccato il thread principale solo per un secondo, non ha bloccato il thread principale finché non
‫è stato completato.
‫Quindi dice che blocca il thread chiamante fino a quando il thread rappresentato da questa istanza non termina
‫o non trascorre il tempo specificato continuando a eseguire diversi commenti su di esso.
‫Pompando così bene, puoi vedere che puoi dire, OK, Myntra, per favore aspetta un secondo.
‫E se non succede o se il terzo non finisce quella roba, allora andrà avanti.
‫Quindi si unirà attraverso due e poi dirà solo che il thread principale del thread Kamden è finito
‫e bene, la funzione del thread uno è ancora in esecuzione o il thread uno è ancora in esecuzione e sta ancora dormendo
‫ed esegue il codice in seguito.
‫Ma non lo fa in tempo, come puoi vedere qui.
‫Quindi la minaccia principale non ha più aspettato, ha solo detto, OK, vado avanti, vado avanti senza
‫di te.
‫Quindi questa è la cosa sull'unione dei thread che puoi vedere qui, è così che funziona.
‫E poi ora diamo un'occhiata a questa è una proprietà della vita.
‫Quindi, se il thread uno è attivo, quindi c'è questa proprietà e come puoi vedere, ottiene un valore che indica lo stato di esecuzione
‫della minaccia corrente, il che significa che la minaccia è stata eseguita o non è stata eseguita?
‫Quindi qui dice se la minaccia è ancora viva, quindi se è ancora in esecuzione nel punto in cui viene
‫eseguito questo codice, allora fai qualcosa.
‫Quindi scriverò qualcosa come la minaccia uno sta ancora facendo cose.
‫Quindi sta ancora eseguendo ed eseguendo codice.
‫E altrimenti dirò solo che la minaccia uno è stata completata.
‫Quindi il thread CW uno è stato completato.
‫Va bene, e qui, ovviamente, dobbiamo finire la stringa ora, controlliamo di nuovo.
‫E il thread principale è terminato e in realtà la mia console si è chiusa.
‫Quindi fammi iniziare con il controllo a cinque thread principale avviato thread una funzione avviata e così via, quindi non
‫è stato fatto entro un secondo, quindi ha provato a funzionare.
‫Due erano fatti.
‫Quindi dice, OK, non aspetterò più.
‫intendo filo.
‫Quindi esegue il thread due quindi.
‫Quello sta ancora facendo cose, quindi significa che la minaccia uno è viva, viene eseguita e solo dopo la minaccia
‫principale è terminata.
‫Quindi questo codice qui viene eseguito alla riga trentotto.
‫E poi la nostra minaccia, una funzione che torna al colore viene chiamata o viene eseguita.
‫Tutto bene.
‫Quindi è quello che puoi controllare e semplicemente controllare, OK.
‫La minaccia è viva o no?
‫E in base a questo, puoi eseguire cose e questo è piuttosto utile.
‫Quindi ora diciamo che vogliamo vedere che la minaccia sta ancora facendo cose su base regolare.
‫Quindi diciamo che lo usiamo per un ciclo qui e I è uguale a zero.
‫Soffio 10 io più più.
‫Quindi all'interno di quel ciclo for, voglio eseguire questo codice.
‫E quello che farà è solo dire che la minaccia sta ancora facendo
‫cose e poi dormirà per, diciamo, trecento millisecondi.
‫Quindi dormi per trecento, il che significa che avremo dieci esecuzioni prima che la nostra minaccia sia completata.
‫Quindi eseguiamolo ancora una volta.
‫La prima minaccia è ancora fare cose fatte e fatte.
‫E come puoi vedere, non è stato eseguito le dieci volte, anche se la sospensione della minaccia è rimasta lì per
‫trecentoventi secondi e millisecondi e questo è stato solo per trecento millisecondi.
‫Quindi quello che ha fatto è eseguire la minaccia uno completata più volte, quindi come puoi vedere, c'è
‫una sovrapposizione in cui la funzione di minaccia sta tornando.
‫Come puoi vedere, questo per Loop è stato eseguito solo un po' più tardi.
‫Quindi l'ordine è il seguente.
‫Iniziamo quello.
‫Iniziamo a iniziare il thread uno, abbiamo aspettato un secondo.
‫Quindi puoi vedere che abbiamo questo un secondo join.
‫Quindi perdiamo già tre esecuzioni del nostro sonno qui, il che significa che questa minaccia, una che sta ancora
‫facendo cose, in realtà viene eseguita solo sei volte qui, sette o sette volte.
‫E poi la funzione di minaccia uno ritorna perché è iniziata.
‫Poi ha aspettato un secondo.
‫Allora non è successo niente.
‫Solo allora ha iniziato a fare tutte queste belle cose.
‫Quindi, poiché questo viene eseguito dieci volte, eseguirà questo sonno più volte fino a quando non tornerà al colore.
‫E questo terzo completato viene eseguito molto rapidamente.
‫Quindi non aspetterà perché non c'è sonno lì dentro.
‫Ma questo è generalmente quello che puoi fare con questi vivi.
‫Quindi generalmente puoi controllare, OK, è la vita, è ancora vivo, è ancora vivo e
‫fare cose mentre è vivo o fare altre cose mentre è vivo e poi non fare niente o qualcos'altro quando è
‫finito.
‫Quindi questo è un esempio molto semplice dell'uso di join ed è vivo, e spero che tu possa afferrare il concetto.
‫Quindi ci vediamo nel prossimo video in cui controlleremo le attività.