线程操作若干（复习）

lock关键 （lock的本质就是Monitor，另外Monitor，Mutex也是排它锁，相比之下Mutex是夸进程的）

 lock(this)
{
        Callback(" A-" + count.ToString());                
}

ILspy下看到的

bool flag = false;
try
{
    Monitor.Enter(this, ref flag);
    this.Callback(" A-" + i.ToString());
}
finally
{
    if (flag)
    {
        Monitor.Exit(this);
    }
}

Task取消

                CancellationTokenSource tokenSource = new CancellationTokenSource();
                CancellationToken token = tokenSource.Token;
                Task task = new Task(() =>
                {
                    try
                    {
                        for (int i = 0; i < int.MaxValue; i++)
                        {
                            if (token.IsCancellationRequested)
                            {
                                Console.WriteLine("task is cancel");
                                token.ThrowIfCancellationRequested();                                
                            }
                            else
                            {
                                Console.WriteLine("Int value {0}", i);
                            }
                        }
                    }
                    catch(OperationCanceledException)
                    {
                        Console.WriteLine("cancelling task callback");
                    }
                }, token);
           
                Console.WriteLine("Press enter to start task");
                Console.WriteLine("Press enter again to cancel task");
                Console.ReadKey();              
                task.Start(); 
              
                Console.ReadKey(); 
                tokenSource.Cancel();

 Task并行

 static void  DoAction(int i)
 {          
            Thread.Sleep(300* i);
            Console.WriteLine("msg:" + i.ToString());
 } 

  Parallel.For(0, 10, i => DoAction(i));

Task串行

      static int Task1(object state)
        {
            int i = (int)state;
         
            Thread.Sleep(100* (10-i));          
            Console.WriteLine("task1:" + i.ToString());
            i += 1;
            return i;
        }

        static int Task2(Task<int> t)
        {
            var i = t.Result;
            Console.WriteLine("task2:" + i.ToString());
            Thread.Sleep(100*(11-i));
            i *= 10;
            return i;
        }

        static Task<int> MergerTask(object input)
        {
            Task<int> t = new Task<int>(Task1, input);
            var t2 = t.ContinueWith<int>(Task2);
            t.Start();
            return t2;
        }

        static async void DoTask(int input)
        {
            var result= await MergerTask(input);
            Console.WriteLine("merger-task:"+ input +" result: "+ result);
        }    

调用

for (int i = 1; i < 10; i++)
{
          DoTask(i);
}

线程量行--Semaphore  限制同一时间内只能跑几个线程，用于排队类型

        static Semaphore _sem = new Semaphore(3, 3);
        static void Enter(object id)
        {
            Console.WriteLine(id + " waitting...");
            _sem.WaitOne();
            Console.WriteLine(id + " is in!");            
            Thread.Sleep(1000 * (int)id);              
            Console.WriteLine(id + " is leaving");    
            _sem.Release();
        }

调用

 for (int i = 1; i <= 10; i++)
  {
          new Thread(Enter).Start(i);
   }