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:
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 #
- 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.
- 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.
- Os encadeamentos minimizam o uso de recursos do sistema, pois compartilham o mesmo espaço de endereço.
- 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:
- Objetos em c #
- Destruidor em c #
- Destruidor em c #
- Herança em C #
- Destruidor em PHP | Exemplos