‫Bem vindo de volta.
‫Neste vídeo, gostaria de falar sobre join and is alive, portanto, join é um método que a ameaça ou a classe de
‫ameaça tem e podemos usar e está vivo é uma propriedade que possui.
‫Então, vamos criar uma ameaça aqui ou realmente contra ameaças.
‫E também criei dois métodos.
‫A ameaça, uma função e a ameaça para funcionar.
‫E o que eles fazem é apenas dizer que começaram.
‫Então, a terceira função foi iniciada e tentou iniciar a função.
‫Então agora você pode ir em frente e apenas copiar ou construir você mesmo bem rápido e então você pode ir em frente.
‫Aqui, apenas direi que o thread de domínio começou e, no final, dirá que o thread principal terminou.
‫Até agora, nada de novo.
‫Se começarmos com o controle cinco, por exemplo, o console permanecerá ativo, a linha de execução principal será iniciada e a linha de
‫execução principal encerrada.
‫Pressione qualquer tecla para continuar.
‫OK, então você pode ver que começou e terminou e que aconteceu muito, muito rápido.
‫Portanto, nada de mais acontecendo aqui.
‫Então agora vamos mudar isso.
‫Vamos criar alguns tópicos lá.
‫Então, vamos criar um novo thread chamado Thread One.
‫Então Thread.
‫E, para usar o thread, precisamos implementar o threading do sistema.
‫Agora podemos usar threads.
‫E vou chamar esse tópico de um.
‫E o que vai fazer é simplesmente ser um novo encadeamento que chama a função de encadeamento um ou função de
‫encadeamento um.
‫Vou apenas executar este código aqui.
‫Isso vai apenas chamá-los de método.
‫E a seguir, outro tópico.
‫Vou chamar o encadeamento dois, que também será um encadeamento e aqui o encadeamento funcionará.
‫Como você pode ver, existem vários encadeamentos do overlord, início de encadeamento parametrizado e início de
‫encadeamento.
‫Então, o que fazemos é apenas o início de um tópico.
‫Portanto, comece com um delegado de início de thread que representa os métodos a serem invocados quando o thread começa a ser
‫executado.
‫Portanto, este será o nosso método.
‫Portanto, esta terceira ou terceira função, que não é realmente um método, é uma função porque
‫não está dentro de uma classe orientada a objetos, mas de maneiras que vão em frente e criam essa função.
‫Como você pode ver, você não precisa dos colchetes aqui porque não o chamamos de delegado aqui.
‫Tudo bem.
‫Em seguida, o que precisamos fazer é simplesmente iniciar esses threads.
‫Então, vamos iniciar esse segmento um ponto e iniciar esse segmento.
‫E vou apenas pressionar control, tenho cinco para iniciá-lo e ver o thread principal iniciado, thread
‫principal encerrado.
‫Uma função foi iniciada e tentou iniciar a função.
‫Então eles não terminaram porque não implementamos nenhuma mensagem final ainda.
‫Portanto, agora vamos seguir em frente e usar o método conjunto nessas duas ameaças ou ameaças, uma que se junta e vamos verificar
‫o que nos uniu os blocos conjuntos, a ameaça de chamada até que a ameaça representada por esta instância
‫termine enquanto continuamos a executar a mensagem padrão de envio e recebimento bombeamento.
‫Então o que faremos é simplesmente entrar ou juntar essas duas ameaças.
‫Então, essa ameaça com a ameaça principal, é o que esse método conjunto faz e bloqueia a ameaça principal
‫naquele momento.
‫Portanto, é chamado pela ameaça principal.
‫É por isso que bloqueia a ameaça principal.
‫Portanto, geralmente é chamado de bloqueio da ameaça de chamada.
‫E, em nosso caso, a ameaça de chamada é a principal, porque estamos dentro da ameaça principal quando a
‫chamamos.
‫OK, então o que fazemos é juntar-nos à segunda ameaça.
‫Então nos juntamos a esses dois.
‫E vamos escrever algo no console, CW e, digamos, encadear uma função, Don.
‫E vamos fazer o mesmo para o segundo, então vamos executá-lo novamente e nada mais acontecerá, na verdade,
‫pressione o controle às cinco, então meu console permanece ativo, thread principal começou a terceira
‫função começou a funcionar e aqui deve ser chamada de ameaçar função.
‫Tudo bem.
‫Assim que estamos agora diz, OK, terceiro, introdução feita e depois apenas a ameaça principal é feita.
‫Portanto, isso não é nada sofisticado e nada de novo.
‫Ele apenas executa essas coisas passo a passo.
‫Então é assim que parece aqui.
‫Mas então vamos fazer algo interessante.
‫Vamos adicionar um sono aqui.
‫Então, na verdade, vamos fazer a ameaça dormir por três segundos.
‫Portanto, ameaça dormir.
‫Três mil milissegundos.
‫E o que isso vai fazer é que esse método vai apenas dizer o método, a thread iniciada e então
‫vai esperar por três segundos.
‫Portanto, agora vamos executá-lo novamente e, na verdade, vamos executá-lo novamente com o controle em cinco.
‫Então, aqui as funções começaram.
‫E depois de um tempo pensando, jogue uma função, Dunn realmente reproduziu aquele bem rápido de forma que um e dois começaram
‫e depois de três segundos você pode ver aquela função.
‫Dunn tentou funcionar, Dunn e a ameaça principal terminaram.
‫Então, o thread principal e espere até que o principal ou o terceiro seja concluído.
‫E isso está acontecendo porque nos juntamos a isso aqui.
‫Então nos juntamos à ameaça um e dizemos, OK, por favor, espere até terminarmos.
‫Agora, se olharmos para o método conjunto, há outra coisa interessante a considerar.
‫Existem várias sobrecargas.
‫Como você pode ver, há apenas um ou não temos nenhum parâmetro aqui ou argumentos que fornecemos, mas
‫há vários.
‫Portanto, podemos adicionar outro argumento aqui, que é o tempo que queremos esperar antes de prosseguir.
‫Então, aqui, vou apenas usar a ameaça IV que, na verdade, encadeia uma que a junção leva uma quantidade específica de tempo e, como você
‫pode ver, o tempo limite de milissegundos.
‫Então, digamos que esperemos um segundo e dêmos um segundo para essa ameaça terminar.
‫E se isso acontecer dentro do tempo, dizemos thread one function done e, do contrário, dizemos algo como ameaça.
‫Uma função não foi concluída em um segundo.
‫Tudo bem.
‫Então, vamos nos livrar dessa junta aqui e vamos realmente substituir todo
‫esse código por isso.
‫Então, agora vamos executá-lo novamente.
‫Controle um cinco.
‫Assim, a função de frente, uma ameaça não foi realizada em um segundo, a ameaça para funcionar até o fim da ameaça principal.
‫Como você pode ver, isso não foi feito dentro do período de tempo especificado.
‫Mas agora vamos adicionar outro código aqui, porque nunca vimos essa ameaça, uma função concluída.
‫Então, vamos adicionar algo como thread, uma função voltando ao principal.
‫Isso significa que está praticamente pronto ou talvez não seja o principal.
‫Mas o chamador, vamos executá-lo novamente com controle de cinco.
‫Então, a ameaça para a função começou, deixe-me chamá-la mais uma vez, então, OK, a ameaça principal terminou e então você verá apenas
‫depois desse tempo, então somente depois de três segundos ele disse que a ameaça uma função estava voltando à
‫cor.
‫Então a ameaça principal já havia sido cumprida e só então voltou para o chamador, que era a principal ameaça.
‫Só então veio, bem, a linha 30 ou, na verdade, depois.
‫Então foi feito com o método principal e só então esse código aqui foi executado.
‫Como você pode ver, ele bloqueou o thread principal apenas por um segundo, não bloqueou o thread principal até
‫que fosse concluído.
‫Portanto, ele diz que bloqueia o encadeamento de chamada até que o encadeamento representado por esta instância termine
‫ou o tempo especificado expire enquanto continua a realizar vários comentários sobre ele.
‫Bombeando tão bem, você pode ver aqui que pode dizer, OK, Myntra, por favor, aguarde um segundo.
‫E se isso não acontecer ou se o terceiro não terminar essas coisas, então continua.
‫Então, ele vai se juntar por meio de dois e então vai apenas dizer que o thread principal do
‫Kamden está pronto e bem, o thread um função ainda está em execução ou o thread um ainda está em execução e ainda está
‫adormecido e executando o código depois.
‫Mas não acontece a tempo, como você pode ver aqui.
‫Portanto, a ameaça principal não esperou mais, apenas disse: OK, vou continuar, vou seguir em frente
‫sem você.
‫Então é isso que você pode ver aqui sobre junção de tópicos, é assim que funciona.
‫E agora vamos dar uma olhada nisso é uma propriedade vitalícia.
‫Portanto, se o thread um está ativo, existe essa propriedade e, como você pode ver, obtém um valor indicando o status
‫de execução da ameaça atual, o que significa que a ameaça foi concluída ou não?
‫Portanto, ele diz aqui se a ameaça ainda está viva, então, se ainda estiver em execução no ponto em que
‫o código foi executado, faça algo.
‫Então, vou escrever algo como uma ameaça que ainda está fazendo coisas.
‫Portanto, ele ainda está executando e executando código.
‫E, caso contrário, direi apenas que a ameaça um foi concluída.
‫Então, o encadeamento um do CW foi concluído.
‫Tudo bem, e aqui, é claro, precisamos terminar a string agora, vamos verificar novamente.
‫E o tópico principal terminou e, na verdade, meu console foi fechado.
‫Deixe-me começar com o controle em cinco thread principal iniciado thread uma função iniciada e assim por diante,
‫então não foi feito em um segundo, então tentei funcionar.
‫Dois foi feito.
‫Então diz: OK, não vou esperar mais.
‫Quero dizer discussão.
‫Então, ele executa o thread dois.
‫Aquele ainda está fazendo coisas, então isso significa que a ameaça um está viva, é executada e somente depois que a ameaça
‫principal é encerrada.
‫Portanto, este código aqui é executado na linha trinta e oito.
‫E então nossa ameaça, uma função voltando à cor é chamada ou executada.
‫Tudo bem.
‫Então é isso que você pode verificar e simplesmente verificar, OK.
‫A ameaça está viva ou não?
‫E com base nisso, você pode executar coisas e isso é muito útil.
‫Agora, digamos que queremos ver se a pessoa que está ameaçando ainda está fazendo coisas regularmente.
‫Então, digamos que o usamos para um loop aqui e I é igual a zero.
‫Eu gasto 10 I mais mais.
‫Portanto, dentro desse loop for, quero executar este código.
‫E o que vai fazer é dizer que a ameaça ainda está fazendo coisas
‫e então vai dormir por, digamos, trezentos milissegundos.
‫Portanto, durma por trezentos, o que significa que teremos dez execuções antes que nossa ameaça seja concluída.
‫Então, vamos executar isso mais uma vez.
‫A ameaça um ainda está fazendo coisas prontas e prontas.
‫E, como você pode ver, ele não foi executado dez vezes, embora o sono de ameaça durasse trezentos
‫e vinte segundos e milissegundos e este durasse apenas trezentos milissegundos.
‫Então, o que ele fez foi executar uma ameaça concluída várias vezes; como você pode ver, há uma
‫sobreposição em que a função de ameaça está voltando.
‫Como você pode ver, isso para Loop só foi executado um pouco mais tarde.
‫Portanto, a ordem é a seguinte.
‫Nós começamos aquele.
‫Começamos a iniciar o thread um, esperamos um segundo.
‫Então você pode ver que temos essa junção de um segundo.
‫Então já perdemos três execuções do nosso sono aqui, o que significa que essa ameaça, uma que ainda está
‫fazendo coisas, na verdade só é executada seis vezes aqui, sete ou sete vezes.
‫E então a função de ameaça um volta porque foi iniciada.
‫Em seguida, esperou por um segundo.
‫Nada aconteceu então.
‫Só então começou a fazer todas essas coisas lindas.
‫Portanto, como isso é executado dez vezes, ele executará o sleep várias vezes até que volte à cor.
‫E este terceiro completado é executado super rápido.
‫Portanto, não vai esperar porque não há sono ali.
‫Mas geralmente é isso que você pode fazer com eles vivos.
‫Então você pode geralmente verificar, OK, é a vida, ainda está vivo, ainda está vivo e
‫fazer coisas enquanto está vivo ou fazer outras coisas enquanto está vivo e então não fazer nada ou outra coisa quando estiver
‫pronto.
‫Esse é um exemplo básico de como usar join e está vivo, e espero que você possa entender o conceito.
‫Então, nos vemos no próximo vídeo, onde verificaremos as tarefas.