网络编程

#!/usr/bin/env python

-- coding:utf-8 --

解耦 ：修改 复用 可读性

把写在一起的大的功能分开成多个小的功能处理

登陆 注册

进程

# 一个进程就是一个生产者
# 一个进程就是一个消费者

队列

# 生产者和消费者之间的容器就是队列

import time
import random
from multiprocessing import Process,Queue

def producer(q,name,food):
for i in range(10):
time.sleep(random.random())
fd = ‘%s%s’%(food,i)
q.put(fd)
print(’%s生产了一个%s’%(name,food))

def consumer(q,name):
while True:
food = q.get()
if not food:break
time.sleep(random.randint(1,3))
print(’%s吃了%s’%(name,food))

def cp(c_count,p_count):
q = Queue(10)
for i in range(c_count):
Process(target=consumer, args=(q, ‘alex’)).start()
p_l = []
for i in range(p_count):
p1 = Process(target=producer, args=(q, ‘wusir’, ‘泔水’))
p1.start()
p_l.append(p1)
for p in p_l:p.join()
for i in range(c_count):
q.put(None)
if name == ‘main’:
cp(2,3)

#!/usr/bin/env python

-- coding:utf-8 --

from multiprocessing import Process,Queue
import requests

import re
import json
def producer(q,url):
response = requests.get(url)
q.put(response.text)

def consumer(q):
while True:
s = q.get()
if not s:break
com = re.compile(
‘

. ?

.?<em . ?>(?P\d+).? (?P’
'.?<span class=“rating_num” . ?>(?P<rating_num>.?). ?(?P<comment_num>.?)评价’, re.S)
ret = com.finditer(s)
for i in ret:
print({
“id”: i.group(“id”),
“title”: i.group(“title”),
“rating_num”: i.group(“rating_num”),
“comment_num”: i.group(“comment_num”)}
)

if name == ‘main’:
count = 0
q = Queue(3)
p_l = []
for i in range(10):
url = ‘https://movie.douban.com/top250?start=%s&filter=’%count
count+=25
p = Process(target=producer,args=(q,url,)).start()
p_l.append§
p = Process(target=consumer, args=(q,)).start()
for p in p_l:p.join()
q.put(None)

#!/usr/bin/env python

-- coding:utf-8 --

import time
import random
from multiprocessing import JoinableQueue,Process

def producer(q,name,food):
for i in range(10):
time.sleep(random.random())
fd = ‘%s%s’%(food,i)
q.put(fd)
print(’%s生产了一个%s’%(name,food))
q.join()

def consumer(q,name):
while True:
food = q.get()
time.sleep(random.random())
print(’%s吃了%s’%(name,food))
q.task_done()

if name == ‘main’:
jq = JoinableQueue()
p =Process(target=producer,args=(jq,‘wusir’,‘泔水’))
p.start()
c = Process(target=consumer,args=(jq,‘alex’))
c.daemon = True
c.start()
p.join()

#!/usr/bin/env python

-- coding:utf-8 --

from multiprocessing import Manager,Process,Lock

def func(dic,lock):
with lock:
dic[‘count’] -= 1

if name == ‘main’:
# m = Manager()
with Manager() as m:
l = Lock()
dic = m.dict({‘count’:100})
p_l = []
for i in range(100):
p = Process(target=func,args=(dic,l))
p.start()
p_l.append§
for p in p_l:p.join()
print(dic)

mulprocessing中有一个manager类

封装了所有和进程相关的 数据共享 数据传递

相关的数据类型

但是对于 字典 列表这一类的数据操作的时候会产生数据不安全

需要加锁解决问题，并且需要尽量少的使用这种方式

#!/usr/bin/env python

-- coding:utf-8 --

线程 开销小 数据共享 是进程的一部分

进程 开销大 数据隔离 是一个资源分配单位

cpython解释器 不能实现多线程利用多核

锁 ：GIL 全局解释器锁

# 保证了整个python程序中，只能有一个线程被CPU执行
# 原因：cpython解释器中特殊的垃圾回收机制
# GIL锁导致了线程不能并行，可以并发

所以使用所线程并不影响高io型的操作

只会对高计算型的程序由效率上的影响

遇到高计算 ： 多进程 + 多线程

          # 分布式

cpython pypy jpython iron python

遇到IO操作的时候

# 5亿条cpu指令/s
# 5-6cpu指令 == 一句python代码
# 几千万条python代码

web框架 几乎都是多线程