并发编程n 07.08

def task1():
    while True：
    	yiled
        print('task1 run')
        
def task2():
    g =task1()
    while True:
        next(g)
        print('task2 run')
task2()

import time
def task1():
    a = 0
    for i in range(100000000):
        a +=i
        yield
        
def task2():
    g = task1()
    b = 0
    for i in range(100000000):
        b += 1
        next(g)
s = time.time()
task2()
print('并发执行时间',time.time()-s)


def task1():
    a = 0
    for i inrange(100000000):
        a += i
        
def task2():
    b = 0
    for i in range(100000000):
        b += i
        
s = time.time()
task1()
task2()
print('串行执行时间',time.time()-s)

# 单线程下串行执行两个计算任务 效率反而比并发高 因为并发需要切换和保存

greenlet模块实现并发

from greenlet import greenlet

def eat(name):
    print('%s eat 1' %name)
    g2.switch('jack')
    print('%s eat 2' %name)
    g2.switch()
    
def play(name):
    print('%s play 1' %name)
    g1.switch()
    print('%s play 2' %name)
    
g1=greenlet(eat)
g2=greenlet(play)

g1.switch('rose')


import time
def f1():
    res = 1
    for i in range(100000000):
        res += i
        g2.switch()
        
def f2():
    res = 1
    for i in range(100000000):
        res *= i
        g1.switch()
        
start=time.time()
g1=greenlet(f1)
g2=greenlet(f2)
g1.switch()
stop=time.time()
print('run time is %s'%(stop-start))

1.协程

协程：是单线程下的并发，又称微线程。英文名Coroutine,是一种用户态的轻量级线程，即线程是由用户状态自己控制调度的。

#1.pythin的线程属于内核级别的，即由操作系统控制调度
#2.单线程内核开启协程，一旦遇到io，就会从应用程序级别控制切换，以此来提升效率。

#优点：
#1.协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
#2.单线程内就可以实现并发的效果，最大限度的利用CPU

#缺点：
#1.协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个线程内开启协程尽可能提高效率
#2.协程本质是单个线程，因而协程一旦出现阻塞，将会阻塞整个线程

#gevent 模块
import gevent
g1 = gevent.spawn(func1,1,2,3,x=4,y=5)
#spawn括号内第一个参数是函数名，如eat，后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数eat的
g2 = gevent.spawn(func2,1,2,3,x=4,y=5)
g1.join() #等待g1结束
g2.join() #等待g2结束
#gevent.joinall([g1,g2])
g1.value #拿到func1的返回值

import gevent,sys
from gevent import monkey #导入monkey补丁
monkey.patch_all() #打补丁
import time

print(sys.path)

def task1():
    print('task1 run')
    time.sleep(3)
    print('task1 over')
    
def task2():
    print('task2 run')
    time.sleep(1)
    print('task2 over')
    
g1 = gevent.spawn(task1)
g2 = gevent.spawn(task2)
g1.join()
g2.join()

#爬虫
from gevent import monkey;monkey.patch_all()
import gevent
import requests
import time

def get_page(url):
    print('GET: %s' %url)
    response=requests.get(url)
    if response.status_code == 200:
        print('%d bytes received from %s' %(len(response.text),url))


start_time=time.time()
gevent.joinall([
    gevent.spawn(get_page,'https://www.python.org/'),
    gevent.spawn(get_page,'https://www.yahoo.com/'),
    gevent.spawn(get_page,'https://github.com/'),
])
stop_time=time.time()
print('run time is %s' %(stop_time-start_time))

#TCP
#服务端
from gevent import monkey
monkey.patch_all()
from socket import *
import gevent

#如果不想用money.patch_all()打补丁,可以用gevent自带的socket
# from gevent import socket
# s=socket.socket()

def server(server_ip,port):
    s = socket(AF_INET,SOCK_STREAM)
    s.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
    s.bind((server_ip,port))
    s.listen(5)
    while True:
        conn,addr = s.accept()
        gevent.spawn(talk,conn,addr)
        
def talk(conn,addr):
    try:
        res=conn.recv(1024)
        print('client %s:%s msg:%s'%(addr[0],addr[1],res))
        conn.send(res.upper())
   	except Except as e:
        print(e)
    finally:
        conn.close()
        
if __name__ == '__main__':
    server('127.0.0.1',8080)
    
    
#客户端
from threading import Thread
from socket import *
import threading

def client(server_ip,port):
    c= socket(AF_INET,SOCK_STREAM)
    c.connect((server_ip,port))
    
    count = 0
    while True:
        c.send((%s say hello %s)%(threading.current_thread().getName(),count)).encode('utf-8'))
        msg=c,recv(1024)
        print(msg.decode('utf_8'))
        count+=1
        
if __name__=='__main__':
    for i in range(500):
        t=Thread(target=client,args=('127.0.0.1',8080)
        t.start