‫E in questo video tratteremo Kyuss e vedremo come utilizzare i segnali nelle nostre applicazioni,
‫i segnali sono significativi e utilizzati molto dal nostro sistema operativo, ad esempio, per gestire attività, pianificazione
‫e molti altri processi.
‫I segnali dovrebbero essere usati quando l'ordine dei dati è importante, come vedremo nel nostro esempio.
‫Quindi andiamo avanti e prima di tutto definiamo una coda per definire una coda che puoi usare per fare la coda.
‫Anche le code di parole chiave fanno parte delle raccolte generiche, il che significa che dobbiamo definire quale
‫coda di tipo A incorporerà.
‫Quindi, in questo caso, conterrà un gruppo di numeri interi, ma potrebbe contenere anche qualsiasi altro tipo.
‫Potrebbe contenere stringhe, potrebbe contenere anche l'intero oggetto.
‫Quindi sei completamente libero di definire ciò che vuoi che questo oggetto contenga.
‫Quindi accoda quindi meno di segno, integra e firma e quindi il nome della coda è uguale e
‫quindi puoi inizializzarlo immediatamente come facciamo qui, dove creiamo solo una coda vuota che contiene numeri interi.
‫OK, ora possiamo andare avanti e aggiungere elementi a questa coda.
‫Per aggiungere elementi da accusare, puoi utilizzare il metodo NQ.
‫Il metodo NQ aggiunge un oggetto alla fine della coda.
‫OK, quindi se aggiungo un elemento come uno, ad esempio, questo elemento sarà il primo perché mentre è
‫il primo che includiamo, ma sarà anche l'ultimo.
‫OK, quindi non appena ne aggiungiamo un altro, il nuovo elemento sarà l'ultimo elemento in coda.
‫OK, è così che si fa l'ordine.
‫È simile a una pila, ma la differenza è che una coda quando ti sbarazzi di
‫qualcosa, quindi quando apri un oggetto, lo prenderà dall'inizio della coda.
‫Quindi l'altro elemento che è stato creato per primo verrà portato via o verrà estratto dalla coda, per così
‫dire.
‫OK, quindi per guardare gli elementi Qs, possiamo usare il metodo peak e questo metodo visualizzerà il primo elemento nella coda, quindi
‫la parte anteriore della coda, per così dire.
‫Quindi è come una coda di persone in cui sei allo sportello e vuoi ordinare qualcosa, ad esempio, quindi
‫il metodo ti darà la prima persona in quella coda che sta per ordinare.
‫OK, quindi eseguiamo questo molto velocemente e vediamo come sarà.
‫E vediamo che il valore nella parte anteriore della coda è uno.
‫Ora aggiungiamo un altro paio di valori per vedere come ciò influenzerà la nostra applicazione.
‫Quindi qui aggiungerò i diversi elementi della coda in questo modo finirò Q1 e Q2 e Q3 e userò solo
‫questi numeri.
‫Uno due tre.
‫Potrebbero essere anche altri numeri.
‫Non deve essere davvero uno, due, tre.
‫OK, quindi con peaking, otteniamo l'elemento che si trova all'inizio della coda.
‫Puoi vedere ogni singola volta, indipendentemente da ciò che aggiungiamo alla coda, quello sarà il nostro primo elemento
‫nella coda.
‫Quindi sarà quello visualizzato quando usavamo il metodo peek.
‫Ora, per eliminare un elemento dalla coda, utilizzeresti il metodo di rimozione dalla coda.
‫OK, quindi qui non ti accoda.
‫Quindi questo dequeue ora eliminerà il primo numero intero della nostra coda e lo memorizzerà anche immediatamente.
‫Quindi potremmo memorizzare questo, chiamiamo questo elemento in coda, ad esempio, e quindi memorizzerà il risultato di questo
‫elemento rimosso dalla coda.
‫Quindi fondamentalmente ne memorizzerà uno lì dentro perché è il primo elemento che abbiamo nell'elenco.
‫E poi si mostrerà anche Pechino, perché ora non c'è più uno.
‫Il primo oggetto è sparito.
‫Quindi ora il valore nella coda sarà due perché, beh, abbiamo appena scoperto il primo elemento.
‫Quindi è simile al pop in una pila, ma toglie l'elemento all'inizio della coda invece che alla fine
‫della coda o alla fine dello stick, comunque tu voglia guardarlo.
‫Ovviamente puoi anche provare a rimuovere dalla coda un elemento all'inizio, se non ci sono elementi
‫all'interno del cubo, ma ti imbatterai in un'eccezione di operazione non valida, la coda è vuota, quindi
‫dovrai controllare se la coda è vuoto o meno prima di eseguire questo.
‫Quindi qui possiamo eseguire il metodo dequeue perché sappiamo di aver appena scoperto qualcosa.
‫Ma altrimenti useresti la proprietà count della tua coda per capire quanti elementi hai
‫lì.
‫Quindi questa è la proprietà che puoi usare, ottiene il numero di elementi contenuti nella
‫coda e puoi quindi controllare se quello è maggiore di zero, ad esempio, per verificare se
‫c'è qualcosa nella coda che puoi, ad esempio , dequee.
‫OK, quindi in questo esempio particolare, andrò avanti e userò my.
‫Q Count per ricontrollare in un ciclo while, e per ogni singolo elemento, lo rimuoverò dalla coda e annoterò anche la
‫quantità di elementi che sono ancora nel Q e anche l'elemento che è stato rimosso.
‫Quindi questa riga qui rimuoverà l'elemento chiamando il metodo dequeue e allo stesso tempo visualizzerà l'elemento
‫proprio qui perché è quello che stiamo usando qui.
‫Stiamo usando la stringa.
‫Destra.
‫E con questa posizione zero, visualizzerà qualunque sia il risultato della chiamata di dequeue.
‫E come puoi vedere qui, il metodo dequeue restituirà un numero intero.
‫Quindi mostreremo un numero qui.
‫OK, quindi fammi sbarazzarmi di questo dequeue che ho usato qui per dimostrare come rimuovere dalla coda un elemento
‫ed eseguiamolo di nuovo e puoi vedere il valore diverso da questo.
‫E poi fondamentalmente iniziamo il loop di filo qui.
‫Questa è la parte interessante.
‫Quindi una parola viene rimossa dal cubo.
‫Ora, abbiamo solo due elementi rimasti.
‫Due sono stati rimossi dalla CUNA.
‫Abbiamo solo un oggetto rimasto e tre sono stati rimossi dal cubo.
‫Ora abbiamo solo zero elementi rimasti.
‫Quindi fondamentalmente la Q è vuota a quel punto.
‫Va bene, quindi diamo un'occhiata a un esempio del mondo più o meno reale, ovviamente, non lavoriamo
‫con i database in questo semplice esempio qui, ma diciamo che abbiamo una piattaforma di e-commerce e siamo un venditore e riceviamo un
‫mucchio di ordini.
‫Questi ordini dovrebbero essere elaborati in modo tale che il tempo di servizio, quindi il tempo di attesa per il cliente dovrebbe
‫essere ridotto al minimo.
‫Questo è il motivo per cui utilizzeremo le Q perché sono molto pratiche poiché
‫ci preoccupiamo dell'ordine degli ordini in arrivo.
‫Quindi l'ordine degli ordini, è un po' uno scioglilingua qui, ma l'ordine con cui sono stati ricevuti
‫i dati, OK, e con questo intendo gli ordini stessi.
‫Quindi diamo un'occhiata a questa classe molto semplice che costruiremo qui e la inserirò nello
‫stesso file qui.
‫Ordine senza disco con una proprietà ID ordine, la proprietà quantità ordine e quindi il costruttore, che in pratica imposta solo
‫quei due valori quando creiamo un oggetto ordine.
‫E poi abbiamo questo messaggio di stampa o questo metodo di elaborazione dell'ordine che stamperà l'ID dell'ordine dell'articolo
‫che stiamo attualmente esaminando.
‫Quindi dell'ordine che stiamo esaminando attualmente.
‫OK, quindi ora quello che vorrei fare è creare effettivamente metodi all'interno della mia classe di
‫programma.
‫Quindi lo metterò ancora qui all'interno di questa parentesi.
‫E i metodi, si prenderanno cura degli ordini dei diversi rami.
‫Quindi diciamo che abbiamo due diverse filiali da cui possiamo ricevere ordini.
‫Diciamo che stiamo vendendo su Amazon e allo stesso tempo su Best Buy, ad esempio, e quindi ora
‫riceveremo quegli ordini.
‫Ora, non lo renderemo troppo complicato quando controlleremo quale ramo è ciò che fa l'ordine dei diversi
‫rami, o qualcosa che potresti, ovviamente, vedere come una sfida per te stesso se
‫vuoi svilupparlo .
‫Ma diremo solo: OK, dammi gli ordini di ciascuno nell'ordine giusto e dammi anche
‫gli ordini dalla filiale a nell'ordine giusto.
‫OK, qui questo sarà il ramo uno con un mucchio di ordini e poi avremo il ramo due con un mucchio di
‫parole.
‫Quindi stiamo ottenendo i dati.
‫Diciamo che otteniamo questi dati da un database in cui stiamo controllando, OK, quali erano gli ordini?
‫E probabilmente li controlleremo per data in modo che ogni ordine ottenga anche una data.
‫Qui abbiamo l'ID dell'ordine, ma di solito cercheremmo anche di memorizzare quando è stato ordinato e così via.
‫Ma per questo esempio lo manterremo semplice.
‫OK, ora abbiamo una serie di ordini in entrambi questi esempi.
‫E quando chiamiamo il metodo ricevi ordini dal ramo uno e due, fondamentalmente trasformeranno semplicemente un array di
‫ordini.
‫Quindi ecco una serie di ordini.
‫OK, questo è ciò che fa questa affermazione qui, restituire gli ordini.
‫Ora, nel nostro esempio particolare, l'ID dell'ordine sarà in effetti univoco per i due diversi ordini,
‫quindi saranno già nell'ordine giusto, per così dire.
‫OK, quindi questo è l'ordine uno fa nell'ordine due, quindi abbiamo l'ordine tre, quattro e cinque dal ramo due
‫e poi la sera e il ramo uno, è arrivato un altro ordine e qualcuno ha acquistato 10 dei nostri
‫articoli.
‫Ora, nel nostro metodo principale, possiamo creare una coda e in realtà ci liberiamo di tutte queste cose qui e il nostro metodo principale,
‫ora possiamo andare avanti e creare una coda di ordini.
‫OK, quindi qui, ordine in coda.
‫Puoi vedere che questo non sarà un tipo semplice come intero ora, ma in realtà
‫conterrà un sacco di ordini.
‫Questa è la cosa bella della coda.
‫Quindi non sono solo tipi semplici e chiamerò questa coda di ordini e la inizializzerò subito
‫proprio qui.
‫E poi, a questo punto, possiamo andare avanti e mettere in coda tutti i nostri ordini che riceviamo dal ramo uno usando questo ciclo
‫for qui, questo per ogni ciclo.
‫Quindi stiamo esaminando ogni singolo ordine che chiamerò O in questo per ogni ciclo in questa iterazione
‫nei nostri ordini di ricezione dal ramo uno.
‫Ora questo qui sarà di tipo order array.
‫OK, quindi quando chiamiamo questo metodo restituirà un array di ordini come vedi qui.
‫Quindi fondamentalmente questo per ogni ciclo passerà attraverso gli ordini che abbiamo all'interno di questo array di ordini e
‫cercherà attraverso ognuno di essi.
‫Quindi tutto sarà prima quest'ordine, poi sarà quest'ordine, poi sarà quell'ordine.
‫E per ognuno di loro, includerà quegli ordini.
‫OK, questo è ciò che fa questo per ogni ciclo.
‫E poi ne creiamo un altro per ogni ciclo anche per l'altro ramo.
‫Così.
‫Lo stesso vale per ogni ciclo, tutto negli ordini ricevuti dal ramo due.
‫OK, quindi questo è Branch, questo è Branch uno e lo stesso vale.
‫Quindi vale lo stesso concetto.
‫Quindi, per gli ordini, esamineremo la nostra coda uno per uno, quindi rimuoveremo gli elementi dalla nostra coda e li
‫elaboreremo finché la nostra coda non sarà vuota e tutti gli ordini saranno finalmente elaborati.
‫OK, ecco perché abbiamo questo metodo di elaborazione dell'ordine qui che elaborerà gli ordini.
‫Ok, ora possiamo andare avanti.
‫E invece del nostro metodo principale quassù, una volta che abbiamo la coda degli ordini con tutti gli
‫articoli al suo interno, possiamo esaminarla e possiamo controllare se la coda degli ordini non è vuota e purché non sia vuota.
‫Quindi finché gli ordini sono in coda, il conteggio è maggiore di zero.
‫Eseguiremo questo ciclo while e rimuoveremo l'ordine all'inizio della coda.
‫Quindi l'ordine che è arrivato per primo, per così dire, e memorizzalo in una variabile chiamata ordine corrente.
‫OK, quindi abbiamo questo oggetto ordine, che verrà chiamato ordine corrente, che sarà fondamentalmente
‫il risultato dell'accodamento del primo elemento della nostra coda ordini.
‫Quindi fondamentalmente togliendo prima questo oggetto, poi questo oggetto, poi quell'oggetto, poi questo oggetto poi
‫quello e quello, OK, e poi elaborerà ognuno di essi passo dopo passo.
‫Quindi l'elaborazione nel nostro caso sarà solo qualcosa di molto semplice e lo stamperemo semplicemente sulla console.
‫Ma ovviamente, potresti eseguire qualcosa di molto più complesso in background qui.
‫Questo potrebbe innescare alcuni eventi, inviando un'e-mail, ad esempio, a un dipendente che
‫deve occuparsene o a qualsiasi sistema di elaborazione che hai impiegato nella tua azienda.
‫Tutto bene.
‫E sì, è fondamentalmente così.
‫Quindi ora eseguiamo questa applicazione per vedere i risultati e possiamo vedere che l'ordine uno è
‫stato elaborato, l'ordine due è stato elaborato, quindi l'ordine sei, quindi tre, quattro, cinque.
‫OK, quindi stiamo elaborando gli ordini, ovviamente, nell'ordine in cui li abbiamo indicati OK con questo,
‫li eseguiamo.
‫Qui puoi vedere che siamo in coda prima dal ramo uno e poi dal ramo due.
‫Quindi immagina solo per il seguente scenario in cui gli ordini vengono creati
‫internamente nel sistema, ma devono prima essere accettati e inviati completamente all'entità di elaborazione, qualunque sia tale
‫entità, come anche l'altro ufficio, ad esempio.
‫E lo fanno alla fine della giornata, per esempio.
‫Quindi il primo ramo finisce il loro staff e dicono, OK, beh, accettiamo quegli ordini.
‫E poi più tardi quel giorno, perché diciamo che sono in un fuso orario diverso.
‫Ad esempio, Branch due dice, sì, siamo d'accordo.
‫Bene, inviamo anche i nostri ordini come approvati a quel punto, e poi iniziano a essere elaborati.
‫OK, ecco come potrebbe essere considerato questo esempio, per esempio.
‫Destra.
‫Altrimenti, ovviamente, li ordineresti subito in base al loro ID o in base al momento in cui
‫sono stati creati.
‫Ok tutto bene.
‫Quindi ora hai una certa idea di come funzionano questi ordini e di come funzionano le code.
‫Questa è la parte più importante.
‫Quindi ora puoi creare le tue code e usarle nelle tue applicazioni.
‫Tutto bene.
‫Quindi spero che questo video vi sia piaciuto.
‫Ci vediamo al prossimo.