C# - Multithreading

Um tópico é definido como o caminho de execução de um programa. Cada thread define um fluxo de controle exclusivo. Se seu aplicativo envolve operações complicadas e demoradas, geralmente é útil definir diferentes caminhos ou threads de execução, com cada thread executando um trabalho específico.

Threads são processos leves . Um exemplo comum de uso de thread é a implementação de programação simultânea por sistemas operacionais modernos. O uso de threads economiza o desperdício do ciclo da CPU e aumenta a eficiência de um aplicativo.

Até agora escrevemos os programas onde um único thread é executado como um único processo que é a instância em execução do aplicativo. No entanto, desta forma, o aplicativo pode executar um trabalho por vez. Para fazê-lo executar mais de uma tarefa por vez, ele pode ser dividido em threads menores.

Ciclo de vida da rosca

O ciclo de vida de um thread começa quando um objeto da classe System.Threading.Thread é criado e termina quando o thread é encerrado ou conclui a execução.

A seguir estão os vários estados no ciclo de vida de um thread -

O estado não iniciado − É a situação em que a instância da thread é criada mas o método Start não é chamado.
O estado pronto − É a situação em que a thread está pronta para rodar e aguardando ciclo de CPU.
O estado não executável − Uma thread não é executável, quando
- O método de suspensão foi chamado
- O método Wait foi chamado
- Bloqueado por operações de E/S
O estado morto − É a situação em que a thread conclui a execução ou é abortada.

O Tópico Principal

Em C#, o System.Threading.Thread A classe é usada para trabalhar com threads. Ele permite criar e acessar threads individuais em um aplicativo multithread. A primeira thread a ser executada em um processo é chamada de principal fio.

Quando um programa C# inicia a execução, o thread principal é criado automaticamente. Os threads criados usando o Thread são chamadas de threads filho da thread principal. Você pode acessar um tópico usando o CurrentThread propriedade da classe Thread.

O programa a seguir demonstra a execução do thread principal -
Demonstração ao vivo

using System;
using System.Threading;

namespace MultithreadingApplication {
   class MainThreadProgram {
      static void Main(string[] args) {
         Thread th = Thread.CurrentThread;
         th.Name = "MainThread";
         
         Console.WriteLine("This is {0}", th.Name);
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

This is MainThread

Propriedades e métodos da classe Thread

A tabela a seguir mostra algumas das propriedades mais usadas do Tópico classe -

Nº Sr.	Propriedade e descrição
1	Contexto Atual Obtém o contexto atual no qual o thread está sendo executado.
2	Cultura atual Obtém ou define a cultura do thread atual.
3	Princípio Atual Obtém ou define o principal atual do thread (para segurança baseada em função).
4	CurrentThread Obtém o thread em execução no momento.
5	AtualUICultura Obtém ou define a cultura atual usada pelo Resource Manager para pesquisar recursos específicos da cultura em tempo de execução.
6	Contexto de Execução Obtém um objeto ExecutionContext que contém informações sobre os vários contextos do thread atual.
7	está vivo Obtém um valor que indica o status de execução do thread atual.
8	IsBackground Obtém ou define um valor que indica se um thread é ou não um thread em segundo plano.
9	IsThreadPoolThread Obtém um valor que indica se um thread pertence ou não ao pool de threads gerenciado.
10	ManagedThreadId Obtém um identificador exclusivo para o thread gerenciado atual.
11	Nome Obtém ou define o nome do thread.
12	Prioridade Obtém ou define um valor que indica a prioridade de agendamento de um thread.
13	ThreadState Obtém um valor que contém os estados do thread atual.

A tabela a seguir mostra alguns dos métodos mais usados do Tópico classe -

Nº Sr.	Método e descrição
1	public void Abort() Gera um ThreadAbortException no thread em que é invocado, para iniciar o processo de encerramento do thread. Chamar esse método geralmente encerra o thread.
2	public estático LocalDataStoreSlot AllocateDataSlot() Aloca um slot de dados sem nome em todos os threads. Para melhor desempenho, use campos marcados com o atributo ThreadStaticAttribute.
3	public estático LocalDataStoreSlot AllocateNamedDataSlot(nome da string) Aloca um slot de dados nomeado em todos os threads. Para melhor desempenho, use campos marcados com o atributo ThreadStaticAttribute.
4	public static void BeginCriticalRegion() Notifica um host que a execução está prestes a entrar em uma região de código na qual os efeitos de uma interrupção de thread ou exceção sem tratamento podem comprometer outras tarefas no domínio do aplicativo.
5	public static void BeginThreadAffinity() Notifica um host que o código gerenciado está prestes a executar instruções que dependem da identidade do thread do sistema operacional físico atual.
6	public static void EndCriticalRegion() Notifica um host que a execução está prestes a entrar em uma região de código na qual os efeitos de uma interrupção de thread ou exceção sem tratamento estão limitados à tarefa atual.
7	public static void EndThreadAffinity() Notifica um host que o código gerenciado concluiu a execução de instruções que dependem da identidade do thread do sistema operacional físico atual.
8	public static void FreeNamedDataSlot(nome da string) Elimina a associação entre um nome e um slot, para todos os threads no processo. Para melhor desempenho, use campos marcados com o atributo ThreadStaticAttribute.
9	objeto estático público GetData(slot LocalDataStoreSlot) Recupera o valor do slot especificado no thread atual, dentro do domínio atual do thread atual. Para melhor desempenho, use campos marcados com o atributo ThreadStaticAttribute.
10	AppDomain estático público GetDomain() Retorna o domínio atual no qual o thread atual está sendo executado.
11	AppDomain estático público GetDomainID() Retorna um identificador de domínio de aplicativo exclusivo
12	public static LocalDataStoreSlot GetNamedDataSlot(nome da string) Procura um slot de dados nomeado. Para melhor desempenho, use campos marcados com o atributo ThreadStaticAttribute.
13	interrupção public void() Interrompe um thread que está no estado de thread WaitSleepJoin.
14	public void Join() Bloqueia o thread de chamada até que um thread termine, enquanto continua a executar o bombeamento padrão de COM e SendMessage. Este método tem diferentes formas sobrecarregadas.
15	public static void MemoryBarrier() Sincroniza o acesso à memória da seguinte forma:O processador que executa o thread atual não pode reordenar instruções de tal forma que os acessos à memória antes da chamada a MemoryBarrier sejam executados após os acessos à memória que seguem a chamada a MemoryBarrier.
16	public static void ResetAbort() Cancela um Abort solicitado para o thread atual.
17	public static void SetData(LocalDataStoreSlot slot, dados do objeto) Define os dados no slot especificado no thread em execução no momento, para o domínio atual desse thread. Para melhor desempenho, use campos marcados com o atributo ThreadStaticAttribute.
18	public void Iniciar() Inicia um tópico.
19	public static void Sleep(int milissegundosTimeout) Faz o thread pausar por um período de tempo.
20	public static void SpinWait(int iterations) Faz com que um encadeamento espere o número de vezes definido pelo parâmetro de iterações
21	byte estático público VolatileRead(endereço de byte de referência) public static double VolatileRead(ref double address) public static int VolatileRead(ref int address) objeto estático público VolatileRead(ref endereço do objeto) Lê o valor de um campo. O valor é o mais recente gravado por qualquer processador em um computador, independentemente do número de processadores ou do estado do cache do processador. Este método tem diferentes formas sobrecarregadas. Apenas alguns são dados acima.
22	public static void VolatileWrite(ref byte address,byte value) public static void VolatileWrite(ref double address, double value) public static void VolatileWrite(ref int address, int value) public static void VolatileWrite(ref endereço do objeto, valor do objeto) Grava um valor em um campo imediatamente, para que o valor fique visível para todos os processadores no computador. Este método tem diferentes formas sobrecarregadas. Apenas alguns são dados acima.
23	public static bool Yield() Faz com que o thread de chamada produza a execução para outro thread que está pronto para ser executado no processador atual. O sistema operacional seleciona o encadeamento ao qual ceder.

Criando tópicos

Os threads são criados estendendo a classe Thread. A classe Thread estendida então chama o Start() método para iniciar a execução do thread filho.

O programa a seguir demonstra o conceito −
Demonstração ao vivo

using System;
using System.Threading;

namespace MultithreadingApplication {
   class ThreadCreationProgram {
      public static void CallToChildThread() {
         Console.WriteLine("Child thread starts");
      }
      static void Main(string[] args) {
         ThreadStart childref = new ThreadStart(CallToChildThread);
         Console.WriteLine("In Main: Creating the Child thread");
         Thread childThread = new Thread(childref);
         childThread.Start();
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

In Main: Creating the Child thread
Child thread starts

Gerenciando tópicos

A classe Thread fornece vários métodos para gerenciar threads.

O exemplo a seguir demonstra o uso da função sleep() método para fazer uma pausa de thread por um período de tempo específico.
Demonstração ao vivo

using System;
using System.Threading;

namespace MultithreadingApplication {
   class ThreadCreationProgram {
      public static void CallToChildThread() {
         Console.WriteLine("Child thread starts");
         
         // the thread is paused for 5000 milliseconds
         int sleepfor = 5000; 
         
         Console.WriteLine("Child Thread Paused for {0} seconds", sleepfor / 1000);
         Thread.Sleep(sleepfor);
         Console.WriteLine("Child thread resumes");
      }
      
      static void Main(string[] args) {
         ThreadStart childref = new ThreadStart(CallToChildThread);
         Console.WriteLine("In Main: Creating the Child thread");
         
         Thread childThread = new Thread(childref);
         childThread.Start();
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

In Main: Creating the Child thread
Child thread starts
Child Thread Paused for 5 seconds
Child thread resumes

Destruindo Tópicos

O Abortar() é usado para destruir threads.

O tempo de execução aborta o encadeamento lançando um ThreadAbortException . Esta exceção não pode ser capturada, o controle é enviado para o finalmente bloco, se houver.

O programa a seguir ilustra isso -
Demonstração ao vivo

using System;
using System.Threading;

namespace MultithreadingApplication {
   class ThreadCreationProgram {
      public static void CallToChildThread() {
         try {
            Console.WriteLine("Child thread starts");
            
            // do some work, like counting to 10
            for (int counter = 0; counter <= 10; counter++) {
               Thread.Sleep(500);
               Console.WriteLine(counter);
            }
            
            Console.WriteLine("Child Thread Completed");
         } catch (ThreadAbortException e) {
            Console.WriteLine("Thread Abort Exception");
         } finally {
            Console.WriteLine("Couldn't catch the Thread Exception");
         }
      }
      static void Main(string[] args) {
         ThreadStart childref = new ThreadStart(CallToChildThread);
         Console.WriteLine("In Main: Creating the Child thread");
         
         Thread childThread = new Thread(childref);
         childThread.Start();
         
         //stop the main thread for some time
         Thread.Sleep(2000);
         
         //now abort the child
         Console.WriteLine("In Main: Aborting the Child thread");
         
         childThread.Abort();
         Console.ReadKey();
      }
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

In Main: Creating the Child thread
Child thread starts
0
1
2
In Main: Aborting the Child thread
Thread Abort Exception
Couldn't catch the Thread Exception

C# - Códigos inseguros No

Linguagem C