# 多进程
# Windows下面没有fork ，请在linux下跑下面的代码
import os
print('Process (%s) start...' % os.getpid())
pid = os.fork()
if pid==0:
print('I am child process (%s) and my parent is %s' % (os.getpid(), os.getppid())
else:
print('I (%s) just created a child process(%s).' % (os.getpid(), pid))
# windows 下没有 fork，实现多进程要使用 multiprocessing 模块
from multiprocessing import Process
import os, time
def run_proc(name):
print('Run child process %s (%s)...' % (name, os.getpid()))
if __name__=='__main__':
print('Parent process %s.' % os.getpid())
p = Process(target=run_proc, args=('test',)) # target 将函数作为单个进程，args 是传参数
print('Child process will start.')
p.start() # 启动
p.join() # 等待子进程结束后继续运行
print('Child process is end.')
print('..................')
time.sleep(1)
# Pool
# 要启动大量的子进程，可以用进程池的方式批量创建子进程：
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(random.random() * 3) # random() 方法返回随机生成的一个实数，它在[0,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(3)
for i in range(4):
p.apply_async(long_time_task, args=(i,))
print('waiting for all subprocesses done...')
p.close()
p.join()
print('Done')
print('..................')
time.sleep(1)
# 对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。
# 进程间通信
# Python的multiprocessing模块包装了底层的机制，提供了Queue、Pipes等多种方式来交换数据。
# 参考链接：https://www.cnblogs.com/kaituorensheng/p/4445418.html#_label5
from multiprocessing import Process, Queue
import os, time, random
# 写数据进程执行的代码：
def write(q):
print('Process to write: %s' % os.getpid())
for value in ['a','b','c']:
print('Put %s to queue...' % value)
q.put(value)
time.sleep(random.random())
# 读
def read(q):
print('Process to read: %s' % os.getpid())
while True:
value = q.get(True)
print('Gets %s from queue.' % value)
if __name__ == '__main__':
# 父进程创建队列，传递给各个子进程
q = Queue()
pw = Process(target=write, args=(q,))
pr = Process(target=read, args=(q,))
pw.start()
pr.start()
pw.join()
pr.terminate() # pr进程里是死循环，无法等待其结束，只能强行终止:
print('Done')
print('..................')
time.sleep(1)
##############################################################
# 多线程
'''
多任务可以由多进程完成，也可以由一个进程内的多线程完成。
我们前面提到了进程是由若干线程组成的，一个进程至少有一个线程。
由于线程是操作系统直接支持的执行单元，因此，高级语言通常都内置多线程的支持，Python也不例外，并且，Python的线程是真正的Posix Thread，而不是模拟出来的线程。
'''
# Python的标准库中，绝大多数情况下，我们只需要使用threading这个高级模块。
# 启动一个线程就是把一个函数传入并创建Thread实例，然后调用start()开始执行：
import time, threading
# 新进程执行的代码：
def loop():
print('thread %s is running ...' % threading.current_thread().name)
n = 0
while n < 3:
n = n + 1
print('thread %s >>> %s' % (threading.current_thread().name,n))
time.sleep(1)
print('thread %s ended.' % threading.current_thread().name)
print('thread %s is running ...' % threading.current_thread().name)
t = threading.Thread(target=loop, name='LoopTread') # 子线程的名字在创建时指定，我们用LoopThread命名子线程。名字仅仅在打印时用来显示，完全没有其他意义
t.start()
t.join()
print('thread %s ended.' % threading.current_thread().name)
# 任何进程默认就会启动一个线程，我们把该线程称为主线程，主线程又可以启动新的线程
# current_thread()函数，它永远返回当前线程的实例。
# Lock
# 多线程和多进程最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响，
# 而多线程中，所有变量都由所有线程共享，所以，任何一个变量都可以被任何一个线程修改，因此，线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了。
# 假定这是你的银行存款:
balance = 0
def change_it(n):
# 先存后取，结果应该为0:
global balance # 告诉Python这个变量名不是局部的，而是 全局 的
###
balance = balance + n
balance = balance - n
### 这两句语句在一个线程里应该是要连续执行才对
def run_thread(n):
for i in range(5000000):
change_it(n)
t1 = threading.Thread(target=run_thread,args=(5,))
t2 = threading.Thread(target=run_thread,args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance) # 由于线程的调度是由操作系统决定的，当t1、t2交替执行时，只要循环次数足够多，balance的结果就不一定是0了。
print('Done.......................')
# 为函数 change_it 添加一个锁
# 当某个线程开始执行change_it()时，该线程因为获得了锁，因此其他线程不能同时执行change_it()，只能等待，直到锁被释放后，获得该锁以后才能执行。
balance = 0
lock = threading.Lock()
def run_thread(n):
for i in range(5000000):
# p(信号量)
lock.acquire()
try:
change_it(n)
finally:
# v(信号量)
lock.release()
print(balance)
print('Done.......................')
