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

常规经典多线程和异步

简单的线程处理 及同步：

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

}

 一些新式让人混淆的lamda匿名委托 伪协程 又像异步的东西

一些关于匿名委托 和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

 一个简易的生产者消费者例子

今天闲得无聊 ，测试一下多线程的例子。

平常我们最简单的 list 链表 ，有个removeAt方法 最容易出错的地方是 倒序remove 其实每当remove一个后 count就自动减一了 。
为了保证索引不超出有时候还不如每次removeAt(0)。
接地系统到处用那种无脑的while true sleep方式 来刷新数据 展现 ，确实这种也是人能想到的最简单粗暴的方式 我们就不讨论那些什么事件通知 信号量玩意儿了。我们这里是一个例子。

//共用数据存储位置
List<int> ar = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8,9,10,11 };


//各处生产数据的方法 每次lock占用 固定加10个数据
//lock的对象在各操作方法多线程间只能被唯一访问
public void method1(){
    lock (this)
    {
        Random rdm = new Random();
        for (int i = 0; i < 10; i++)
        {
            Thread.Sleep(10);
            int beadd = rdm.Next(1, 100);
            ar.Add(beadd);
            Console.WriteLine("加入" + beadd);
        }
    }            
}

//消费数据的方法
//无脑式的 一直运行 ，采用while 然后sleep一秒的方式 
//当然也可以while 不加sleep  不像单片机那样把资源占完 ，只是资源占用多总是不好的也没必要那么高密度检测
public void method2()
{
    while (true)//为什么不lock此处 想也想得到啊 一直独占消费 你到底放不放权出去让别人生产数据啊
    {
        lock (this)//这个lock位置必须放在此处 ，一次占用直到退出消费10个数据（期间生产数据必须等待他完成 为了避免混乱）
        {
            if (ar.Count > 10)
            {
                for (int i = 0; i < 10; i++)
                {
                    Thread.Sleep(10);
                    Console.WriteLine("移除" + ar[ar.Count - 1]);
                    ar.RemoveAt(ar.Count - 1);
                }
            }
        }
        Thread.Sleep(1000);
    }           
}

//消费数据一直在后台运行 一有数据就会消费
Thread t2 = new Thread(method2);
t2.IsBackground = true;
//多线程的精妙之处 调用后会进入代码 去获权 或者称之为信号量 就是lock的那个东西
//获到权后 代码会自动往下走 总会执行 ，这一切是自动的 
method1();

 仿c#自带Beginxxx 异步结构 和 AutoResetEvent信号量使用

前段时间看一个原来网上下载的sock包装代码，看到里面把IAsyncResult包装了玩一种很花哨的套路，然后写成仿c#自带的beginxxx()  endxxx()的结构 ，为了研究明白 今天我们也来写这么一个类似结构。

public class Class1
{
    //异步测试入口
    public void AsyncTest()
    {
        //AutoResetEvent aa = new AutoResetEvent(true);
        ////跟嵌入式一样 set就是信号量置1，reset就是信号量置0
        //aa.Set();
        ////等待一个信号量在没等到时会一直阻塞于此
        ////while(true){} 也是类似作用 但是是一种很低级的线程间同步的手段
        ////因为while(true){} 会把时间片占完 WaitOne() 不会
        //aa.WaitOne();

        ////beginxxx  endxxx 本质还是伪多线程 ，只不过没有Thread.Start 这几个字写在你眼前而已

        byte[] data = new byte[20];
        IAsyncResult iar= Beginxx(data, CallBack, null);
        ////endxxx 相当于阻塞模式运行 阻断主线程 
        ////你看 是不是就类似于 c#原生的那种套路方式了？
        Endxxxx(iar);
        ////也可以不Endxxx 立即下面代码获取AsyncState结果 但是状态是未完成
        ////只能等begin代码自由运行结束 然后去触发Endxxx回调， 
        ////当你要手动Endxxx 那个代码点相当于意思是要进行同步了 手动归拢不同异步到一个时间点
        //Console.WriteLine(iar.AsyncState.ToString());
        Console.WriteLine("begin后立即调用时结果："+Encoding.UTF8.GetString(data));
        Thread.Sleep(4000);
        Console.WriteLine("现在是" + Encoding.UTF8.GetString(data));
        //Console.WriteLine("现在的值是" + iar.AsyncState.ToString());


    }
    //异步方法begin
    //本质上传进去的 AsyncCallback这种类型的玩意儿 就只是一个method(IAsyncResult iar)这种带IAsyncResult参数的方法而已
    //IAsyncResult 参数是为了结束时 把执行结果传给回调函数 ，并没特别意思没那么神秘
    public IAsyncResult Beginxx(byte[] dataBeFull, AsyncCallback calback,object state)
    {
        //初始化一个自定义AsyncResult 完成为false
        MyAsyncResult sresult = new MyAsyncResult();
        sresult.IsCompleted = false;
        sresult.AsyncState = "aaa";

        //用Thread仿异步 执行 ，在执行完后设置IsCompleated为true 附上结果数据
        //并调用回调委托 传result进去
        Thread t = new Thread(() =>
        {
            Thread.Sleep(3000);

            sresult.IsCompleted = true;
            sresult.AsyncState = "bbb";
            byte[] bts = Encoding.UTF8.GetBytes("bbb");

            Array.Copy(bts, dataBeFull, bts.Length);
            calback(sresult);
        });
        t.IsBackground = true;
        t.Start();

        ////不用Thread 像下面这种代码 就没意思了哈 就不叫仿异步了
        ////跟流水线没什么区别
        //Thread.Sleep(2000);
        //sresult.IsCompleted = true;
        //sresult.AsyncState = "86547";
        //Console.WriteLine("ccc");
        //calback(sresult);

        return sresult;
    }

    //这里Endxxx 相当于是封装成 c#自带的Endxxx的样子
    public int Endxxxx(IAsyncResult iar)
    {
        while (iar.IsCompleted == false)
        {
            //如果这样一直while 不加sleep 会把时间片占完 并不友好 
            //像waitOne 这种类信号量的东西 就好的多 会把时间片让出来
            //这里只是为了演示同步异步的原理
            Thread.Sleep(500);
        }

        return 4684;
    }

    //这里的CallBack 相当于 是用户自己写的代码
    public void CallBack(IAsyncResult iar){
        
        int rsInt = Endxxxx(iar);

        Console.WriteLine("endxxx 的返回结果："+rsInt);

        string rs = iar.AsyncState.ToString();

        Console.WriteLine(rs);
    }
}

public class MyAsyncResult : IAsyncResult
{

    public object AsyncState
    { get; set; }

    public WaitHandle AsyncWaitHandle
    { get; set; }

    public bool CompletedSynchronously
    { get; set; }

    public bool IsCompleted
    { get; set; }
}

异步与界面更新的新方法

一直以为更新winform界面只能用Control.BeginInvoke ，今天无意中又发现一些新方式，总体来说是利用c#新特性的语法糖，但是依然有些坑，花样是新了 但是lamda表达式转换为匿名委托的过程中一些概念的理解很让人混淆。以下代码还是用于简易socket通信结构的 onReceive事件界面更新。

SynchronizationContext synccontext = null;

public Form1()
{
    InitializeComponent();
    synccontext = SynchronizationContext.Current;
}


private void Form1_Load(object sender, EventArgs e)
{


    server.onReceive += new Action<Telegram_Base>((msg) =>
    {
        //synccontext.Post(UpdateTxt, msg);
        this.BeginInvoke(
            new Action(() =>
            {
                UpdateTxt(msg.p);
            })
            ////总而言之 Invode 或者 BeginInvoke 需要一个确切类型的委托 光()=>{}只能代表一个匿名方法 系统不知道如何转换
            ////Action就代表确切类型 ，但是 外面的(msg)=>{}不就代表 委托么为啥可以 真是费解 ，文章上说我们参数是具体的委托类型 就可以用匿名表达式

            ////这种也是可以 意思是新线程会自动去判断 界面UI资源使用冲突咯
            ////等同于new thread().start()
            //(ThreadStart)(() => {
            //    UpdateTxt(msg);
            //})

            ////文章上说
            ////那么编译器在转化这个匿名函数的时候，就不知道要将这个匿名函数转为 ThreadStart还是MethodInvoker，于是报错
            ////下面的代码也是可以的
            //new MethodInvoker(
            //delegate
            //{
            //    UpdateTxt(msg);
            //})

            ////下面这种lamda 匿名委托的方式都不行的哈 ，只有action func 这种 是派生自Delegate的 metholdInvoker
            ////()=>{}
            ////delegate() { }
            );
    });

}

//最后，附上几个Delegate的原型：
//public delegate void ThreadStart();
//public delegate void MethodInvoker();
//public delegate void WaitCallback(object state);
//public delegate void ParameterizedThreadStart(object obj);
//public delegate void AsyncCallback(IAsyncResult ar);