Параллельный поток с параметром. Как ускорить работу

public static int sum;
static void Main(string[] args)
{
sum=1;
for (int i = 2; i <= 11; i++)
  {
  sum=sum*i;
  }
Console.WriteLine("факториал="+sum);  
}

public static int sum;
static void Main(string[] args)
{
sum=1;
Thread t1 = new Thread(new ParameterizedThreadStart(ThreadProc1));
for (int i = 2; i <= 10; i=i+2)
  {
  t1.Start(i+1);
  sum=sum*i;
  }
Console.WriteLine("факториал="+sum);  
}
 
public static void ThreadProc1(Object number)
{
    int ii = (int) number;
    sum=sum*ii;
 
}

public static int sum;
static void Main(string[] args)
{
sum=1;
Thread t1;
 
for (int i = 2; i <= 11; i++)
  {
  t1= new Thread(new ParameterizedThreadStart(ThreadProc1));
  start(2);
  sum=sum*i;
  }
Console.WriteLine("факториал="+sum);  
}
 
public static void ThreadProc1(Object number)
{
 
}

public static int sum;
static void Main(string[] args)
{
sum=1;
Thread t1= new Thread(new ParameterizedThreadStart(ThreadProc1));
start(2);
 
for (int i = 2; i <= 11; i++)
  {
  sum=sum*i;
  }
Console.WriteLine("факториал="+sum);  
}
 
public static void ThreadProc1(Object number)
{
 
}

static void Main(string[] args)
{
 
Thread t1;
 
for (int i = 2; i <= 11; i++)
  {
  t1= new Thread(new ParameterizedThreadStart(ThreadProc1));
  t1.Start(i);
  }
}
 
public static void ThreadProc1(Object number)
{
  var id = Thread.CurrentThread.ManagedThreadId;
 
    Console.WriteLine($"thread id: {id}");
}

using System.Numerics;
 
var count = 50;
var n = 4;
var tasks = new Thread[n];
var results = new BigInteger?[n];
var block = Math.Max((int)Math.Ceiling((double)count / n), n);
 
for (int i = 1, index = 0; i <= count; index++)
{
    var start = i;
    var size = Math.Min(block, count + 1 - i);
    i += size;
    var parameters = (start, size, index);
    var th = new Thread(CalcBlock) { IsBackground = true };
    th.Start(parameters);
    tasks[index] = th;
}
 
for(var i = 0; i < tasks.Length; i++)
    tasks[i]?.Join();
 
var result = BigInteger.One;
foreach(var item in results.Where(x => x is not null))
    result *= item!.Value;
 
Console.WriteLine(result);
 
 
void CalcBlock(object? obj)
{ 
    if(obj is null)
        throw new ArgumentNullException(nameof(obj));
 
    (var start, var size, var index) = ((int, int, int))obj;
    BigInteger result = start;
    for (var i = start + 1; i < start + size; i++)
        result *= i;
    results[index] = result;
}

for (int i = 100_001; i <= 150_000; i = i + 1)
{
    i3 = -1;
    sum1 = 0;
    ii1 = i1 >> 1;
    i5 = i1;
 
    t1= new Thread(new ParameterizedThreadStart(ThreadProc1));
    t1.Start(i);
 
    while (i1 >= ii1)
    {
        i3++;
        sum = aa[i3 + i6, 0] * i + sum1;
        aa[i3, 1] = sum % j;
        sum1 = sum / j;
 
        if (i1 == ii1 && sum1 > 0)
        {
            while (t1.IsAlive == true)
            {
 
            }
            i3++;
            aa[i3, 1] = aa[i3, 1]+ sum1;
        } 
 
        i1--;
 
    }
 
    while(t1.IsAlive==true)
    {
 
    }
 
    i1 = j3;
    i6 = 0;
 
    while (aa[j3 - i1, 1] == 0)
    {
        i1--;
        i4++;
        i6++;
    }
...
}
...
public static void ThreadProc1(Object number)
{
    int ii = (int) number;
    j1 = ii1 - 1;
    j3 = i5-ii1;
    sumj1 = 0;
 
    while (j1 >= 0)
    {
        j3++;
        sumj = aa[j3 + i6, 0] * ii + sumj1;
        aa[j3, 1] = sumj % j;
        sumj1 = sumj / j;
        if (j1 == 0 && sumj1 > 0)
        {
            j3++;
            aa[j3, 1] = sumj1;
        }
      
        j1--;
 
    }
}

using System.Collections.Concurrent;
 
var act = (string item) => Console.WriteLine(item);
 
using ThreadedQueue<string> q = new(act);
for (int i = 0; i < 5; i++)
{
    q.Enqueue($"Nya! - {i}");
    await Task.Delay(TimeSpan.FromSeconds(1));
}
 
public class ThreadedQueue<T> : IDisposable
{
    private readonly Task _task;
    private readonly CancellationTokenSource _token;
    private readonly ConcurrentQueue<T> _queue;
    private readonly SemaphoreSlim _event;
    private readonly Action<T> _action;
    private bool disposed;
 
    public ThreadedQueue(Action<T> action)
    {
        disposed = false;
        _action = action;
        _queue = new ConcurrentQueue<T>();
        _event = new SemaphoreSlim(0, int.MaxValue);
        _token = new CancellationTokenSource();
        _task = Func();
    }
 
    public void Dispose()
    {
        disposed = true;
        _token.Cancel();
        _task.Wait();
    }
 
    public void Enqueue(T item)
    {
        if (disposed)
            throw new ObjectDisposedException(GetType().Name);
        _queue.Enqueue(item);
        _event.Release();
    }
 
    private async Task Func()
    {
        while (!_token.IsCancellationRequested)
        {
            try
            {
                await _event.WaitAsync(_token.Token);
                if (_queue.TryDequeue(out var item))
                    _action(item);
                else
                    throw new Exception("unexpected signal");
            }
            catch (OperationCanceledException)
            {
                if (!_token.IsCancellationRequested)
                    throw;
            }
        }
    }
}