Início / coding / Perguntas / 79237404
Accepted
Minimus Heximus
Asked: 2024-11-29 22:17:13 +0800 CST

Por que a saída deste programa multithread varia a menos que Thread.Join seja usado ou Thread.Sleep seja removido?

  • 772

Tenho o seguinte programa, onde gero 1000 threads para incrementar uma variável compartilhada a e então faço cada thread dormir por 1 segundo:

using System;
using System.Diagnostics;
using System.Diagnostics.Metrics;
using System.Runtime.CompilerServices;
using System.Threading;

class Program
{

    static volatile int a = 0;
    static void Main()
    {
        List<Thread> threads = new List<Thread>();
        for (int i = 0; i < 1000; i++)
        {
            var t = new Thread(() =>
            {
                a++;
                Thread.Sleep(1000);
            });
            t.Start();
            threads.Add(t);
        }
        // foreach(Thread t in threads) t.Join();
        Thread.Sleep(60000);
        Console.WriteLine(a);
        Console.ReadKey();
    }
}

Problema:

Quando executo este código com a linha Thread.Sleep(1000) incluída e t.Join() comentado, a saída de Console.WriteLine(a) é menor que 1000, mesmo que eu aguarde 60 segundos para que os threads terminem.

Se eu descomentar o loop t.Join() ou comentar a linha Thread.Sleep(1000), a saída será consistentemente 1000.

Questões:

Por que a saída varia quando Thread.Sleep(1000) está presente e t.Join() está comentado?

Por que a saída se torna consistente (sempre 1000) quando t.Join() é usado ou Thread.Sleep(1000) é removido?

Eu apreciaria uma explicação do que está acontecendo aqui em termos de comportamento de thread e sincronização. Obrigado!

c#

2 respostas

  1. Best Answer

    TBH não foi capaz de reproduzir o efeito foreach(Thread t in threads) t.Join();vs Thread.Sleep- ambos consistentemente (em um número relativamente pequeno de tentativas, no entanto) dão a soma "esperada" (talvez haja alguma diferença de configuração que faça com que nem todos os threads consigam completar, embora isso Thread.Sleep(60000)seja muito duvidoso). Eu sugeriria alterar o código para:

    var t = new Thread(() =>
{
    Thread.Sleep(1000);   
    a++;
});

    ou seja, altere a ordem das operações, então o foreach(Thread t in threads) t.Join();truque vai parar de funcionar (pelo menos "na minha máquina"). O fato de que foi uma mera coincidência, eu diria que relacionado ao fato de que a++é uma operação relativamente rápida e, como você está iniciando o thread antes de adicioná-lo à lista e criar o próximo, ele tem tempo suficiente para ser concluído.

    Alterar a ordem de suspensão e incremento traz (pelo menos para mim) o problema principal à tona: incremento ( a++) não é atômico , e usá-lo em contexto multithread torna seu programa inválido . Você deve usar alguma sincronização ou versão atômica da operação (se houver).

    Por exemplo, Interlocked.Incrementtornará seu programa correto:

    var t = new Thread(() =>
{
    Thread.Sleep(1000);   
    Interlocked.Increment(ref a);
});

    Eu também recomendo conferir:

    1. Threading em C# por Joseph Albahari - um pouco datado por conceitos ainda relevantes
    2. The Deadlock Empire - o jogo expondo algumas armadilhas de atomicidade e sincronização (via .NET)
    • 4

  2. Por que a saída varia quando Thread.Sleep(1000) está presente e t.Join() está comentado?

    O SO pode agendar threads sempre que desejar. Então, é provável que nem todas as threads tenham tido a chance de rodar. Como o SO não fornece nenhuma garantia de tempo específica, você não pode confiar apenas em esperar para garantir que as threads rodaram.

    Por que a saída se torna consistente (sempre 1000) quando t.Join()

    Join bloqueia a execução do thread atual até que o thread de junção tenha sido concluído. Então, se você juntar todos os threads, você pode ter certeza de que todos os threads concluíram a execução.

    Mas isso não significa que aseja garantido que seja 1000. É possível que o primeiro thread:

    1. Leia acomo0
    2. Seja preemptado pelo sistema operacional
    3. Retomar a execução após a conclusão de todos os outros threads
    4. Incremento apara1
    5. Escreva 1de memória

    Resultar em uma saída de 1 volatilenão impede isso, você precisaria de um bloqueio, ou Interlocked.Increment para incrementar uma variável com segurança.

    Multithreading é difícil , e você não pode usar testes como este para verificar se um comportamento está correto. Um teste pode ser bem-sucedido um milhão de vezes, mas falhar em outro computador, ou quando há uma carga alta, ou quando há lua cheia. Na melhor das hipóteses, você pode verificar se um comportamento está incorreto . Você precisa saber os perigos e como resolvê-los. As melhores práticas de threading gerenciado são um bom começo, mas há muitos outros bons artigos sobre segurança de thread.

    • 3

relate perguntas