python怎么并行

python怎么并行

为了保证多线程数据安全，python语言的设计中，有个全局解释锁GIL(global interpretor lock)，每个线程在开始运行时必须获得锁，遇到I/O或sleep挂起时释放锁，从而保证同一时刻只有一个线程在运行，多个线程在不同的时间片上执行，达到多任务的目的，使python具有 并发 能力，使得python可以充分使用CPU的单个核心。多线程并发在python网络爬虫中使用普遍，可以一次性开启大量下载任务，而大部分任务都在等待I/O的状态，比单线程速度快很多倍，另外，使用协程也能达到到多线程的的效果。
很多时候我们希望提高效率，充分利用多核CPU的优势，同时执行多个任务，做到多任务 并行，应该怎样做呢？既然绕不开GIL，解决方案有：

1. 使用多进程，开启多个python实例，使用进程池
2. 用C/C++写出多线程代码，通过cython调用；或者将C/C++编译成dll文件(linux下为so文件)，通过ctypes模块直接调用其中的代码；用python的C接口写拓展，或者用Boost.Python等。
3. 换解释器，不用C语言版的Pyhton，而是使用jpython(java)，pypy(python)，ironpython(C#)等

note: python2中单个线程每执行固定字节码后会主动释放GIL锁，python3中改为每隔固定时间主动释放GIL锁。

python多线程demo

import time
from threading import Thread
def countdown(n):
    while n > 0:
        n -= 1

count = 2e7
start = time.time()
n_threads = 10 # 线程数
threads = [Thread(target=countdown, args=(count//n_threads,)) for i in range(n_threads)] 
for t in threads: t.start() # 启动多个线程
for t in threads: t.join() # 等待线程结束
print(time.time() - start)

在多核CPU上运行上述代码，无论线程数是1还是10，运行时间几乎相同，多线程不能利用多核优势提高效率。

python多进程demo

import time
import os
from multiprocessing import Pool
def countdown(n):
    while n > 0:
        n -= 1

if __name__ == "__main__":
    count = 2e7
    start = time.time()
    # n_processes = os.cpu_count()
    n_processes = 8 # 进程数 
    pool = Pool(processes=n_processes) # 进程池 
    for i in range(n_processes): 
        pool.apply_async(countdown, (count//n_processes,)) # 启动多进程 
    pool.close() # 使进程池不能添加新任务 
    pool.join() # 等待进程结束 
    print(time.time() - start)

在多核CPU上运行，两个进程明显比1个快，效率差异明显，但多进程的系统开销也更大。
note: 在windows上执行时，多进程代码一定要放在if __name__ == '__main__':里面执行，否则，这些全局表达式在子进程中也会执行，从而导致不断生成大量进程，直到崩溃，这一点与linux中通过fork调用实现多进程是完全不同的。

cython多线程demo

多进程系统开销大，而且python这种动态语言执行效率不高，即使用多进程仍然可能面临性能瓶颈，这时候可以利用C/C++语言的优势，将关键部分重写，从python调用，通过C/C++还可以直接使用不受GIL制约的多线程，提高代码性能。
为了测试，用C语言写个简单死循环，发现只能利用1个核，为了最大化利用CPU，还得上多线程，创建多线程需要利用操作系统提供的内核方法，在linux和windows的实现上存在差异。

linux多线程demo

// mthread_linux.c
#include 
#include 

int thread_run(int thread_id)
{
    int s = 0;
    printf("thread %i started...\n", thread_id);
    for (size_t i = 0; i < 4000000000; i++)
        for (size_t j = 0; j < 5; j++)
            s += j;
    printf("%i: %d\n", thread_id, s);
    int ret = thread_id;
    return ret;
}

int main()
{
    const size_t num_threads = 8;
    // pthread_t threads[num_threads];
    pthread_t threads[8];
    for (size_t i = 0; i < num_threads; i++)
    {
        int t_id = i+1;
        pthread_create(threads + i, NULL, (void *)&thread_run, (void *)t_id);
        printf("thread %lu created\n", i + 1);
    }

    for (size_t i = 0; i < num_threads; i++)
    {
        void *ret_val;
        int exit_code = pthread_join(threads[i], &ret_val);
        printf("thread %lu exited with %d and returned %d.\n", i + 1, exit_code, (int)ret_val);
    }
    return 0;
}

// 编译命令 && 运行命令
// gcc mthreads_linux.c -lpthread && ./a.out

用gcc编译就好，8线程下来，家用机CPU接近100%了

windows多线程demo

// mthread_windows.cpp
#include 
#include 

DWORD WINAPI thread_run(LPVOID lp_thread_id)
{
	int thread_id = *(int*)lp_thread_id;
	int s = 0;
	printf("thread %i started...\n", thread_id);
	for (size_t i = 0; i < 4000000000; i++) 
		for (size_t j = 0; j < 5; j++) 
			s += j;
	printf("%i: %d\n", thread_id, s);
	int ret = thread_id;
	return ret;
}

int main()
{
	const size_t num_threads = 8;
	// HANDLE threads[num_threads];
	HANDLE threads[8];
	for (size_t i = 0; i < num_threads; i++)
	{
		int t_id = i + 1;
		threads[i] = CreateThread(NULL, 0, thread_run, &t_id, 0, NULL);
		printf("thread %lu created\n", i + 1);
	}

	for (size_t i = 0; i < num_threads; i++)
	{
		int exit_code = WaitForSingleObject(threads[i], INFINITE);
		printf("thread %lu exited with %d.\n", i + 1, exit_code);
	}
	getchar();
	return 0;
}

用Visual Studio自带的MSVC编译运行，同样，跑起来CPU也接近100%了

cython的简单使用

cython是一种语言，语法是C语言和python的混合体，不能单独执行，代码文件后缀为.pyx，.pyx文件需要翻译成.c文件，然后由C语言编译器生成目标文件，后缀为.so(linux)或.pyd(windows)，在python解释器中可以直接import调用。
根据缩写代码的语法，会按照C模式运行或Python模式运行，完全按照C模式运行会有极高的效率，根据cython的官方文档，使用cython最简单的例子只需四步：
(1). 编写cython文件(hello.pyx)

def say_hello_to(name):
    print("Hello %s!" % name)

(2). 编写用来编译hello.pyx的文件(setup.py)

from distutils.core import setup
from Cython.Build import cythonize

setup(
    name="hello module",
    ext_modules=cythonize("hello.pyx")
)

(3). 执行python setup.py build_ext --inplace，该步骤生成hello.cp36-win_amd64.pyd文件(windows,python36,64bit)
不用理会中间这一串，编译要求电脑上装了Visual Studio(Windows)或gcc(linux)

(4). 打开python解释器中执行from hello import say_hello_to

cython调用C语言编写的代码

如何利用上述windows下多线程代码充分使用cpu，同样是四步：
(1). 编写cython文件(demo.pyx)，引用mthread_windows.cpp中的函数，将其包裹在python函数_main内

cdef extern from "mthread_windows.cpp":
    int main()

def _main():
    main()

(2). 编写用来编译demo.pyx的文件(setup.py)

from distutils.core import setup
from Cython.Build import cythonize

setup(
    name="demo module",
    ext_modules=cythonize("demo.pyx")
)

(3). 执行python setup.py build_ext --inplace，该步骤生成demo.cp36-win_amd64.pyd文件(windows,python36,64bit)

(4). 打开python解释器中执行from demo import _main