对多进程的补充

对比下面两段代码

>>> if __name__=='__main__':
...     print('Parent process %s.' % os.getpid())
...     p = Process(target=run_proc, args=('test',))
...     print('Child process will start.')
...     p.start()
...     p.join()
...     print('Child process end.')
... 
Parent process 2404.
Child process will start.
Run child process test (2414)...
Child process end.```

if name=='main':
... print('Parent process %s.' % os.getpid())
... p = Process(target=run_proc, args=('test',))
... print('Child process will start.')
... p.start()
... #p.join()
... print('Child process end.')
...
Parent process 2404.
Child process will start.
Child process end.
Run child process test (2415)...

1.`join()`方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。
否则会先同步进行，子程序后面的父程序部分就会提前运行。
2.上一篇笔记的问题中，fork的时候是直接同时运行了两个程序，但是只有一个界面显示，所以才会出现上一篇笔记所说的结果。
所以一般用py文件来运行
3.Pool的默认大小是CPU的核数。

import time
from multiprocessing import Pool

def A():
for i in range(2):
print(i)
time.sleep(1)

pool = Pool(3) #定义进程池大小
for i in range(6):
pool.apply_async(A)

以上循环在命令行界面会输出六个函数类型，但其实在py文件中是没有输出的

pool.close() #关闭Pool，使其不再接受新的任务，并不是退出子程序的意思
pool.join() #主进程阻塞，等待子进程的退出 否则会把主进程和子进程同时运行，那么就会把p.join 后面的内容同时打印。这样可以等子进程结束后在打印后面内容

pool.join()和process的join不同

一个必须要start后才可以join，一个必须要close后才可以join

####多线程

from multiprocessing import Pool
import os, time, random

def long_time_task(name):
print('Run task %s (%s)...' % (name, os.getpid()))
start = time.time()
time.sleep(1)
end = time.time()
print('Task %s runs %0.2f seconds.' % (name, (end - start)))

if name=='main':
print('Parent process %s.' % os.getpid())
p = Pool(4)
for i in range(5):
p.apply_async(long_time_task, args=(i,))
print('Waiting for all subprocesses done...')
p.close()
p.join()
print('All subprocesses done.')

结果：

Parent process 2439.
Waiting for all subprocesses done...
Run task 0 (2440)...
Run task 1 (2441)...
Run task 2 (2442)...
Run task 3 (2443)...
Task 3 runs 1.00 seconds.
Task 1 runs 1.00 seconds.
Task 0 runs 1.00 seconds.
Task 2 runs 1.00 seconds.
Run task 4 (2440)...
Task 4 runs 1.00 seconds.
All subprocesses done.

1.由于任何进程默认就会启动一个线程，我们把该线程称为主线程，主线程又可以启动新的线程，Python的threading模块有个current_thread()函数，它永远返回当前线程的实例。
2.主线程实例的名字叫MainThread，子线程的名字在创建时指定，我们用LoopThread命名子线程。名字仅仅在打印时用来显示，完全没有其他意义，如果不起名字Python就自动给线程命名为Thread-1，Thread-2……
3.threading的thread 就相当于  multiprocessing中的Process
4.线程的调度是由操作系统决定的

t = threading.Thread(target=loop, name='LoopThread')
t.start()
t.join()

同一进程的两个线程可以同时更改一个变量。如果我们要确保计算正确，就要给函数上一把锁，该线程因为获得了锁，因此其他线程不能同时执行只能等待，直到锁被释放后，获得该锁以后才能改。由于锁只有一个，无论多少线程，同一时刻最多只有一个线程持有该锁，所以，不会造成修改的冲突。创建一个锁就是通过threading.Lock()来实现：

balance = 0
lock = threading.Lock()

def run_thread(n):
for i in range(100000):
# 先要获取锁:
lock.acquire()
try:
# 放心地改吧:
change_it(n)
finally:
# 改完了一定要释放锁:
lock.release()

这里上锁的是代码

当多个线程同时执行`lock.acquire()`时，只有一个线程能成功地获取锁，然后继续执行代码，其他线程就继续等待直到获得锁为止。
获得锁的线程用完后一定要释放锁，否则那些苦苦等待锁的线程将永远等待下去，成为死线程。所以我们用`try...finally`来确保锁一定会被释放。

锁的好处就是确保了某段关键代码只能由一个线程从头到尾完整地执行，坏处当然也很多，首先是阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了。其次，由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁，导致多个线程全部挂起，既不能执行，也无法结束，只能靠操作系统强制终止。
**所以最好不要同时用多把锁**


另外，Python解释器由于设计时有GIL全局锁，导致了多线程无法利用多核。
Python虽然不能利用多线程实现多核任务，但可以通过多进程实现多核任务。多个Python进程有各自独立的GIL锁，互不影响。