class1.cs

这是学习java基础的好的源代码的学习资料

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