Multiprocessing и тормозящий поток

 StartTime = time.clock()
 
        Ticks = []
 
        for line in open('ticks.txt'):
            Ticks.append(float(line))
 
        worker_count = cpu_count()
        print ("worker_count",worker_count)
        print("worker_count-2", worker_count-1)
 
        Steps =  (EndInaquality - StartInaquality)//(worker_count-1)
        IncrementStepValue = (EndInaquality - StartInaquality)//(worker_count-1)
        print("IncrementStepValue:",IncrementStepValue)
 
        tmpStartValueLWMA1 = StartValueLWMA1
        tmpStartValueLWMA2 = StartValueLWMA2
        tmpStartInaquality = StartInaquality
        tmpEndInaquality = tmpStartInaquality + IncrementStepValue
 
        num = 0
        jobs = []
        for i in range(worker_count-1):
 
            p = Process(target=Calculate, args=(num,StartTime,Stats,Ticks,Steps,tmpStartValueLWMA1,StartValueLWMA1,
                    EndValueLWMA1,tmpStartValueLWMA2,StartValueLWMA2,EndValueLWMA2,tmpStartInaquality,tmpEndInaquality))
            jobs.append(p)
            p.start()
            num += 1
            tmpStartInaquality += IncrementStepValue
            print("tmpStartInaquality += IncrementStepValue:",tmpStartInaquality)
            if(tmpEndInaquality > EndInaquality):
                tmpEndInaquality = EndInaquality
                print("tmpEndInaquality = EndInaquality:",tmpEndInaquality)
            else:
                tmpEndInaquality += IncrementStepValue
                print("tmpEndInaquality += IncrementStepValue:",tmpEndInaquality)
 
 
            print (p)
 
        for w in jobs:
            w.join()
            print (w)

import math
import dask
from dask import compute, delayed
import dask.multiprocessing
import os
 
def func(i):
    #print("[ProcessID %d] Task for row %d" % (os.getpid(), i))
    res = math.factorial(i) # задача имитирующая длительное вычисление
    return res # какой-то результат вычисления, который мы возвращаем
    
 
if __name__ == "__main__":    
    import time
    n_tasks = 10000
    
    # обычный с последовательным выполнением кода  single-threaded
    start = time.time()
    # создаем список n_tasks однотипных задач
    values = [delayed(func)(x) for x in range(n_tasks)]
    results = compute(*values, scheduler='single-threaded')
    #print(results)
    print('ELAPSED single-thread:', time.time() - start) 
    #------------------------------------------------------------
    input("Нажмите для продолжения")
    #------------------------------------------------------------
    
    # многопроцессный вариант - используются все ядра по умолчанию
    start = time.time()
    # создаем список n_tasks однотипных задач
    values = [delayed(func)(x) for x in range(n_tasks)]
    results = compute(*values, scheduler='processes')
    #print(results)
    print('ELAPSED processes:', time.time() - start) 
    
    #------------------------------------------------------------
    input("Нажмите для продолжения")
    #------------------------------------------------------------
 
    # многопоточный вариант - не дает никаких преимуществ для вычислений так как GIL
    start = time.time()
    # создаем список n_tasks однотипных задач
    values = [delayed(func)(x) for x in range(n_tasks)]
    results = compute(*values, scheduler='threads')
    #print(results)
    print('ELAPSED threads:', time.time() - start)