C#多线程和线程同步总结

Thread

没有参数的线程启动

Thread newThread = new Thread(new ThreadStart(DoWork));

newThread.Start();

　　

有参数的线程启动

注意DoWork()的参数必须为object

Thread newThread2 = new Thread(new ParameterizedThreadStart(this.DoWork)); newThread2.Start("111");

　　

AutoResetEvent

通知等待的其他线程，本线程已经工作做完.

比如要计算1-N的各个数的平方之和,每个数的平方由不同的线程去计算

/// <summary>
/// 求数组平方和
/// </summary>
public class GetSquareSum
{
    //建立事件数组  ,N个线程,就N个AutoResetEvent
    public AutoResetEvent[] autoEvents = null;
     //数组
    public int[] array = null;

    public int Sum = 0;

    public GetSquareSum(int []arrays)
    {
        this.array = arrays;
        autoEvents = new AutoResetEvent[arrays.Length];
        for (int i = 0; i < arrays.Length; i++)
        {
            autoEvents[i] = new AutoResetEvent(false);//初始化
        }
        this.GetResult();
        WaitHandle.WaitAll(autoEvents);
        //autoEvents.ToList().ForEach(s => s.WaitOne());
        foreach (int r in array)
        {
            Sum += r;
        }
        Console.WriteLine("Sum="+Sum);
    }

    public void GetResult()
    {
        for (int i = 0; i < array.Length; i++)
        {
            Calculate(i);
        }
    }

    /// <summary>
    /// 计算第index个数
    /// </summary>
    /// <param name="index"></param>
    public void Calculate(int index)
    {
            Thread newThread2 = new Thread(
                new ParameterizedThreadStart(
                    (obj) =>
                    {
                        int j = (int)obj;
                        array[j] = array[j] * array[j];
                        Console.WriteLine(array[j]);
                        autoEvents[j].Set();
                    }
                    )
                );
            newThread2.Start(index);

    }
}

　　

ManualResetEvent

MSDN上的解释是：通知一个或多个正在等待的线程已发生事件。

例子解释：

• 打印方法已经准备好，但是打印的东西没准备好，所以打印之前mreInit.WaitOne(),等待资源

• 通过控制台输入资源,mreInit.Set()通知资源准备好,打印程序开始打印

  public class ManualResetEventTestExample2
  {
  
  private static ManualResetEvent mreInit;
  
  private string _test = "";
  public void Test()
  {
  
      mreInit = new ManualResetEvent(false);//
      Thread newThread = new Thread(new ThreadStart(() => Print()));
      newThread.Start();
  
      _test = (Console.ReadLine());
      mreInit.Set();
  }
  
  /// <summary>
  /// 打印程序准备就绪
  /// </summary>
  private void Print()
  {
      mreInit.WaitOne();
      Console.WriteLine(_test);
  }
  }
  

  　　

ManualResetEvent的reset看下面代码

public class ManualResetEventTestExample2
{
    private static ManualResetEvent mreInit;

    private string _test = "";
    public void Test()
    {

        mreInit = new ManualResetEvent(false);//
         new Thread(new ThreadStart(() => Print())).Start();//Print 1
        _test = (Console.ReadLine());//Input 1
        mreInit.Set();

        mreInit.Reset();
        new Thread(new ThreadStart(() => Print())).Start();//Print 2
        new Thread(new ThreadStart(() => Print())).Start();//Print 3
        new Thread(new ThreadStart(() => Print())).Start();//Print 4
        new Thread(new ThreadStart(() => Print())).Start();//Print 5

        _test = (Console.ReadLine());//Input 2
        mreInit.Set();
    }

    /// <summary>
    /// 打印程序准备就绪
    /// </summary>
    private void Print()
    {
        mreInit.WaitOne();
        Console.WriteLine(_test);
    }

　　

print 1肯定会在输入后执行,Print 2,3,4,5的执行,则依赖reset.如果没有mreInit.Reset()这句,则Print1,2,3,4,5会直接依次执行.如果加了mreInit.Reset()这句,这Print2,3,4,5只有在input 2执行了之后才会执行.

Reset就是让ManualResetEvent回复到初始状态.

线程池 ThreadPool

public static bool QueueUserWorkItem (WaitCallback callBack);
public static bool QueueUserWorkItem(WaitCallback callback, Object state);

　　

这两个方法向线程池的队列添加一个工作项（work item）以及一个可选的状态数据。然后，这两个方法就会立即返回。

工作项其实就是由callback参数标识的一个方法，该方法将由线程池线程执行。 同时写的回调方法必须匹配System.Threading.WaitCallback委托类型，定义为：

public delegate void WaitCallback(Object state);

　　

就是说如果要带参数，callback参数必须为object.

 ThreadPool.QueueUserWorkItem(new WaitCallback(obj => { System.Threading.Thread.Sleep(1000); Console.WriteLine(obj.ToString()); }),"canshu");

　　

或者这么写

 ThreadPool.QueueUserWorkItem(new WaitCallback(Func), "canshu");
 private void Func(object obj)
    {
        System.Threading.Thread.Sleep(1000);
        Console.WriteLine(obj.ToString());
    }

　　

或者

ThreadPool.QueueUserWorkItem(a=>{Func(a);}, "canshu");

　　

以下代码改造求平方的问题.

class ThreadPoolTest2
{
    public void Test()
    { // List<int> result = new List<int>();
        int sum = 0;
        object lockobj = new object();
        Action<object> action = obj =>
        {
            Parm p = (Parm)obj;
            lock (lockobj)
            {
                sum += p.Num * p.Num;
            }
            p.Are.Set();

        };

        int[] array = new int[] { 1, 2, 3, 4, 5,6,7,8,9,10,11,12,13,14,15 };

        AutoResetEvent[] autos = new AutoResetEvent[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            autos[i] = new AutoResetEvent(false);
            ThreadPool.QueueUserWorkItem(a=>action(a), new Parm() { Are = autos[i], Num = array[i] });
        }
        Console.WriteLine(sum);
        //WaitHandle.WaitAll(autos);
        autos.ToList().ForEach(s=>s.WaitOne());
        Console.WriteLine(sum);
    }

    class Parm
    {
        public int Num { set; get; }
        public AutoResetEvent Are { set; get; }
    }
}

　　

注意:在sum += p.Num * p.Num这句必须lock,不然会得不到正确结果

CancellationTokenSource

例子讲解:有5个数组,需要在数组中找是否有0元素,找到则返回.

实现:每个数据开启一个现场,如果某一个线程先找到0,则返回,同时,通知其他线程不用计算了.

class CancellationTokenSourceTest2
{
    public void Test()
    {
        CancellationTokenSource cts = new CancellationTokenSource();
        CancellationToken token = cts.Token;
        int[][] array = new int[][]
        {
            new []{1,2,3,0,5,6,7,8,9,10},
            new []{1,2,3,4,5,6,7,8,9,0},
            new []{1,2,3,4,5,6,7,8,0,10},
            new []{1,2,3,4,5,6,0,8,9,10},
            new []{1,2,3,4,5,0,7,8,9,10}
        };

        for (int i = 0; i < array.Length; i++)
        {
            Thread th = new Thread(new ParameterizedThreadStart
            ((obj) =>
            {
                Parm p = (Parm)obj;
                int[] a = p.Value;
                for (int n=0;n<a.Length;n++)
                {
                    int j = a[n];
                    Console.WriteLine("in array " + p.Index +" "+ (n + 1) + " times");
                    if (!p.Cts.IsCancellationRequested)
                    {
                        if (j == 0)
                        {
                            p.Cts.Cancel();
                            Console.WriteLine("Cancelling at task " + p.Index + "th array");
                            break;
                        }
                        Thread.Sleep(1000);
                    }
                    else
                    {
                        break;
                    }
                }
            }
                ));
            th.Start(new Parm() { Cts = cts, Value = array[i] , Index=i});
        }
        Console.ReadLine();//敲下回车后，，

    }
    public class Parm
    {
        public CancellationTokenSource Cts;
        public int []Value;
        public int Index;

    }
}

　　

运行结果,首先在第0个数组中找到,总共比较次数为20次左右.

也可以尝试用AutoResetEvent实现,用 WaitHandle.WaitAny()等待.

BeginInvoke 和 EndInvoke

例子1:说明异步执行,将一个数乘以2返回,异步后等待结果后求和.

class BeginInvokeTest
{
    public void Test()
    {
        Func<int, int> GetDouble = (a) => { Console.WriteLine(a); return a * 2; };

        IAsyncResult ar1 = GetDouble.BeginInvoke(100, null, null);
        IAsyncResult ar2 = GetDouble.BeginInvoke(200, null, null);

        int result = GetDouble.EndInvoke(ar1)+GetDouble.EndInvoke(ar2);
        Console.WriteLine("result = " + result);
    }
}

　　

打印结果为

100

200

result = 600

或者

200

100

result = 600

100和200的打印是异步执行,不知道誰先执行完,但是求和得等到EndInvoke两个异步完成,才能计算

例子2:两个异步去发送消息,发送完成后,去做其他事情,并且在发送消息的回调中保存消息记录↓.

class BeginInvokeTest2//回调方法中处理
{
    public void Test()
    {
        Func<string, string> SendMessage = (a) =>
        {
            System.Threading.Thread.Sleep(1000);
              Console.WriteLine("发送消息:"+a+" ,");
              return "OK";
        };
        AsyncCallback callback = (ar) =>
        {

            Parm p = (Parm)ar.AsyncState;
              if (p.F.EndInvoke(ar) == "OK")
              {
                  Console.WriteLine("消息发送成功,保存聊天记录 "+p.Message);
              }
        };

        Parm p1=new Parm(){ F=SendMessage, Message= "message1"};
        Parm p2 = new Parm() { F = SendMessage, Message = "message2" };

        IAsyncResult iar1 = SendMessage.BeginInvoke(p1.Message, callback, p1);
        IAsyncResult iar2 = SendMessage.BeginInvoke(p2.Message, callback, p2);

        iar1.AsyncWaitHandle.WaitOne();//等待执行完毕,并不是等待callback执行完
        iar2.AsyncWaitHandle.WaitOne();//等待执行完毕,并不是等待callback执行完

        Console.WriteLine("消息发完,做其他事情");
        Console.Read();
    }

    class Parm
    {
       public Func<string, string> F;
       public string Message;
    }
}

　　

线程同步Interlocked.Increment

以原子操作的形式递增指定变量的值并存储结果

例子说明:用3种方法对初始值为1的进行一百次++操作.第一种直接加,第二,三种方法多线程.第三种用Interlocked.Increment.运行结果为第二种的结果值可能不为101.

class InterlockedTest
{
    public void Test()
    {
        int N = 1;
        for (int i = 1; i <= 100; i++)
        {
            N++;
        }
        Console.WriteLine(N);

        int M = 1;
        Action<object> action = obj =>
        {
            Parm p = (Parm)obj;
            M++;
            p.au.Set();

        };

        AutoResetEvent[] autos = new AutoResetEvent[100];
        for (int i = 1; i <= 100; i++)
        {
            autos[i-1] = new AutoResetEvent(false);
            ThreadPool.QueueUserWorkItem(a=>action(a), new Parm() { au = autos[i-1], index = i });
        }
        autos.ToList().ForEach(s => s.WaitOne());
        Console.WriteLine(M);

        int Q = 1;
        Action<object> action2 = obj =>
        {
            Parm p = (Parm)obj;
            Interlocked.Increment(ref Q);
            p.au.Set();

        };
        autos = new AutoResetEvent[100];
        for (int i = 1; i <= 100; i++)
        {
            autos[i - 1] = new AutoResetEvent(false);
            ThreadPool.QueueUserWorkItem(a => action2(a), new Parm() { au = autos[i - 1], index = i });
        }
        autos.ToList().ForEach(s => s.WaitOne());
        Console.WriteLine(Q);
    }

    public class Parm
    {
        public AutoResetEvent au;
        public int index;
    }
}

　　

线程同步 Monitor.Enter和Lock

Lock关键字是一个语法糖，它将Monitor对象进行封装.

语法糖(Syntactic sugar),是由Peter J. Landin(和图灵一样的天才人物，是他最先发现了Lambda演算，由此而创立了函数式编程)创造的一个词语，它意指那些没有给计算机语言添加新功能，而只是对人类来说更“甜蜜”的语法。语法糖往往给程序员提供了更实用的编码方式，有益于更好的编码风格，更易读。不过其并没有给语言添加什么新东西。

例子同Interlocked.Increment,不再详细说明

class MonitorTest
{

    public void Test()
    {
        int N = 1;
        for (int i = 1; i <= 100; i++)
        {
            N++;
        }
        Console.WriteLine(N);

        int M = 1;
        Action<object> action = obj =>
        {
            Parm p = (Parm)obj;
            M++;
            p.au.Set();

        };

        AutoResetEvent[] autos = new AutoResetEvent[100];
        for (int i = 1; i <= 100; i++)
        {
            autos[i - 1] = new AutoResetEvent(false);
            ThreadPool.QueueUserWorkItem(a => action(a), new Parm() { au = autos[i - 1], index = i });
        }
        autos.ToList().ForEach(s => s.WaitOne());
        Console.WriteLine(M);

        int Q = 1;
        object objMonitor=new object();
        Action<object> action2 = obj =>
        {
            Parm p = (Parm)obj;
            Monitor.Enter(objMonitor);
            try
            {
                Q++;
            }
            finally
            {
                Monitor.Exit(objMonitor);
            }
            p.au.Set();

        };
        autos = new AutoResetEvent[100];
        for (int i = 1; i <= 100; i++)
        {
            autos[i - 1] = new AutoResetEvent(false);
            ThreadPool.QueueUserWorkItem(a => action2(a), new Parm() { au = autos[i - 1], index = i });
        }
        autos.ToList().ForEach(s => s.WaitOne());
        Console.WriteLine(Q);
    }

    public class Parm
    {
        public AutoResetEvent au;
        public int index;
    }
}

　　

ReaderWriterLock

例子说明:ReaderWriterLockEntity有2个成员变量X,Y,读写方法各有2个,一个使用读写锁,一个直接读写.我们设定X和Y必须相等.

class ReaderWriterLockEntity
{
    ReaderWriterLock locker = new ReaderWriterLock();

    public int X { set; get; }
    public int Y { set; get; }

    public void ReadLock(ref int x, ref int y)
    {
        locker.AcquireReaderLock(Timeout.Infinite);
        try
        {
            x = this.X;
            y = this.Y;
        }
        finally
        {
            locker.ReleaseReaderLock();
        }
    }

    public void WriteLock(int x, int y)
    {
        locker.AcquireWriterLock(Timeout.Infinite);
        try
        {
            this.X = x;
            Thread.Sleep(10);
            this.Y = y;
        }
        finally
        {
            locker.ReleaseWriterLock();
        }
    }

    public void Read(ref int x, ref int y)
    {
        x = this.X;
        y = this.Y;
    }

    public void Write(int x, int y)
    {
        this.X = x;
        Thread.Sleep(10);
        this.Y = y;
    }
}

　　

读写类,其中Test方法中,开启两组现场写线程,对ReaderWriterLockEntity中的X,Y进行自增.两组读线程,不停的打印X,Y.

打印的结果中,有X和Y不相等的结果出现.

Test2方法中,加了读写锁,打印的结果,不会有X和Y不等的情况.

ReaderWriterLock和Lock的区别就是,当加了ReaderLock,应该不会影响多个ReaderLock的增加.一个资源可以被Reader Lock多次.而lock则达不到这个要求.所以,ReadWriterLock在某些场景,比Lock效率更高.

class ReaderWriterTest2
{
    ReaderWriterLockEntity entity = new ReaderWriterLockEntity();
    public void Test()
    {

        Action writer = () =>
        {
            int a = 10;
            int b = 10;
            //Console.WriteLine("************** Write *************");

            for (int i = 0; i < 5; i++)
            {
                this.entity.Write(a++, b++);
                Thread.Sleep(10);
            }
        };

        Action reader = () =>
        {
           // Console.WriteLine("************** Reader *************");

            int x=0, y=0;
            for (int i = 0; i < 50; i++)
            {
                this.entity.Read(ref x, ref y);
                Console.WriteLine("Read:X={0},y={1}", x, y);
                Thread.Sleep(1);
            }
        };

        //Writer Threads
        Thread wt1 = new Thread(new ThreadStart(writer));
        wt1.Start();
        Thread wt2 = new Thread(new ThreadStart(writer));
        wt2.Start();

        //Reader Threads
        Thread rt1 = new Thread(new ThreadStart(reader));
        rt1.Start();
        Thread rt2 = new Thread(new ThreadStart(reader));
        rt2.Start();
    }

    public void Test2()
    {
        Action writer = () =>
        {
            int a = 10;
            int b = 10;
            for (int i = 0; i < 5; i++)
            {
                this.entity.WriteLock(a++, b++);
                Thread.Sleep(10);
            }
        };

        Action reader = () =>
        {
            int x = 0, y = 0;
            for (int i = 0; i < 50; i++)
            {
                this.entity.ReadLock(ref x, ref y);
                Console.WriteLine("Read:X={0},y={1}", x, y);
                Thread.Sleep(1);
            }
        };

        //Writer Threads
        Thread wt1 = new Thread(new ThreadStart(writer));
        wt1.Start();
        Thread wt2 = new Thread(new ThreadStart(writer));
        wt2.Start();

        //Reader Threads
        Thread rt1 = new Thread(new ThreadStart(reader));
        rt1.Start();
        Thread rt2 = new Thread(new ThreadStart(reader));
        rt2.Start();
    }
}

　　

Semaphore信号量

例子说明:厕所有5个位置,每个人上厕所五秒.程序输入1后,表示有一个人要上厕所.如果厕所已满,则会自动等待.

class SemaphoreTest
{
    Semaphore sem = new Semaphore(5,5);//厕所空的

    public void In()
    {
        sem.WaitOne();
        Console.WriteLine("有空位,上厕所");
        Thread.Sleep(5000);//上厕所需要五秒
        sem.Release();//上完了
        Console.WriteLine("出厕所");
    }
    public void Out()
    {
        Thread.Sleep(5000);//上厕所需要五秒
        sem.Release();
        Console.WriteLine("出厕所");
    }
    public void Test()
    {
        while(true)
        {
            string input = Console.ReadLine();
            if (input == "1")//入厕
            {
              new Thread(new ThreadStart(()=>{ In();})).Start(); ;
            }

        }
    }
}

　　

不同程序,不同的exe，只要信号量的Name相同，信号量是共享的。

例子说明:修改上厕所的程序.一个程序只负责入厕,什么时候出厕所,则由管理人员来控制(另一个程序). SemaphoreTest2运行后,输入5次1,表示有5个人入厕了.然后在输入几个1,表示还有人在等待.

class SemaphoreTest2
{
    Semaphore sem = new Semaphore(0, 5, "AAA");//厕所空的
    public void In()
    {
        sem.WaitOne();
        Console.WriteLine("有空位,上厕所");
    }

    public void Test()
    {
        while (true)
        {
            string input = Console.ReadLine();
            if (input == "1")//入厕
            {
                new Thread(new ThreadStart(() => { In(); })).Start(); ;
            }

        }
    }
}

　　

在启动另外的项目,代码如下:启动后,输入2(喊一个人出厕所),发现入厕程序会有人进入厕所

class SemaphoreTest3
{
    Semaphore sem = new Semaphore(0,5,"AAA");//厕所空的
    public void Out()
    {
        Thread.Sleep(1000);//上厕所需要五秒
        sem.Release();
        Console.WriteLine("出厕所");
    }
    public void Test()
    {
        while(true)
        {
            string input = Console.ReadLine();
            if (input == "2")//出厕
            {
              new Thread(new ThreadStart(()=>{ Out();})).Start(); ;
            }

        }
    }
}

　　

注意:这是2个不同的程序,他们的Semaphore的Name是相同的.

有一点不明白的地方是在程序1中运行 Semaphore sem = new Semaphore(0, 5, "AAA");//表示厕所满了. 在运行第二个程序 Semaphore sem = new Semaphore(5, 5, "AAA");这时候,程序1中仍然是满的.在new的时候,没有互相干扰.

注意下面这个构造函数,可以检测信号量Name是否重复.

public Semaphore(
int initialCount,
int maximumCount,
string name,
out bool createdNew
)

　　

意外发现: Semaphore sem = new Semaphore(0, 5,"厕所"); 如果Name为中文,new Semaphore(0, 5,"厕所")和new Semaphore(5, 5,"厕所")是一样的.一开始就会有5个可用信号量.

Mutex

只理解了这句,Mutex本身是可以系统级别的，所以是可以跨越进程的。比如我们要实现一个软件不能同时打开两次，那么Mutex是可以实现的，而lock和monitor是无法实现的。其他和lock的区别,其实没太懂.