C#多线程（三）

     bool  blocked = (Thread.ThreadState & ThreadState.WaitSleepJoin) != 0;

• 阻塞条件满足
• 执行时间完毕
• 使用Thread.Interrupt打断
• 使用Thread.Abort丢弃

       static object locker = new object();
        static int val1, val2;
        static void Main(string[] args)
        {
            val1 = 100;
            val2 = 10;
            Thread t1 = new Thread(Go);
            Thread t2 = new Thread(Go);

            t1.Start();
            t2.Start();

            Console.ReadKey();
        }
        static void Go()
        {
            lock (locker)
            {
                if (val2 != 0) Console.WriteLine(val1 / val2);
                val2 = 0;
            }
        }

Monitor.Enter(locker);
try
{
    if (val2 != 0)  Console.WriteLine(val1/val2);
    val2 = 0;
}
finally
{
    Monitor.Exit(locker);
}

        static void Main(string[] args)
        {
            using (var mutex = new Mutex(false, "mutex"))
            {
                if (!mutex.WaitOne(TimeSpan.FromSeconds(3), false))
                {
                    Console.WriteLine("Another app instance is running. Bye!");
                    return;
                }
                RunProgram();
            }
        }

        static void RunProgram()
        {
            Console.WriteLine("Running. Press Enter to exit");
            Console.ReadLine();
        }

        static SemaphoreSlim sem = new SemaphoreSlim(3);
        static void Main(string[] args)
        {
            for (int i = 1; i < 10; i++)
                new Thread(Enter).Start(i);
            Console.ReadKey();
        }

        static void Enter(object id)
        {
            Console.WriteLine(id + "wants to enter");
            sem.Wait();
            Console.WriteLine(id + "enter in!");
            Thread.Sleep(1000 * (int)id);
            Console.WriteLine(id + "is leaving");
            sem.Release();
        }

• 一种是牺牲粒度包含大段的代码——甚至在排他锁中访问全局对象，迫使在更高的级别上实现串行化访问。这一策略也很关键，让非线程安全的对象用于线程安全代码中，避免了相同的互斥锁被用于保护对在非线程安全对象的所有的属性、方法和字段的访问。
  
• 另一个方式欺骗是通过最小化共享数据来最小化线程交互。这是一个很好的途径，被暗中地用于“弱状态”的中间层程序和web服务器。自多个客户端请求同时到达，每个请求来自它自己的线程（效力于ASP.NET，Web服务器或者远程体系结构），这意味着它们调用的方法一定是线程安全的。弱状态设计（因伸缩性好而流行）本质上限制了交互的能力，因此类不能够在每个请求间持久保留数据。线程交互仅限于可以被选择创建的静态字段，多半是在内存里缓存常用数据和提供基础设施服务，例如认证和审核。
  

        static SemaphoreSlim sem = new SemaphoreSlim(3);
        static void Main(string[] args)
        {
            Thread t = new Thread(delegate()
            {
                try
                {
                    Thread.Sleep(Timeout.Infinite);
                }
                catch (ThreadInterruptedException)
                {
                    Console.WriteLine("Exception!");
                }
                Console.WriteLine("Woken");
            });
            t.Start();
            t.Interrupt();
            Console.ReadKey();
        }

WaitOne 接受一个可选的超时参数——当等待以超时结束时这个方法将返回false，WaitOne在等待整段时间里也通知离开当前的同步内容，为了避免过多的阻止发生。Reset作用是关闭旋转门，也就是无论此时是否已经set过，都将阻塞下一次WaitOne——它应该是开着的。

使用构造函数创建对象或者使用基类创建：

EventWaitHandle wh = new AutoResetEvent (false);
EventWaitHandle wh = new EventWaitHandle (false, EventResetMode.Auto);

EventWaitHandle的构造器允许以“命名”的方式进行创建，它有能力跨多个进程。名称是个简单的字符串，可能会无意地与别的冲突！如果名字使用了，你将引用相同潜在的EventWaitHandle，除非操作系统创建一个新的。

EventWaitHandle wh = new EventWaitHandle (false, EventResetMode.Auto,
  "MyCompany.MyApp.SomeName");

假设希望在后台完成任务，但又不在每次得到任务时再创建一个新的线程。可以通过一个轮询的线程来完成：等待一个任务，执行它，然后等待下一个任务。这是一个普遍的多线程方案。也就是在创建线程上切分内务操作，任务执行被序列化，在多个工作线程和过多的资源消耗间排除潜在的不想要的操作。

        static EventWaitHandle ready = new AutoResetEvent(false);
        static EventWaitHandle go = new AutoResetEvent(false);
        static volatile string task;
        static void Main(string[] args)
        {
            new Thread(work).Start();

            for (int i = 1; i <= 5; i++)
            {
                ready.WaitOne();
                task = "#".PadRight(i, ‘@‘);
                go.Set();
            }
            ready.WaitOne();
            task = null;
            go.Set();
            Console.ReadKey();
        }

        static void work()
        {
            while (true)
            {
                ready.Set();
                go.WaitOne();
                if (task == null) return;
                Console.WriteLine(task);
            }
        }

4、生成者消费者模型

还有一个普遍的线程方案是在后台工作进程从队列中分配任务，称为生产者/消费者队列：在工作线程中生产者入列任务，消费者出列任务。下面例子中，AutoResetEvent用来通知工作线程，只有在用完任务事等待。集合类队列来表示，通过锁来控制访问确保线程安全，队列为Null时结束任务。

     class ProducerConsumerQueue : IDisposable
    {
        EventWaitHandle wh = new AutoResetEvent(false);
        Thread worker;
        object locker = new object();
        Queue<string> tasks = new Queue<string>();

        public ProducerConsumerQueue()
        {
            worker = new Thread(Work);
            worker.Start();
        }

        public void EnqueueTask(string task)
        {
            lock (locker) tasks.Enqueue(task);
            wh.Set();
        }

        public void Dispose()
        {
            EnqueueTask(null);     // Signal the consumer to exit.
            worker.Join();          // Wait for the consumer‘s thread to finish.
            wh.Close();             // Release any OS resources.
        }

        void Work()
        {
            while (true)
            {
                string task = null;
                lock (locker)
                    if (tasks.Count > 0)
                    {
                        task = tasks.Dequeue();
                        if (task == null) return;
                    }
                if (task != null)
                {
                    Console.WriteLine("Performing task: " + task);
                    Thread.Sleep(1000);
                }
                else
                    wh.WaitOne();
            }
        }
    }

        static void Main(string[] args)
        {
            using (ProducerConsumerQueue q = new ProducerConsumerQueue())
            {
                q.EnqueueTask("Hello");
                for (int i = 0; i < 10; i++) q.EnqueueTask("Say " + i);
                q.EnqueueTask("Goodbye!");
            }
            Console.ReadKey();
        }

5、ManualResetEvent

ManualResetEvent是AutoResetEvent变化的一种形式，它的不同之处在于：在线程被WaitOne的调用而通过的时候，它不会自动地reset，这个过程就像大门一样——调用Set打开门，允许任何数量的已执行WaitOne的线程通过；调用Reset关闭大门，可能会引起一系列的“等待者”直到下次门打开。

ManualResetEvent有时被用于给一个完成的操作发送信号，又或者一个已初始化正准备执行工作的线程。

参考：http://www.albahari.com/threading/part2.aspx