何人把实实在在的Rap,变成了超新星机器

回来目录

葡京网上娱乐场 1

关于死锁的来头

知晓该死锁的缘由在于精晓await
处理contexts的章程,暗中同意的,当几个未成功的Task 被await的时候,当前的上下文将在该Task达成的时候重新得到并继续执行剩余的代码。这一个context就是当前的SynchronizationContext ,除非它是空的。WEB应用程序的SynchronizationContext
有排他性,只允许一个线程运营。当await
完毕的时候,它准备在它原先的代码上下文执行它剩余的一部分,但是该代码上下文中已经有贰个线程在了,正是丰盛一直在一块儿等待async
完成的老大线程,它们七个相互等待,因而就死锁了。

     
二〇一九年上5个月,赵雷的一首《塔林》,响遍街头巷尾,越来越多的民歌歌迷涌入音乐节现场,愈多的地点开头积极争取主办音乐节。

MSDN使用异步应该小心

规则
描述
例外
避免使用 async void
优先使用 async Task 而不用 async void
Event handlers
Async到顶
不要混合使用 blocking 和 async 的代码
Console main method
注意配置好执行的context
尽量设置 ConfigureAwait(false)
需要context的除外

 

      小编私自窃喜,以为中中原人民共和国舞曲终于初叶被公众肯定并欣赏。

感恩的心

多谢网上海人民广播广播台大稿子的分享,在有关文章中找到了在一块代码中动用异步代码的无阻塞方案,在此以前也要好写了多少个测试的DEMO,但Task<T>那种带有再次来到值的异步方法照旧会晤世死锁,此前代码如下:

    /// <summary>
    /// 大叔测试
    /// </summary>
    public class tools
    {
        #region 假设这些方法被第三方被封装的,不可修改的方法
        public static async Task TestAsync()
        {
            await Task.Delay(1000)
                      .ConfigureAwait(false);//不会死锁
        }

        public static async Task<string> GetStrAsync()
        {
            return await Task.Run(() => "OK").ConfigureAwait(false);
        }

        public static async Task DelayTestAsync()
        {
            Logger.LoggerFactory.Instance.Logger_Info("DelayAsync");
            await Task.Delay(1000);
        }

        public static async Task<string> DelayGetStrAsync()
        {
            return await Task.Run(() => "OK");
        }
        #endregion

        #region 我们需要在自己代码中封装它,解决线程死锁
        /// <summary>
        /// 没有返回值的同步调用异步的实体
        /// </summary>
        /// <param name="func"></param>
        public static void ForWait(Func<Task> func)
        {
            func().ConfigureAwait(false);
        }
        /// <summary>
        /// 存在返回值的同步调用异步的实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="func"></param>
        /// <returns></returns>
        public static T ForResult<T>(Func<Task<T>> func)
        {
            var a = func();
            a.ConfigureAwait(false);
            return a.Result;
        }
        #endregion
    }

葡京网上娱乐场,对此地方的代码,当执行多少个Task反回类型(即无再次来到结果)时,程序是未曾难题的,但足以存在再次回到结果,那么地方的ForResult方法依旧会发生死锁!执着的自家自然不会就此罢休,找了有的稿子后,终于如故有了结果,在对当下上下文和异步上下文进行了简

单的拍卖后,最终依旧促成了一同与异步的并存从而说,人是最精晓的一种动物,一切都皆有大概,只要您想!

Lind.DDD.Utils.AsyncTaskManager代码如下,希望得以给大家带来一些启示和帮助

 

  /// <summary>
    /// 异步线程管理-在同步程序中调用异步,解决了线程死锁问题
    /// </summary>
    public class AsyncTaskManager
    {
        /// <summary>
        /// 运行无返回类型的异步方法
        /// </summary>
        /// <param name="task"></param>
        public static void RunSync(Func<Task> task)
        {
            var oldContext = SynchronizationContext.Current;//同步上下文 
            var synch = new ExclusiveSynchronizationContext();//异步上下文
            SynchronizationContext.SetSynchronizationContext(synch);//设置当前同步上下文
            synch.Post(async obj =>
            {
                try
                {
                    await task();
                }
                catch (Exception e)
                {
                    synch.InnerException = e;
                    throw;
                }
                finally
                {
                    synch.EndMessageLoop();
                }
            }, null);
            synch.BeginMessageLoop();
            SynchronizationContext.SetSynchronizationContext(oldContext);
        }
        /// <summary>
        /// 运行返回类型为T的异步方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="task"></param>
        /// <returns></returns>
        public static T RunSync<T>(Func<Task<T>> task)
        {
            var oldContext = SynchronizationContext.Current;
            var synch = new ExclusiveSynchronizationContext();
            SynchronizationContext.SetSynchronizationContext(synch);
            T ret = default(T);//动作的默认值
            synch.Post(async obj =>
            {
                try
                {
                    ret = await task();
                }
                catch (Exception e)
                {
                    synch.InnerException = e;
                    throw;
                }
                finally
                {
                    synch.EndMessageLoop();
                }
            }, null);
            synch.BeginMessageLoop();
            SynchronizationContext.SetSynchronizationContext(oldContext);
            return ret;
        }

        /// <summary>
        /// 异步上下文对象
        /// </summary>
        class ExclusiveSynchronizationContext : SynchronizationContext
        {
            private bool done;
            public Exception InnerException { get; set; }
            readonly AutoResetEvent workItemsWaiting = new AutoResetEvent(false);
            readonly Queue<Tuple<SendOrPostCallback, object>> items =
             new Queue<Tuple<SendOrPostCallback, object>>();

            public override void Send(SendOrPostCallback d, object state)
            {
                throw new NotSupportedException("We cannot send to our same thread");
            }
            /// <summary>
            /// 添加到异步队列
            /// </summary>
            /// <param name="d"></param>
            /// <param name="state"></param>
            public override void Post(SendOrPostCallback d, object state)
            {
                lock (items)
                {
                    items.Enqueue(Tuple.Create(d, state));
                }
                workItemsWaiting.Set();
            }
            /// <summary>
            /// 异步结束
            /// </summary>
            public void EndMessageLoop()
            {
                Post(obj => done = true, null);
            }
            /// <summary>
            /// 处理异步队列中的消息
            /// </summary>
            public void BeginMessageLoop()
            {
                while (!done)
                {
                    Tuple<SendOrPostCallback, object> task = null;
                    lock (items)
                    {
                        if (items.Count > 0)
                        {
                            task = items.Dequeue();
                        }
                    }
                    if (task != null)
                    {
                        task.Item1(task.Item2);
                        if (InnerException != null) // the method threw an exeption
                        {
                            throw new AggregateException("AsyncInline.Run method threw an exception.",
                             InnerException);
                        }
                    }
                    else
                    {
                        workItemsWaiting.WaitOne();
                    }
                }
            }
            public override SynchronizationContext CreateCopy()
            {
                return this;
            }
        }
    }

终一点都不小家举办测试中,看到线程没有出现死锁难点!

多谢各位的翻阅!

回去目录

     
小编间接觉得,喜欢音乐的人都以善良的,而热爱舞曲的人,更是温润儒雅、清风傲骨。从未想象过,还会现出音乐节现场集体冲突的轩然大波。

      他们是随着舞曲去的,依旧追器重打击乐音乐人去的啊?

      眼前,PG
One正面临着被周全封闭扼杀的囧境。笔者不关怀他与李小璐女士之间的各个讲不清,笔者只是好奇,一场娱乐圈数见不鲜的轩然大波,竟会让许几人坚信,刚刚走入群众视野,为广大客官接受的嘻哈文化,或然要在这一场轩然大波中,失去最好的腾飞机会。

      小小的2个嘻哈影星被封闭扼杀,竟会对嘻哈文化的开拓进取,发生这么大的震慑?

     
打开博客园热搜,网上一度是单方面喜庆景观。PG迷们正在无辜地接受铺天盖地的谩骂。更有甚者,很几个人初叶和嘻哈划清界限。

     
正所谓成也萧何,败也萧相国。今天的舞曲、rap等音乐圈,早已被渲染成娱乐圈的一有的。于是,很多青睐亦或不爱音乐的音乐人成了超新星。一拥而上的客官,也许高喊赵雷好帅,恐怕宣称PG
One是团结男生,也许根本都没有当真停下来去考虑音乐小说或然文化自身。

     
或然,彼时的歌谣,此时的嘻哈,已成为他们展现逼格的道具,还不自知。前几天,他们照旧二个民歌爱好者,后天,就成了嘻哈的狂热徒。

      但本人心目亮堂,那不是他们的错。

     
前日,音乐还从未那么多的宣扬造势,音乐正是音乐,而rap依旧比重打击乐更小众的音乐。一群坚韧不拔的rap者,爱慕那份呈现性情的策反精神。

     
今日,音乐细分领域曾经包含了重打击乐、嘻哈、三次元、古风等等,圈子盛行,媒体疯狂造势,人人梦想一夜成名。rap快成了从未灵魂的形体和游乐造星的老路。

     
是哪个人,把实实在在的rap,变成了超新星机器,笔者所强调的歌谣依旧一篇净土啊?

     
小说来源:山谷牧歌(Valley_Song)微信公众号,更加多美丽,欢迎关切!