-2


我需要使用两个线程创建一个计数为 10 的程序。
一个线程应该打印偶数，另一个应该打印奇数。
这些线程应按顺序打印数字（1、2、3、4、5...）

我已经完成了这段代码，但它似乎不起作用......有什么想法吗？

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        private static AutoResetEvent autoEvent;
        private static int num = 10;

        static void DoWork(object data)
        {
            var counter = (int)data;

            if (counter == 1)
            {
                autoEvent.WaitOne();
            }

            while (counter <= num)
            {
                Console.WriteLine(counter);
                counter += 2;
                autoEvent.Set();
                autoEvent.WaitOne();
            }
        }

        static void Main(string[] args)
        {
            autoEvent = new AutoResetEvent(false);

            var evenCounter = new Thread(DoWork);
            evenCounter.Start(0);

            var notEvenCounter = new Thread(DoWork);
            notEvenCounter.Start(1);

            Console.ReadLine();
        }
    }
}
4

3 回答 3

1

这似乎是你的问题：

   autoEvent.Set();
   autoEvent.WaitOne();

您将锁设置为空闲，然后立即等待锁，这将导致任意执行模式。

我建议你使用 2 个锁，这样一个线程可以阻塞另一个线程。

于 2014-05-25T16:55:22.487 回答
1

在该代码autoEvent.WaitOne()中可能不会阻塞，因为AutoResetEvent已经处于信号状态：

        autoEvent.Set();
        autoEvent.WaitOne();

这样该线程就不会按照您的计划等待另一个线程。
要解决该问题，您需要使用 2AutoResetEvent秒。一个线程将等待第一个AutoResetEvent，第二个线程将等待第二个AutoResetEvent。每个线程都会发出一个AutoResetEvent“属于”另一个线程的信号。
为了演示我的想法，我将只向您展示您需要进行更改的代码行：

private static AutoResetEvent autoEvents[] = new AutoResetEvent[2];

... 

autoEvents[0] = new AutoResetEvent(false);
autoEvents[1] = new AutoResetEvent(false);

...

var counter = (int)data;
int initial_counter = counter;

...

if (counter == 1)
{
autoEvents[initial_counter].WaitOne();
}

...

autoEvents[1 - initial_counter].Set();
autoEvents[initial_counter].WaitOne();

在 DoWork 信号结束时，适当AutoResetEvent避免另一个线程的无限阻塞：

autoEvents[1 - initial_counter].Set();
于 2014-05-25T17:59:40.133 回答
0 
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ThreadTest
{
    class Program
    {
        static void Main(string[] args)
        {

            Thread t1 = new Thread(Method1);
            Thread t2 = new Thread(Method2);
            t1.Start();
            Thread.Sleep(100);
            t2.Start();
            t1.Join();
            t2.Join();
            _autoEvent1.Close();
            _autoEvent2.Close();
        }

        private static void Method1()
        {

            do
            {
               _autoEvent2.WaitOne();

                if (!SharedCode(Thread.CurrentThread.ManagedThreadId))
                {
                    break;
                }

                _autoEvent1.Set();
            } while (true);
        }

        private static void Method2()
        {
            do
            {
                _autoEvent1.WaitOne();
                //_autoEvent2.Set();
                if (!SharedCode(Thread.CurrentThread.ManagedThreadId))
                    break;
                _autoEvent2.Set();
            } while (true);
        }

        private static bool SharedCode(int threadId)
        {
           lock (_lockObject)
            {

                Interlocked.Increment(ref _count);
                if (_count > 10)
                    return false;
                Console.WriteLine("ThreadId={0} , count={1}", threadId,_count);
            }

            return true;
        }
        private  static AutoResetEvent _autoEvent1 = new AutoResetEvent(true);
        private static AutoResetEvent _autoEvent2 = new AutoResetEvent(true);
        private static Object _lockObject = new object();
        private static int _count = 0;
    }
}
于 2016-12-02T13:41:04.663 回答