思路来源:http://bbs.csdn.NET/topics/390819824,引用该页面某网友提供的方法。

题目:我现在有100个任务,需要多线程去完成,但是要限定同时并发数量不能超过5个。

原理:初始启用5个线程,然后让线程中的过程执行完毕之后,自己去取下一个任务,启动下一个线程。

  1. public class MyTaskList
  2. {
  3. public List<Action> Tasks = new List<Action>();
  4. public void Start()
  5. {
  6. for (var i = 0; i < 5; i++)
  7. StartAsync();
  8. }
  9. public event Action Completed;
  10. public void StartAsync()
  11. {
  12. lock (Tasks)
  13. {
  14. if (Tasks.Count > 0)
  15. {
  16. var t = Tasks[Tasks.Count - 1];
  17. Tasks.Remove(t);
  18. ThreadPool.QueueUserWorkItem(h =>
  19. {
  20. t();
  21. StartAsync();
  22. });
  23. }
  24. else if (Completed != null)
  25. Completed();
  26. }
  27. }
  28. }
    public class MyTaskList
{
public List<Action> Tasks = new List<Action>(); public void Start()
{
for (var i = 0; i < 5; i++)
StartAsync();
} public event Action Completed; public void StartAsync()
{
lock (Tasks)
{
if (Tasks.Count > 0)
{
var t = Tasks[Tasks.Count - 1];
Tasks.Remove(t);
ThreadPool.QueueUserWorkItem(h =>
{
t();
StartAsync();
});
}
else if (Completed != null)
Completed();
}
}
}

调用方式:

1,自动加入的100个测试任务,每一个运行时间都是不定的、随机的。

2,这里的 StartAsync 方法瞬间就结束了,根本不会阻塞,也不会等待什么 while 循环结束

  1. var rnd = new Random();
  2. var lst = new MyTaskList();
  3. for (var i = 0; i < 100; i++)
  4. {
  5. var s = rnd.Next(10);
  6. var j = i;
  7. var 测试任务 = new Action(() =>
  8. {
  9. Console.WriteLine(string.Format("第{0}个任务(用时{1}秒)已经开始", j, s));
  10. Thread.Sleep(s * 1000);
  11. Console.WriteLine(string.Format("第{0}个任务(用时{1}秒)已经结束", j, s));
  12. });
  13. lst.Tasks.Add(测试任务);
  14. }
  15. lst.Completed += () => Console.WriteLine("____________________没有更多的任务了!");
  16. lst.Start();
            var rnd = new Random();
var lst = new MyTaskList();
for (var i = 0; i < 100; i++)
{
var s = rnd.Next(10);
var j = i;
var 测试任务 = new Action(() =>
{
Console.WriteLine(string.Format("第{0}个任务(用时{1}秒)已经开始", j, s));
Thread.Sleep(s * 1000);
Console.WriteLine(string.Format("第{0}个任务(用时{1}秒)已经结束", j, s));
});
lst.Tasks.Add(测试任务);
}
lst.Completed += () => Console.WriteLine("____________________没有更多的任务了!");
lst.Start();

自己使用到程序中,自定义最大线程数,然后循环启用最大线程数个线程执行任务,等待有线程完成,退出本次运行方法和线程前,再次调用启用线程方法调用下一个线程,依次循环,直至完成:

  1. AutoResetEvent[] waitEnents = new AutoResetEvent[n_max_thread];
  2. for (int i = 0; i < n_max_thread; i++)
  3. {
  4. calcState.wait_event = waitEnents[i] = new AutoResetEvent(false);
  5. StartAsync(calcState);
  6. }
  7. AutoResetEvent.WaitAll(waitEnents);
  8. private static void StartAsync(CalcState calcState)
  9. {
  10. lock (calcState.locker_ListFormula)
  11. {
  12. if (calcState.lstFormula.Count > 0)
  13. {
  14. calcState.formulaAttr = calcState.lstFormula.ElementAt(calcState.lstFormula.Count - 1).Value;
  15. calcState.lstFormula.Remove(calcState.lstFormula.ElementAt(calcState.lstFormula.Count - 1).Key);
  16. ThreadPool.QueueUserWorkItem(new WaitCallback(ExecAsync), calcState);
  17. }
  18. else
  19. {
  20. calcState.wait_event.Set();
  21. }
  22. }
  23. }
  24. private static void ExecAsync(object obj)
  25. {
  26. CalcState calcState = obj as CalcState;
  27. startCalcFormula(calcState);
  28. //递归处理下一个公式
  29. StartAsync(calcState);
  30. }
  31. private static void startCalcFormula(CalcState calcState)
  32. {
  33. }
        AutoResetEvent[] waitEnents = new AutoResetEvent[n_max_thread];
for (int i = 0; i < n_max_thread; i++)
{
calcState.wait_event = waitEnents[i] = new AutoResetEvent(false); StartAsync(calcState);
} AutoResetEvent.WaitAll(waitEnents); private static void StartAsync(CalcState calcState)
{
lock (calcState.locker_ListFormula)
{
if (calcState.lstFormula.Count > 0)
{
calcState.formulaAttr = calcState.lstFormula.ElementAt(calcState.lstFormula.Count - 1).Value;
calcState.lstFormula.Remove(calcState.lstFormula.ElementAt(calcState.lstFormula.Count - 1).Key);
ThreadPool.QueueUserWorkItem(new WaitCallback(ExecAsync), calcState);
}
else
{
calcState.wait_event.Set();
}
} } private static void ExecAsync(object obj)
{
CalcState calcState = obj as CalcState;
startCalcFormula(calcState);
//递归处理下一个公式
StartAsync(calcState);
} private static void startCalcFormula(CalcState calcState)
{ }

C# 执行固定个数任务自行控制进入线程池的线程数量,多任务同时但是并发数据限定的更多相关文章

  1. 由浅入深理解Java线程池及线程池的如何使用

    前言 多线程的异步执行方式,虽然能够最大限度发挥多核计算机的计算能力,但是如果不加控制,反而会对系统造成负担.线程本身也要占用内存空间,大量的线程会占用内存资源并且可能会导致Out of Memory ...

  2. Java多线程、线程池和线程安全整理

    多线程 1.1      多线程介绍 进程指正在运行的程序.确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能. 1.2      Thread类 通 ...

  3. Java多线程系列 JUC线程池03 线程池原理解析(二)

    转载  http://www.cnblogs.com/skywang12345/p/3509954.html  http://www.cnblogs.com/skywang12345/p/351294 ...

  4. Java多线程系列 JUC线程池02 线程池原理解析(一)

    转载  http://www.cnblogs.com/skywang12345/p/3509960.html ; http://www.cnblogs.com/skywang12345/p/35099 ...

  5. Java多线程系列 JUC线程池01 线程池框架

    转载  http://www.cnblogs.com/skywang12345/p/3509903.html 为什么引入Executor线程池框架 new Thread()的缺点 1. 每次new T ...

  6. 异步线程编程,线程池,线程组,后面涉及ThreadLocal在理解

    join模拟订单 package com.future.demo.future; /** * * * @author Administrator * */ public class NormalThr ...

  7. java并发编程(十五)----(线程池)java线程池简介

    好的软件设计不建议手动创建和销毁线程.线程的创建和销毁是非常耗 CPU 和内存的,因为这需要 JVM 和操作系统的参与.64位 JVM 默认线程栈是大小1 MB.这就是为什么说在请求频繁时为每个小的请 ...

  8. 多线程、线程池、线程创建、Thread

    转载自https://www.cnblogs.com/jmsjh/p/7762034.html 多线程 1.1 多线程介绍 学习多线程之前,我们先要了解几个关于多线程有关的概念. 进程:进程指正在运行 ...

  9. java 线程池(线程的复用)

    一. 线程池简介 1. 线程池的概念: 线程池就是首先创建一些线程,它们的集合称为线程池.使用线程池可以很好地提高性能,线程池在系统启动时即创建大量空闲的线程,程序将一个任务传给线程池,线程池就会启动 ...

随机推荐

  1. [AT697]フィボナッチ

    题目大意:给你$n,k(n\leqslant10^9,k\leqslant10^3)$,求$f_n$.$f$数组满足$f_1=f_2=\cdots=f_k=1$,$f_n=\sum\limits_{i ...

  2. Nagios通过企业微信报警

    主要分两部分进行: 注册企业微信,自建应用,获取与发送消息相关的信息: 编写调用微信API脚本(bash),配置Nagios微信报警: 一.企业微信 1.注册企业微信:https://work.wei ...

  3. Go interface{}、类型断言

    在 golang 中 interface{} 可用于向函数传递任意类型的变量, 但在函数内部使用的话, 该变量的类型就是 interface{}, 也称为空接口类型 比如我们定义一个函数, 输出字符串 ...

  4. Java EE之JSTL(下)

    3.使用国际化和格式化标签库(FMT命名空间) 如果你希望创建部署在Web上,并面向庞大的国际化用户的企业级Java应用程序,那么你最终需要为世界的特定区域进行应用程序本地化.这将通过国际化实现(通常 ...

  5. 图解HTTP(六)HTTP首部

    一.HTTP报文的结构: 二.4种首部字段: 1. 通用首部字段 请求报文和响应报文都会使用的首部. 首部字段名 说明 Cache-Control 控制缓存行为 Connection 逐跳首部.连接的 ...

  6. poj 3294 后缀数组 多字符串中不小于 k 个字符串中的最长子串

    Life Forms Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 16223   Accepted: 4763 Descr ...

  7. 《xxx重大需求征集系统的》可用性和可修改性战术分析

    阅读<大型网站技术架构:核心与案例分析>,第五,六章,结合<河北省重大需求填报系统>,列举实例分析采用的可用性和可修改性战术,将上述内容撰写成一篇1500字左右的博客阐述你的意 ...

  8. Java 守护线程概述

    原文出处: 朱小厮 Java的线程分为两种:User Thread(用户线程).DaemonThread(守护线程). 只要当前JVM实例中尚存任何一个非守护线程没有结束,守护线程就全部工作:只有当最 ...

  9. spring中的控制反转

    为什么使用spring框架,控制反转是它的重要优势之一. 传统的程序设计中,某个对象需要被调用时(比如mvc模式中controller调用service),需要调用者自己创建被调用对象. 而在spri ...

  10. RabbitMQ消息队列里积压很多消息

    1.场景:上千万条消息在mq里积压了几个小时了还没解决 2.解决: 1)先修复consumer的问题,确保其恢复消费速度,然后将现有cnosumer都停掉 2)新建一个topic,partition是 ...