using System;
using System.Threading;

namespace ThreadConsole
{	
	public class TestMonitor
	{
		public static void Main()
		{		
			DataPackage pack = new DataPackage( );

			// 創建包含線程方法的對象
			SendPackage server = new SendPackage(pack, 20);  
			ReceivePackage client = new ReceivePackage(pack, 20); 

			// 創建兩個線程對象，一個用于發送數據包，另一個用于接收數據包 
			Thread sendthread = new Thread(new ThreadStart(server.SendPackageThreadRun));
			Thread receivethread = new Thread(new ThreadStart(client.ReceivePackageThreadRun));	
	
			//啟動線程以前查看線程狀態
			ThreadState ts = sendthread.ThreadState;	// 獲取并顯示線程的狀態
			Console.WriteLine( "發送線程的目前狀態：" + ts.ToString() );

			try
			{
				// 啟動兩個線程
				sendthread.Start( );
				while( !sendthread.IsAlive );	// 等待線程進入運行狀態
				ts = sendthread.ThreadState;
				Console.WriteLine( "發送線程啟動而接受線程沒有啟動時的狀態：" + ts.ToString() );

				receivethread.Start( );	

				//下面這三行代碼是否增加，輸出結果不一樣，由此可以看到Suspend的作用
				//receivethread.Suspend();
				//Thread.Sleep(2000);
				//receivethread.Resume();
			
				// 等待兩個線程結束
				sendthread.Join( );  
				receivethread.Join( );  			
			}
			catch (ThreadStateException e) //線程異常處理
			{
				Console.WriteLine(e); 
			}
			catch (ThreadInterruptedException e) //線程異常處理
			{
				Console.WriteLine(e); 
			}	
	
			ts = sendthread.ThreadState;
			Console.WriteLine( "發送和接受線程都啟動后的狀態1：" + ts.ToString() );
			ts = receivethread.ThreadState;
			Console.WriteLine( "發送和接受線程都啟動后的狀態2：" + ts.ToString() );
		}
	} //end of class TestMonitor

	// 發送數據包的類
	public class SendPackage
	{
		DataPackage pack;      // 保存將被發送的數據包
		int quantity = 1;  // 數據包的個數
		
		// 發送數據包
		public SendPackage(DataPackage p, int count)
		{
			pack = p;  
			quantity = count; 
		}
		public void SendPackageThreadRun( )
		{
			Console.WriteLine("---------------------------");
			Console.WriteLine("    開始執行發送線程方法... ");
			Thread.Sleep( 1000 );	// 線程暫停1秒鐘
			// 發送指定數量的數據包
			for(int looper = 1; looper <= quantity; looper++) 
				pack.Send(looper);  // 調用數據包對象的發送方法
			Console.WriteLine("    發送線程方法結束... ");
			Console.WriteLine("---------------------------");
		}
	} // end of class SendPackage

	// 接收數據包的類
	public class ReceivePackage
	{
		DataPackage pack;     
		int quantity = 1; 

		// 接收數據包
		public ReceivePackage(DataPackage p, int count)
		{
			pack = p;       
			quantity = count;
		}
		public void ReceivePackageThreadRun( )
		{
			int valReturned;
			// 接收指定數量的數據包
			for(int looper = 1; looper <= quantity; looper++)			
				valReturned = pack.Receive( );
		}
	} // end of class ReceivePackage
	
/*	// 數據包類--定義一，使用monitor類，并且由該類來獲取、釋放同步鎖
	public class DataPackage
	{
		int packContents;         // 數據包的內容		
		bool readerFlag = false;  // 狀態標識,初始值設置為false， 表示只能發送而不能接收
	
		// 接收方法
		public int Receive( )
		{
			Monitor.Enter(this);  // 獲取同步鎖
			if (!readerFlag)
			{            // 等待數據包到達
				try
				{					
					Monitor.Wait(this); // 等待同步鎖
				}
				catch (SynchronizationLockException e) //同步鎖異常處理
				{
					Console.WriteLine(e);
				}
				catch (ThreadInterruptedException e) //同步鎖異常處理
				{
					Console.WriteLine(e);
				}
			}
			Console.WriteLine("...接收（{0,2}）",packContents);
			readerFlag = false;		// false表示接收結束
			Monitor.Pulse(this);	// 通知其他線程
			Monitor.Exit(this);	// 釋放同步鎖
			return packContents;
		}
   
		// 發送數據
		public void Send(int n)
		{
			Monitor.Enter(this);
			if (readerFlag)
			{      // 等待前一個數據包被接收
				try
				{
					Monitor.Wait(this);  					
				}
				catch (SynchronizationLockException e)
				{
					Console.WriteLine(e);
				}
				catch (ThreadInterruptedException e)
				{
					Console.WriteLine(e);
				}
			}
			packContents = n;
			Console.Write("發送（{0,2}）...",packContents);
			readerFlag = true;    
			Monitor.Pulse(this);  
			Monitor.Exit(this);
		}
	} // end of class Package   
*/
	// 數據包類--定義二，使用monitor類，但不由該類來獲取、釋放同步鎖，而是使用lock語句
	public class DataPackage
	{
		int packContents;         // 數據包的內容		
		bool readerFlag = false;  // 狀態標識,初始值設置為false， 表示只能發送而不能接收
	
		// 接收方法
		public int Receive( )
		{
		     lock(this)
		     {
			if (!readerFlag)
			{            // 等待數據包到達
				try
				{					
					Monitor.Wait(this); // 等待同步鎖
				}
				catch (SynchronizationLockException e) //同步鎖異常處理
				{
					Console.WriteLine(e);
				}
				catch (ThreadInterruptedException e) //同步鎖異常處理
				{
					Console.WriteLine(e);
				}
			}
			Console.WriteLine("...接收（{0,2}）",packContents);
			readerFlag = false;		// false表示接收結束
			Monitor.Pulse(this);	// 通知其他線程			
		    } // end of lock
			return packContents;
		}
   
		// 發送數據
		public void Send(int n)
		{
		    lock (this) 
	            {
			if (readerFlag)
			{      // 等待前一個數據包被接收
				try
				{
					Monitor.Wait(this);  					
				}
				catch (SynchronizationLockException e)
				{
					Console.WriteLine(e);
				}
				catch (ThreadInterruptedException e)
				{
					Console.WriteLine(e);
				}
			}
			packContents = n;
			Console.Write("發送（{0,2}）...",packContents);
			readerFlag = true;    
			Monitor.Pulse(this);  
		    } // end of lock
		}
	} // end of class Package  
} // end of namespace