五：并发模块:
1.多线程：
每个进程一定要有一个线程 启动程序默认都会要一个主线程
进程是资源单位，线程是执行单位。
例子：
1.学习的例子
#不是2线程的例子：下面
# def fun():
# for i in range(1000):
# print("func",i)
# if __name__ == '__main__':
# fun()
# for i in range(1000):
# print("main",i)
#多线程
#第一种
from threading import Thread
#
# def fun():
# for i in range(1000):
# print("func",i)
# if __name__ == '__main__':
# t = Thread(target=fun) #分配线程
# t.start() #开始的状态为可以开始的状态，具体的执行时间要看cpu决定
#
# for i in range(1000):
# print("main",i)
#第二种
class myThread(Thread):#继承Thread 父类重写父类的方法
def run(self):#固定的、
for i in range(1000):
print("子线程",i)
if __name__ == '__main__':
t=myThread()
# t.run()#发法的调运单线程
t.start()
for i in range(1000):
print("主线程",i)
2.北京新发地：
# 指定url
# 分析url
# http://www.xinfadi.com.cn/getPriceData.html(数据）
# http://www.xinfadi.com.cn/priceDetail.html #发现只是一个页面的框架然后动态的加载不同的数据
import requests
import csv
from concurrent.futures import ThreadPoolExecutor
# 定义变量
url = 'http://www.xinfadi.com.cn/getPriceData.html'
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.102 Safari/537.36",
'Referer': "http://www.xinfadi.com.cn/priceDetail.html"
}
# 保存文件
f = open("data_1.csv", mode="w", encoding="utf-8")
csvwriter = csv.writer(f)
def down_one_page(url, i):
num = format(i)
# 存放表格数据
# prodName=[]#菜名
# lowPrice=[]#最低价格
# highPrice=[]#最高价格
# avgPrice=[]#平均价格
# place=[]#产地
# unitInfo=[]#单位
result = []
# for num in range(3):
# page = str(num)
params = {
"limit": "20",
"current": num,
"pubDateStartTime": "",
"pubDateEndTime": "",
"prodPcatid": "",
"prodCatid": "",
"prodName": "",
}
# 发起请求
resp = requests.post(url, params=params, headers=headers)
# print(resp.text)
# 获得相应数据
ret = resp.json()
# print(resp.text)
# 数据解析
# 处理字典
ret_1 = ret["list"]
for it in ret_1:
result.append(it['prodName'])
result.append(it['lowPrice'])
result.append(it['highPrice'])
result.append(it['avgPrice'])
result.append(it['place'])
result.append(it['unitInfo'])
result.append('\n')
csvwriter.writerow(result)
result = []
ret_1 = []
if __name__ == '__main__':
with ThreadPoolExecutor(10) as t:
for i in range(1, 50):
down_one_page(url, i)
print(url+"over")
2.多进程
例子：
1.学习的例子
# from multiprocessing import Process
#
# def fun():
# for i in range(1000):
# print("子进程",i)
#
# if __name__ == '__main__':
# p = Process(target=fun)
# p.start()
# for i in range(1000):
# print("主线程",i)
from threading import Thread
# class myThread(Thread):
# def run(self):
def func(name):
for i in range(1000):
print("子进程",i)
if __name__ == '__main__':
t1 = Thread(target=func,args=("周杰伦",))#传参必须是元组
t1.start()
t2 =Thread(target=func,args=("王力宏",))
t2.start()
线程池
例子：
#线程池：一次性开辟一些线程，我们用户直接给线程池子提交任务。线程的任务交给线程池来完成
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def fn(name):
for i in range(1000):
print(name,i)
if __name__ == '__main__':
#创建线程池
with ThreadPoolExecutor(50) as t:
for i in range(1000):
t.shutdown(fn,name="线程{i}")#加f
#等待线程池中的任务全部执行完成，才能继续执行（守护）
print("123")
""""
多线程的使用：
import threading
def func(x):
print(x)
t= threading.Thread(target=func,args=(12,))
# 线程启动
t.start()
# 主进程阻塞，等待子进程的退出
t.join()
# 设置线程为主线程的守护线程
t.setDaemon()
多进程的使用
from multiprocessing import Process
def func(x):
print(x)
p = Process(target=func,args=(12,))
p.start()# 启动子进程实例(创建子进程)
p.is_alive()# 判断进程子进程是否还在活着
p.join(timeout)# 是否等待子进程执行结束，或者等待多少秒
p.terminate()# 不管任务是否完成，立即终止子进程
p.daemon = True # 设置守护进程
线程池、进程池的使用：
# 进程池
from multiprocessing import Pool
# 线程池
from multiprocessing.dummy import Pool
pool = Pool(5) # 同时最大运行线程或者进程个数
def _excute(x,y):
print(x+y)
def _callback(self, temp): # temp必有参数
print("线程或进程任务完成后的回调")
pool.apply_async(target=_excute, callback=_callback)
poll.close()# 关闭Pool，使其不再接受新的任务；
poll.terminate()# 不管任务是否完成，立即终止；
poll.join()# 主进程阻塞，等待子进程的退出,必须在close或terminate之后使用
进程或者线程的间通信工具--Queue
# 线程池、多线程 使用的Queue
from queue import Queue
# 多进程使用的queue
from multiprocessing import JoinableQueue as Queue
# 进程池使用的queue
from multiprocessing import Manager
queue = Manager().Queue()
queue = Queue()
queue.qsize()# 返回当前队列包含的消息数量。
queue.empty()# 如果队列为空，返回True,反之False。
queue.full()# 如果队列满了，返回True，反之False。
queue.put(item, block=True, timeout=None)
将item消息写入队列，block默认值为True；
如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停
在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛
出"Queue.Full"异常；
如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常；
queue.get(item, block=True, timeout=None)
获取队列中的一条消息，然后将其从队列中移除，block默认值为True。如果block使用默认值，且没有设置
timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果
设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常；
如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常；
# get方法并不能让queue的计数-1，必须调用task_done
queue.task_done()
"""
浙公网安备 33010602011771号