C # Performs a fixed number of tasks self-control the number of threads entering the thread pool, multitasking but concurrent data qualification

Source of thought: http://bbs.csdn.NET/topics/390819824, quoting the method provided by a netizen on this page.

Title: I now have 100 tasks that require multiple threads to complete, but limit the concurrent number to 5.

Principle: Initially enable 5 threads, then let the process in the thread complete, and then go to fetch the next task, start the next thread.

[CSharp]View PlainCopyPrint?

2. Public class mytasklist
4. {
6. Public list<action> Tasks = New  list<action> ();
10. Public void Start ()
12. {
14. for (var i = 0; i < 5; i++)
16. Startasync ();
18. }
22. Public   Event Action completed;
26. Public void startasync ()
28. {
30. Lock (Tasks)
32. {
34. if (Tasks.count > 0)
36. {
38. var t = tasks[tasks.count-1];
40. Tasks.remove (t);
42. ThreadPool.QueueUserWorkItem (h =
44. {
46. T ();
48. Startasync ();
50. });
52. }
54. Else if (completed! = null)
56. Completed ();
58. }
60. }
62. }

    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 ();}}}    

Call Mode:

1, automatically join the 100 test tasks, each run time is uncertain, random.

2, here the Startasync method is instantly over, does not block at all, does not wait for what while loop ends

[CSharp]View PlainCopyPrint?

2. var rnd = New  Random ();
4. var lst = new mytasklist ();
6. for (var i = 0; i <; i++)
8. {
10. var s = rnd. Next (10);
12. var j = i;
14. var test task = new Action (() =
16. {
18. Console.WriteLine (string.  Format ("{0} tasks (spents {1} seconds) has begun", J, s));
20. Thread.Sleep (S * 1000);
22. Console.WriteLine (string.  Format ("{0} tasks (spents {1} seconds) has ended", J, s));
24. });
26. Lst. Tasks.add (test Task);
28. }
30. lst.completed + = () = Console.WriteLine ("____________________ no more missions anymore!"  ");
32. Lst. Start ();

            var rnd = new Random ();            var lst = new Mytasklist ();            for (var i = 0; i < i++)            {                var s = rnd. Next (ten);                var j = i;                var test task = new Action (() =                {                    Console.WriteLine (string. Format ("{0} tasks (spents {1} seconds) has begun", J, s));                    Thread.Sleep (S * +);                    Console.WriteLine (String. Format ("{0} tasks (spents {1} seconds) has ended", J, s);                });                Lst. Tasks.add (test Task);            }            lst.completed + = () = Console.WriteLine ("____________________ no more missions anymore!" ");            Lst. Start ();

You use the custom maximum number of threads in your program, and then loop through the threads that enable the maximum number of threads to perform the task, wait for the thread to finish, exit this run method and thread before you call the Enable thread method call the next thread, loop until it is complete :

[CSharp]View PlainCopyPrint?

2. autoresetevent[] waitenents = New  Autoresetevent[n_max_thread];
4. for (int i = 0; i < n_max_thread; i++)
6. {
8. Calcstate.wait_event = waitenents[i] = new AutoResetEvent (false);
12. Startasync (CalcState);
14. }
18. Autoresetevent.waitall (waitenents);
22. Private static void startasync (calcstate calcstate)
24. {
26. Lock (Calcstate.locker_listformula)
28. {
30. if (CalcState.lstFormula.Count > 0)
32. {
34. Calcstate.formulaattr = CalcState.lstFormula.ElementAt (calcstate.lstformula.count-1). Value;
36. CalcState.lstFormula.Remove (CalcState.lstFormula.ElementAt (calcstate.lstformula.count-1). Key);
38. ThreadPool.QueueUserWorkItem (new WaitCallback (execasync), calcstate);
40. }
42. Else   
44. {
46. Calcstate.wait_event. Set ();
48. }
50. }
54. }
58. Private static void Execasync (object obj)
60. {
62. CalcState calcstate = obj as calcstate;
64. Startcalcformula (CalcState);
66. //recursive processing of the next formula   
68. Startasync (CalcState);
70. }
74. Private static void Startcalcformula (calcstate calcstate)
76. {
80. }

        autoresetevent[] waitenents = new Autoresetevent[n_max_thread]; for (int i = 0; i < N_max_thread; i++) {calcstate.wait_event = waitenents[i] = new AutoResetEvent (f             Alse);        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);        Recursive processing of the next formula Startasync (CalcState); } private static void Startcalcformula (CalcState calcstate) {}

C # Performs a fixed number of tasks self-control the number of threads entering the thread pool, multitasking but concurrent data qualification