tofacebook.com -专业IT技术社区 【百家号】脸书百科,(转)NET-异步 Web程序 - tofacebook.com-专业IT技术社区
74°

【百家号】脸书百科,(转)NET-异步 Web程序

标签:时间   获取   引入   入口   blog   tca   那是   硬件   步骤   

在说到异步前,先来理一下几个容易混淆的概念,并行、多线程、异步。

并行
,一般指并行计算,是说同一时刻有多条指令同时被执行,这些指令可能执行于同一CPU的多核上,或者多个CPU上,或者多个物理主机甚至多个网络中。

多线程
,一般指同一进程中多个线程(包含其数据结构、上下文与代码片段)协作运行。在多核计算机中多个线程将有机会同时运行于多个核上,如果线程中进行的是计算,则行成并行计算。

异步
,与同步相对应,是指呼叫另一操作后,不等待其结果,继续执行之后的操作,若之后没有其他操作,当前线程将进入睡眠状态,而CPU时间将有机会切至其他线程。在异步操作完成后通过回调函数的方式获取通知与结果。异步的实现方式有多种,如多线程与完成端口。多线程将异步操作放入另一线程中运行,通过轮询或回调方法得到完成通知;完成端口,由操作系统接管异步操作的调度,通过硬件中断,在完成时触发回调方法,此方式不需要占用额外线程。

本文讨论.NET下的异步,以及其进化过程中出现的多种异步模式。

首先看一下两段需要花较长时间运行的代码在同步方式下的情形。

public class ProgramClass
{
    public static void Main()
    {
        using (var fs = new FileStream("Data.dat", FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, 4096))
        {
            fs.Write(new byte[100], 0, 100);
        }

        DoSomething();

        Console.WriteLine("END");
    }

    static string DoSomething()
    {
        Thread.Sleep(2000);
        return "Finished";
    }
}

同步方式运行时,所有操作会顺序执行,当某方法被阻塞时,线程即进入阻塞状态。该情形下,CPU时间无法得到充分利用,当前线程长时间处于阻塞状态,任务总时间长。

开始异步化

为提高CPU使用率,从而减少任务时间,采用多线程方式实现异步调用。

public class ProgramClass
{
    public static void Main()
    {
        Thread writeThread = new Thread(new ThreadStart(WriteWapper));
        Thread doSomethingThread = new Thread(new ParameterizedThreadStart(DoSomethingWapper));

        ClosureClass closure = new ClosureClass();
        writeThread.Start();
        doSomethingThread.Start(closure);//闭包对象,用于变量穿越

        writeThread.Join();
        doSomethingThread.Join();

        Console.WriteLine(closure.Result);
    }

    //将方法包装成适于线程调用的签名
    private static void WriteWapper()
    {
        using (var fs = new FileStream("Data.dat", FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, 4096))
        {
            fs.Write(new byte[100], 0, 100);
        }
    }

    //将方法包装成适于线程调用的签名
    static void DoSomethingWapper(object state)
    {
        ClosureClass closure = state as ClosureClass;
        var result = DoSomething();
        if (closure != null)
        {
            closure.Result = result;
        }
    }

    static string DoSomething()
    {
        Thread.Sleep(2000);
        return "Finished";
    }

    //闭包辅助类,用于存储在方法间传递内部变量与参数
    class ClosureClass
    {
        //存储方法返回值
        public string Result { get; set; }
    }
}

利用多线程将耗时操作放入其他线程中进行处理,主线程继续做自己的事(本例中,主线程进行等待其他线程完成)。从而减少任务处理时间。

【注意】本例中,write与dosomething操作内部均有线程等待,在单核中依然可以通过操作系统的线程切换提高CPU使用率,但是如果操作是需要大量CPU计算,则在单核情况下并不一定能够提高CPU使用率,并且可能增加线程调试的开销,因此单核情况下此种方式不适合用于密集型运算。

【提示】对于线程的入口方法,我们往往会对其进行包装,形成一致的方法签名、处理异常、拦截请求等。在本例中,由于被调用的方法有输入与输出,困此采用辅助对象进行传递,在C#2开始引入的闭包,采用类似的原理实现,从而减少大量的代码,并提高程序可读性。

public class ProgramClass
{
    public static void Main()
    {
        string result = null;

        Thread writeThread = new Thread(new ThreadStart(WriteWapper));
        Thread doSomethingThread = new Thread(new ThreadStart(() =>
        {
            result = DoSomething();//跨方法访问临时变量,形成闭包
        }));

        writeThread.Start();
        doSomethingThread.Start();

        writeThread.Join();
        doSomethingThread.Join();

        Console.WriteLine(result);
    }

    //将方法包装成适于线程调用的签名
    private static void WriteWapper()
    {
        using (var fs = new FileStream("Data.dat", FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, 4096))
        {
            fs.Write(new byte[100], 0, 100);
        }
    }

    static string DoSomething()
    {
        Thread.Sleep(2000);
        return "Finished";
    }
}

开启一个新线程将带来可观的开销,因此我们希望能够重用线程,在.NET中,可以采用线程池达到这一目的,同时简化线程的操作。

public class ProgramClass
{
    public static void Main()
    {
        string result = null;

        AutoResetEvent resetEvent = new AutoResetEvent(false);
        ThreadPool.QueueUserWorkItem(new WaitCallback(state =>
        {
            result = DoSomething();
            resetEvent.Set();
        }));

        resetEvent.WaitOne();
        Console.WriteLine(result);
    }

    static string DoSomething()
    {
        Thread.Sleep(2000);
        return "Finished";
    }
}

由于线程池中,我们无法对线程进行更为细致的操作,为得到操作完成的通知,我们需要在包装方法中,在操作完成后加入适当的代码,本例中我们采用ResetEvent进行线程的同步。

【注意】在ASP.NET中,所有的WEB线程均运行于线程池,因此线程池中的线程是非常宝贵的资源,耗尽线程池中的线程将可能引起所有的请求进入等待队列,从而无法提供服务,在ASP.NET中的线程池操作应该更为谨慎。

完成端口与异步模型

到这里为止,都是采用多线程的方式手动实现了异步,正如前面所说,多线程不适用于单核密集运算,在非密集运算下也会产生线程调度的开销,在需要大量线程的应用中会浪费宝贵资源。考察需要阻塞等待的场景,往往是与系统外部数据交换有关,如大量内存数据的复制、读写磁盘文件、访问网络等,这种情况下,在硬件完成操作前CPU无能为力,因此只能等待,更完美的方案是发出指令后不进入等待,当操作完毕后通过某种方式得到通知并执行相关代码,称为完成端口。

完成端口编程复杂,并且需要操作系统支持,使用中需要先判断是否支持,再采用不同的方式去实现,并且实现的方法多样,在异步使用频繁的今天,为简化异步操作,往往会制订一种统一的异步模型,并且这类模型也在不断进化中。

在介绍异步模型时,我们会用不同的方法先将一个普通方法异步调用,再调用类库中提供的异步方法,然后实现一个自己的异步方法,最后将多个异步方法按顺序调用包装成新的异步方法。

在早期的.NET中,采用 BeginXXX/EndXXX 方式实现异步。

对于普通的方法,可以采用委托的 BeginInvoke / EndInvoke 实现异步化。

public class ProgramClass
{
    public static void Main()
    {
        string result = null;

        var doSomgthingDelegate = new Func<string>(DoSomething);
        var asyncResult = doSomgthingDelegate.BeginInvoke(new AsyncCallback(aresult =>
        {
            result = doSomgthingDelegate.EndInvoke(aresult);
        }), null);

        asyncResult.AsyncWaitHandle.WaitOne();

        Console.WriteLine(result);
    }

    static string DoSomething()
    {
        Thread.Sleep(2000);
        return "Finished";
    }
}

委托的异步内部采用线程池实现。

有些类库中的方法,实现了异步版本。

public static void Main()
{
    using (var fs = new FileStream("Data.dat", FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, 4096
        , FileOptions.Asynchronous))
    {
        fs.Write(new byte[100], 0, 100);
        var asyncResult = fs.BeginWrite(new byte[100], 0, 100, new AsyncCallback(aresult => {
            fs.EndWrite(aresult);//执行完毕后的回调方法
        }), null);

        asyncResult.AsyncWaitHandle.WaitOne();
    }
}

对于类库的方法的异步版本,内部会进行判断决定采用何种方式实现。

【注意】对于FileStream,必须加上FileOptions.Asynchronous才会有机会使用完成端口。

现在我们可以根据这个模型来实现自己的异步方法

public class ProgramClass
{
    public static void Main()
    {
        DoSomeThing();

        var result = BeginDoSomeThing(1, new AsyncCallback(aresult =>
            {
                ProgramClass.EndDoSomeThing(aresult);
            }), null);
        result.AsyncWaitHandle.WaitOne();
    }

    //同步版本
    public static string DoSomeThing()
    {
        Thread.Sleep(2000);
        return "Finished";
    }

    //异步版本开始
    public static IAsyncResult BeginDoSomeThing(int arg1, AsyncCallback callback, object state)
    {
        var asyncResult = new DoSomethingAsyncResult(callback, state);

        Timer timer = null;
        timer = new Timer(new TimerCallback(s =>
            {
                timer.Dispose();
                asyncResult.SetComplete("Finished");
            }), state, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(2));

        return asyncResult;
    }

    //异步版本结束
    public static string EndDoSomeThing(IAsyncResult asyncResult)
    {
        DoSomethingAsyncResult result = asyncResult as DoSomethingAsyncResult;
        if (result != null)
        {
            return result.Result;
        }
        return null;
    }

    //AsyncResult对象
    public class DoSomethingAsyncResult : IAsyncResult
    {
        private AsyncCallback _asyncCallback;
        private AutoResetEvent _asyncWaitHandle;

        public DoSomethingAsyncResult(AsyncCallback asyncCallback, object state)
        {
            AsyncState = state;
            _asyncCallback = asyncCallback;
            _asyncWaitHandle = new AutoResetEvent(false);
        }

        //设置结果
        public void SetComplete(string result)
        {
            Result = result;
            IsCompleted = true;
            if (_asyncCallback != null)
            {
                _asyncCallback(this);
            }
            _asyncWaitHandle.Set();
        }

        public string Result
        {
            get;
            private set;
        }

        public object AsyncState
        {
            get;
            private set;
        }

        public WaitHandle AsyncWaitHandle
        {
            get { return _asyncWaitHandle; }
        }

        public bool CompletedSynchronously
        {
            get { return false; }
        }

        public bool IsCompleted
        {
            get;
            private set;
        }
    }
}

本例中,采用定时器触发完成动作,实际中,可以在需要的时候触发完成。

对于BeginXXX/EndXXX模式,调用BeginXXX表示开始一个异步方法,前面的参数表示方法所需的参数(可无),倒数第二个参数为回调方法(可空),最后一个参数用于穿越整个过程的相关对象(可空)。返回的IAsyncResult存储了异步方法的相关状态信息,一般来说我们自己的异步方法需要一个实现了该接口的类,类中包含了回调方法、等待对象、相关参数与结果等。

异步方法的协作有三种方法,第一种,通过轮询 IsCompleted 属性,直到为true时,触发完成动作。

第二种,通过回调方法,当异步方法完成时,由异步方法调用回调方法。

第三种,通过WaitHandler等待异步方法完成,当异步方法完成时,由异步方法发出完成信号,使等待结束。

当我们需要将多个异步方法包装成一个异步方法时,方法内部将充斥着大量的回调方法。

类似于这样:

public static IAsyncResult BeginDoSomeThing(int arg1, AsyncCallback callback, object state)
{
    var asyncResult = new DoSomethingAsyncResult(callback, state);

    Timer timer = null;
    timer = new Timer(new TimerCallback(s =>
        {
            timer.Dispose();

            using (var fs = new FileStream("Data.dat", FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, 4096,  FileOptions.Asynchronous))
            {
                var writeresult = fs.BeginWrite(new byte[100], 0, 100, new AsyncCallback(wresult =>
                {
                    fs.EndWrite(wresult);

                    asyncResult.SetComplete("Finished");
                }), null);
            }
        }), state, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(2));

    return asyncResult;
}

呼~幸好还有匿名方法与闭包,否则将是一件多么恐怖的事啊。

新的异步模型

我们清醒的看到,当需要多个异步方法需要协作时,代码将显得十分复杂,无法表现清晰的逻辑,于是,我们需要一个更好的异步模型。

从.NET4开始,引入了新的异步模型。

首先引入一个新概念:Task。

Task代表一个可以被执行的任务,我们可以让他运行,关联其他任务,等待他,获取他的结果。值得注意的是,这里的Task可以是一个异步的任务,也可以是同步的任务,在没有特别说明的情况下都指异步任务。而返回一个Task对象的方法,我们一般认为这是一个异步方法。new Task或者Task.Run将生成一个在线程池中运行的异步任务。

我们看一下如何把一个普通的方法异步执行。

public static void Main()
{
    var t1 = Task<int>.Run(() =>
    {
        Thread.Sleep(2000);
        return 100;
    }).ContinueWith(new Action<Task<int>>(t =>
        {
            Console.WriteLine(t.Result);
        }));
    t1.Wait();
}

对于类库中提供的异步方法,也有了新版本,XXXAsync。

public static void Main()
{
    using (var fs = new FileStream("Data.dat", FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, 4096,
        FileOptions.Asynchronous))
    {
        var task = fs.WriteAsync(new byte[100], 0, 100)
            .ContinueWith(new Action<Task>(t => {
                Console.WriteLine("Finished");
            }));
        task.Wait();
    }
}

我们不再关心如何去开始,何时会结束,一切变成了一些有关或无关的任务。

让我们自己写一个异步方法吧。

public static Task<string> DoSomethingAsync(int value)
{
    return Task<string>.Run(() => 
        {
            Thread.Sleep(2000);
            return value.ToString();
        }); ;
}

好吧,你肯定是以我在偷懒,为什么不像BeginXXX/EndXXX一样从底层开始实现一个呢,那是因为Task的封装比较严,我们无法直接对其扩展。为了达到获取一个Task,在需要的时候设置完成与结果,可以借助 AsyncTaskMethodBuilder 来实现。

public class ProgramClass
{
    public static void Main()
    {
        var task = ProcessAsync();
        task.Wait();
        var r = task.Result;
    }

    static Task<string> ProcessAsync()
    {
        //辅助工具
        AsyncTaskMethodBuilder<string> builder = AsyncTaskMethodBuilder<string>.Create();
        Timer timer = null;
        timer = new Timer(s =>
        {
            timer.Dispose();
            builder.SetResult("Finished");//在需要时设置结果
        }, null, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(2));
        return builder.Task;//获取需要的Task
    }
}

类似的方法,我们封装一个由多个异步方法组合成的异步方法。

public class ProgramClass
{
    public static void Main()
    {
        var task = ProcessAsync();
        task.Wait();
        var r = task.Result;
    }

    static Task<string> ProcessAsync()
    {
        //辅助工具
        AsyncTaskMethodBuilder<string> builder = AsyncTaskMethodBuilder<string>.Create();

        DoSomethingAync1().GetAwaiter().OnCompleted(() =>
        {
            DoSomethingAync2().GetAwaiter().OnCompleted(() =>
            {
                DoSomethingAync2().GetAwaiter().OnCompleted(() =>
                {
                    builder.SetResult("Finished");
                });
            });
        });

        return builder.Task;//获取需要的Task
    }

    static Task<string> DoSomethingAync1() { ... }
    static Task<string> DoSomethingAync2() { ... }
    static Task<string> DoSomethingAync3() { ... }
}

组合异步方法调用后,按顺序调用第一个异步方法,紧接着,产生需要的结果Task后返回。异步方法完成时回调指定的方法,并按顺序继续调用,所有方法完成后,把运行的最终结果设置给结果Task,那么整个任务即完成。

如果异步方法有回返值,那么组合的异步方法看上去会复杂一点。

static Task<string> ProcessAsync()
{
    //辅助工具
    AsyncTaskMethodBuilder<string> builder = AsyncTaskMethodBuilder<string>.Create();

    string r1, r2, r3;//用于存储每一个任务的结构
    var awaitor1 = DoSomethingAync1().GetAwaiter();
    awaitor1.OnCompleted(() =>
    {
        r1 = awaitor1.GetResult();
        var awaitor2 = DoSomethingAync2().GetAwaiter();
        awaitor2.OnCompleted(() =>
        {
            r2 = awaitor2.GetResult();
            var awaitor3 = DoSomethingAync3().GetAwaiter();
            awaitor3.OnCompleted(() =>
            {
                r3 = awaitor3.GetResult();
                builder.SetResult(r1 + r2 + r3);//计算最终结构并设置结果
            });
        });
    });

    return builder.Task;//获取需要的Task
}

代码虽然复杂了一点,但还能够接受,这里的每个异步方法的返回值需要临时变量来存储,包括每个异步方法的TaskAwaiter对象,需要跨越多个方法,这里将形成闭包,使得这些对象无法尽快释放,同时,每一个异步方法都将附加一个OnComplete回访方法的委托对象,这些都是使用上述方法的代价,这些代价在理论上是可以被优化的,但是带来的是更为复杂的代码结果,暂且放下吧,因为,解决方案就在后面。

重口味语法糖

在C#5中,添加了 async/await 关键字,使得上面遗留的问题得以解决,而且重点是,用起来非常简单!

上面的代码在C#5时代可以写成下面的样子:

static async Task<string> ProcessAsync()
{
    var r1 = await DoSomethingAync1();
    var r2 = await DoSomethingAync2();
    var r3 = await DoSomethingAync3();

    return r1 + r2 + r3;
}

是不是震惊了。

他几乎和同步方法写法一致。程序的逻辑完全没有因为异步而打乱,并且减少了代码量,这就是语法糖的魅力。

语法糖的背后隐藏了不为人知的内部实现,特别重口味语法糖,我们需要知道他背后的实现,才不致于消化不良。

先看一下语法,async关键字告诉编译器,对本方法使用语法糖,对于这类方法只能返回 void/Task/Task

该方法的执行顺序与前面我们自己实现的相同,内部实现也有一些类似,同样采用AsyncTaskBuilder构建Task对象,在我们自己实现的方法中,在方法内部(一个或多个匿名方法与闭包对象)实现多个异步方法的调度,而async/await语法糖则采用一个状态机对象作为媒介进行多个异步方法的调度。

编译后,async异步方法将执行过程委托给状态机,自己则向AsyncTaskBuilder获取Task返回,状态机内部存储方法内部参与计算的临时变量(闭包),维护当前执行状态,-1代表开始与中间状态,-2代表结束,0-n代表正在执行第n个异步方法,状态机的MoveNext方法按顺序去调用其他的异步方法,如异步方法已执行完毕则继续往下执行,如未完毕,则设置当前状态,存储任务的Awaiter对象,并关联完成动作(状态机方法本身的单例委托对象)后结束,当异步方法执行完毕,继续调用状态机MoveNext方法,按照状态找到执行入口点,找到上次执行的Awaiter对象,并获取执行结果,然后继续找到下一个异步方法执行,重复以上的步骤,如果异步方法间有其他代码,照本执行,当所有异步方法与内部代码执行完毕后,通过AsyncTaskBuilder向异步方法的结果Task设置结果值,该Task即完成。

从编译后的结果可以看到,这里不再存在闭包对象与多个回调方法及其委托对象,全部合在状态机对象当中,而每一次异步方法调用后的Awaiter对象也可以在异步方法完成后释放引用,在状态机对象中根据签名的种类提供必要的字段位置,状态机本身也是结构体,最大限度上减少了空间的开销与GC的压力,而所有的这一切,编译器通通搞定,而程序员,只需要关注逻辑的顺序与结果的处理即可。

原文链接:

https://www.cnblogs.com/wisdomqq/archive/2012/03/26/2412349.html

(转)NET-异步

标签:时间   获取   引入   入口   blog   tca   那是   硬件   步骤   

原文地址:https://www.cnblogs.com/MingsonZheng/p/9375170.html


本文由百家号/熊掌号作者上传并发布,百家号仅提供信息发布平台。文章仅代表作者个人观点,不代表百度立场。

已有 0 条评论

    我有话说: