189 8069 5689
并发网络
十余年的靖江网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。全网整合营销推广的优势是能够根据用户设备显示端的尺寸不同，自动调整靖江建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联从事“靖江网站设计”,“靖江网站推广”以来，每个客户项目都认真落实执行。
Server：
#!/usr/bin/env python
#-*-conding:utf-8-*-
importsocket
sk = socket.socket()
sk.bind(('127.0.0.1',9009))
sk.listen()
conn,addr = sk.accept()
conn.send(b'heooo')
msg = conn.recv(1024)
print(msg)
conn.close()
sk.close()
Client：
#!/usr/bin/env python
#-*-conding:utf-8-*-
importsocket
sk = socket.socket()
sk.connect(('127.0.0.1',9009))
print(sk.recv(1024))
sk.send(b'busdf')
sk.close()
socketserver并发的模块
模块：
#!/usr/bin/env python
#-*-conding:utf-8-*-
importsocketserver
classMyserver(socketserver.BaseRequestHandler):
defhandle(self):
conn =self.request
print(conn)
myserver = socketserver.ThreadingTCPServer(('127.0.0.1',9988),Myserver)
myserver.serve_forever()
Server端：
Client端：
并发编程：
一个程序在同一时刻做多件事情
基于多道批处理系统和分时系统
解决程序中IO操作影响程序的效率问题
多个程序、作业在遇到IO操作的时候，操作系统会帮助你进行切换
让cpu的利用率得到最大的提高
操作系统 只负责管理调度进程
什么叫进程：
运行中的程序：
进程：是操作系统总资源分配的最小单位
每一个运行中的程序都需要有自己的内存、资源
都分配给进程 纪录执行的状态 管理自己的内存资源
importos,time
print(os.getpid())
time.sleep(1000)
Multiprocess模块（包）异步执行，就是两个程序一起执行
importos
importtime
from multiprocessingimportProcess
deflxf(*args):
print(args,os.getpid())
time.sleep(2)
if__name__=='__main__':
print(os.getpid())
p = Process(target=lxf,args=(12,10,))
p.start()
print(os.getpid())
importos
importtime
from multiprocessingimportProcess
deffunc(num):
print(num,os.getpid())
time.sleep(10)
if__name__=='__main__':
print(os.getpid())
p = Process(target=func,args=(10,))
p.start()
print(os.getpid())
importos
importtime
frommultiprocessingimportProcess
deffunc(num):
print(num,os.getpid())
time.sleep(0.5)
print(num,os.getpid())
time.sleep(0.5)
print(num,os.getpid())
time.sleep(0.5)
print(num,os.getpid())
if__name__ =='__main__':
print(os.getpid())
p = Process(target=func,args=(10,))
p.start()
print(os.getpid())
time.sleep(1)
print(os.getpid(),1)
time.sleep(1)
print(os.getpid(),2)
什么是进程： 运行中的程序，计算机中最小的资源分配单位
程序开始执行就会产生一个主进程
Python中可以主进程中用代码启动一个进程----------------子进程
同时主进程也呗称为父进程
父子进程之间的代码执行是一步的，各自执行自己的
父子进程之间的数据是不可以共享
from multiprocessingimportProcess
importtime
n =100
deffunc():
globaln
n =0
print('&&&&')
if__name__ =='__main__':
Process(target=func).start()
time.sleep(1)
print(n)
开启多个子进程：
frommultiprocessingimportProcess
importtime
deffunc(n):
time.sleep(1)
print('_&*'*n)
if__name__=='__main__':
Process(target=func,args=(1,)).start()
Process(target=func,args=(2,)).start()
Process(target=func,args=(3,)).start()
开启10个进程去发邮件：
frommultiprocessingimportProcess
importtime
deffunc(n):
time.sleep(1)
print('-'* n)
if__name__ =='__main__':
foriinrange(10):
p = Process(target=func,args=(1,))
p.start()
print('子进程开始了')
p.join()
print('十条信息发送完了')
完善10条短信发送：
importos
importtime
from multiprocessingimportProcess
deffunc(n):
time.sleep(1)
print('&'*n)
if__name__=='__main__':
l = []
foriinrange(10):
p = Process(target=func,args=(i,))
p.start()
l.append(p)
forpinl:
p.join()
print('发完了10条短信')
守护进程：也是一个子进程
当主进程的代码执行完毕之后会自动结束的子进程交做守护进程
importtime
frommultiprocessingimportProcess
defdeamon_func():
while True:
print('活着真好')
time.sleep(0.5)
if__name__=='__main__':
p = Process(target=deamon_func)
p.daemon =True
p.start()
foriinrange(3):
print(i*'*')
time.sleep(1)
、
守护进程
守护进程也是一个子进程
当主进程的代码执行完毕之后自动结束的子进程叫做守护进程
如果要在主进程当中要等待子进程结束之后在执行某段代码：join方法
如果有多个子进程，不能在start一个进程之后就立刻join，吧所有的进程放到列表中，等待所有进程都start之后在逐一join
importos
importtime
from multiprocessingimportProcess
defdaemon_func():
while True:
print('活着真好呀')
time.sleep(0.5)
defwahaha():
foriinrange(10):
time.sleep(1)
print(i *'#')
if__name__=='__main__':
Process(target=wahaha).start()
p = Process(target=daemon_func)
p.daemon =True
p.start()
foriinrange(3):
print(i*'*')
time.sleep(1)
锁：
例子：
importos
importtime
importrandom
from multiprocessingimportProcess
defwork(n):
print('%s:%s is runing'%(n,os.getpid()))
time.sleep(random.random())
print('%s:%s is done'%(n,os.getpid()))
if__name__=='__main__':
foriinrange(3):
p = Process(target=work,args=(1,))
p.start()
改进一下：使用锁：
importos
importtime
importrandom
from multiprocessingimportProcess,Lock
defwork(n,lock):
lock.acquire()
print('%s:%s is runing'%(n,os.getpid()))
time.sleep(random.random())
print('%s:%s is done'%(n,os.getpid()))
lock.release()
if__name__=='__main__':
lock = Lock()
foriinrange(3):
p = Process(target=work,args=(1,lock))
p.start()
抢火车票：使用锁：牺牲效率，但是保证安全
frommultiprocessingimportProcess,Lock
importtime,json,random
defsearch():
dic = json.load(open('db'))
print('\033[43m剩余票数%s\033[0m'%dic['count'])
defget(num):
dic=json.load(open('db'))
time.sleep(random.random())
ifdic['count'] >0:
dic['count']-=1
time.sleep(0.2)
json.dump(dic,open('db','w'))
print('\033[43m%s购票成功\033[0m'%num)
deftask(num,lock):
search()
lock.acquire()
get(num)
lock.release()
if__name__=='__main__':
lock = Lock()
foriinrange(10):
p = Process(target=task,args=(i,lock))
p.start()
信号量：
#!/usr/bin/env python
#-*-conding:utf-8 -*-
frommultiprocessingimportSemaphore
sem = Semaphore(5)
sem.acquire()
print(1)
sem.acquire()
print(2)
sem.acquire()
print(3)
sem.acquire()
print(4)
sem.acquire()
print(5) #到这里就卡住了
sem.acquire()
print(6)
sem.acquire()
print(7)
#!/usr/bin/env python
#-*-conding:utf-8 -*-
frommultiprocessingimportProcess,Semaphore
importtime,random
defgo_ktv(sem,user):
sem.acquire()
print('%s 占到了一间×××包间'%(user))
time.sleep(random.randint(3,5))# 模拟每个人在里面呆的时间不同
sem.release()
print('%s 走出×××包间'% (user))
if__name__=='__main__':
sem = Semaphore(4)
p_l=[]
foriinrange(13):
p = Process(target=go_ktv,args=(sem,'user%s'%i,))
p.start()
p_l.append(p)
foriinp_l:
i.join()
print('========>')
事件：
内部内置了一个标志
Wait 方法 如果这个标志是True那么wait == pass
Wait 方法 如果这个标志是False那么wait会陷入阻塞，一直阻塞到标志从False变成True
一个时间在创建之初 内部的标志默认是False
红绿灯
队列：Queue：
自己人为的去传输的结果的东西
importos
importtime
from multiprocessingimportQueue,Process
deffunc(n,q):
q.put(n*n)
if__name__=='__main__':
q = Queue()
Process(target=func,args=(100,q,)).start()
print(q.get())
管道+锁 ==队列
管道也是一个可以实现进程之间通信的模型
但是管道没有锁，数据不安全
数据共享：
线程：
启动线程：
importos
importtime
from threadingimportThread
deffunc(i):
print(os.getpid())
time.sleep(1)
print('thread%s'%i)
Thread(target=func,args=(1,)).start()
print(10*'*')
print('main:',os.getpid())
线程之间的数据是共享的：
实现线程之间并发：
GIL锁 全局解释器锁：
是cpython解释器的问题
在同一个进程中 同一时刻 只能有一个线程呗cpu执行
导致高计算型， 代码 不适合用python的多线程来解决
用多进程或者分布式来解决高计算型代码
守护线程：
线程锁
池的概念：
线程池：
importtime
fromconcurrent.futuresimportThreadPoolExecutor
deffunc(num):
time.sleep(5)
print(num)
t = ThreadPoolExecutor(20)
foriinrange(100):
t.submit(func,i)
t.shutdown() #join 整个池子
print(3333335555)
协程：
