C#多線程，參數返回值，及回調歸納總結

第一個知識點:線程如何帶參數，返回值

總結有三種：

1.基於主線程臨時變量，作爲參數，返回接收

2.Task<IResult>，通過task.Result獲取結果，參數仍然是上述方式，接收

3.new Thread(new ParameterizedThreadStart(參數委託))，將參數，返回值都是定義成一個類，封裝

實例代碼：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace MutityDemoReturn_Param
{
    public class MyThread
        {
            public double X= 10;
            public double Y= 0;   
            public double Result; 
            public MyThread(int x,int y)
            {
                this.X= X;    
                this.Y= y;   
            }    //真正方法
            public double SomeFunc(double x,double y)  
            {        //加法運算等 
                return x+y;
            }    //加殼方法
            public void Calculate()
            {
                Thread.Sleep(5000);
                Result = SomeFunc(X,Y);     }
        }




    class Program
    {
        public delegate int Del(int x,int y);
        static void Main(string[] args)
        {
            //多線程如何傳參數，返回值
            //本質還是藉助委託，將參數傳到多線程中去，初始化線程即傳參數進來
            //
            int x = 1, y = 2;
            int result = 0;
            Task task = Task.Run(() =>
            {
                result = TestParamReturn(x, y);
            });
            task.Wait();
            Console.WriteLine(result);
            //int result=t.Result;

            {
                //這是一個委託，返回結果int
                Func<int> fun1 = () =>
                {
                    return TestParamReturn(x, y);
                };
                Task<int> tt = Task.Run(fun1);
                int res = tt.Result;
                //只有是帶返回結果的<int>纔有Result屬性，它會阻塞UI線程
            }

            {
                //更簡單寫法，直接帶返回值
                Task<int> taskk = Task.Run<int>(() =>
                {
                    return 3;
                });
                int reslt = taskk.Result;
            }

           


            MyThread t = new MyThread(1, 2);
            ThreadStart threadStart = new ThreadStart(t.Calculate);
            Thread thread = new Thread(threadStart);
            thread.Start();
            thread.Join();
            Console.WriteLine(t.Result);

            //傳一個帶參數，無返回的委託
            ParameterizedThreadStart pts = new ParameterizedThreadStart((o) =>
            {
                Console.WriteLine("我是參數委託中執行的代碼");

            });
            //ThreadStart是無參無返回值的委託

            Thread thread1 = new Thread(pts);
        }

        //如何在多線程調用這個函數方法，去做一些事情，參數如何傳進來，結果如何返回出來？？？？
        public static int TestParamReturn(int x,int y) {
            Thread.Sleep(3000);
            return x + y;
        }
    }
}

第二個知識點：

確保一個線程結束，開始另一個線程呢？

總結有四種方式實現：

1.同步運行，相當於運行在主線程中ta.RunSynchronously();

2.task.GetAwaiter().OnCompleted(委託);即確保在線程執行完，執行什麼

3.contiueWith(帶參委託)，參數是上一個委託實例

4.while()輪詢方式，不停等待，等待

代碼如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace MutityThreadCallback
{
    class Program
    {
        static void Main(string[] args)
        {

            Task<int> ta = new Task<int>(() =>
            {
                return 422;
            });
            //同步運行，相當於運行在主線程中
            ta.RunSynchronously();
            Console.WriteLine(ta.Result);

            Task<int> task = Task.Run<int>(() => {
                return 42;
            });
            //task.GetAwaiter().OnCompleted(() =>
            //{
            //    //這個一定會執行
            //    Console.WriteLine(task.Result);
            //});
            //Console.WriteLine("主線程結束！");

            Task<int> taskcontinue= task.ContinueWith<int>((tsk) => {
                //傳入的是task任務對象
                Console.WriteLine(tsk.Result);
                return 24 + tsk.Result;
            });

            Console.WriteLine(taskcontinue.Result);
            //taskcontinue.GetAwaiter().OnCompleted(() =>
            //{
            //    //這個一定會執行
            //    Console.WriteLine(taskcontinue.Result);
            //});

            Task<int> tasktask = Task.Run<int>(() =>
            {
                return 4200;
            });
            //tasktask.Status!=TaskStatus.
            while (!tasktask.IsCompleted)
            {
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
            }
            Console.WriteLine(tasktask.Result);
        }
    }
}