线程打印，用户模式构造

namespace Lesson6;

public class DEMO1
{
    public static void Main()
    {
        //一个简单的混合锁
        SimpleHybridLock SimpleHybridLock = new SimpleHybridLock();
        //创建一个新的线程命名为 2 thread,每隔2秒打印1次时间及相关的线程，打印颜色为绿色；
        Thread thread2 = new Thread(() => {
            Thread.CurrentThread.Name = "2 thread";
            while (true)
            {
                SimpleHybridLock.Enter();
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine($"Thread name: {Thread.CurrentThread.Name} Time:{DateTime.Now.ToString("HHmmss fff")}");
                SimpleHybridLock.Leave();
                Thread.Sleep(2000);
            }

        });
        thread2.Name = "2 thread";

        //创建一个新的线程命名为 3 thread,每隔2秒打印1次时间及相关的线程，打印颜色为黄色；
        Thread thread3 = new Thread(() => {
            Thread.CurrentThread.Name = "3 thread";
            while (true)
            {
                SimpleHybridLock.Enter();
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine($"Thread name: {Thread.CurrentThread.Name} Time:{DateTime.Now.ToString("HHmmss fff")}");
                SimpleHybridLock.Leave();
                Thread.Sleep(4000);
            }

        });
        thread3.Name = "2 thread";

        thread2.Start();
        thread3.Start();

        //在主线程命名为 1 thread ,每隔1秒打印1次当前时间及相关的线程，打印颜色为红色；
        Thread.CurrentThread.Name = "1 thread";
        while (true)
        {
            SimpleHybridLock.Enter();
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine($"Thread name: {Thread.CurrentThread.Name} Time:{DateTime.Now.ToString("HHmmss fff")}");
            SimpleHybridLock.Leave();
            Thread.Sleep(1000);
        }
    }
}

public sealed class SimpleHybridLock : IDisposable
{
    //int由基元用户模式构造（interlocked的方法）使用
    private Int32 m_waiters = 0;

    //autoResetEvent基元内核模式构造
    private AutoResetEvent m_waiterLock = new AutoResetEvent(false);

    public void Enter()
    {
        //指出这个线程想要获得锁
        if (Interlocked.Increment(ref m_waiters) == 1)
        {
            return;//锁可以使用，无竞争，直接返回
        }
        //另一个线程用有锁（发送竞争），使这个线程等待
        m_waiterLock.WaitOne();//这里产生性能消耗
        //waitone返回后，这个线程拿到了锁
    }
    public void Leave()
    {
        //这个线程准备释放锁
        if (Interlocked.Decrement(ref m_waiters) == 0)
        {
            return;
        }
        //其他线程正在阻塞，唤醒其中一个
        m_waiterLock.Set();

    }
    public void Dispose()
    {
        m_waiterLock.Dispose();
    }
}