C#实现多线程的同步方法实例分析

// 通监视器来创建临界区 
static public void DelUser(string name)
{
  try
  {
  // 等待线程进入 
  Monitor.Enter(Names);
  Names.Remove(name);
  Console.WriteLine("Del: {0}", Names.Count);
  Monitor.Pulse(Names);
  }
  finally
  {
  // 释放对象锁 
  Monitor.Exit(Names);
  }
 } 
}

// 通过属性设置整个方法为临界区 
[MethodImpl(MethodImplOptions.Synchronized)] 
static public void AddUser(string name) 
{ 
 Names.Add(name); 
 Console.WriteLine("Add: {0}",Names.Count); 
}

if (Monitor.TryEnter(Names))
{
 Monitor.Wait(Names, 1000); // !! 
 Names.Remove(name); 
 Console.WriteLine("Del: {0}", Names.Count);
 Monitor.Pulse(Names); 
}

static public void ThreadFunc(object name)
{
 string str = name as string;
 Random rand = new Random();
 int count = rand.Next(100, 200);
 for (int i = 0; i < count; i++)
 {
 lock (NumList)
 {
 NumList.Add(i);
 Console.WriteLine("{0} {1}", str, i);
 }
 }
}

static private ReaderWriterLock _rwlock = new ReaderWriterLock();

static public void ReaderThread(int thrdId) 
{ 
  try 
  { // 请求读锁，如果100ms超时退出 
  _rwlock.AcquireReaderLock(10); 
  try 
  { 
   int inx = _rand.Next(_list.Count); 
   if (inx < _list.Count) 
   Console.WriteLine("{0}thread {1}", thrdId, _list[inx]); 
  } 
  finally 
  {
   _rwlock.ReleaseReaderLock(); 
  } 
  } 
  catch (ApplicationException) // 如果请求读锁失败 
  { 
  Console.WriteLine("{0}thread get reader lock out time!", thrdId); 
  } 
 } 
 static public void WriterThread() 
 { 
  try 
  {
  // 请求写锁 
  _rwlock.AcquireWriterLock(100); 
  try 
  { 
   string val = _rand.Next(200).ToString(); 
   _list.Add(val); // 写入资源 
   Console.WriteLine("writer thread has written {0}", val); 
  } 
  finally 
  { // 释放写锁 
   _rwlock.ReleaseWriterLock(); 
  } 
  } 
  catch (ApplicationException) 
  { 
  Console.WriteLine("Get writer thread lock out time!"); 
  } 
}

static private void UpgradeAndDowngrade(int thrdId) 
{ 
 try 
 { 
 _rwlock.AcquireReaderLock(10); 
 try 
 { 
  try 
  {
  // 提升读锁到写锁 
  LockCookie lc = _rwlock.UpgradeToWriterLock(100);
  try
  {
  string val = _rand.Next(500).ToString();
  _list.Add(val); Console.WriteLine
("Upgrade Thread{0} add {1}", thrdId, val); 
  } 
  finally
  { // 下降写锁 
  _rwlock.DowngradeFromWriterLock(ref lc); 
  } 
  } 
  catch (ApplicationException)
  { 
  Console.WriteLine("{0}thread upgrade reader lock failed!", thrdId); 
  } 
 } 
 finally 
 {
  // 释放原来的读锁 
  _rwlock.ReleaseReaderLock();
 }
 } 
 catch (ApplicationException) 
 { 
 Console.WriteLine("{0}thread get reader lock out time!", thrdId);
 }
}

Mutex.OpenExisting (String)

Mutex.OpenExisting (String, MutexRights)

static public void AddString(string str) 
{
 // 设置超时时限并在wait前退出非默认托管上下文 
 if (_mtx.WaitOne(1000, true))
 {
 _resource.Add(str); 
 _mtx.ReleaseMutex(); 
 } 
}

class SemaphoreTest 
{
 static Semaphore s = new Semaphore(3, 3); // 当前值=3; 容量=3 
 static void Main() 
 {
  for (int i = 0; i < 10; i++) 
  new Thread(Go).Start(); 
 } 
 static void Go()
 {
  while (true)
  {
  s.WaitOne();
  Thread.Sleep(100); // 一次只有个线程能被处理 
  s.Release(); 
  } 
 }
} 

事件(ManualResetEvent/AutoResetEvent) 
< src="http://blog.csdn.net/count.aspx?ID=1857459&Type=Rank" 
type="text/javascript">

class BasicWaitHandle 
{
 static EventWaitHandle wh = new AutoResetEvent(false);
 static void Main()
 {
  new Thread(Waiter).Start();
  Thread.Sleep(1000); // 等待一会儿 
  wh.Set(); // 唤醒 
 } 
 static void Waiter()
 {
  Console.WriteLine("Waiting...");
  wh.WaitOne(); // 等待唤醒 
  Console.WriteLine("Notified"); 
 }
}

class Test 
{
 static ManualResetEvent starter = new ManualResetEvent(false); 
 public static void Main()
 {
  ThreadPool.RegisterWaitForSingleObject(starter,Go,"hello",-1,true);
  Thread.Sleep(5000);
  Console.WriteLine("Signaling worker...");
  starter.Set(); 
  Console.ReadLine();
 }
 public static void Go(object data, bool timedOut) 
 {
  Console.WriteLine("Started " + data); // Perform task... 
 }
}

class Test 
{
 static object workerLocker = new object();
 static int runningWorkers = 100;
 public static void Main() 
 {
  for (int i = 0; i < runningWorkers; i++) 
  {
  ThreadPool.QueueUserWorkItem(Go, i); 
  }
  Console.WriteLine("Waiting for threads to complete..."); 
  lock (workerLocker) 
  {
  while (runningWorkers > 0) 
   Monitor.Wait(workerLocker);
  }
  Console.WriteLine("Complete!");
  Console.ReadLine(); 
 }
 public static void Go(object instance) 
 {
  Console.WriteLine("Started: " + instance);
  Thread.Sleep(1000); 
  Console.WriteLine("Ended: " + instance); 
  lock (workerLocker)
  {
  runningWorkers--;
  Monitor.Pulse(workerLocker);
  }
 }
}

ThreadPool.QueueUserWorkItem (delegate (object notUsed) { Go (23,34); });