Introdução ao multithreading em C #

Para entender o multithreading em c #, vamos primeiro entender o que é um thread?

  • Uma rosca é um processo leve.
  • É um caminho de execução de um programa.
  • É a menor unidade de processamento em um sistema operacional.
  • Assim, um processo pode ter vários threads.

Portanto, multithreading é um processo que contém vários threads em que cada thread executa uma atividade diferente. Isso economiza tempo porque várias tarefas estão sendo executadas ao mesmo tempo por threads diferentes. Aumenta a utilização da CPU e aumenta a eficiência de um aplicativo. Isso funciona no conceito de compartilhamento de tempo.

Sintaxe com Explicação

Thread first_thread_name = new Thread(new ThreadStart(method_to_be_executed1));
Thread second_thread_name = new Thread(new ThreadStart(method_to_be_executed2));
first_thread_name.Start();
second_thread_name.Start();

Para criar um thread, precisamos criar um objeto da classe Thread. O construtor da classe Thread faz referência ao ThreadStart. ThreadStart é um delegado que representa um método que precisa ser executado quando o thread inicia a execução.

O encadeamento inicia a execução quando o método Start () é chamado.

Podemos criar um encadeamento sem usar o delegado ThreadStart, como mostrado na sintaxe abaixo:

Thread thread_name = new Thread(method_to_be_executed);
thread_name.Start();

Criando Vários Threads em C #

Para criar threads, precisamos importar o espaço para nome system.Threading. Podemos criar e inicializar threads usando a classe Thread.

Exemplo usando Classe de Thread

using System;
using System.Threading;
public class MultiThreadingDemo
(
public static void Method1()
(
for (int i = 0; i <= 5; i++)
(
Console.WriteLine("Method1 : (0)", i);
)
)
public static void Method2()
(
for (int i = 0; i <= 5; i++)
(
Console.WriteLine("Method2 : (0)", i);
)
)
public static void Main()
(
// Creating and initializing threads
Thread thread1 = new Thread(Method1);
Thread thread2 = new Thread(Method2);
//beginning thread execution
thread1.Start();
thread2.Start();
)
)

Resultado:

Exemplo usando o delegado ThreadStart

using System;
using System.Threading;
public class MultiThreading
(
public static void Method1()
(
for (int i = 1; i <= 5; i++)
(
Console.WriteLine("Method1 : (0)", i);
)
)
public static void Method2()
(
for (int i = 1; i <= 5; i++)
(
Console.WriteLine("Method2 : (0)", i);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Thread thread1 = new Thread(new ThreadStart(MultiThreading.Method1 ) );
Thread thread2 = new Thread(new ThreadStart(MultiThreading.Method2 ) );
thread1.Start();
thread2.Start();
)
)

Resultado:

Nota: Não é necessário que os métodos usados ​​no multithreading sejam estáticos, como nos dois exemplos acima, ambos os métodos, ie Método1 e Método2, são estáticos. Esses métodos podem ser não estáticos e, nesse caso, primeiro precisamos criar um objeto da classe que contém métodos e, em seguida, podemos acessar os métodos usando o objeto

Em C #, um programa sempre contém um thread, ou seja, Thread Principal. Quando criamos outros threads, ele se torna um programa de multithreading e no multithreading em C #, existem dois tipos de threads:

  • Segmento em primeiro plano : esse segmento continua em execução até concluir seu trabalho, mesmo que o segmento principal termine.
  • Thread de segundo plano : Quando o Thread principal é encerrado, o thread de segundo plano também para de ser executado e termina com o thread principal.

Métodos com exemplos

Vamos ver alguns métodos comumente usados ​​da classe Thread com exemplos.

  • Sleep (): Usado para pausar a execução do encadeamento atual por um período especificado, para que outros encadeamentos iniciem a execução.

Exemplo:

using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 1; i <= 10; i++)
(
Console.WriteLine(i);
//suspending execution of current thread for 100 milliseconds
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
thread1.Start();
thread2.Start();
)
)

Resultado:

A saída mostra que os dois threads foram executados em paralelo.

  • Abort (): Usado para finalizar o encadeamento ou podemos dizer que é usado para interromper a execução do encadeamento permanentemente.

Exemplo

using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 0; i < 10; i++)
(
Console.WriteLine(i);
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
Console.WriteLine("Threads start execution");
thread1.Start();
thread2.Start();
try
(
//terminating execution of thread using Abort()
thread1.Abort();
thread2.Abort();
Console.WriteLine("Threads execution terminated");
)
catch (ThreadAbortException threadAbortException)
(
Console.WriteLine(threadAbortException.ToString());
)
)
)

Resultado:

  • Join (): Usado para fazer com que todos os threads de chamada esperem até o thread atual concluir sua execução e terminar.

Exemplo:

using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 0; i < 5; i++)
(
Thread thread = Thread.CurrentThread;
Console.WriteLine(thread.Name +" : "+i);
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
Thread thread3 = new Thread(new ThreadStart(multithreading.Display));
//Assigning names to threads using Name property
thread1.Name = "Thread1";
thread2.Name = "Thread2";
thread3.Name = "Thread3";
thread1.Start();
//Making Thread2 and Thread3 wait until Thread1 completes execution
thread1.Join();
thread2.Start();
thread3.Start();
)
)

Resultado:

Vantagens do multithreading em C #

  1. Ajuda a manter uma interface de usuário responsiva: às vezes, temos um método demorado em nosso aplicativo. Nesse caso, se tornarmos nosso aplicativo multithread, então outro thread assumirá a responsabilidade pela execução desse método, enquanto o thread Main poderá se concentrar na capacidade de resposta do aplicativo. Portanto, não congelará nosso aplicativo, fornecendo uma resposta adequada ao usuário em tempo hábil.
  2. Aumenta o desempenho do aplicativo: se tivermos tantos threads quanto núcleos de processador, cada thread será executado independentemente, aumentando o número de cálculos por segundo.
  3. Os encadeamentos minimizam o uso de recursos do sistema, pois compartilham o mesmo espaço de endereço.
  4. Torna o código mais rápido e mais simples ao mesmo tempo.

Conclusão - Multithreading em C #

A classe Thread fornece muitas propriedades importantes, como Prioridade, Nome, IsAlive, segundo plano, que podemos usar em nosso aplicativo multithreading. A Sincronização de Encadeamentos é uma técnica pela qual um encadeamento pode acessar um recurso por um tempo específico sem a interrupção de outros encadeamentos até que sua tarefa seja concluída.

Artigos recomendados

Este foi um guia para o Multithreading em C #. Aqui também discutimos sua introdução, sintaxe, criação e exemplos de multithreading em c #. Você também pode dar uma olhada nos seguintes artigos para saber mais:

  1. Objetos em c #
  2. Destruidor em c #
  3. Destruidor em c #
  4. Herança em C #
  5. Destruidor em PHP | Exemplos

Categoria:

Desenvolvimento de software