‫Bem-vindo de volta e a última palavra.
‫Você viu como usar ameaças e como configurá-las e simplesmente iniciá-las.
‫E neste vídeo, vamos dar uma olhada na conclusão.
‫Então, queremos usar um thread para fazer algo.
‫E somente se uma tarefa específica for realizada, então queremos ir em frente.
‫Então, vamos dar uma olhada nisso.
‫Vou criar uma nova variável chamada Fonte de conclusão da tarefa e, portanto, preciso de uma nova tarefa, fonte de
‫conclusão e um booleano.
‫Como você pode ver, ele está reclamando porque não sabe o que é essa fonte de conclusão de tarefa.
‫E, para consertá-lo, preciso usar tarefas de threading do sistema.
‫Vou fazer isso por um segundo e depois ouvir o que vou fazer a seguir é apenas criar uma variável
‫de teste.
‫Vou apenas chamar uma tarefa, que é uma fonte de conclusão de tarefa, ou apenas chamamos essa fonte de conclusão
‫de tarefa.
‫E dissemos que é tarefa para os resultados.
‫Então, queremos ter o resultado dessa tarefa.
‫Digamos que haja uma tarefa específica que deve ser executada e fazer algo e, em seguida, queremos ver os
‫resultados.
‫Então, se deu certo ou não deu certo e para testar isso, vou me livrar desta linha vermelha aqui.
‫Vou apenas executar o código como se não houvesse mais nada neste método principal, apenas este código aqui.
‫Então, vou executá-lo.
‫E como você pode ver, nada acontece.
‫Portanto, o console é mantido ativo ou aberto, mesmo que não tenhamos essa linha vermelha do
‫console, que normalmente sempre usamos se quisermos manter o console aberto, isso significa que há algo que não foi concluído.
‫Então, isso aqui nunca termina porque não há resultados.
‫Portanto, essa fonte de conclusão nunca está realmente completa.
‫Portanto, nunca é definido como verdadeiro.
‫E isso é algo que podemos fazer manualmente.
‫Então, digamos que temos uma tarefa e queremos ter o resultado como o temos aqui, mas na verdade queremos terminar a
‫tarefa em um ponto.
‫Então, o que precisamos fazer para isso é criar um thread.
‫Vou criar um thread
‫maior igual a um novo thread e esse thread não será iniciado imediatamente.
‫Portanto, estou usando uma abordagem um pouco diferente da que fizemos aqui.
‫Então aqui nós dissemos novo tópico e então tínhamos o corpo do tópico.
‫Portanto, o código que deve ser executado sempre que este thread é iniciado e nós iniciamos
‫imediatamente, começamos imediatamente.
‫Mas aqui nós apenas criamos o thread e podemos fazer coisas com ele mais tarde.
‫Então aqui vou apenas dizer thread sleep.
‫Então, apenas durma por, digamos, 1000 milissegundos e depois tente definir a fonte de conclusão da
‫tarefa como verdadeira.
‫Portanto, tente definir o resultado que fará é tentar fazer a transição da tarefa subjacente para as tarefas que são executadas para o
‫estado de conclusão, o que significa que está concluído.
‫Direito.
‫Então ele vai tentar dizer que é verdade.
‫Isso significa que essa fonte de conclusão da tarefa será definida como verdadeira e só então chegaremos até aqui,
‫que é o resultado dessa tarefa.
‫Então, vamos criar uma pequena etapa aqui, então Dybbuk Step e a verificação, os IDs de ameaças, e agora, para iniciar uma
‫ameaça, na verdade precisamos chamar o thread desse início.
‫E como você pode ver, este objeto thread aqui, que é um thread que fará tudo isso, será
‫iniciado.
‫Vou começar um tópico como este.
‫E já que estamos nisso, vamos dar uma olhada no que o segmento tem a oferecer.
‫Portanto, sempre que você cria um objeto thread, existem várias propriedades e métodos para usar ou podemos usar
‫vários aqui.
‫Portanto, você pode ver que um quadro é aquele onde você pode abortar o tópico para interrompê-lo, mas
‫isso executará ou causará uma exceção.
‫Então, isso é muito perigoso de se fazer.
‫Portanto, você pode travar seu aplicativo com base na segurança que temos, construa-o.
‫Mas uma placa é algo que você pode, é claro, usar para parar um thread, mas nunca se sabe a que distância ela
‫está e sua execução.
‫Portanto, pode acontecer que ele não tenha feito bem as tarefas que você desejava.
‫E isso vai custar, bem, o seu problema não funcionar corretamente.
‫E então, é claro, existem muitos outros métodos que são muito interessantes, como propriedades de palavras como este está vivo, o que
‫significa que esta ameaça está atualmente viva e depois em seu plano de fundo, o que significa que podemos dizer que
‫um thread deve ser executado em segundo plano e podemos verificar com esta propriedade se ela está em segundo
‫plano ou não é uma ameaça de pool de ameaças.
‫Isso é algo que verificaremos mais tarde.
‫Então, o que é um pool de ameaças?
‫Isso é o que veremos mais tarde e assim por diante.
‫Então, essa ID de ameaça gerenciada é algo muito interessante, que nos dirá sobre a ideia da ameaça que
‫estamos executando no momento.
‫Então, vamos usar isso.
‫Vamos imprimir isso no console.
‫Então, CW e eu usaremos o thread não dessa forma.
‫Então, você usa o cifrão e tem o número da ameaça ou a ID da ameaça para poder ligar.
‫E então em colchetes você costumava encadear id menaged assim.
‫Thread gerenciado por thread, Edem, e é claro, você precisa fechar uma string.
‫Tudo bem, agora vamos testar.
‫Vamos executar o código.
‫E nós temos nossa principal ameaça, e até agora temos algo no console, como você pode ver, o número
‫da ameaça é três.
‫Portanto, o número dessa ameaça que temos aqui e que criamos é na verdade três.
‫E a principal ameaça é o ID gerenciado.
‫Como você pode ver, os números não precisam ser da maneira que você espera.
‫Portanto, embora não tenhamos criado nossa própria ameaça adicional aqui, ela vai de um para três.
‫Portanto, deve haver outras ameaças em execução que não vemos aqui.
‫Tudo bem.
‫E a propósito, se você quiser ver se o tópico começou e terminou, você pode fazer o seguinte.
‫Então, vamos cortar isso aqui e colocá-lo nesta linha aqui e, na verdade, digamos que começou.
‫E aqui não podemos usar thread porque thread é esse thread que criamos aqui.
‫Mas se quisermos usá-lo aqui dentro do próprio corpo do segmento e precisaremos usar o segmento atual de ponto de
‫segmento.
‫Então, se fizermos isso agora, teremos o segmento em que estamos atualmente, que é exatamente isso.
‫E aqui dizemos que começou e depois de concluído, dizemos que terminou e agora vamos executá-lo.
‫Para executar o código e como você pode ver, nada é exibido no console.
‫Vamos para a próxima etapa.
‫E então começou e terminou, então aconteceu bem rápido, mas como você pode ver, existem, então vamos dar um pouco
‫mais de tempo.
‫Vamos mudar para cinco segundos.
‫E também vamos nos livrar desse ponto Dybbuk aqui e vamos executá-lo.
‫A ameaça número três começou, demorou um pouco e acabou.
‫Agora você vê que esta linha de código é realmente executada corretamente e simplesmente para o nosso console.
‫Portanto, vamos fazer com que o console leia uma linha para mantê-lo aberto.
‫Portanto, a ameaça número três começou e, cinco segundos depois, deve terminar, de modo que a ameaça número
‫três terminou.
‫Agora, digamos que queremos ver se a tarefa realmente funcionou, então se funcionou para defini-la como verdadeira ou
‫não?
‫Bem, sabemos porque, de outra forma, não iríamos para a próxima etapa.
‫Mas vamos usar a linha certa do console aqui.
‫Tarefa concluída.
‫E aqui é só escrever o resultado, que será o teste.
‫Então o teste é apenas um touro, como você pode ver aqui, porque funcionou ou não funcionou, então o resultado é
‫verdadeiro ou falso.
‫Então, vamos dar uma olhada.
‫E agora precisamos esperar cinco segundos.
‫O número três começou cinco segundos e, em seguida, o número três terminou e diz que a tarefa foi realizada é igual a
‫verdadeiro.
‫Então é isso que está acontecendo aqui com esta linha.
‫Portanto, ele simplesmente diz que foi feito com essa tarefa específica.
‫Tudo bem, então neste vídeo, você viu como você pode usar a fonte de conclusão da tarefa,
‫que indica se uma tarefa foi feita ou não, você pode enviá-la para o Drew ou pode simplesmente fazer algo e ser feito
‫depois de um tempo também para que você pode criar um thread de uma maneira diferente, então você pode realmente
‫criar uma variável de thread, que você então tem que iniciar, é claro, e você pode simplesmente usar como um objeto do thread de
‫classe.
‫E então vimos como podemos usar o tópico I. D. portanto, conhecemos a ideia dessa ameaça específica.
‫E isso é algo que veremos um pouco mais no próximo vídeo,
‫onde criamos vários threads ao mesmo tempo e veremos como isso será tratado por nossa máquina.
‫Então nos vemos no próximo vídeo.