Как использовать многопоточность для улучшения производительности в Python

Приведет ли многопоточность к реальному увеличению производительности, зависит не только от реализации в Python и объема данных, но также от аппаратного обеспечения, выполняющего программу. В некоторых случаях, когда аппаратное обеспечение не дает никаких преимуществ, многопоточность может привести к замедлению работы из-за увеличения накладных расходов.

Однако, если вы работаете на современном стандартном ПК или лучше, вы можете увидеть некоторые улучшения с многопоточностью. Задача состоит в том, чтобы создать ряд работников, передать им работу и собрать результаты.

Оставайтесь ближе к вашему примеру структуры, реализации и именования:

import re
import queue
import threading

sentences = ['data mining is the process of discovering patterns in large data sets involving methods at the intersection of machine learning statistics and database systems',
             'data mining is an interdisciplinary subfield of computer science and statistics with an overall goal to extract information from a data set and transform the information into a comprehensible structure for further use',
             'data mining is the analysis step of the knowledge discovery in databases process or kdd']

concepts = ['data mining', 'database systems', 'databases process',
            'interdisciplinary subfield', 'information', 'knowledge discovery',
            'methods', 'machine learning', 'patterns', 'process']

re_concepts = [re.escape(t) for t in concepts]

find_all_concepts = re.compile('|'.join(re_concepts), flags=re.DOTALL).findall


def do_find_all_concepts(q_in, l_out):
    while True:
        sentence = q_in.get()
        l_out.append(find_all_concepts(sentence))
        q_in.task_done()


# Queue with default maxsize of 0, infinite queue size
sentences_q = queue.Queue()
output = []

# any reasonable number of workers
num_threads = 2
for i in range(num_threads):
    worker = threading.Thread(target=do_find_all_concepts, args=(sentences_q, output))
    # once there nothing but daemon threads left, Python exits the program
    worker.daemon = True
    worker.start()

# put all the input on the queue
for s in sentences:
    sentences_q.put(s)

# wait for the entire queue to be processed
sentences_q.join()
print(output)

Пользователь @wwii спросил о нескольких потоках, не влияющих на производительность для проблем с процессором. Вместо использования нескольких потоков, обращающихся к одной и той же выходной переменной, вы также можете использовать несколько процессов, получить доступ к общей очереди вывода, например:

import re
import queue
import multiprocessing

sentences = [
    'data mining is the process of discovering patterns in large data sets involving methods at the intersection of machine learning statistics and database systems',
    'data mining is an interdisciplinary subfield of computer science and statistics with an overall goal to extract information from a data set and transform the information into a comprehensible structure for further use',
    'data mining is the analysis step of the knowledge discovery in databases process or kdd']

concepts = ['data mining', 'database systems', 'databases process',
            'interdisciplinary subfield', 'information', 'knowledge discovery',
            'methods', 'machine learning', 'patterns', 'process']

re_concepts = [re.escape(t) for t in concepts]

find_all_concepts = re.compile('|'.join(re_concepts), flags=re.DOTALL).findall


def do_find_all_concepts(q_in, q_out):
    try:
        while True:
            sentence = q_in.get(False)
            q_out.put(find_all_concepts(sentence))
    except queue.Empty:
        pass


if __name__ == '__main__':
    # default maxsize of 0, infinite queue size
    sentences_q = multiprocessing.Queue()
    output_q = multiprocessing.Queue()

    # any reasonable number of workers
    num_processes = 2
    pool = multiprocessing.Pool(num_processes, do_find_all_concepts, (sentences_q, output_q))

    # put all the input on the queue
    for s in sentences:
        sentences_q.put(s)

    # wait for the entire queue to be processed
    pool.close()
    pool.join()
    while not output_q.empty():
        print(output_q.get())

Еще больше накладных расходов, но с использованием ресурсов ЦП, доступных и на других ядрах.

Вот два решения, использующие concurrent.futures.ProcessPoolExecutor, который будет распределять задачи по разным процессам. Ваша задача связана с процессором, а не с вводом/выводом, поэтому потоки, вероятно, не помогут.

import re
import concurrent.futures

# using the lists in your example

re_concepts = [re.escape(t) for t in concepts]
all_concepts = re.compile('|'.join(re_concepts), flags=re.DOTALL)

def f(sequence, regex=all_concepts):
    result = regex.findall(sequence)
    return result

if __name__ == '__main__':

    out1 = []
    with concurrent.futures.ProcessPoolExecutor() as executor:
        futures = [executor.submit(f, s) for s in sentences]
        for future in concurrent.futures.as_completed(futures):
            try:
                result = future.result()
            except Exception as e:
                print(e)
            else:
                #print(result)
                out1.append(result)   

    out2 = []
    with concurrent.futures.ProcessPoolExecutor() as executor:
        for result in executor.map(f, sentences):
            #print(result)
            out2.append(result)

Executor.map() имеет параметр chunksize: в документах говорится, что отправка кусков, содержащих более одного элемента итерируемого, может быть полезной. Функция должна быть реорганизована для учета этого. Я протестировал это с помощью функции, которая просто возвращала бы то, что было отправлено, но независимо от размера фрагмента, который я указал, тестовая функция возвращала только отдельные элементы. Figure пойди разберись?

def h(sequence):
    return sequence

Один из недостатков многопроцессорной обработки заключается в том, что данные должны быть сериализованы/обработаны для отправки в процесс, что занимает много времени и может быть значительным для такого большого скомпилированного регулярного выражения - это может свести на нет выгоды от нескольких процессов.

Я сделал набор из 13e6 случайных строк по 20 символов в каждой, чтобы приблизиться к вашему скомпилированному регулярному выражению.

data =set(''.join(random.choice(string.printable) for _ in range(20)) for _ in range(13000000))

Выборка для потока io.BytesIO занимает около 7,5 секунд, а удаление из потока io.BytesIO - 9 секунд. Если используется многопроцессорное решение, может быть выгодно один раз протолкнуть объект концепта (в любой форме) на жесткий диск, а затем каждый процесс отрывать от жесткого диска вместо того, чтобы проталкивать/отрывать на каждой стороне IPC каждый раз новый процесс. создан, безусловно, стоит попробовать - YMMV. На моем жестком диске маринованный набор - 380 МБ.

Когда я пытался провести некоторые эксперименты с concurrent.futures.ProcessPoolExecutor, я продолжал взрывать свой компьютер, потому что каждому процессу требовалась своя копия набора, а на моем компьютере просто не было оперативной памяти.

Я собираюсь опубликовать еще один ответ, касающийся метода тестирования понятий в предложениях.