关于并发下内存及CPU使用情况的思考

Posted 又见阿郎

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了关于并发下内存及CPU使用情况的思考相关的知识,希望对你有一定的参考价值。

鉴于昨天的文章<<使用Interlocked在多线程下进行原子操作,无锁无阻塞的实现线程运行状态判断>>里面有一个封装好的无锁的类库可以判断并发下的结束状况,我们可以完成并发时,以及并发的同时做一些事,因此,今天我做了个小demo:

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp6
{
    
    public enum CoordinationStatus
    {
        AllDone,
        Timeout,
        Cancel
    };

    public sealed class AsyncCoordinator
    {
        private Int32 m_opCount = 1;        // Decremented when AllBegun calls JustEnded
        private Int32 m_statusReported = 0; // 0=false, 1=true
        private Action<CoordinationStatus> m_callback;
        private Timer m_timer;

        // This method MUST be called BEFORE initiating an operation
        public void AboutToBegin(Int32 opsToAdd = 1)
        {
            Interlocked.Add(ref m_opCount, opsToAdd);
        }

        // This method MUST be called AFTER an operations result has been processed
        public void JustEnded()
        {
            if (Interlocked.Decrement(ref m_opCount) == 0)
                ReportStatus(CoordinationStatus.AllDone);
        }

        // This method MUST be called AFTER initiating ALL operations
        public void AllBegun(Action<CoordinationStatus> callback, Int32 timeout = Timeout.Infinite)
        {
            m_callback = callback;
            // 是否需要永远运行
            if (timeout != Timeout.Infinite)
            {
                // 在指定的时间点(dueTime) 调用回调函数,随后在指定的时间间隔(period)调用回调函数
                m_timer = new Timer(TimeExpired, null, timeout, Timeout.Infinite);
            }
            JustEnded();
        }

        // 处理过时的线程
        private void TimeExpired(Object o)
        {
            ReportStatus(CoordinationStatus.Timeout);
        }

        public void Cancel()
        {
            if (m_callback == null)
                throw new InvalidOperationException("Cancel cannot be called before AllBegun");
            ReportStatus(CoordinationStatus.Cancel);
        }

        private void ReportStatus(CoordinationStatus status)
        {
            if (m_timer != null)
            {  // If timer is still in play, kill it
                Timer timer = Interlocked.Exchange(ref m_timer, null);
                if (timer != null) timer.Dispose();
            }

            // If status has never been reported, report it; else ignore it
            if (Interlocked.Exchange(ref m_statusReported, 1) == 0)
                m_callback(status);
        }
    }

    

    class Program
    {
        static AsyncCoordinator m_ac = new AsyncCoordinator();
        static void Main(string[] args)
        {
            Console.BufferHeight = Int16.MaxValue - 10;
            Console.BufferWidth = Int16.MaxValue - 10;

            ConcurrentQueue<int> concurrentQueue = new ConcurrentQueue<int>();

            for(int i =0;i<10000; i++)
            {
                concurrentQueue.Enqueue(i);
            }

            Console.WriteLine("添加完毕....");

            var t = new Task[50];
            
            for (int i=0; i<50; i++)
            {
                m_ac.AboutToBegin(1);
                t[i] = Task.Factory.StartNew((param) =>
                {
                    while (concurrentQueue.Count>0)
                    {
                        int x;
                        if(concurrentQueue.TryDequeue(out x))
                        {
                            Console.WriteLine(x + "   线程Id: {0},   线程数: {1}", Task.CurrentId, param.ToString());
                        }
                        //Thread.Sleep(150);
                    }
                    m_ac.JustEnded();
                }, i);
            }
            
            m_ac.AllBegun(AllDone, Timeout.Infinite);
            Console.ReadKey();
        }

        public static void AllDone(CoordinationStatus status)
        {
            switch (status)
            {
                case CoordinationStatus.Cancel:
                    Console.WriteLine("Operation canceled.");
                    break;

                case CoordinationStatus.Timeout:
                    Console.WriteLine("Operation timed-out.");
                    break;

                case CoordinationStatus.AllDone:
                    Console.WriteLine("处理完毕....");
                    break;
            }
        }
    }
}

但是发现了一个问题:

这CPU使用率....
然后我看了下输出结果:

可以看到线程数才只有5个(我的线程数是从0开始算的),这不会啊,明明我们就开了50个线程啊,不过不管开多少个线程,这CPU扛不住啊,要是说在项目中的某个模块需要用到并发,这CPU使用率你扛得住?服务器本来配置就不会太好,网站的其余模块不要用CPU了?而且,我明明开了50个线程跑啊,为什么只有五个线程?其实很简单,因此并发下,代码只用了五个线程就跑完了这一万个数据,剩下的线程开了没有用武之地。找到只有五个线程开着的原因了之后,要想想怎么解决啊,多的45个线程也是要占内存的,尽管是线程池线程,但也是要占用内存啊,既然是因为并发下运行太快,只要五个线程就能跑满一万个数据,那我就阻塞一会线程就可以了,这样让剩下的45个线程能够有机会运行。改代码!
将上面的Thread.Sleep(150)的注释给去掉哦!

嗯,这个结果还是可以的,但是有个Console host占用内存高啊,占就占呗,反正该用的内存还是要用。我们睡眠了一段时间的线程,那么与不睡眠相比,并发的CPU使用率是不是下降了?我们开线程最好的期待不就是跑满CPU么?其实不然,开线程不过就是为了更快的运行程序,将耗时的程序分批次运行,但是如果期间占用CPU太高,我这里是个demo,占用CPU时间很短,也就几十秒。但是真的项目中会允许么?具体情况具体分析吧,如果不介意的话,可以这么跑,大不了另外弄个服务器专门跑并发,然后将数据存储到数据库中(如果你的业务是: 并发调用第三方接口,然后将接口获取的数据做处理,完全可以采用这种设计)。但是请注意,还是不要太耗费CPU的好。
并发线程的睡眠时间,我们也可以自己调节下,建议是100-200ms吧。

以上是关于关于并发下内存及CPU使用情况的思考的主要内容,如果未能解决你的问题,请参考以下文章

HashMap并发下死循环问题解析

高并发下,HashMap会产生哪些问题?

面对缓存,有哪些问题需要思考?

高并发下的内存管理技巧

如何测量 F# 代码的 CPU 和内存使用情况?

python常用代码