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);
        }
    }
}