autoEvent.WaitOne(1000,true)第二个参数啥作用啊，有高手知道吗？

[cxycappuccino]

class Program
{
static AutoResetEvent autoEvent = new AutoResetEvent(false);
static void Main(string[] args)
{
Console.WriteLine("Main starting.");



ThreadPool.QueueUserWorkItem(new WaitCallback(WorkMethod), autoEvent);



// Wait for work method to signal.

if (autoEvent.WaitOne(1000,true))//问题在这里
{

Console.WriteLine("Work method signaled.");

}
else
{

Console.WriteLine("Timed out waiting for work " + "method to signal.");

}

Console.WriteLine("Main ending.");


Console.Read();
}
static void WorkMethod(object stateInfo)
{

Console.WriteLine("Work starting.");



// Simulate time spent working.

Thread.Sleep(2000);



// Signal that work is finished.

Console.WriteLine("Work ending.");

((AutoResetEvent)stateInfo).Set();

}

[wuyq11]

http://msdn.microsoft.com/zh-cn/library/system.threading.autoresetevent.waitone.aspx

[cxycappuccino]

MSDN中的使用 TimeSpan 度量时间间隔并指定是否在等待之前退出同步域，以此阻止当前线程，直到当前的实例收到信号。什么意思啊，这个是看到了就是看不懂

[Ny-6000]

执行下面的逻辑判断喽．

[gomoku]

在大部分情况下那个参数是没有用的。

只有在使用ContextBoundObject来进行同步的时候，那个参数才有用。

1、Synchronization可以用来同步一个类（基于ContextBoundObject）。
比如以下的例子，同一时间只能运行一个方法A。把标志行1注释掉，则可观察到乱序执行。

2、WaitOne(...，true)使得方法B可以暂时脱离ContextBound同步保护，让A有机会在B等待的时候得到执行。比如以下的例子的结果为：
...
Start B
Start A
End A
End B
把标志行2的true改成false，那么A就要等到B执行后才能执行。

using System;
using System.Threading;

[System.Runtime.Remoting.Contexts.Synchronization(true)]   // 1
class My : ContextBoundObject
{
    static void Main(string[] args)
    {
        My my = new My();
        ThreadPool.QueueUserWorkItem(my.FuncA);
        Thread.Sleep(50);
        ThreadPool.QueueUserWorkItem(my.FuncA);
        Thread.Sleep(50);
        ThreadPool.QueueUserWorkItem(my.FuncB);
        Thread.Sleep(50);
        ThreadPool.QueueUserWorkItem(my.FuncA);

        Console.ReadLine();
    }

    AutoResetEvent myEvent = new AutoResetEvent(false);
    public void FuncA(object state)
    {
        Console.WriteLine("Start A");
        System.Threading.Thread.Sleep(2000);
        Console.WriteLine("End   A");
    }
    public void FuncB(object state)
    {
        Console.WriteLine("Start B");
        myEvent.WaitOne(10 * 1000, true);                // 2
        Console.WriteLine("End   B");
    }
}

[freeboy1015]

a set of context-bound objects which share a lock (through SynchronizationAttribute) are said to be in a synchronization domain

if a client is calling any object in the synchronization domain, it needs to acquire this lock, once the lock is acquired, no other clients can access any object in the synchronization domain

If this client calls WaitOne, it has a choice to stay in the synchronization domain (with the second parameter exitContext set to false), so it will keep the lock (then no other clients can access any object in the domain during the waiting period), or it can leave the synchronization domain (with the second parameter exitContext set to true) and the system will release the lock, so other clients can access the objects in the synchronization domain