//SystemThread.csusing 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 codeT 线程A ---0lock( 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); 
　　} 
}