关于并发下内存及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吧。