Vida

Como usar o multiencadeamento com tarefas em c #

Como usar o multiencadeamento com tarefas em c #


We are searching data for your request:

Forums and discussions:
Manuals and reference books:
Data from registers:
Wait the end of the search in all databases.
Upon completion, a link will appear to access the found materials.

O termo de programação do computador "thread" é ​​abreviação de thread de execução, no qual um processador segue um caminho especificado no seu código. O conceito de seguir mais de um segmento de cada vez introduz o assunto de multitarefa e multithreading.

Um aplicativo possui um ou mais processos. Pense em um processo como um programa em execução no seu computador. Agora cada processo possui um ou mais encadeamentos. Um aplicativo de jogo pode ter um encadeamento para carregar recursos do disco, outro para fazer IA e outro para executar o jogo como um servidor.

No .NET / Windows, o sistema operacional aloca tempo do processador para um encadeamento. Cada encadeamento controla os manipuladores de exceção e a prioridade com que é executado e tem um local para salvar o contexto do encadeamento até que seja executado. O contexto do encadeamento é a informação que o encadeamento precisa retomar.

Tarefas múltiplas com threads

Os threads ocupam um pouco de memória e a criação deles leva um pouco de tempo; portanto, geralmente você não deseja usar muitos. Lembre-se, eles competem pelo tempo do processador. Se o seu computador tiver várias CPUs, o Windows ou .NET poderá executar cada thread em uma CPU diferente, mas se vários threads forem executados na mesma CPU, apenas um poderá estar ativo por vez e a troca de threads demorará.

A CPU executa um encadeamento para alguns milhões de instruções e depois muda para outro encadeamento. Todos os registros da CPU, o ponto de execução do programa atual e a pilha precisam ser salvos em algum lugar para o primeiro encadeamento e depois restaurados em outro lugar no próximo encadeamento.

Criando um Thread

No espaço para nome Sistema. Threading, você encontrará o tipo de thread. O thread do construtor (ThreadStart) cria uma instância de um thread. No entanto, no código C # recente, é mais provável que você passe uma expressão lambda que chama o método com qualquer parâmetro.

Se você não tiver certeza sobre expressões lambda, vale a pena conferir o LINQ.

Aqui está um exemplo de um segmento que é criado e iniciado:

using System;

using System.Threading;
namespace ex1
{
Programa de aula
{
estático público Write1 ()
{
Console.Write ('1');
Thread.Sleep (500);
}
static void Main (string args)
{
var tarefa = novo segmento (Write1);
task.Start ();
for (var i = 0; i <10; i ++)
{
Console.Write ('0');
Console.Write (task.IsAlive? 'A': 'D');
Thread.Sleep (150);
}
Console.ReadKey ();
}
}
}

Todo este exemplo é escrever "1" no console. O segmento principal grava um "0" no console 10 vezes, cada vez seguido por um "A" ou "D", dependendo se o outro segmento ainda está ativo ou morto.

O outro thread é executado apenas uma vez e grava um "1". Após o atraso de meio segundo no segmento Write1 (), o segmento termina e o Task.IsAlive no loop principal agora retorna "D."

Pool de threads e biblioteca paralela de tarefas

Em vez de criar seu próprio encadeamento, a menos que você realmente precise fazer isso, use um Pool de Encadeamentos. No .NET 4.0, temos acesso à Task Parallel Library (TPL). Como no exemplo anterior, novamente precisamos de um pouco de LINQ e, sim, são todas expressões lambda.

O Tasks usa o Pool de threads nos bastidores, mas faz melhor uso dos threads, dependendo do número em uso.

O principal objeto no TPL é uma tarefa. Esta é uma classe que representa uma operação assíncrona. A maneira mais comum de começar a rodar é com o Task.Factory.StartNew como em:

Task.Factory.StartNew (() => DoSomething ());

Onde DoSomething () é o método que é executado. É possível criar uma tarefa e não executá-la imediatamente. Nesse caso, basta usar a tarefa assim:

var t = nova tarefa (() => Console.WriteLine ("Hello"));

t.Start ();

Isso não inicia o thread até que o .Start () seja chamado. No exemplo abaixo, há cinco tarefas.

using System;
using System.Threading;
using System.Threading.Tasks;
namespace ex1
{
Programa de aula
{
Write1 vazio estático público (int i)
{
Console.Write (i);
Thread.Sleep (50);
}
static void Main (string args)
{
for (var i = 0; i <5; i ++)
{
valor var = i;
var runningTask = Task.Factory.StartNew (() => Write1 (valor));
}
Console.ReadKey ();
}
}
}

Execute isso e você obtém os dígitos de 0 a 4 de saída em uma ordem aleatória como 03214. Isso ocorre porque a ordem de execução da tarefa é determinada pelo .NET.

Você pode estar se perguntando por que o valor var = i é necessário. Tente removê-lo e chame Write (i), e você verá algo inesperado como 55555. Por que isso? É porque a tarefa mostra o valor de i no momento em que a tarefa é executada, não quando a tarefa foi criada. Ao criar uma nova variável a cada vez no loop, cada um dos cinco valores é armazenado e selecionado corretamente.


Video, Sitemap-Video, Sitemap-Videos