EventWaitHandle - Différence entre WaitAny() et WaitOne()

J'ai 3 fils, deux des "travailleurs" et un "manager" . Les "Travailleurs" threads Attend sur EventWaitHandle que le "gestionnaire" thread sera le signal de l' EventWaitHandle après que leur augmentation de leurs compteurs.
La seule différence entre les "travailleurs" threads est que l'on utilise EventWaitHandle.WaitAny() et de l'autre on utilise EventWaitHandle.WaitOne() .

voici le code:

class Program
{
    static void Main(string[] args)
    {
        MultiThreadedJobs multyThreadedJobs = new MultiThreadedJobs();
        multyThreadedJobs.Start();

        Console.ReadLine();

        multyThreadedJobs.Stop();
    }
}

class MultiThreadedJobs : IDisposable
{
    private EventWaitHandle syncEvent;
    private EventWaitHandle[] syncEventsArray;

    private Thread managerThread;
    private Thread firstWorkerThread;
    private Thread secondWorkerThread;

    private volatile bool running = false;


    public MultiThreadedJobs() //Ctor
    {
        syncEvent = new EventWaitHandle(false, EventResetMode.AutoReset, "JobsSyncEvent");

        syncEventsArray = new EventWaitHandle[1];
        syncEventsArray[0] = syncEvent;

        managerThread = new Thread(ManagerThreadMethod);
        firstWorkerThread = new Thread(FirstWorkerThreadMethod);
        secondWorkerThread = new Thread(SecondWorkerThreadMethod);
    }

    public void Start()
    {
        running = true;

        managerThread.Start();
        firstWorkerThread.Start();
        secondWorkerThread.Start();
    }

    public void Stop()
    {
        running = false;
    }

    private void ManagerThreadMethod() //Manager Thread
    {
        while (running)
        {
            Thread.Sleep(1000);
            syncEvent.Set();
        }
    }

    private void FirstWorkerThreadMethod() //Worker Thread
    {
        int counter = 0;
        while (running)
        {
            syncEvent.WaitOne();
            counter++;
        }
    }

    private void SecondWorkerThreadMethod() //Worker Thread
    {
        int counter = 0;
        while (running)
        {
            EventWaitHandle.WaitAny(syncEventsArray);
            counter++;
        }
    }

    public void Dispose()
    {
        syncEvent.Close();
    }
}

Le problème, c'est juste La deuxième thread de travail avec le EventWaitHandle.WaitAny() toujours attraper l'Événement, et à mourir de faim le premier thread de travail. au lieu d'environ 50/50 pourcentage de chacun d'eux.

Jetez un oeil à ceci: stackoverflow.com/questions/1816099/...
S'il vous plaît montrer tous les code, où en êtes-vous de faire Thread.Start()?
merci, mais je ne suis pas d'y voir une réponse pour mon problème
le " Fil.Start()' existe pas dans un autre méthode Start() .
tous les code ici.

OriginalL'auteur Jacob | 2013-02-06