c#没有wait（）,notify()怎么实现延迟情况下的读取无错误

[lyfuci]

namespace testDemo4
{
class people
{
private string name;
private string gender;
public string Name
{
get { return name; }
set { name = value; }
}
public string Gender
{
get { return gender; }
set { gender = value; }
}

}
class producer
{
public producer(people p)
{
this.p = p;
}
bool isEmpty = false;
object locker = new object();
private people p;

internal people P
{
get { return p; }
set { p = value; }
}

public void produce()
{
for (int i = 0; i < 2000; i++)
{

if (i % 2 == 0)
{

p.Name = "春哥";
Thread.Sleep(1);
p.Gender = "男";
Thread.Sleep(1);
}
else
{
p.Name = "凤姐";
Thread.Sleep(1);
p.Gender = "女";
Thread.Sleep(1);
}


}

}
}
class comsumer
{
private people p;
object locker = new object();
internal people P
{
get { return p; }
set { p = value; }
}
public comsumer(people p)
{
this.p = p;
}
public void comsume()
{
for (int i = 0; i < 2000; i++)
{
Console.WriteLine(p.Name + "——>" + p.Gender);
}
}
}
class Program
{
static void Main(string[] args)
{
people p = new people();
producer pro = new producer(p);
comsumer com = new comsumer(p);
Thread a = new Thread(pro.produce );
Thread b = new Thread(com.comsume);
a.Start();
b.Start();
Console.ReadKey();



}
}
}

[Ptrtoptr]

有,只不过它们披了一个不一样的英文名字 public static ManualResetEvent allDone = new ManualResetEvent(false);

[notax]

using System;
using System.Threading;

namespace ThreadTest_2
{
    class People
    {
        public string Name {get; set;}
        public string Gender { get; set; }
    }

    class Producer
    {
        readonly AutoResetEvent autoResetEvent;
        internal People people { get; set; }
        public Producer(People people, AutoResetEvent mre)
        {
            this.people = people;
            this.autoResetEvent = mre;
        }

        public void Produce()
        {
            for (int i = 0; i < 2000; i++)
            {
                autoResetEvent.WaitOne();
                if (i % 2 == 0)
                {
                    people.Name = "春哥";
                    Thread.Sleep(1);
                    people.Gender = "男";
                    Thread.Sleep(1);
                }
                else
                {
                    people.Name = "凤姐";
                    Thread.Sleep(1);
                    people.Gender = "女";
                    Thread.Sleep(1);
                }
                autoResetEvent.Set();
            }

        }
    }

    class Comsumer
    {
        readonly AutoResetEvent autoResetEvent;
        internal People people { get; set; }
        public Comsumer(People people, AutoResetEvent mre)
        {
            this.people = people;
            this.autoResetEvent = mre;
        }

        public void Comsume()
        {
            for (int i = 0; i < 2000; i++)
            {
                autoResetEvent.WaitOne();
                if (people.Name == "凤姐" &&  people.Gender != "女")
                {
                    Console.WriteLine(" fail ");
                    break;
                }

                if (people.Name == "春哥" && people.Gender != "男")
                {
                    Console.WriteLine(" fail");
                    break;
                }                    

                Console.WriteLine(people.Name + "->" + people.Gender);
                autoResetEvent.Set();
            }
        }
    }
    class Program
    {
        static void Main()
        {
            AutoResetEvent autoResetEvent = new AutoResetEvent(false);

            People people = new People();
            Producer producer = new Producer(people, autoResetEvent);
            Comsumer comsumer = new Comsumer(people, autoResetEvent);
            Thread a = new Thread(producer.Produce);
            Thread b = new Thread(comsumer.Comsume);

            a.Start();
            b.Start();
            autoResetEvent.Set();

            a.Join();
            b.Join();

            Console.ReadKey();
        }
    }
}

[Ptrtoptr]

它们用了autoRestEvent, 我大概说下,不过不太容易能说清,这个东西主要是你调试下 .一下就明白 在主线里有个autoResetEvent对象,它被主线和其它两个线程共同使用,就像水闸一样. autoResetEvent.Set();就是打开了水闸门, autoResetEvent..WaitOne()会看到水闸门在开着就过去了,过去后水闸自动又关闭了, 再有autoResetEvent..WaitOne()时,发现水闸门在关着就过不去了.直到autoResetEvent.Set();才能过去

[cbr600]

[lyfuci]

引用 4 楼 Ptrtoptr 的回复:

它们用了autoRestEvent, 我大概说下,不过不太容易能说清,这个东西主要是你调试下 .一下就明白 在主线里有个autoResetEvent对象,它被主线和其它两个线程共同使用,就像水闸一样. autoResetEvent.Set();就是打开了水闸门, autoResetEvent..WaitOne()会看到水闸门在开着就过去了,过去后水闸自动又关闭了, 再有autoResetEvent..WaitOne()时,发现水闸门在关着就过不去了.直到autoResetEvent.Set();才能过去

其实单个函数功能我大概都调试懂了，但是不要怪我蠢，我就是整个工作过程看不懂，一开始两个线程开始了，然后进入for语句，等待着宠幸，然后主线程set（）函数起作用，起作用不是应该produc和comsume同时开始进行吗，这个里面是怎么确定一定是交替出现的啊，莫非是两个先后顺序的join（）？？？？我试了一下，删除join也没有一点点影响，或者有影响只不过是观察不到的罢了，我就是不清楚这个为何能保证交替出现。

[Ptrtoptr]

然后主线程set（）函数起作用，起作用不是应该produc和comsume同时开始进行吗， 不是,set是开门,product 或comsume只能有一个过去,因为过去后门会自动关上.只有再调set()门才能打开

[lyfuci]

引用 2 楼 notax 的回复:

using System;
using System.Threading;

namespace ThreadTest_2
{
    class People
    {
        public string Name {get; set;}
        public string Gender { get; set; }
    }

    class Producer
    {
        readonly AutoResetEvent autoResetEvent;
        internal People people { get; set; }
        public Producer(People people, AutoResetEvent mre)
        {
            this.people = people;
            this.autoResetEvent = mre;
        }

        public void Produce()
        {
            for (int i = 0; i < 2000; i++)
            {
                autoResetEvent.WaitOne();
                if (i % 2 == 0)
                {
                    people.Name = "春哥";
                    Thread.Sleep(1);
                    people.Gender = "男";
                    Thread.Sleep(1);
                }
                else
                {
                    people.Name = "凤姐";
                    Thread.Sleep(1);
                    people.Gender = "女";
                    Thread.Sleep(1);
                }
                autoResetEvent.Set();
            }

        }
    }

    class Comsumer
    {
        readonly AutoResetEvent autoResetEvent;
        internal People people { get; set; }
        public Comsumer(People people, AutoResetEvent mre)
        {
            this.people = people;
            this.autoResetEvent = mre;
        }

        public void Comsume()
        {
            for (int i = 0; i < 2000; i++)
            {
                autoResetEvent.WaitOne();
                if (people.Name == "凤姐" &&  people.Gender != "女")
                {
                    Console.WriteLine(" fail ");
                    break;
                }

                if (people.Name == "春哥" && people.Gender != "男")
                {
                    Console.WriteLine(" fail");
                    break;
                }                    

                Console.WriteLine(people.Name + "->" + people.Gender);
                autoResetEvent.Set();
            }
        }
    }
    class Program
    {
        static void Main()
        {
            AutoResetEvent autoResetEvent = new AutoResetEvent(false);

            People people = new People();
            Producer producer = new Producer(people, autoResetEvent);
            Comsumer comsumer = new Comsumer(people, autoResetEvent);
            Thread a = new Thread(producer.Produce);
            Thread b = new Thread(comsumer.Comsume);

            a.Start();
            b.Start();
            autoResetEvent.Set();

            a.Join();
            b.Join();

            Console.ReadKey();
        }
    }
}

能解释下这两个函数吗，有点感觉但，还是不太懂这个交替运行的机制。求注释解释一下下。

[lwbjiuqi]

楼上的代码能保证生产和消费过程不被打断，但是貌似不能保证生产和消费一定是交替执行的。

[Ptrtoptr]

孩子,我服了你,下面我把程序改了下, 写的有点笨拙,但意思是那个意思.如果你能看懂的话,请把40分都给我吧... 1保证produce先运行.2.保证producte和comsumer是交替运行.

 namespace ThreadTest {
        class People {
            public string Name { get; set; }
            public string Gender { get; set; }
        }
        class Producer {
              readonly AutoResetEvent Self;
             readonly AutoResetEvent Other;
            internal People people { get; set; } 
            public Producer(People people, AutoResetEvent self ,AutoResetEvent other) {
                         this.people = people;
                this.Self = self;
                this.Other = other;
            }
            public void Produce() {
                for (int i = 0; i < 2000; i++) {
                    Self.WaitOne();                 
                    if (i % 2 == 0) {
                        people.Name = "春哥";                 
                        people.Gender = "男";              
                    } else {
                        people.Name = "凤姐";                
                        people.Gender = "女";                
                    }
                    Other.Set();
                }
            }
        }
        class Comsumer {
            readonly AutoResetEvent Self;
             readonly AutoResetEvent Other;
            internal People people { get; set; }
            public Comsumer(People people, AutoResetEvent self ,AutoResetEvent other) {
                this.people = people;
                this.Self = self;
                this.Other = other;
            }
            public void Comsume() {
                for (int i = 0; i < 2000; i++) {
                    Self.WaitOne();                   
                    if (people.Name == "凤姐" && people.Gender != "女") {
                        Console.WriteLine(" fail ");
                        break;
                    }
                    if (people.Name == "春哥" && people.Gender != "男") {
                        Console.WriteLine(" fail");
                        break;
                    }
                    Console.WriteLine(people.Name + "->" + people.Gender);
                  Other.Set();
                }
            }
        }
        class Program {
            static void Main() {
                //producerAuto参数为true,保证producer门处于打开状态,让producer先运行.
                AutoResetEvent producerAuto= new AutoResetEvent(true);
                AutoResetEvent comsumerAuto = new AutoResetEvent(false);
                People people = new People();
                Producer producer = new Producer(people, producerAuto,comsumerAuto);
                Comsumer comsumer = new Comsumer(people, comsumerAuto, producerAuto);
                Thread a = new Thread(producer.Produce);
                Thread b = new Thread(comsumer.Comsume);
                a.Start();
                b.Start();
               Console.ReadKey();
            }
        }
    }

[Ptrtoptr]

引用 6 楼 lyfuci10 的回复:

[quote=引用 4 楼 Ptrtoptr 的回复:] 它们用了autoRestEvent, 我大概说下,不过不太容易能说清,这个东西主要是你调试下 .一下就明白 在主线里有个autoResetEvent对象,它被主线和其它两个线程共同使用,就像水闸一样. autoResetEvent.Set();就是打开了水闸门, autoResetEvent..WaitOne()会看到水闸门在开着就过去了,过去后水闸自动又关闭了, 再有autoResetEvent..WaitOne()时,发现水闸门在关着就过不去了.直到autoResetEvent.Set();才能过去

其实单个函数功能我大概都调试懂了，但是不要怪我蠢，我就是整个工作过程看不懂，一开始两个线程开始了，然后进入for语句，等待着宠幸，然后主线程set（）函数起作用，起作用不是应该produc和comsume同时开始进行吗，这个里面是怎么确定一定是交替出现的啊，莫非是两个先后顺序的join（）？？？？我试了一下，删除join也没有一点点影响，或者有影响只不过是观察不到的罢了，我就是不清楚这个为何能保证交替出现。[/quote] 怎么我感觉我说的已经很清楚了,你几乎还是有些不清楚... AutoReset就是自动复位嘛.我到底哪点没说到你的心里?

[lyfuci]

引用 9 楼 Ptrtoptr 的回复:

[quote=引用 6 楼 lyfuci10 的回复:] [quote=引用 4 楼 Ptrtoptr 的回复:] 它们用了autoRestEvent, 我大概说下,不过不太容易能说清,这个东西主要是你调试下 .一下就明白 在主线里有个autoResetEvent对象,它被主线和其它两个线程共同使用,就像水闸一样. autoResetEvent.Set();就是打开了水闸门, autoResetEvent..WaitOne()会看到水闸门在开着就过去了,过去后水闸自动又关闭了, 再有autoResetEvent..WaitOne()时,发现水闸门在关着就过不去了.直到autoResetEvent.Set();才能过去

其实单个函数功能我大概都调试懂了，但是不要怪我蠢，我就是整个工作过程看不懂，一开始两个线程开始了，然后进入for语句，等待着宠幸，然后主线程set（）函数起作用，起作用不是应该produc和comsume同时开始进行吗，这个里面是怎么确定一定是交替出现的啊，莫非是两个先后顺序的join（）？？？？我试了一下，删除join也没有一点点影响，或者有影响只不过是观察不到的罢了，我就是不清楚这个为何能保证交替出现。[/quote] 怎么我感觉我说的已经很清楚了,你几乎还是有些不清楚... AutoReset就是自动复位嘛.我到底哪点没说到你的心里?[/quote]其实我需要的就是set只打开一个口子这句话。不对，其实我还是不清楚，为什么一定会是produce这个方法先打开，因为测试了好多遍，都是produce先打开，虽然3楼写了如果先运行了comsume的情况会显示fail然后break，但是从来没有出现过这种情况。总的来说就是怎么保证肯定先运行produce的。

[notax]

改了改，当练手吧，我不要分哦，应该还有四五种其他的方法，可惜太早结贴了

using System;
using System.Threading;

namespace ThreadTest_3
{
    class ResetEvent
    {
        public AutoResetEvent ModifyEvent { get; set; }
        public AutoResetEvent PrintEvent { get; set; }

        public ResetEvent()
        {
            ModifyEvent = new AutoResetEvent(false);
            PrintEvent = new AutoResetEvent(false);
        }
    }

    class People
    {
        public string Name { get; set; }
        public string Gender { get; set; }
    }

    class Producer
    {
        readonly ResetEvent resetEvent;
        internal People people { get; set; }
        public Producer(People people, ResetEvent resetEvent)
        {
            this.people = people;
            this.resetEvent = resetEvent;
        }

        public void Produce()
        {
            for (int i = 0; i < 2000; i++)
            {
                resetEvent.ModifyEvent.WaitOne();
                if (i % 2 == 0)
                {
                    people.Name = "春哥";
                    Thread.Sleep(1);
                    people.Gender = "男";
                    Thread.Sleep(1);
                }
                else
                {
                    people.Name = "凤姐";
                    Thread.Sleep(1);
                    people.Gender = "女";
                    Thread.Sleep(1);
                }
                resetEvent.PrintEvent.Set();
            }

        }
    }

    class Consumer
    {
        readonly ResetEvent resetEvent;
        internal People people { get; set; }
        public Consumer(People people, ResetEvent resetEvent)
        {
            this.people = people;
            this.resetEvent = resetEvent;
        }

        public void Consume()
        {
            for (int i = 0; i < 2000; i++)
            {
                resetEvent.PrintEvent.WaitOne();
                if (people.Name == "凤姐" && people.Gender != "女")
                {
                    Console.WriteLine(" fail ");
                    break;
                }

                if (people.Name == "春哥" && people.Gender != "男")
                {
                    Console.WriteLine(" fail");
                    break;
                }

                Console.WriteLine(people.Name + "->" + people.Gender);
                resetEvent.ModifyEvent.Set();
            }
        }
    }
    class Program
    {
        static void Main()
        {
            ResetEvent resetEvent = new ResetEvent();

            People people = new People();
            Producer producer = new Producer(people, resetEvent);
            Consumer comsumer = new Consumer(people, resetEvent);
            Thread a = new Thread(producer.Produce);
            Thread b = new Thread(comsumer.Consume);

            a.Start();
            b.Start();
            resetEvent.ModifyEvent.Set();

            a.Join();
            b.Join();

            Console.ReadKey();
        }
    }
}