9）網絡并發 編程、進程、線程和協程

                          并發網絡

Server：

#!/usr/bin/env python
#-*-conding:utf-8-*-
import socket
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-*-
import socket
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-*-
import socketserver
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        conn = self.request
        print(conn)
myserver = socketserver.ThreadingTCPServer(('127.0.0.1',9988),Myserver)
myserver.serve_forever()

Server端：

 Client端：

并發編程：

一個程序在同一時刻做多件事情

基于多道批處理系統和分時系統

解決程序中IO操作影響程序的效率問題

多個程序、作業在遇到IO操作的時候，操作系統會幫助你進行切換

讓cpu的利用率得到最大的提高

操作系統 只負責管理調度進程

什么叫進程：

運行中的程序：

進程：是操作系統總資源分配的最小單位

每一個運行中的程序都需要有自己的內存、資源

都分配給進程  紀錄執行的狀態 管理自己的內存資源

import os,time
print(os.getpid())
time.sleep(1000)

Multiprocess模塊（包）異步執行，就是兩個程序一起執行

import os

import time
from  multiprocessing import Process
def lxf(*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())

import os
import time
from  multiprocessing import Process
def func(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())

import os
import time
from multiprocessing import Process
def func(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  multiprocessing import Process
import time
n = 100
def func():
    global n
    n = 0
    print('&&&&')

if __name__ =='__main__':
    Process(target=func).start()
    time.sleep(1)
    print(n)

開啟多個子進程：

from multiprocessing import Process
import time
def func(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個進程去發郵件：

from multiprocessing import Process
import time
def func(n):
    time.sleep(1)
    print('-' * n)
if __name__ == '__main__':
    for i in range(10):
        p = Process(target=func, args=(1,))
        p.start()
    print('子進程開始了')
    p.join()
    print('十條信息發送完了')

完善10條短信發送：

import os
import time
from  multiprocessing import Process
def func(n):
    time.sleep(1)
    print('&'*n)

if __name__=='__main__':
    l = []
    for i in range(10):
        p = Process(target=func,args=(i,))
        p.start()
        l.append(p)
    for p in l:
        p.join()
    print('發完了10條短信')

守護進程：也是一個子進程

當主進程的代碼執行完畢之后會自動結束的子進程交做守護進程

import time
from multiprocessing import Process
def deamon_func():
    while True:
        print('活著真好')
        time.sleep(0.5)

if __name__=='__main__':
    p = Process(target=deamon_func)
    p.daemon = True
    p.start()
    for i in range(3):
        print(i*'*')
        time.sleep(1)

、

守護進程

守護進程也是一個子進程

當主進程的代碼執行完畢之后自動結束的子進程叫做守護進程

如果要在主進程當中要等待子進程結束之后在執行某段代碼：join方法

如果有多個子進程，不能在start一個進程之后就立刻join，吧所有的進程放到列表中，等待所有進程都start之后在逐一join

import os
import time
from  multiprocessing import Process
def daemon_func():
    while True:
        print('活著真好呀')
        time.sleep(0.5)

def wahaha():
    for i in range(10):
        time.sleep(1)
        print(i * '#')
if __name__=='__main__':
    Process(target=wahaha).start()
    p = Process(target=daemon_func)
    p.daemon = True
    p.start()
    for i in range(3):
        print(i*'*')
        time.sleep(1)

鎖：

例子：

import os
import time
import random
from  multiprocessing import Process

def work(n):
    print('%s:%s is runing' %(n,os.getpid()))
    time.sleep(random.random())
    print('%s:%s is done'%(n,os.getpid()))

if __name__=='__main__':
    for i in range(3):
        p = Process(target=work,args=(1,))
        p.start()

改進一下：使用鎖：

import os
import time
import random
from  multiprocessing import Process,Lock

def work(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()
    for i in range(3):
        p = Process(target=work,args=(1,lock))
        p.start()

搶火車票：使用鎖：犧牲效率，但是保證安全

from multiprocessing import Process,Lock
import time,json,random
def search():
    dic = json.load(open('db'))
    print('\033[43m剩余票數%s\033[0m'%dic['count'])
def get(num):
    dic=json.load(open('db'))
    time.sleep(random.random())
    if dic['count'] >0:
        dic['count']-=1
        time.sleep(0.2)
        json.dump(dic,open('db','w'))
        print('\033[43m%s購票成功\033[0m'%num)

def task(num,lock):
    search()
    lock.acquire()
    get(num)
    lock.release()


if __name__=='__main__':
    lock = Lock()
    for i in range(10):
        p = Process(target=task,args=(i,lock))
        p.start()

信號量：

#!/usr/bin/env python
#-*-conding:utf-8 -*-
from multiprocessing import Semaphore
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 -*-
from multiprocessing import Process,Semaphore
import time,random
def go_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=[]
    for i in range(13):
        p = Process(target=go_ktv,args=(sem,'user%s'%i,))
        p.start()
        p_l.append(p)
    for i in p_l:
        i.join()
    print('========>')

事件：

內部內置了一個標志

Wait 方法 如果這個標志是True 那么wait == pass

Wait 方法 如果這個標志是False 那么wait 會陷入阻塞，一直阻塞到標志從False變成True

一個時間在創建之初 內部的標志默認是False

紅綠燈

隊列：Queue：

自己人為的去傳輸的結果的東西

import os
import time
from  multiprocessing import Queue,Process
def func(n,q):
    q.put(n*n)

if __name__=='__main__':
    q = Queue()
    Process(target=func,args=(100,q,)).start()
    print(q.get())

管道+鎖 ==隊列

管道也是一個可以實現進程之間通信的模型

但是管道沒有鎖，數據不安全

數據共享：

線程：

啟動線程：

import os
import time
from  threading import Thread
def func(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的多線程來解決

用多進程或者分布式來解決高計算型代碼

守護線程：

線程鎖

池的概念：

線程池：

import time
from concurrent.futures import ThreadPoolExecutor
def func(num):
    time.sleep(5)
    print(num)

t = ThreadPoolExecutor(20)
for i in range(100):
    t.submit(func,i)

t.shutdown()  #join 整個池子

print(3333335555) 

協程：