C# 多线程控制 通讯 和切换

//SystemThread.cs
using System;
using System.Threading; 

namespace ThreadTest
{
　　class RunIt
　　{
　　　　[STAThread]
　　　　static void Main(string[] args)
　　　　{
　　　　　　Thread.CurrentThread.Name="System Thread";//给当前线程起名为"System Thread"
Console.WriteLine(Thread.CurrentThread.Name+"‘Status:"+Thread.CurrentThread.ThreadState);
　　　　　　Console.ReadLine();
　　　　}
　　}
}

　　//ThreadTest.cs 

　　using System;
　　using System.Threading; 

　　namespace ThreadTest
　　{
　　public class Alpha
　　　　{
　　　　　　public void Beta()
　　　　　　{
　　　　　　　　while (true)
　　　　　　　　{
　　　　　　　　　　Console.WriteLine("Alpha.Beta is running in its own thread.");
　　　　　　　　}
　　　　　　}
　　　　}; 

　　　　public class Simple
　　　　{
　　　　　　public static int Main()
　　　　　　{
　　　　　　　　Console.WriteLine("Thread Start/Stop/Join Sample");

　　　　　　　　Alpha oAlpha = new Alpha();
　　　　　　　　file://这里创建一个线程，使之执行Alpha类的Beta()方法
　　　　　　　　Thread oThread = new Thread(new ThreadStart(oAlpha.Beta));
　　　　　　　　oThread.Start();
　　　　　　　　while (!oThread.IsAlive);
　　　　　　　　　　Thread.Sleep(1);
　　　　　　　　oThread.Abort();
　　　　　　　　oThread.Join();
　　　　　　　　Console.WriteLine();
　　　　　　　　Console.WriteLine("Alpha.Beta has finished"); 
　　　　　　　　try 
　　　　　　　　{
　　　　　　　　　　Console.WriteLine("Try to restart the Alpha.Beta thread");
　　　　　　　　　　oThread.Start();
　　　　　　　　}
　　　　　　　　catch (ThreadStateException) 
　　　　　　　　{
　　　　　　　　　　Console.Write("ThreadStateException trying to restart Alpha.Beta. ");
　　　　　　　　　　Console.WriteLine("Expected since aborted threads cannot be restarted.");
　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　　　　　return 0;
　　　　　　}
　　　　}
　　}

　　Alpha oAlpha = new Alpha();
　　Thread oThread = new Thread(new ThreadStart(oAlpha.Beta));
　　oThread.Start();

　　//设定优先级为最低
　　myThread.Priority=ThreadPriority.Lowest;

lock(expression) statement_block

　　//lock.cs
　　using System;
　　using System.Threading; 

　　internal class Account 
　　{
　　int balance;
　　Random r = new Random();
　　internal Account(int initial) 
　　{
　　　　balance = initial;
　　} 

　　internal int Withdraw(int amount) 
　　{
　　　　if (balance < 0) 
　　　　{
　　　　file://如果balance小于0则抛出异常
　　　　throw new Exception("Negative Balance");
　　　　}
　　　　//下面的代码保证在当前线程修改balance的值完成之前
　　　　//不会有其他线程也执行这段代码来修改balance的值
　　　　//因此，balance的值是不可能小于0的
　　　　lock (this)
　　　　{
　　　　Console.WriteLine("Current Thread:"+Thread.CurrentThread.Name);
　　　　file://如果没有lock关键字的保护，那么可能在执行完if的条件判断之后
　　　　file://另外一个线程却执行了balance=balance-amount修改了balance的值
　　　　file://而这个修改对这个线程是不可见的，所以可能导致这时if的条件已经不成立了
　　　　file://但是，这个线程却继续执行balance=balance-amount，所以导致balance可能小于0
　　　　if (balance >= amount) 
　　　　{
　　　　　　Thread.Sleep(5);
　　　　　　balance = balance - amount;
　　　　　　return amount;
　　　　} 
　　　　else 
　　　　{
　　　　　　return 0; // transaction rejected
　　　　}
　　　　}
　　}
　　internal void DoTransactions() 
　　{
　　　　for (int i = 0; i < 100; i++) 
　　　　Withdraw(r.Next(-50, 100));
　　}
　　} 

　　internal class Test 
　　{
　　static internal Thread[] threads = new Thread[10];
　　public static void Main() 
　　{
　　　　Account acc = new Account (0);
　　　　for (int i = 0; i < 10; i++) 
　　　　{
　　　　Thread t = new Thread(new ThreadStart(acc.DoTransactions));
　　　　threads[i] = t;
　　　　}
　　　　for (int i = 0; i < 10; i++) 
　　　　threads[i].Name=i.ToString();
　　　　for (int i = 0; i < 10; i++) 
　　　　threads[i].Start();
　　　　Console.ReadLine();
　　}
　　}

　　......
　　Queue oQueue=new Queue();
　　......
　　Monitor.Enter(oQueue);
　　......//现在oQueue对象只能被当前线程操纵了
　　Monitor.Exit(oQueue);//释放锁

　　using System;
　　using System.Threading;

　　public class Cell
　　{
　　int cellContents; // Cell对象里边的内容
　　bool readerFlag = false; // 状态标志，为true时可以读取，为false则正在写入
　　public int ReadFromCell( )
　　{
　　　　lock(this) // Lock关键字保证了什么，请大家看前面对lock的介绍
　　　　{
　　　　if (!readerFlag)//如果现在不可读取
　　　　{ 
　　　　　　try
　　　　　　{
　　　　　　file://等待WriteToCell方法中调用Monitor.Pulse()方法
　　　　　　Monitor.Wait(this);
　　　　　　}
　　　　　　catch (SynchronizationLockException e)
　　　　　　{
　　　　　　Console.WriteLine(e);
　　　　　　}
　　　　　　catch (ThreadInterruptedException e)
　　　　　　{
　　　　　　Console.WriteLine(e);
　　　　　　}
　　　　}
　　　　Console.WriteLine("Consume: {0}",cellContents);
　　　　readerFlag = false; file://重置readerFlag标志，表示消费行为已经完成
　　　　Monitor.Pulse(this); file://通知WriteToCell()方法（该方法在另外一个线程中执行，等待中）
　　　　}
　　　　return cellContents;
　　}

　　public void WriteToCell(int n)
　　{
　　　　lock(this)
　　　　{
　　　　if (readerFlag)
　　　　{
　　　　　　try
　　　　　　{
　　　　　　Monitor.Wait(this);
　　　　　　}
　　　　　　catch (SynchronizationLockException e)
　　　　　　{
　　　　　　file://当同步方法（指Monitor类除Enter之外的方法）在非同步的代码区被调用
　　　　　　Console.WriteLine(e);
　　　　　　}
　　　　　　catch (ThreadInterruptedException e)
　　　　　　{
　　　　　　file://当线程在等待状态的时候中止 
　　　　　　Console.WriteLine(e);
　　　　　　}
　　　　}
　　　　cellContents = n;
　　　　Console.WriteLine("Produce: {0}",cellContents);
　　　　readerFlag = true; 
　　　　Monitor.Pulse(this); file://通知另外一个线程中正在等待的ReadFromCell()方法
　　　　}
　　}
　　}

　　public class CellProd
　　{
　　Cell cell; // 被操作的Cell对象
　　int quantity = 1; // 生产者生产次数，初始化为1 

　　public CellProd(Cell box, int request)
　　{
　　　　//构造函数
　　　　cell = box; 
　　　　quantity = request; 
　　}
　　public void ThreadRun( )
　　{
　　　　for(int looper=1; looper<=quantity; looper++)
　　　　cell.WriteToCell(looper); file://生产者向操作对象写入信息
　　}
　　} 

　　public class CellCons
　　{
　　Cell cell; 
　　int quantity = 1; 

　　public CellCons(Cell box, int request)
　　{
　　　　cell = box; 
　　　　quantity = request; 
　　}
　　public void ThreadRun( )
　　{
　　　　int valReturned;
　　　　for(int looper=1; looper<=quantity; looper++)
　　　　valReturned=cell.ReadFromCell( );//消费者从操作对象中读取信息
　　}
　　}

　　public class MonitorSample
　　{
　　public static void Main(String[] args)
　　{
　　　　int result = 0; file://一个标志位，如果是0表示程序没有出错，如果是1表明有错误发生
　　　　Cell cell = new Cell( ); 

　　　　//下面使用cell初始化CellProd和CellCons两个类，生产和消费次数均为20次
　　　　CellProd prod = new CellProd(cell, 20); 
　　　　CellCons cons = new CellCons(cell, 20); 

　　　　Thread producer = new Thread(new ThreadStart(prod.ThreadRun));
　　　　Thread consumer = new Thread(new ThreadStart(cons.ThreadRun));
　　　　//生产者线程和消费者线程都已经被创建，但是没有开始执行 

　　　　try
　　　　{
　　　　producer.Start( );
　　　　consumer.Start( ); 

　　　　producer.Join( ); 
　　　　consumer.Join( );
　　　　Console.ReadLine();
　　　　}
　　　　catch (ThreadStateException e)
　　　　{
　　　　file://当线程因为所处状态的原因而不能执行被请求的操作
　　　　Console.WriteLine(e); 
　　　　result = 1; 
　　　　}
　　　　catch (ThreadInterruptedException e)
　　　　{
　　　　file://当线程在等待状态的时候中止
　　　　Console.WriteLine(e); 
　　　　result = 1; 
　　　　}
　　　　//尽管Main()函数没有返回值，但下面这条语句可以向父进程返回执行结果
　　　　Environment.ExitCode = result;
　　}
　　}

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

namespace Test
{
    class TestThread
    {
        private static void ThreadFuncOne()
        {
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(Thread.CurrentThread.Name +"   i =  " + i);
            }
            Console.WriteLine(Thread.CurrentThread.Name + " has finished");
        }

        static void Main(string[] args)
        {
            Thread.CurrentThread.Name = "MainThread";

            Thread newThread = new Thread(new ThreadStart(TestThread.ThreadFuncOne));
            newThread.Name = "NewThread";

            for (int j = 0; j < 20; j++)
            {
                if (j == 10)
                {
                    newThread.Start();
                    newThread.Join();
                }
                else
                {
                    Console.WriteLine(Thread.CurrentThread.Name + "   j =  " + j);
                }
            }
            Console.Read();
        }
    }
}

    class Program
    {
        staticvoid Main(string[] args)
        {
            new Thread(A).Start();
            new Thread(B).Start();
            new Thread(C).Start();
            Console.ReadLine();
        }
        staticobject lockObj = newobject();
        staticvoid A()
        {
            lock (lockObj) //进入就绪队列 
            {
                Thread.Sleep(1000);
                Monitor.Pulse(lockObj);
                Monitor.Wait(lockObj); //自我流放到等待队列 
            }
            Console.WriteLine("A exit...");
        }
        staticvoid B()
        {
            Thread.Sleep(500);
            lock (lockObj) //进入就绪队列 
            {
                Monitor.Pulse(lockObj);
            }
            Console.WriteLine("B exit...");
        }
        staticvoid C()
        {
            Thread.Sleep(800);
            lock (lockObj) //进入就绪队列 { } 
                Console.WriteLine("C exit...");
        }
    }

Assembly code
T 线程A ---0

lock( lockObj ) ---1
{ 
 //... 线程B 线程C ---2
 //... lock( lockObj ) lock( lockObj ) ---3
 //... { { ---4
 //... //... ---5
 //... //... ---6
 Monitor.Pulse //... ---7
 Monitor.Wait //... ---8
 //... Monitor.Pulse ---9
 //... } } ---10
 }
时间点0，假设线程A先得到了同步对象，它就登记到同步对象lockObj的“拥有者引用”中。时间点3，线程B和C要求拥有同步对象，他们将在“就绪队列”排队： |--(拥有锁的线程) A | 3 lockObj--|--(就绪队列) B,C | |--(等待队列) 时间点7，线程A用Pulse发出信号，允许第一个正在"等待队列"中的线程进入到”就绪队列“。但由于就绪队列是空的，什么事也没有发生。时间点8，线程A用Wait放弃同步对象，并把自己放入"等待队列"。B,C已经在就绪队列中，因此其中的一个得以获得同步对象（假定是B）。B成了同步 对象的拥有者。C现在还是候补委员，可以自动获得空缺。而A则被关在门外，不能自动获得空缺。 |--(拥有锁的线程) B | 8 lockObj--|--(就绪队列) C | |--(等待队列) A 时间点9，线程B用Pulse发出信号开门，第一个被关在门外的A被允许放入到就绪队列，现在C和A都成了候补委员，一旦同步对象空闲，都有机会得它。 |--(拥有锁的线程) B | 9 lockObj--|--(就绪队列) C,A | |--(等待队列) 时间点10，线程B退出Lock区块，同步对象闲置，就绪队列队列中的C或A就可以转正为拥有者（假设C得到了同步对象）。 |--(拥有锁的线程) C | 10 lockObj--|--(就绪队列) A | |--(等待队列) 随后C也退出Lock区块，同步对象闲置，A就重新得到了同步对象，并从Monitor.Wait中返回... 最终的执行结果就是： B exit... C exit... A exit...

class MyManualEvent 
{ 
　　privateobject lockObj =newobject(); 
　　privatebool hasSet =false; 
　　publicvoid Set() 
　　{ 
　　　　lock (lockObj) 
　　　　{ 
　　　　　　hasSet =true; 
　　　　　　Monitor.PulseAll(lockObj); 
　　　　}
　　 } 
　　publicvoid WaitOne() 
　　{ 
　　　　lock (lockObj) 
　　　　{ 
　　　　　　while (!hasSet) 
　　　　　　{ 
　　　　　　　　Monitor.Wait(lockObj); 
　　　　　　}
　　　　} 
　　} 
} 

class Program 
{ 
　　static MyManualEvent myManualEvent =new MyManualEvent(); 
　　staticvoid Main(string[] args) 
　　{ 
　　　　ThreadPool.QueueUserWorkItem(WorkerThread, "A"); 
　　　　ThreadPool.QueueUserWorkItem(WorkerThread, "B"); 
　　　　Console.WriteLine("Press enter to signal the green light"); 
　　　　Console.ReadLine(); 
　　　　myManualEvent.Set(); ThreadPool.QueueUserWorkItem(WorkerThread, "C"); 
　　　　Console.ReadLine(); 
　　} 
　　staticvoid WorkerThread(object state) 
　　{ 
　　　　myManualEvent.WaitOne(); 
　　　　Console.WriteLine("Thread {0} got the green light...", state); 
　　} 
}