Устранение узкого места в многопоточной программе

''' Counting specified key sequence in the specified file
and printing result to the standard output with elapsed time '''
 
import sys
import argparse
import threading
import queue
 
from timeit import default_timer as timer
 
def worker(lines_slice, keyseq, results):
    counter = 0
 
    # подсчет количества совподений в каждой строке
    for line in lines_slice:
        counter += line.count(keyseq)
 
    # сохранение результата подсчета в очереде
    results.put(counter)
 
def main(argv_slice):
    res = 0
 
    # разбор аргументов командной строки
    parser = argparse.ArgumentParser(
        description='Counting key sequence in the file')
 
    parser.add_argument('-f', '--fpath', type=str, required=True,
                        help='File path to reading')
    parser.add_argument('-k', '--keyseq', type=str, required=True,
                        help='Key sequence to counting')
 
    parsed_argv = parser.parse_args(argv_slice)
 
    fpath = parsed_argv.fpath
    keyseq = parsed_argv.keyseq
 
    with open(fpath) as fin:
        start = timer()
 
        # считывание всего содержимого исходного файла
        lines = fin.readlines()
 
        # создание очереди для хранения результатов
        results = queue.Queue()
 
        threads_list = [] # список потоков
 
        lines_slices = [] # список ссылок на данные
 
        threads_count = 1; # 4
 
        thread_part = len(lines) / threads_count
 
        # цикл инициализации и создания потоков выполнения
        for thread_index in range(0, threads_count):
            from_index = thread_index * int(thread_part)
 
            if thread_index != threads_count - 1:
                to_index = from_index + int(thread_part)
            else:
                to_index = len(lines)
 
            # создание дополнительной ссылки на данные для каждого потока !!!
            lines_slices.append(lines[from_index:to_index])
 
            # сохранение дескриптора потока в списке потоков
            threads_list.append(threading.Thread(target=worker,
                                                 args=(lines_slices[thread_index],
                                                       keyseq, results)))
 
            threads_list[thread_index].start()
 
        # ожидание завершения потоков выполнения
        for thread_index in range(0, threads_count):
            threads_list[thread_index].join()
 
        custom_counter = 0
 
        # расчет окончательного результата подсчета
        for thread_index in range(0, threads_count):
            custom_counter += results.get()
 
        elapsed = timer() - start # расчет затраченного времени на вычисление
 
    print('Counter: {}'.format(custom_counter))
    print('Elapsed: {}'.format(elapsed))
    
    return res
 
if __name__ == '__main__':
    sys.exit(main(sys.argv[1:]))