C# 如何在不使用threadPool的情况下以线程束的形式运行多个进程&；用于处理的EventWaitHandler 类进程 { 静态void Main（字符串[]参数） { int线程=0； int进程=0； Console.WriteLine（“进程总数：”）； processs=Convert.ToInt32（Console.ReadLine（））； WriteLine（“输入并行线程数：”）； threads=Convert.ToInt32（Console.ReadLine（））； ManualResetEvent[]事件=新的ManualResetEvent[线程]； int k=0，innercount=0； //----成群结队地跑 做 { 对于（int l=0；l

我必须运行多个线程。如果一个线程已完成，则启动另一个线程。问题是它同时启动了所有进程。（似乎此条件无法正常工作WaitHandle.WaitAny（事件）；）

1：如果20个线程正在运行，那么当一个线程从20个线程释放时，第21个线程将启动

2：如果不使用线程池，可以使用EventWaitHandler来完成。请尝试使用来控制线程的释放。看看这里的例子。但我想知道为什么您不能使用

ThreadPool

来实现这一点

每次线程进入信号时，信号量上的计数都会减少 信号量，并在线程释放信号量时递增。什么时候 计数为零，后续请求阻塞，直到其他线程 释放信号灯。当所有线程都释放了信号量时， 计数是在发送信号量时指定的最大值 创造

这样，一旦一个线程释放了信号量中的一个插槽，另一个线程就可以占用该插槽并运行。

您可以使用PLinq和

WithDegreeOfParallelism

将限制同时运行的线程数

下面的示例演示如何使用Plinq以有限的并行性运行多个辅助进程，将不同的对象传递给每个辅助进程

它假定您从一系列对象开始，并希望将这些对象中的每一个传递给辅助方法：

  class Process
{
    static void Main(string[] args)
    {
        int threads = 0;
        int processes = 0;
        Console.WriteLine("Total number of processes:");
        processes = Convert.ToInt32(Console.ReadLine());
        Console.WriteLine("Enter number of parallel threads:");
        threads = Convert.ToInt32(Console.ReadLine());

        ManualResetEvent[] events = new ManualResetEvent[threads];

        int k = 0, innercount = 0;           
        //----running in bunches
        do
        {
            for (int l = 0; l < threads; l++)
            {
                if (k < threads)
                {
                    events[l] = new ManualResetEvent(false);
                    Runner r = new Runner(events[l], innercount);
                    new Thread(new ThreadStart(r.Run)).Start();
                    Console.WriteLine("running start...{0}", innercount);
                    k++;
                    innercount++;
                }
            }
            WaitHandle.WaitAny(events);
            k--;
            Console.WriteLine("Decrement counter...{0}", k);
        }
        while (innercount < processes);

        WaitHandle.WaitAll(events);

        Console.WriteLine("All finished!");

        Console.ReadLine();

    }
}
 class Runner
{
    static readonly object rngLock = new object();
    static Random rng = new Random();

    ManualResetEvent ev;
    int id;

    internal Runner(ManualResetEvent ev, int id)
    {
        this.ev = ev;
        this.id = id;
    }

    internal void Run()
    {

            int sleepTime;
            lock (rngLock)
            {
                sleepTime = rng.Next(2000);
            }
            Thread.Sleep(sleepTime);
            Console.WriteLine("Thread Runner {0}",
                               id);
            if (ev.Set())
            {
                Console.WriteLine("release thread...{0}", id);
            }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统线程；
名称空间演示
{
类DataForWorker
{
公共int ID；
公共字符串值；
};
班级计划
{
随机rng=新随机（）；
int numberOfThreadsRunning；
无效运行（）
{
int-maxThreads=8；
IEnumerable dataForWorkers=getDataForWorkers（）；
工人数据
.天冬酰胺（）
.带平行度（最大螺纹）
.ForAll（工人）；
}
IEnumerable getDataForWorkers（）
{
//只需返回一些虚拟数据。
int numberOfDataItems=30；
返回可枚举的范围（1，numberOfDataItems）。选择
(
n=>newdataforworker
{
ID=n，
Value=n.ToString（）
}
);
}
void worker（DataForWorker数据）
{
int n=联锁增量（参考螺纹运行编号）；
Console.WriteLine（“线程”+data.ID+”正在启动。#线程现在=“+n”）；
线程睡眠（rng.Next（10002000））；
WriteLine（“线程”+data.ID+“正在停止”）；
联锁。减量（参考螺纹运行编号）；
}
静态void Main（）
{
新程序（）.Run（）；
}
}
}

您能定义进程和线程之间的区别吗？（当然在你的术语中）我有100个[进程]&想要在不同的组中运行（10或20个[线程]）。进程，你是指逻辑/函数或进程，比如可执行文件？（函数）我必须在线程上运行一个函数100次，但在一些组中&如果我必须在worker中传递对象，我如何使用上面的Plink传递它

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

namespace Demo
{
    class DataForWorker
    {
        public int ID;
        public string Value;
    };

    class Program
    {
        Random rng = new Random();
        int numberOfThreadsRunning;

        void Run()
        {
            int maxThreads = 8;

            IEnumerable<DataForWorker> dataForWorkers = getDataForWorkers();

            dataForWorkers
                .AsParallel()
                .WithDegreeOfParallelism(maxThreads)
                .ForAll(worker);
        }

        IEnumerable<DataForWorker> getDataForWorkers()
        {
            // Just return some dummy data.

            int numberOfDataItems = 30;

            return Enumerable.Range(1, numberOfDataItems).Select
            (
                n => new DataForWorker
                {
                    ID = n,
                    Value = n.ToString()
                }
            );
        }

        void worker(DataForWorker data)
        {
            int n = Interlocked.Increment(ref numberOfThreadsRunning);
            Console.WriteLine("Thread " + data.ID + " is starting. #threads now = " + n);
            Thread.Sleep(rng.Next(1000, 2000));
            Console.WriteLine("Thread " + data.ID + " is stopping.");
            Interlocked.Decrement(ref numberOfThreadsRunning);
        }

        static void Main()
        {
            new Program().Run();
        }
    }
}