多线程，匿名委托，异步调用

简单的线程处理 及同步：

public class MuThread
{
    int a = 0;

    int i = 0;
    private volatile bool _run=true;
    public void method(object par)
    {
        while (_run)
        {
            Console.WriteLine("运行中"+par.ToString());
        }
        Console.WriteLine("已结束");
        
    }
    public void stop()
    {
        _run = false;
    }

    public void method1()
    {
        while (a < 100)
        {
            a++; Console.WriteLine("线程1输出：" + a);
        }
    }
    public void method2()
    {
        //当不加入线程同步代码的时候调用method1跟method2 会出现混乱
        //但是通过数他们的输出行数依然是100行 
        //说明while判断是正确的 
        //当CPU分配时间片的时候 无论他们有多么接近 其实同一时间依然只有一个线程在访问变量a

        //但是线程1跟2是CPU随机分配时间片交替前进的 实现同一时间多个进度协同执行任务的效果

        while (a < 100)
        {
            a++; Console.WriteLine("线程2输出：" + a);
        }
    }

    public void methodSyn1()
    {
        while (a < 100)
        {
            lock (this)
            {
                //意思是代码进入lock范围后 大括号内的代码将会被单独占用直到执行完
                //而不会临时被其他时间片插入导致a的值已经更改
                //当时间片继续回到此段时还沿用原来的 变量 导致混乱
                //如果去掉前面的判断 会输出101 ，至于原理么跟孙鑫C++线程同步是一样的 也有Monitor.Entry()
                if (a < 100)
                {
                    a++; Console.WriteLine("线程1输出：" + a);
                }
            }
        }
    }

    public void methodSyn2()
    {
        while (a < 100)
        {
            Monitor.Enter(this);
            if (a < 100)
            {
                a++; Console.WriteLine("线程2输出：" + a);
            }
            Monitor.Exit(this);
        }
    }
}

线程示例：

static void Main()
{
    //Service s = new Service();
    //s.start();

    //初始化MuThread的时候可以在构造函数 中传入一个方法引用也就是delegate
    //然后再MuThread实例的线程方法执行完毕后调用该delegate 
    //这种编程方式我一直认为很高深 被那些砖家称之为"回调"callback
    //参见ms-help://MS.VSCC.v90/MS.MSDNQTR.v90.chs/dv_fxadvance/html/52b32222-e185-4f42-91a7-eaca65c0ab6d.htm
    MuThread m = new MuThread();

    //ThreadStart 其实是一个委托
    //在C++里就需要声明委托 
    //为了给方法传参数但是不能为每种类型都定义一个委托 所以只能传入object类型

    //.Net为我们简化了的语法
    Thread tPar = new Thread(m.method);
    tPar.Start("传入的参数");

    //ParameterizedThreadStart委托显示语法 start()其实相当于Event.do()            
    ParameterizedThreadStart del = new ParameterizedThreadStart(m.method);
    Thread tPar2 = new Thread(del);
    tPar2.Start("传入的参数");

    Thread t = new Thread(new ThreadStart(m.method1));
    Thread t2 = new Thread(new ThreadStart(m.method2));
    t2.Start();
    t.Start();
    //利用volatile 参数的状态终止线程
    while (!tPar.IsAlive) ;

    Thread.Sleep(100);
    m.stop();
    //MSDN的意思是阻断当前调用t的线程 也就是Main 主线程 直到让t执行完毕
    //事实确实是这样的 当不加Join()的时候 看着t.start()的语句在main方法下面的循环语句前面
    //其实他们的时间片依然由CPU随机分配的 "主线程调用"这句输出是穿插在前面子线程输出一起的
    //参见ms-help://MS.VSCC.v90/MS.MSDNQTR.v90.chs/fxref_mscorlib/html/56ed7b6f-efe0-67e7-34bc-766dd9f693f9.htm
    //当主线程 也就是Main方法里进行Thread.Sleep(200)时 其实是挂起主线程 这样就可以把时间片让给那些子线程
    t.Join();
    for (int i = 0; i < 50; i++)
    {
        Console.WriteLine("主线程调用");
    }

    //使用线程池
    //ms-help://MS.VSCC.v90/MS.MSDNQTR.v90.chs/dv_csref/html/5426dae4-c3f3-4e76-a998-19f7ca4baf3f.htm
    Console.ReadKey();
}

 又反复测试了下join其实感觉就像endInvoke 就是阻止，说白了把指定的线程join到当前主线程 说白了就是阻塞操作 可不就是endInvoke么  ，到trd.Join()的 地方位置 必须要等待trd执行完毕

使用backgroundworker组件：

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        backgroundWorker1.WorkerReportsProgress = true;
        backgroundWorker1.WorkerSupportsCancellation = true;
        button3.Enabled = false;
    }

    private void button2_Click(object sender, EventArgs e)//start
    {
        textBox1.Text = "开始产生10000以内的随机数。。。\n\n";
        button2.Enabled = false;
        button3.Enabled = true;
        //在后台开始操作
        backgroundWorker1.RunWorkerAsync();
    }

    private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
    {
        //不要直接使用组件实例名称（backgroundworker1）因为有多个backgroundworker时
        //直接使用会产生耦合问题 应该通过下面的转换使用它
        BackgroundWorker worker = sender as BackgroundWorker;
        //下面的内容相当于线程要处理的内容。//注意 不要在此事件中和界面控件打交道
        Random r = new Random();
        int numCount = 0;
        while (worker.CancellationPending==false)
        {
            int num = r.Next(10000);
            if (num%5==0)
            {
                numCount++;
                worker.ReportProgress(0, num);
                Thread.Sleep(1000);
            }
        }
        e.Result = numCount;
    }

    private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        int num = (int)e.UserState;
        textBox1.Text += num + " ";
    }

    private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        if (e.Error==null)
        {
            textBox1.Text += "\n\n操作停止,共产生" + e.Result + "个能被5整除的随机数";
        }
        else
        {
            textBox1.Text += "\n操作过程中产生错误：" + e.Error;
        }
    }

    private void button3_Click(object sender, EventArgs e)
    {
        backgroundWorker1.CancelAsync();
        button3.Enabled = false;
        button2.Enabled = true;
    }

}

一些关于匿名委托 和lambda表达式的写法 ，还有异步调用：

public void callDel(Func<int,int,int> dd)
        {
            int rst = dd.Invoke(5, 2);
            Console.WriteLine("call Func rst is:{0}", rst);
        }

        public int method1()
        {
            
            //delDone.WaitOne(2000);
            Thread.Sleep(2000);
            
            return 1;
        }

        public delegate int MyDele();
ManualResetEvent delDone = new ManualResetEvent(false);
        private void Form3_Load(object sender, EventArgs e)
        {

            //waitone的作用 仅仅是阻断当前行代码以后的部分继续执行
            //然后在回调里证明已经回调已经完成了  继续放行
            //实际上是一种失去异步意义的一种方式 ，线程同步
            delDone.Reset();
            MyDele d4 = new MyDele(method1);
            d4.BeginInvoke((iar) =>
            {
                int rdmResult = d4.EndInvoke(iar);
                Console.WriteLine("iar call back state :" + iar.AsyncState.ToString());
                Console.WriteLine("iar call back rst is :{0}", rdmResult);
                delDone.Set();
            }, "ss");
            //delDone.Set();
            delDone.WaitOne(1000);
            Console.WriteLine("lalalala....");

            return;//----------------------------------------------------------------------------------------------------
            var cl = new {name="xiang",age=21};
            Console.WriteLine(cl.name);
            return;//-----------------------------------------------------------------------------------------------------
            //调用func  调用func 的直接好处就是 让你连委托声明 那句都省了
            //说白了就是你传一段代码进来 我来执行 ，那么你传的这段代码就是参数 。你只需要把方法原型作为形参定义好
            //感觉完全一锅写 有点类似于脚本语言的写法
            //上面是lambda写法 下面是 匿名委托写法
            callDel((num1, num2) => {
                return num1 + num2;
            });
            callDel((num1, num2) => {
                return num1 - num2;
            });

            callDel(delegate (int num1, int num2) {
                return num1 * num2;
            });

            MyDele d2 = delegate ()
            {
                Console.WriteLine("call myDel2....");
                return 0;
            };
            d2();

            MyDele d3 = new MyDele(
            delegate {
                Console.WriteLine("call myDel3....");
                return 0;
            });
            d3();

            return;//-----------------------------------------------------------------------------------------------
            //异步回调
            MyDele d1 = new MyDele(() => {
                //MessageBox.Show("mydel process");
                Console.WriteLine("mydel start");
                Thread.Sleep(2000);
                Console.WriteLine("mydel end");
                return new Random().Next();
            });
            //d1.Invoke();

            IAsyncResult iars= d1.BeginInvoke((iar) =>
            {
                //委托内容执行完成 后的回调

                //iar 可以理解为特定的线程的句柄 进行回溯的 找到我们当初调用的 那个方法
                //从而获取到 方法执行的结果 ,endinvolve 代表实质性的异步调用结束 可获得实实在在的执行结果
                //既然执行到这里了 那么自然代表可以正常endinvoke了。
                int rdmResult = d1.EndInvoke(iar);
                Console.WriteLine("iar call back state :" + iar.AsyncState.ToString());
                Console.WriteLine("iar call back rst is :{0}",rdmResult);
            }, "ss");

            //执行到这里 你无法确定能否 IsCompleted 啊 ，如果强行endinvoke  不就市区异步的意义了么,
            //d1.EndInvoke(iars);

            //比如这里我们等待3秒钟 没有执行完成 就结束线程

            //wait one 就是阻塞主线程 把时间片完全让给 异步委托去执行 ，等待异步委托执行完成 。也是一种失去异步的意义的一种方式
            //waitone 的时间 并不代表一定需要执行那么长时间，如果不带时间参数表示等待直至异步线程完成
            iars.AsyncWaitHandle.WaitOne();
            Console.WriteLine("wait one 1000");
            //Thread.Sleep(3000);
            //if (iars.IsCompleted)
            //    Console.WriteLine("mydel is complete");
            //else
            //{
            //    Console.WriteLine("mydel is not complete");
            //}
            return;//---------------------------------------------------------------------------------------------------
            //空参数 的lambda 委托写法 去掉action 一样的效果
            Thread t1 = new Thread(new ThreadStart( new Action(()=>
            {
                MessageBox.Show("t1 process");
            })));
            t1.Start();
            return;//-----------------------------------------------------------------------------------------------------
            //用lambda的方式来写事件绑定
            button2.Click += new EventHandler((sender2, e2) =>
            {
                MessageBox.Show("hellow");
            });

            //Func 是一个带返回值形式  委托 ，就是微软新搞的一种花样  就是委托
            //也可用lambda 的方式来写
            List<string> strArr = new List<string>() {
                "xiang",
                "zhang",
                "chen"        };
            //var sel = strArr.Where(wheretest);
            var sel = strArr.Where((r) =>
            {
                if (r.Contains("g"))
                    return true;
                else
                    return false;
            });

            //lamda 方式的action
            sel.ToList().ForEach(i =>
            {
                Console.WriteLine(i);
            });

            return;//-----------------------------------------------------------------------------------------------------
            List<int> arr = new List<int>();
            arr.Add(23);
            arr.Add(45);
            arr.Add(22);
            arr.ForEach((i) =>
           {
               Console.WriteLine(i + "");
           });
        }

 每次看都有不一样的东西，看山不是山 ，人生就是不断的学习。以前以为异步调用就是简单的分一个通道来做事情 ，还真不是那么简单

mydel d;
private void button3_Click(object sender, EventArgs e)
{

    d = new mydel(deldo);
    Console.WriteLine("aaa");
    //注意下面的d.BeginInvoke(null,null);并不一定要传入asyncCallBack ，根据你情况定 ，
    //比如你不需要得到异步调用的结果 （那还不如task.run() ? thread.start()?
    //注意 注意 注意 再次说明 这个asynCallBack 在异步方法调用完成后 才会执行 ，仅仅是一个获取结果用 并无特别意思

    //IAsyncResult ar= d.BeginInvoke(null,null);
    //deldoend这个方法只有结束时才会调 ，只是相当于结束时候的一个通知 并没有其他意思
    //如果不这样写 你就无法确定调用何时结束，当然你也可以 在begininvoke 后 同步做一些其他事， 
    //在最终的时候使用ar.synchandle.waitOne 等待调用结束 ，由此来做到不同线程的同步
    IAsyncResult ar = d.BeginInvoke(deldoEnd, "hhh");
    //hhh为你想自定义传入end方法里的参数 end方法里使用ar.asyncState获取
    Console.WriteLine("bbb");

    //Thread.Sleep(4000);
    //Console.WriteLine("rstttt"+d.EndInvoke(ar));

}

public int deldo()
{
    Console.WriteLine("ccc");
    Thread.Sleep(3000);
    Console.WriteLine(555);
    return 5;
}

public void deldoEnd(IAsyncResult ar)
{
    Console.WriteLine("ddd");
    int rest = d.EndInvoke(ar);
    Console.WriteLine(ar.AsyncState.ToString());
    Console.WriteLine(rest);
}

delegate int mydel();

 又是一些新的Task特性的使用方式，还是线程只不过换了种方式：

https://www.cnblogs.com/lonelyxmas/p/9509298.html

https://www.cnblogs.com/jesse2013/p/async-and-await.html

https://www.cnblogs.com/CreateMyself/p/5983208.html