.net 理解信号量有很多困难

这是一个基本代码，我的目标是打印出aaabbcaaabc…等等

信号量（int，int）中两个参数的意义是什么

有人能解释为什么我得到输出BBAAABBC，然后它就结束了吗

总的来说，当我修改代码并观察输出时，我真的很难看到模式

    #include "stdafx.h"

    using namespace System;
    using namespace System::Threading;

    ref class PrintTasks
    {
    private:
        static Semaphore ^canPrintA = gcnew Semaphore(0,3);
        static Semaphore ^canPrintB = gcnew Semaphore(2,2);
        //static Semaphore ^canPrintC = gcnew Semaphore(0,1);
        static Semaphore ^Idle = gcnew Semaphore(0,3);


    public: static bool runFlag = true;

    public:
        void PrintA(Object^ name) {
            while (runFlag) {
                canPrintA->WaitOne();
                Console::Write("{0}\n", "A");
                Idle->Release();
            }
        }

        void PrintB(Object^ name) {
            while (runFlag) {
                canPrintB->WaitOne();
                Console::Write("{0}\n", "B");
                Idle->Release();
            }
        }

        void PrintC(Object^ name) {
            while (runFlag) {
                Idle->WaitOne();
                Idle->WaitOne();
                                    Console::Write("{0}\n", "C");
                canPrintA->Release(3);
                Idle->WaitOne();
                Idle->WaitOne();
                Idle->WaitOne();
                canPrintB->Release(2);
                //Console::Write("{0}\n", "C");



            }
        }

    };

    int main(array<System::String ^> ^args)
    {

        PrintTasks ^tasks = gcnew PrintTasks();

        // First Method
        Thread ^thread1 = gcnew Thread ( gcnew ParameterizedThreadStart( tasks, &PrintTasks::PrintA ) );
        Thread ^thread2 = gcnew Thread ( gcnew ParameterizedThreadStart( tasks, &PrintTasks::PrintB ) );
        Thread ^thread3 = gcnew Thread ( gcnew ParameterizedThreadStart( tasks, &PrintTasks::PrintC ) );

        thread1->Start("printA");
        thread2->Start("printB");
        thread3->Start("printC");

        Thread::Sleep(50);

        PrintTasks::runFlag=false;

        thread3->Abort();
        thread2->Abort();
        thread1->Abort();

        return 0;
    }

#包括“stdafx.h”
使用名称空间系统；
使用名称空间系统：：线程；
ref类打印任务
{
私人：
静态信号量^canPrintA=gcnew信号量（0,3）；
静态信号量^canPrintB=gcnew信号量（2,2）；
//静态信号量^canPrintC=gcnew信号量（0,1）；
静态信号量^Idle=gcnew信号量（0,3）；
public:static bool runFlag=true；
公众：
void PrintA（对象^name）{
while（runFlag）{
canPrintA->WaitOne（）；
控制台：：写入（“{0}\n”，“A”）；
空闲->释放（）；
}
}
无效打印B（对象^name）{
while（runFlag）{
canPrintB->WaitOne（）；
控制台：：写入（“{0}\n”，“B”）；
空闲->释放（）；
}
}
void PrintC（对象^name）{
while（runFlag）{
空闲->等待（）；
空闲->等待（）；
控制台：：写入（“{0}\n”，“C”）；
canPrintA->发布（3）；
空闲->等待（）；
空闲->等待（）；
空闲->等待（）；
canPrintB->发布（2）；
//控制台：：写入（“{0}\n”，“C”）；
}
}
};
int main（数组^args）
{
PrintTasks^tasks=gcnew PrintTasks（）；
//第一种方法
线程^thread1=gcnew线程（gcnew ParameterizedThreadStart（tasks，&PrintTasks:：PrintA））；
线程^thread2=gcnew线程（gcnew ParameterizedThreadStart（tasks，&PrintTasks:：PrintB））；
线程^thread3=gcnew线程（gcnew参数化线程启动（tasks，&PrintTasks:：PrintC））；
thread1->Start（“printA”）；
thread2->Start（“printB”）；
thread3->Start（“printC”）；
线程：：睡眠（50）；
PrintTasks:：runFlag=false；
thread3->Abort（）；
thread2->Abort（）；
thread1->Abort（）；
返回0；
}

信号量（int，int）中两个参数的意义是什么

信号量有两种主要的使用方式

有限的资源 可以使用信号量来限制对有限资源的访问。要实现这一点，请将最大计数器设置为所需限制，并将初始计数设置为零。分配资源的每个线程必须在获得空闲信号量“slot”之前

WaitForSingleObject（）

。如果没有更多的空闲插槽，等待将阻塞，直到一个线程释放信号量句柄，为下一个等待的线程腾出空间。对于这个用例，最好将信号量的使用描述为多互斥

多个事件 另一个典型的用例是能够发出多个事件发生的信号，例如线程池。用MAXINT或其他足够高的值初始化信号量最大值和当前计数。值本身并不重要（越高越好），它必须足够高，以覆盖所有可能的场景。然后让所有工作线程等待您的信号量。由于还没有空闲句柄，所有工作线程都将阻塞等待

现在，每当线程池处理某个任务时，就会通过

ReleaseSemaphore（）

释放一个或多个句柄来通知此事件，从线程池中完全唤醒该数量的线程。这些线程现在将执行其所需的工作，例如从某处拾取和处理工作任务

---

线程完成工作后，他再次开始等待信号灯。如果还有任何剩余事件（因为发出信号的事件数量超过了可用的线程数量），线程将立即开始处理下一个包。否则线程将再次进入休眠状态，等待新事件。

1）：“初始化信号量类的新实例，指定最大并发条目数，并选择性地保留一些条目。”好的……但将其设置为信号量（2,2）实现了什么？您不明白或根本没有阅读它吗？If 1：你知道信号量是用来做什么的吗？你不能用一个信号量来订购三个线程，它需要三个线程。允许一个线程释放另一个线程。您通常会使用三个自动重置事件。整个方法从一开始就是错误的，如果你想让ABC按顺序出现，那么只需使用一个线程打印A、B、C。让更多的线程等待轮到它们是没有意义的，这只是浪费和缓慢。我读了一遍，但我仍然感到困惑。似乎第二个用法就是我想要使用的。