Minimus Heximus's questions

Depois da minha pergunta anterior , tentei consertar o código, mas ainda assim a saída não é o que eu esperava. Tentei definir um inteiro thread safe:

using System;
using System.Threading;

public struct SInt
{
    private int _value;

    public SInt(int initialValue = 0)
    {
        _value = initialValue;
    }

    public int Value => Volatile.Read(ref _value); // Interlocked.CompareExchange(ref _value, 0, 0);

    // Add a value
    public int Add(int value) => Interlocked.Add(ref _value, value);

    // Subtract a value
    public int Subtract(int value) => Interlocked.Add(ref _value, -value);

    // Multiply the value
    public int Multiply(int value)
    {
        int initial, computed;
        do
        {
            initial = Value;
            computed = initial * value;
        }
        while (Interlocked.CompareExchange(ref _value, computed, initial) != initial);

        return computed;
    }

    // Divide the value
    public int Divide(int value)
    {
        if (value == 0)
            throw new DivideByZeroException();

        int initial, computed;
        do
        {
            initial = Value;
            computed = initial / value;
        }
        while (Interlocked.CompareExchange(ref _value, computed, initial) != initial);
        return computed;
    }

    // Increment the value
    public int Increment() => Interlocked.Increment(ref _value);

    // Decrement the value
    public int Decrement() => Interlocked.Decrement(ref _value);

    // Overloaded operators
    public static SInt operator +(SInt a, int b)
    {
        a.Add(b);
        return a;
    }

    public static SInt operator -(SInt a, int b)
    {
        a.Subtract(b);
        return a;
    }

    public static SInt operator *(SInt a, int b)
    {
        a.Multiply(b);
        return a;
    }

    public static SInt operator /(SInt a, int b)
    {
        a.Divide(b);
        return a;
    }

    public static SInt operator ++(SInt a)
    {
        a.Increment();
        return a;
    }

    public static SInt operator --(SInt a)
    {
        a.Decrement();
        return a;
    }

    // Equality operators
    public static bool operator ==(SInt a, SInt b) => a.Value == b.Value;

    public static bool operator !=(SInt a, SInt b) => a.Value != b.Value;

    // Comparison operators
    public static bool operator <(SInt a, SInt b) => a.Value < b.Value;
    public static bool operator <=(SInt a, SInt b) => a.Value <= b.Value;
    public static bool operator >(SInt a, SInt b) => a.Value > b.Value;
    public static bool operator >=(SInt a, SInt b) => a.Value >= b.Value;

    // Implicit conversion from int to SInt
    public static implicit operator SInt(int value) => new SInt(value);

    // Implicit conversion from SInt to int
    public static implicit operator int(SInt sInt) => sInt.Value;

    public override bool Equals(object? obj)
    {
        if (obj is SInt other)
        {
            return this == other;
        }
        return false;
    }

    public override int GetHashCode() => Value.GetHashCode();

    public override string ToString() => Value.ToString();
}

Então reescrevi o programa:

using System;
using System.Diagnostics;
using System.Threading;

class Program
{
    static void Main(string[] args)
    {
        List<Thread> threads = new List<Thread>();
        SInt s = 0;
        Stopwatch stopwatch = new Stopwatch();
        stopwatch.Start();
        for (int i = 0; i <1000; i++)
        {
            var t = new Thread(() =>
            {
                s++;
                Thread.Sleep(1000);
            });
            t.Priority = ThreadPriority.Highest;
            threads.Add(t);
            t.Start();
        }
        foreach (var t in threads)
            t.Join();
        stopwatch.Stop();
        Console.WriteLine($"Time: {stopwatch.ElapsedMilliseconds / 1000.0} Seconds");
        Console.WriteLine(s);
        Console.WriteLine(threads.Count(t => t.ThreadState == System.Threading.ThreadState.Stopped));
        Console.ReadKey();
    }
}

saída no meu laptop:

Time: 85.16 Seconds
989
1000

Espero que 989 seja 1000.

O que está errado?

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!