廖雪峰Python学习笔记day9

学习笔记day8

# python study day9

# 进程和线程。实现多任务的方式
# 1、多进程模式
# 2、多线程模式
# 3、多进程+多线程模式

# multiprocessing 跨平台多进程模块。Unix/Linux/Mac环境下可以使用fork创建子进程
# from multiprocessing import Process
# import os
# def run_proc(name): # 子程序要执行的代码
#     print('Parent process %s (%s)...' % (name, os.getpid))
# 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 928.
# # Child process will start.
# # Run child process test (929)...
# # Process end.
# 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)
#     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() # 需要在join之前，调用后不能再添加process
#     p.join() # 同步，等待所有子进程结束
#     print('All subprocesses done.') #>>>
#     Parent process 22900.
# # Waiting for all subprocesses done...
# # Run task 0 (19656)...
# # Run task 1 (10880)...
# # Run task 2 (11372)...
# # Run task 3 (19780)...
# # Task 2 runs 0.35 seconds.
# # Run task 4 (11372)...
# # Task 0 runs 0.83 seconds.
# # Task 3 runs 1.03 seconds.
# # Task 4 runs 1.10 seconds.
# # Task 1 runs 2.25 seconds.
# # All subprocesses done.
# 进程间的通信通过Queue、Pipes实现
# from multiprocessing import Process, Queue
# import os, time, random
# def write(q): # 写数据进程执行代码
#     print('Process to write: %s' % os.getpid())
#     for value in [1, 2, 3]:
#         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('get %s from queue.' % value)
# if __name__ == '__main__':
#     q = Queue() # 父进程创建Queue, 并传给各个子进程
#     pw = Process(target=write, args=(q,))
#     pr = Process(target=read, args=(q,))
#     pw.start() # 启动子进程pw, 写入
#     pr.start() # 启动pr, 读取
#     pw.join()
#     pr.terminate() # pr进程死循环，强行终止 >>>
# # Process to write: 9468
# # put 1 to queue...
# # process to read: 18696
# # get 1 from queue.
# # put 2 to queue...
# # get 2 from queue.
# # put 3 to queue...
# # get 3 from queue.

# 多线程，python提供低级的_thread和高级的threading模块，常用threading
# import time,threading
# def son_thread_task():
#     for i in range(5):
#         print(threading.current_thread().name, i)
#         time.sleep(1)
# print(threading.current_thread().name, 'running')
# son_thread = threading.Thread(target=son_thread_task, name='sonthread')
# son_thread.start()
# son_thread.join()
# print(threading.current_thread().name, 'end') #>>>
# # MainThread running
# # sonthread 0
# # sonthread 1
# # sonthread 2
# # sonthread 3
# # sonthread 4
# # MainThread end
# Lock 线程安全
# import time, threading
# balance = 0 # 全局银行存款变量
# lock = threading.Lock()
# def balance_saveAndGet(money):
#     global balance
#     balance = balance + money
#     balance = balance - money
# def run_thread(money):
#     for i in range(2000000):
#         lock.acquire() # 获取锁后再修改
#         try:
#             balance_saveAndGet(money)
#         finally:
#             lock.release() # 释放锁。with threading.Lock() as lock:……
# def main():
#     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 now is:', balance)
# if __name__ == '__main__':
#     main()'
# python 因为解析器设计时有GIL全局锁导致多线程无法利用多核，不过可以考虑多进程代替

# ThreadLocal 全局线程变量，每个线程只能读写自己线程，互不干扰。
# 解决了线程内多函数之间相互传递参数的问题。
# import threading
# local_school = threading.local() # 创建全局ThreadLocal对象, 可以看作是dict
# def process_student():
#     std = local_school.student # 获取当前线程的student
#     print(std, threading.current_thread().name)
# def process_thread(name):
#     local_school.student = name # 使用ThreadLocal绑定线程的student
#     process_student()
# t1 = threading.Thread(target=process_thread, args=('Alice',),name='threada')
# t2 = threading.Thread(target=process_thread, args=('Bob',),name='threadb')
# t1.start()
# t2.start()
# t1.join()
# t2.join() #>>>
# # Alice threada
# # Bob threadb

# 单线程的异步编程模型称为协程
# 在Thread和Process中当应优选Process
# Process可以分布到多台机械上，Thread最大只能分布到多个CPU上
# managers模块通过网络暴露Queue可以实现分布式进程
# task_worker.py
# import time, sys, queue
# from multiprocessing.managers import BaseManager
# # 创建类似的QueueManager:
# class QueueManager(BaseManager):
#     pass
# # 由于这个QueueManager只从网络上获取Queue，所以注册时只提供名字:
# QueueManager.register('get_task_queue')
# QueueManager.register('get_result_queue')
# # 连接到服务器，也就是运行task_master.py的机器:
# server_addr = '127.0.0.1'
# print('Connect to server %s...' % server_addr)
# # 端口和验证码注意保持与task_master.py设置的完全一致:
# m = QueueManager(address=(server_addr, 5000), authkey=b'abc') #authkey连接标识
# # 从网络连接:
# m.connect()
# # 获取Queue的对象:
# task = m.get_task_queue()
# result = m.get_result_queue()
# # 从task队列取任务,并把结果写入result队列:
# for i in range(10):
#     try:
#         n = task.get(timeout=1)
#         print('run task %d * %d...' % (n, n))
#         r = '%d * %d = %d' % (n, n, n*n)
#         time.sleep(1)
#         result.put(r)
#     except Queue.Empty:
#         print('task queue is empty.')
# # 处理结束:
# print('worker exit.')

学习笔记day10