class Program
    {
        static async Task Main(string[] args)
        {
            for (int i = 0; i < 100; i++)
            {
                var copy = i;

                _ = Task.Run(() =>
                {
                    Console.WriteLine("Start " + copy);
                    Thread.Sleep(5000);
                    Console.WriteLine("End " + copy);
                });
            }

            Console.ReadLine();
            Console.WriteLine("Hello World!");
        }
    }

for( int i = 0; i < 50; i++ )
            {
                var copy = i;
                ThreadPool.QueueUserWorkItem( ( state ) => {
                    Console.WriteLine( "init pool" );
                    Thread.Sleep( 3000 );
                } );
            }
            Thread.Sleep( 20000 );

int maxThreads = 2;
LimitedConcurrencyLevelTaskScheduler lcs = new LimitedConcurrencyLevelTaskScheduler(maxThreads);
QueuedTaskScheduler qs = new QueuedTaskScheduler(maxThreads);
TaskFactory factory = new TaskFactory(qs|lcs);

...
await factory.StartNew(() => ...);

S>    class Program
S>    {
S>        static async Task Main(string[] args)
S>        {
S>            for (int i = 0; i < 100; i++)
S>            {
S>                var copy = i;

S>                _ = Task.Run(() =>
S>                {
S>                    Console.WriteLine("Start " + copy);
S>                    Thread.Sleep(5000);
S>                    Console.WriteLine("End " + copy);
S>                });
S>            }

S>            Console.ReadLine();
S>            Console.WriteLine("Hello World!");
S>        }
S>    }
S>

await Task.Delay(5000)

var task = Task.Factory.StartNew(() =>
    {
        Console.WriteLine("Start " + copy);
        Thread.Sleep(5000);
        Console.WriteLine("End " + copy);
    },
    TaskCreationOptions.LongRunning
);

Может и дорого, но данный код выполняется быстрее во много крат, если одновременно стартануть все 100 потоков (т.к. большую часть времени просто ждет).

Maximum number of thread pool threads
The number of operations that can be queued to the thread pool is limited only by available memory. However, the thread pool limits the number of threads that can be active in the process simultaneously. If all thread pool threads are busy, additional work items are queued until threads to execute them become available. Beginning with the .NET Framework 4, the default size of the thread pool for a process depends on several factors, such as the size of the virtual address space. A process can call the ThreadPool.GetMaxThreads method to determine the number of threads.

You can control the maximum number of threads by using the ThreadPool.GetMaxThreads and ThreadPool.SetMaxThreads methods.

Note

Code that hosts the common language runtime can set the size using the ICorThreadpool::CorSetMaxThreads method.

Thread pool minimums
The thread pool provides new worker threads or I/O completion threads on demand until it reaches a specified minimum for each category. You can use the ThreadPool.GetMinThreads method to obtain these minimum values.

Note

When demand is low, the actual number of thread pool threads can fall below the minimum values.

When a minimum is reached, the thread pool can create additional threads or wait until some tasks complete. Beginning with the .NET Framework 4, the thread pool creates and destroys worker threads in order to optimize throughput, which is defined as the number of tasks that complete per unit of time. Too few threads might not make optimal use of available resources, whereas too many threads could increase resource contention.

Caution

You can use the ThreadPool.SetMinThreads method to increase the minimum number of idle threads. However, unnecessarily increasing these values can cause performance problems. If too many tasks start at the same time, all of them might appear to be slow. In most cases the thread pool will perform better with its own algorithm for allocating threads.