.NET多线程总结和实例介绍

public void test()
{
ThreadStart threadStart = new ThreadStart(Calculate);
Thread thread = new Thread(threadStart);
thread.Start();
} public void Calculate()
{
double Diameter = 0.5;
Console.Write("The perimeter Of Circle with a Diameter of {0} is {1}", Diameter, Diameter * Math.PI);
}

public void test
{
//ParameterThreadStart的定义为void ParameterizedThreadStart(object state)
//使用这个这个委托定义的线程的启动函数可以接受一个输入参数,具体例子如下
ParameterizedThreadStart threadStart=new ParameterizedThreadStart(Calculate);
Thread thread=new Thread();
thread.Start(0.9);
} public void Calculate(object arg)
{
double Diameter=double(arg);
Console.Write("The perimeter Of Circle with a Diameter of {0} is {1}",
Diameter,Diameter*Math.PI);
}

public class MyThread
{
public double Diameter = ;
public double Result = ; public MyThread(int Diameter)
{
this.Diameter = Diameter;
} public void Calculate()
{
Console.WriteLine("Calculate Start");
Thread.Sleep();
Result = Diameter * Math.PI; ;
Console.WriteLine("Calculate End, Diameter is {0},Result is {1}", this.Diameter, Result);
}
}MyThread t=new MyThread(5.0);
ThreadStart threadStart=new ThreadStart(t.Calculate)
Thread thread=new Thread(threadStart);
thread.Start();
}

double Diameter = ;
double Result=;
Thread ta = new Thread(new ThreadStart(delegate()
{
Thread.Sleep();
Result=Diameter * Math.PI;
Console.WriteLine("匿名 Calculate End, Diameter is {0},Result is {1}",
Diameter, Result); ;
}));
ta.Start();

delegate double CalculateMethod(double Diameter); static CalculateMethod calcMethod;
double result = ; static void Main(string[] args)
{
calcMethod = new CalculateMethod(Calculate);
calcMethod.BeginInvoke(, new AsyncCallback(TaskFinished), null);
} ///<summary>
///线程调用的函数
///<summary>
public static double Calculate(double Diameter)
{
return Diameter * Math.PI;
} ///<summary>///线程完成之后回调的函数
///<summary>
public static void TaskFinished(IAsyncResult result)
{
result=calcMethod.EndInvoke(result);
}

WaitCallback w = new WaitCallback(Calculate);
ThreadPool.QueueUserWorkItem(w, 1.0);
ThreadPool.QueueUserWorkItem(w, 2.0);
ThreadPool.QueueUserWorkItem(w, 3.0);
ThreadPool.QueueUserWorkItem(w, 4.0);public static void Calculate(double Diameter)
{
return Diameter * Math.PI;
}

public static void TaskFinished(IAsyncResult result)
{
result=calcMethod.EndInvoke(result);
this.TextBox1.Text=result;
}

delegate void changeText(string result);public static void TaskFinished(IAsyncResult result)
{
result=calcMethod.EndInvoke(result);
this.BeginInvoke(new changeText(this.textBox1.AppendText),t.Result.ToString())
}

public void AcquireReaderLock( int millisecondsTimeout )
{
// m_mutext很快可以得到，以便进入临界区 m_mutex.WaitOne( );
// 是否有写入线程存在
bool bExistingWriter = ( m_nActive < );
if( bExistingWriter )
{ //等待阅读线程数目加1,当有锁释放时，根据此数目来调度线程
m_nWaitingReaders++;
}
else
{ //当前活动线程加1
m_nActive++;
} m_mutex.ReleaseMutex();
//存储锁标志为Reader
System.LocalDataStoreSlot slot = Thread.GetNamedDataSlot(m_strThreadSlotName);
object obj = Thread.GetData( slot );
LockFlags flag = LockFlags.None; if( obj != null )
flag = (LockFlags)obj ;
if( flag == LockFlags.None )
{
Thread.SetData( slot, LockFlags.Reader );
}
else
{
Thread.SetData( slot, (LockFlags)((int)flag | (int)LockFlags.Reader ) );
}
if( bExistingWriter )
{ //等待指定的时间
this.m_aeReaders.WaitOne( millisecondsTimeout, true );
}
}

public void AcquireWriterLock( int millisecondsTimeout )
{
// m_mutext很快可以得到，以便进入临界区
m_mutex.WaitOne( );
// 是否有活动线程存在
bool bNoActive = m_nActive == ;
if( !bNoActive )
{ m_nWaitingWriters++;
}
else
{
m_nActive--;
}
m_mutex.ReleaseMutex();
//存储线程锁标志
System.LocalDataStoreSlot slot = Thread.GetNamedDataSlot( "myReaderWriterLockDataSlot" );
object obj = Thread.GetData( slot );
LockFlags flag = LockFlags.None;
if( obj != null )
flag = (LockFlags)Thread.GetData( slot );
if( flag == LockFlags.None )
{ Thread.SetData( slot, LockFlags.Writer );
}
else
{
Thread.SetData( slot, (LockFlags)((int)flag | (int)LockFlags.Writer ) );
} //如果有活动线程，等待指定的时间 if( !bNoActive )
this.m_aeWriters.WaitOne( millisecondsTimeout, true );
}

public void ReleaseReaderLock() {
System.LocalDataStoreSlot slot = Thread.GetNamedDataSlot(m_strThreadSlotName );
LockFlags flag = (LockFlags)Thread.GetData( slot );
if( flag == LockFlags.None ) { return;
} bool bReader = true; switch( flag )
{
case LockFlags.None:
break;
case LockFlags.Writer:
bReader = false;
break;
} if( !bReader )
return;
Thread.SetData( slot, LockFlags.None );
m_mutex.WaitOne();
AutoResetEvent autoresetevent = null;
this.m_nActive --;
if( this.m_nActive == )
{ if( this.m_nWaitingReaders > ) {
m_nActive ++ ;
m_nWaitingReaders --;
autoresetevent = this.m_aeReaders;
}
else if( this.m_nWaitingWriters > )
{
m_nWaitingWriters--; m_nActive --; autoresetevent = this.m_aeWriters ; } } m_mutex.ReleaseMutex();
if( autoresetevent != null )
autoresetevent.Set();
}

using System;
using System.Threading;
using MyThreading;
class Resource {
myReaderWriterLock rwl = new myReaderWriterLock();
public void Read(Int32 threadNum) {
rwl.AcquireReaderLock(Timeout.Infinite); try { Console.WriteLine("Start Resource reading (Thread={0})", threadNum); Thread.Sleep(); Console.WriteLine("Stop Resource reading (Thread={0})", threadNum);
} finally { rwl.ReleaseReaderLock(); } } public void Write(Int32 threadNum) {
rwl.AcquireWriterLock(Timeout.Infinite);
try {
Console.WriteLine("Start Resource writing (Thread={0})", threadNum);
Thread.Sleep();
Console.WriteLine("Stop Resource writing (Thread={0})", threadNum);
} finally { rwl.ReleaseWriterLock();
} }
}
class App { static Int32 numAsyncOps = ;
static AutoResetEvent asyncOpsAreDone = new AutoResetEvent(false);
static Resource res = new Resource();
public static void Main() {
for (Int32 threadNum = ; threadNum < ; threadNum++) {
ThreadPool.QueueUserWorkItem(new WaitCallback(UpdateResource), threadNum);
} asyncOpsAreDone.WaitOne();
Console.WriteLine("All operations have completed.");
Console.ReadLine();
} // The callback method's signature MUST match that of a System.Threading.TimerCallback
// delegate (it takes an Object parameter and returns void)
static void UpdateResource(Object state) {
Int32 threadNum = (Int32) state;
if ((threadNum % ) != ) res.Read(threadNum);
else res.Write(threadNum);
if (Interlocked.Decrement(ref numAsyncOps) == )
asyncOpsAreDone.Set();
}
}