Python基础22-并发编程

#一 操作系统的作用：
    1：隐藏丑陋复杂的硬件接口，提供良好的抽象接口
    2：管理、调度进程，并且将多个进程对硬件的竞争变得有序

#二 多道技术：
    1.产生背景：针对单核，实现并发
    ps：
    现在的主机一般是多核，那么每个核都会利用多道技术
    有4个cpu，运行于cpu1的某个程序遇到io阻塞，会等到io结束再重新调度，会被调度到4个
    cpu中的任意一个，具体由操作系统调度算法决定。
    
    2.空间上的复用：如内存中同时有多道程序
    3.时间上的复用：复用一个cpu的时间片
       强调：遇到io切，占用cpu时间过长也切，核心在于切之前将进程的状态保存下来，这样
            才能保证下次切换回来时，能基于上次切走的位置继续运行

### 详解
现代计算机或者网络都是多用户的，多个用户不仅共享硬件，而且共享文件，数据库等信息，共享意味着冲突和无序。

操作系统主要使用来

1.记录哪个程序使用什么资源

2.对资源请求进行分配

3.为不同的程序和用户调解互相冲突的资源请求。

我们可将上述操作系统的功能总结为：处理来自多个程序发起的多个（多个即多路）共享（共享即复用）资源的请求，简称多路复用

多路复用有两种实现方式

1.时间上的复用

当一个资源在时间上复用时，不同的程序或用户轮流使用它，第一个程序获取该资源使用结束后，在轮到第二个。。。第三个。。。

例如：只有一个cpu，多个程序需要在该cpu上运行，操作系统先把cpu分给第一个程序，在这个程序运行的足够长的时间（时间长短由操作系统的算法说了算）或者遇到了I/O阻塞，操作系统则把cpu分配给下一个程序，以此类推，直到第一个程序重新被分配到了cpu然后再次运行，由于cpu的切换速度很快，给用户的感觉就是这些程序是同时运行的，或者说是并发的，或者说是伪并行的。至于资源如何实现时间复用，或者说谁应该是下一个要运行的程序，以及一个任务需要运行多长时间，这些都是操作系统的工作。

2.空间上的复用

每个客户都获取了一个大的资源中的一小部分资源，从而减少了排队等待资源的时间。

例如：多个运行的程序同时进入内存，硬件层面提供保护机制来确保各自的内存是分割开的，且由操作系统控制，这比一个程序独占内存一个一个排队进入内存效率要高的多。

有关空间复用的其他资源还有磁盘，在许多系统中，一个磁盘同时为许多用户保存文件。分配磁盘空间并且记录谁正在使用哪个磁盘块是操作系统资源管理的典型任务。

这两种方式合起来便是多道技术

## 例一
你是一个cpu，你同时谈了三个女朋友，每一个都可以是一个恋爱任务，你被这三个任务共享
要玩出并发恋爱的效果，
应该是你先跟女友1去看电影，看了一会说：不好，我要拉肚子，然后跑去跟第二个女友吃饭，吃了一会说：那啥，我
去趟洗手间，然后跑去跟女友3开了个房

## 例二
某天下午，zls、bgx、zls、alex、约好了一起去嫖娼，但娼只有一个(cpu只有一个)，但是却要‘同时’干
四个任务(嫖出并发的效果)，那就必须是干一会zls，再干一会zls，再干一会alex，再干一会bgx
zls：花了200块钱，因为人美活好
bgx：500块钱
alex：100块钱，可能是不太行
zls：没要钱，为啥？？？因为大家刚刚嫖的是他女朋友

tail -f access.log |grep '404'

#所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不会返回。按照这个定义，其实绝大多数函数都是同步调用。但是一般而言，我们在说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。
#举例：
#1. multiprocessing.Pool下的apply #发起同步调用后，就在原地等着任务结束，根本不考虑任务是在计算还是在io阻塞，总之就是一股脑地等任务结束
#2. concurrent.futures.ProcessPoolExecutor().submit(func,).result()
#3. concurrent.futures.ThreadPoolExecutor().submit(func,).result()

#异步的概念和同步相对。当一个异步功能调用发出后，调用者不能立刻得到结果。当该异步功能完成后，通过状态、通知或回调来通知调用者。如果异步功能用状态来通知，那么调用者就需要每隔一定时间检查一次，效率就很低（有些初学多线程编程的人，总喜欢用一个循环去检查某个变量的值，这其实是一 种很严重的错误）。如果是使用通知的方式，效率则很高，因为异步功能几乎不需要做额外的操作。至于回调函数，其实和通知没太多区别。
#举例：
#1. multiprocessing.Pool().apply_async() #发起异步调用后，并不会等待任务结束才返回，相反，会立即获取一个临时结果（并不是最终的结果，可能是封装好的一个对象）。
#2. concurrent.futures.ProcessPoolExecutor(3).submit(func,)
#3. concurrent.futures.ThreadPoolExecutor(3).submit(func,)

#阻塞调用是指调用结果返回之前，当前线程会被挂起（如遇到io操作）。函数只有在得到结果之后才会将阻塞的线程激活。有人也许会把阻塞调用和同步调用等同起来，实际上他是不同的。对于同步调用来说，很多时候当前线程还是激活的，只是从逻辑上当前函数没有返回而已。
#举例：
#1. 同步调用：apply一个累计1亿次的任务，该调用会一直等待，直到任务返回结果为止，但并未阻塞住（即便是被抢走cpu的执行权限，那也是处于就绪态）;
#2. 阻塞调用：当socket工作在阻塞模式的时候，如果没有数据的情况下调用recv函数，则当前线程就会被挂起，直到有数据为止。

#非阻塞和阻塞的概念相对应，指在不能立刻得到结果之前也会立刻返回，同时该函数不会阻塞当前线程。

#1. 同步与异步针对的是函数/任务的调用方式：同步就是当一个进程发起一个函数（任务）调用的时候，一直等到函数（任务）完成，而进程继续处于激活状态。而异步情况下是当一个进程发起一个函数（任务）调用的时候，不会等函数返回，而是继续往下执行当，函数返回的时候通过状态、通知、事件等方式通知进程任务完成。

#2. 阻塞与非阻塞针对的是进程或线程：阻塞是当请求不能满足的时候就将进程挂起，而非阻塞则不会阻塞当前进程

Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）

强调：
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号

group参数未使用，值始终为None

target表示调用对象，即子进程要执行的任务

args表示调用对象的位置参数元组，args=(1,2,'zls',)

kwargs表示调用对象的字典,kwargs={'name':'zls','age':18}

name为子进程的名称

p.start()：启动进程，并调用该子进程中的p.run()
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法

p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():如果p仍然运行，返回True

p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程

p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置

p.name:进程的名称

p.pid：进程的pid

p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)

p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）

import time

def task(name):
    print('%s is runnging' %name)
    time.sleep(3)
    print('%s is down' %name)

task('zls')
print('主进程')

from multiprocessing import Process
import time

def task(name):
    print('%s is runnging' %name)
    time.sleep(3)
    print('%s is down' %name)


if __name__ == '__main__': ## windows上开启进程必须使用__main__的方式，在Linux就无所谓了
    ## 实例化，需要传参，有两种传参方式。1.使用args传一个元组。2.使用kwargs传一个字典。
    obj=Process(target=task,args=('zls',))
    # Process(target=task,kwargs={'name':'zls'})
    obj.start()
    print('主进程')

from multiprocessing import Process
import time

class  MyProcess(Process):
    def __init__(self,name):
        super().__init__()
        self.name=name

    def run(self):
        print('%s is runnging' %self.name)
        time.sleep(3)
        print('%s is down' %self.name)



if __name__ == '__main__': ## windows上开启进程必须使用__main__的方式，在Linux就无所谓了
    ## 实例化，需要传参，有两种传参方式。1.使用args传一个元组。2.使用kwargs传一个字典。
    # obj=Process(target=MyProcess,args=('zls',))
    # Process(target=task,kwargs={'name':'zls'})
    obj=MyProcess('zls')
    obj.start()
    print('主进程')

from multiprocessing import Process
import time

def task(name):
    print('%s is runnging' %name)
    time.sleep(3)
    print('%s is down' %name)


if __name__ == '__main__': ## windows上开启进程必须使用__main__的方式，在Linux就无所谓了
    ## 实例化，需要传参，有两种传参方式。1.使用args传一个元组。2.使用kwargs传一个字典。
    obj1=Process(target=task,args=('子进程1',))
    obj2=Process(target=task,args=('子进程2',))
    # Process(target=task,kwargs={'name':'zls'})
    obj1.start()
    obj2.start()
    print('主进程')

from multiprocessing import Process
import time

def task(name):
    print('%s is runnging' %name)
    time.sleep(3)
    print('%s is down' %name)


if __name__ == '__main__': ## windows上开启进程必须使用__main__的方式，在Linux就无所谓了
    ## 实例化，需要传参，有两种传参方式。1.使用args传一个元组。2.使用kwargs传一个字典。
    obj1=Process(target=task,args=('子进程1',))
    obj2=Process(target=task,args=('子进程2',))
    # Process(target=task,kwargs={'name':'zls'})
    obj1.start()
    obj2.start()
    time.sleep(4)
    print('主进程')

from multiprocessing import Process
import time

def task(name):
    print('%s is runnging' %name)
    time.sleep(3)
    print('%s is down' %name)


if __name__ == '__main__': ## windows上开启进程必须使用__main__的方式，在Linux就无所谓了
    ## 实例化，需要传参，有两种传参方式。1.使用args传一个元组。2.使用kwargs传一个字典。
    obj1=Process(target=task,args=('子进程1',))
    obj2=Process(target=task,args=('子进程2',))
    # Process(target=task,kwargs={'name':'zls'})
    obj1.start()
    obj2.start()

    obj1.join()
    obj2.join()
    print('主进程')

from multiprocessing import Process
import time

def task(name,n):
    print('%s is runnging' %name)
    time.sleep(n)
    print('%s is down' %name)


if __name__ == '__main__': ## windows上开启进程必须使用__main__的方式，在Linux就无所谓了
    ## 实例化，需要传参，有两种传参方式。1.使用args传一个元组。2.使用kwargs传一个字典。
    obj1=Process(target=task,args=('子进程1',1))
    obj2=Process(target=task,args=('子进程2',2))
    obj3=Process(target=task,args=('子进程3',3))
    # Process(target=task,kwargs={'name':'zls'})
    obj1.start()
    obj2.start()
    obj3.start()

    obj1.join()
    obj2.join()
    obj3.join()
    print('主进程')

from multiprocessing import Process
import time

def task(name,n):
    print('%s is runnging' %name)
    time.sleep(n)
    print('%s is down' %name)


if __name__ == '__main__': ## windows上开启进程必须使用__main__的方式，在Linux就无所谓了
    ## 实例化，需要传参，有两种传参方式。1.使用args传一个元组。2.使用kwargs传一个字典。

    start=time.time()
    p_l=[]
    for i in range(1,4):
        obj=Process(target=task,args=('子进程%s' %i,i))
        p_l.append(obj)
        obj.start()

    for p in p_l:
        p.join()
    print('主进程')

from multiprocessing import Process
n=100 #在windows系统中应该把全局变量定义在if __name__ == '__main__'之上就可以了
def work():
    global n
    n=0
    print('子进程内: ',n)


if __name__ == '__main__':
    p=Process(target=work)
    p.start()
    p.join
    print('主进程内: ',n)

from multiprocessing import Process,current_process

import time

def task():
    print('%s is running' %current_process().pid)
    time.sleep(3)
    print('%s is down' % current_process().pid)


if __name__ == '__main__':
    p=Process(target=task)
    p.run()
    print('主进程',current_process().pid)

from multiprocessing import Process,current_process

import time,os

def task():
    print('%s is running' %os.getpid())
    time.sleep(3)
    print('%s is down' %os.getpid())


if __name__ == '__main__':
    p=Process(target=task)
    p.run()
    print('主进程',os.getpid())

#守护进程: 本质就是一个"子进程",该"子进程"的生命周期<=被守护进程的生命周期
from multiprocessing import Process
import time

def task(name):
    print('老太监%s活着....' %name)
    time.sleep(3)
    print('老太监%s正常死亡....' %name)

if __name__ == '__main__':
    p=Process(target=task,args=('爱根',))
    p.daemon=True
    p.start()#一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行
    time.sleep(1)
    print('皇上:ZLS正在死...')

{"count": 0}

import json
import time,random
from multiprocessing import Process

def search(name):
    with open('db.json','rt',encoding='utf-8') as f:
        dic=json.load(f)
    time.sleep(1)
    print('%s 查看到余票为%s' %(name,dic['count']))

def get(name):
    with open('db.json','rt',encoding='utf-8') as f:
        dic=json.load(f)
        if dic['count'] > 0:
            dic['count'] -= 1
            time.sleep(random.randint(1,3))
            with open('db.json','wt',encoding='utf-8') as f:
                json.dump(dic,f)
                print('%s 购票成功' % name)
        else:
            print('%s 查看到没有票了' %name)

def task(name):
    search(name)
    get(name)

if __name__ == '__main__':
    for i in range(10):
        p=Process(target=task,args=('路人 %s' %i,))
        p.start()

import json
import time,random
from multiprocessing import Process

def search(name):
    with open('db.json','rt',encoding='utf-8') as f:
        dic=json.load(f)
    time.sleep(1)
    print('%s 查看到余票为%s' %(name,dic['count']))

def get(name):
    with open('db.json','rt',encoding='utf-8') as f:
        dic=json.load(f)
        if dic['count'] > 0:
            dic['count'] -= 1
            time.sleep(random.randint(1,3))
            with open('db.json','wt',encoding='utf-8') as f:
                json.dump(dic,f)
                print('%s 购票成功' % name)
        else:
            print('%s 查看到没有票了' %name)

def task(name):
    search(name)
    get(name)

if __name__ == '__main__':
    for i in range(10):
        p=Process(target=task,args=('路人 %s' %i,))
        p.start()
        p.join()  #join只能将进程的任务整体变成串行

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

def search(name):
    with open('db.json','rt',encoding='utf-8') as f:
        dic=json.load(f)
    time.sleep(1)
    print('%s 查看到余票为%s' %(name,dic['count']))

def get(name):
    with open('db.json','rt',encoding='utf-8') as f:
        dic=json.load(f)
        if dic['count'] > 0:
            dic['count'] -= 1
            time.sleep(random.randint(1,3))
            with open('db.json','wt',encoding='utf-8') as f:
                json.dump(dic,f)
                print('%s 购票成功' % name)
        else:
            print('%s 查看到没有票了' %name)

def task(name,mutex):
    search(name)        #并发
    mutex.acquire()     #互斥锁
    get(name)           #购票
    mutex.release()     #释放锁     #写法一，get之后释放互斥锁。

    # with mutex:   #写法二
    #     get(name)

if __name__ == '__main__':
    mutex=Lock()
    for i in range(10):
        p=Process(target=task,args=('路人 %s' %i,mutex))
        p.start()

from multiprocessing import Queue

q=Queue(3)
q.put(['first',])
q.put({'x':1})
q.put(3)

print(q.get())
print(q.get())
print(q.get())

from multiprocessing import Queue
q=Queue(3)
q.put(['first',],block=True,timeout=3)  # block阻塞   timeout超时
q.put({'x':1},block=True,timeout=3)
q.put(3,block=True,timeout=3)

print(q.get())
print(q.get())
print(q.get())

q.put_nowait()  #不等了 q.put(1,block=False)
q.get(block=True,timeout=3)
q.get_nowait() # q.get(block=False)

生产者:代指生产数据的任务
消费者:代指处理数据的任务

该模型的工作方式:
    生产生产数据传递消费者处理

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

基于队列实现生产者消费者模型

import time,random
from multiprocessing import Process,Queue

def producter(name,food,q):
    for i in range(10):
        #造数据...
        res='%s%s' %(food,i)
        time.sleep(random.randint(1,3))     #模拟生产数据的时间
        q.put(res)
        print('厨师[%s]生产了<%s>' %(name,res))

def consumer(name,q):
    while True:
        res=q.get(q)
        time.sleep(random.randint(1,3))     #模拟处理数据的时间
        print('吃货[%s]吃了<%s>' %(name,res))

if __name__ == '__main__':
    q=Queue()

    #生产者们
    p1=Process(target=producter,args=('zls','泔水',q))
    #消费者们
    c1=Process(target=consumer,args=('zls',q))

    p1.start()
    c1.start()

    print('主进程')

import time,random
from multiprocessing import Process,Queue

def producter(name,food,q):
    for i in range(3):
        #造数据...
        res='%s%s' %(food,i)
        time.sleep(random.randint(1,3))     #模拟生产数据的时间
        q.put(res)
        print('厨师[%s]生产了<%s>' %(name,res))
    q.put(None)

def consumer(name,q):
    while True:
        res=q.get(q)
        if res is None:break
        time.sleep(random.randint(1,3))     #模拟处理数据的时间
        print('吃货[%s]吃了<%s>' %(name,res))

if __name__ == '__main__':
    q=Queue()

    #生产者们
    p1=Process(target=producter,args=('zls','泔水',q))
    #消费者们
    c1=Process(target=consumer,args=('zls',q))

    p1.start()
    c1.start()

    print('主进程')

import time,random
from multiprocessing import Process,Queue

def producter(name,food,q):
    for i in range(3):
        #造数据...
        res='%s%s' %(food,i)
        time.sleep(random.randint(1,3))     #模拟生产数据的时间
        q.put(res)
        print('厨师[%s]生产了<%s>' %(name,res))
    q.put(None)

def consumer(name,q):
    while True:
        res=q.get(q)
        if res is None:break
        time.sleep(random.randint(1,3))     #模拟处理数据的时间
        print('吃货[%s]吃了<%s>' %(name,res))

if __name__ == '__main__':
    q=Queue()

    #生产者们
    p1=Process(target=producter,args=('小zls','泔水',q))
    p2=Process(target=producter,args=('中zls','屎包子',q))
    p3=Process(target=producter,args=('大zls','腰子汤',q))
    #消费者们
    c1=Process(target=consumer,args=('zls',q))
    c2=Process(target=consumer,args=('zls',q))

    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()

    print('主进程')

import time,random
from multiprocessing import Process,Queue

def producter(name,food,q):
    for i in range(3):
        #造数据...
        res='%s%s' %(food,i)
        time.sleep(random.randint(1,3))     #模拟生产数据的时间
        q.put(res)
        print('厨师[%s]生产了<%s>' %(name,res))
    q.put(None)

def consumer(name,q):
    while True:
        res=q.get(q)
        if res is None:break
        time.sleep(random.randint(1,3))     #模拟处理数据的时间
        print('吃货[%s]吃了<%s>' %(name,res))

if __name__ == '__main__':
    q=Queue()

    #生产者们
    p1=Process(target=producter,args=('小zls','泔水',q))
    p2=Process(target=producter,args=('中zls','屎包子',q))
    p3=Process(target=producter,args=('大zls','腰子汤',q))
    #消费者们
    c1=Process(target=consumer,args=('zls',q))
    c2=Process(target=consumer,args=('zls',q))

    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    p3.join()
    q.put(None)
    q.put(None)
    print('主进程')

import time,random
from multiprocessing import Process,JoinableQueue

def producter(name,food,q):
    for i in range(3):
        #造数据...
        res='%s%s' %(food,i)
        time.sleep(random.randint(1,3))     #模拟生产数据的时间
        q.put(res)
        print('厨师[%s]生产了<%s>' %(name,res))
    # q.put(None)

def consumer(name,q):
    while True:
        res=q.get(q)
        if res is None:break
        time.sleep(random.randint(1,3))     #模拟处理数据的时间
        print('吃货[%s]吃了<%s>' %(name,res))
        q.task_done()

if __name__ == '__main__':
    q=JoinableQueue()

    #生产者们
    p1=Process(target=producter,args=('小zls','泔水',q))
    p2=Process(target=producter,args=('中zls','屎包子',q))
    p3=Process(target=producter,args=('大zls','腰子汤',q))
    #消费者们
    c1=Process(target=consumer,args=('zls',q))
    c2=Process(target=consumer,args=('zls',q))

    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    p3.join()
    q.join() #主进程等q结束，即q内的数据被取干净
    print('主进程')

import time,random
from multiprocessing import Process,JoinableQueue

def producter(name,food,q):
    for i in range(3):
        #造数据...
        res='%s%s' %(food,i)
        time.sleep(random.randint(1,3))     #模拟生产数据的时间
        q.put(res)
        print('厨师[%s]生产了<%s>' %(name,res))
    # q.put(None)

def consumer(name,q):
    while True:
        res=q.get(q)
        if res is None:break
        time.sleep(random.randint(1,3))     #模拟处理数据的时间
        print('吃货[%s]吃了<%s>' %(name,res))
        q.task_done()

if __name__ == '__main__':
    q=JoinableQueue()

    #生产者们
    p1=Process(target=producter,args=('小zls','泔水',q))
    p2=Process(target=producter,args=('中zls','屎包子',q))
    p3=Process(target=producter,args=('大zls','腰子汤',q))
    #消费者们
    c1=Process(target=consumer,args=('zls',q))
    c2=Process(target=consumer,args=('zls',q))

    c1.daemon=True
    c2.daemon=True

    p1.start()
    p2.start()
    p3.start()
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    p3.join()
    q.join() #主进程等q结束，即q内的数据被取干净
    print('主进程')

from  threading import Thread

import time
def task(name):
    print('%s is running' %name)
    time.sleep(2)
    print('%s is down' %name)

if __name__ == '__main__':
    obj=Thread(target=task,args=('线程1',))
    obj.start()
    print('主线程')

from  threading import Thread

import time

class MyThread(Thread):
    def run(self):
        print('%s is running' %self.name)
        time.sleep(2)
        print('%s is down' %self.name)

if __name__ == '__main__':
    obj=MyThread()
    obj.start()
    print('主线程')

Thread实例对象的方法
  # isAlive(): 返回线程是否活动的。
  # getName(): 返回线程名。
  # setName(): 设置线程名。

threading模块提供的一些方法：
  # threading.currentThread(): 返回当前的线程变量。
  # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

from threading import Thread
import threading
from multiprocessing import Process
import os

def work():
    import time
    time.sleep(3)
    print(threading.current_thread().getName())


if __name__ == '__main__':
    #在主进程下开启线程
    t=Thread(target=work)
    t.start()

    print(threading.current_thread().getName())
    print(threading.current_thread()) #主线程
    print(threading.enumerate()) #连同主线程在内有两个运行的线程
    print(threading.active_count())
    print('主线程/主进程')

    '''
    打印结果:
    MainThread
    <_MainThread(MainThread, started 140735268892672)>
    [<_MainThread(MainThread, started 140735268892672)>, <Thread(Thread-1, started 123145307557888)>]
    主线程/主进程
    Thread-1
    '''

from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print('%s say hello' %name)

if __name__ == '__main__':
    t=Thread(target=sayhi,args=('zls',))
    t.start()
    t.join()
    print('主线程')
    print(t.is_alive())
    '''
    zls say hello
    主线程
    False
    '''

from threading import Thread,active_count,current_thread
import time,os

def task():
    print('%s is running' %current_thread().name)
    time.sleep(2)

if __name__ == '__main__':
    t=Thread(target=task,)
    t.start()
    # t.join()
    # print('主',active_count())
    print('主',current_thread().name)

#1.对主进程来说，运行完毕指的是主进程代码运行完毕

#2.对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕

#1 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，

#2 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。

from threading import Thread
from multiprocessing import Process
import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")

if __name__ == '__main__':
    # t1=Thread(target=foo)
    # t2=Thread(target=bar)

    t1=Process(target=foo)
    t2=Process(target=bar)
    t1.daemon=True
    t1.start()
    t2.start()
    print("main-------")

    '''
    123
    main-------
    456
    end456
    '''

    '''
    main-------
    123
    456
    end456
    '''

    '''
    main-------
    456
    end456
    '''

from threading import Thread,Lock
import time

mutex=Lock()
n=100
def task():
    global n
    mutex.acquire()
    temp=n
    time.sleep(0.1)
    n=temp-1
    mutex.release()

if __name__ == '__main__':
    t_l=[]
    for i in range(100):
        t=Thread(target=task)
        t_l.append(t)
        t.start()

    for t in t_l:
        t.join()
    print(n)

'''
定义：
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple 
native threads from executing Python bytecodes at once. This lock is necessary mainly 
because CPython’s memory management is not thread-safe. (However, since the GIL 
exists, other features have grown to depend on the guarantees that it enforces.)
'''
结论：在Cpython解释器中，同一个进程下开启的多线程，同一时刻只能有一个线程执行，无法利用多核优势

'''
#验证python test.py只会产生一个进程
#test.py内容
import os,time
print(os.getpid())
time.sleep(1000)
'''
python3 test.py 
#在windows下
tasklist |findstr python
#在linux下
ps aux |grep python

验证python test.py只会产生一个进程

#1 所有数据都是共享的，这其中，代码作为一种数据也是被所有线程共享的（test.py的所有代码以及Cpython解释器的所有代码）
例如：test.py定义一个函数work（代码内容如下图），在进程内所有线程都能访问到work的代码，于是我们可以开启三个线程然后target都指向该代码，能访问到意味着就是可以执行。

#2 所有线程的任务，都需要将任务的代码当做参数传给解释器的代码去执行，即所有的线程要想运行自己的任务，首先需要解决的是能够访问到解释器的代码。

from threading import Thread,Lock
import time

mutex=Lock()
n=100
def task():
    global n
    with mutex:
        temp=n
        time.sleep(0.1)
        n=temp-1

if __name__ == '__main__':
    l=[]
    for i in range(100):
        t=Thread(target=task)
        l.append(t)
        t.start()

    for t in l:
        t.join()
    print(n)

#1. cpu到底是用来做计算的，还是用来做I/O的？

#2. 多cpu，意味着可以有多个核并行完成计算，所以多核提升的是计算性能

#3. 每个cpu一旦遇到I/O阻塞，仍然需要等待，所以多核对I/O操作没什么用处 

#分析：
我们有四个任务需要处理，处理方式肯定是要玩出并发的效果，解决方案可以是：
方案一：开启四个进程
方案二：一个进程下，开启四个线程

#单核情况下，分析结果: 
　　如果四个任务是计算密集型，没有多核来并行计算，方案一徒增了创建进程的开销，方案二胜
　　如果四个任务是I/O密集型，方案一创建进程的开销大，且进程的切换速度远不如线程，方案二胜

#多核情况下，分析结果：
　　如果四个任务是计算密集型，多核意味着并行计算，在python中一个进程中同一时刻只有一个线程执行用不上多核，方案一胜
　　如果四个任务是I/O密集型，再多的核也解决不了I/O问题，方案二胜

 
#结论：现在的计算机基本上都是多核，python对于计算密集型的任务开多线程的效率并不能带来多大性能上的提升，甚至不如串行(没有大量切换)，但是，对于IO密集型的任务效率还是有显著提升的。

from multiprocessing import Process
from threading import Thread
import threading
import os,time
def work():
    time.sleep(2)
    print('===>')

if __name__ == '__main__':
    l=[]
    print(os.cpu_count()) #本机为4核
    start=time.time()
    for i in range(400):
        # p=Process(target=work) #耗时12s多,大部分时间耗费在创建进程上
        p=Thread(target=work) #耗时2s多
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop=time.time()
    print('run time is %s' %(stop-start))

from multiprocessing import Process
from threading import Thread
import os,time
def work():
    res=0
    for i in range(100000000):
        res*=i


if __name__ == '__main__':
    l=[]
    print(os.cpu_count()) #本机为4核
    start=time.time()
    for i in range(4):
        p=Process(target=work) #耗时5s多
        p=Thread(target=work) #耗时18s多
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop=time.time()
    print('run time is %s' %(stop-start)

from threading import Thread,Lock
import time
mutexA=Lock()
mutexB=Lock()

class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()
    def func1(self):
        mutexA.acquire()
        print('\033[41m%s 拿到A锁\033[0m' %self.name)

        mutexB.acquire()
        print('\033[42m%s 拿到B锁\033[0m' %self.name)
        mutexB.release()

        mutexA.release()

    def func2(self):
        mutexB.acquire()
        print('\033[43m%s 拿到B锁\033[0m' %self.name)
        time.sleep(2)

        mutexA.acquire()
        print('\033[44m%s 拿到A锁\033[0m' %self.name)
        mutexA.release()

        mutexB.release()

if __name__ == '__main__':
    for i in range(10):
        t=MyThread()
        t.start()

'''
Thread-1 拿到A锁
Thread-1 拿到B锁
Thread-1 拿到B锁
Thread-2 拿到A锁
然后就卡住，死锁了
'''

mutexA=mutexB=threading.RLock() #一个线程拿到锁，counter加1,该线程内又碰到加锁的情况，则counter继续加1，这期间所有其他线程都只能等待，等待该线程释放所有锁，即counter递减到0为止

## 互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去，如果指定信号量为3，那么来一个人获得一把锁，计数加1，当计数等于3时，后面的人均需要等待。一旦释放，就有人可以获得一把锁

## 信号量与进程池的概念很像，但是要区分开，信号量涉及到加锁的概念

from multiprocessing import Process,Semaphore
import time,random

def go_wc(sem,user):
    sem.acquire()
    print('%s 占到一个茅坑' %user)
    time.sleep(random.randint(0,3)) #模拟每个人拉屎速度不一样，0代表有的人蹲下就起来了
    sem.release()

if __name__ == '__main__':
    sem=Semaphore(5)
    p_l=[]
    for i in range(13):
        p=Process(target=go_wc,args=(sem,'user%s' %i,))
        p.start()
        p_l.append(p)

    for i in p_l:
        i.join()
    print('============》')

## python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。

## 事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。

# clear：将“Flag”设置为False
# set：将“Flag”设置为True
 
from multiprocessing import Process,Event
import time,random

def car(e,n):
    while True:
        if not e.is_set(): #Flase
            print('\033[31m红灯亮\033[0m，car%s等着' %n)
            e.wait()
            print('\033[32m车%s 看见绿灯亮了\033[0m' %n)
            time.sleep(random.randint(3,6))
            if not e.is_set():
                continue
            print('走你,car', n)
            break

def police_car(e,n):
    while True:
        if not e.is_set():
            print('\033[31m红灯亮\033[0m，car%s等着' % n)
            e.wait(1)
            print('灯的是%s，警车走了,car %s' %(e.is_set(),n))
            break

def traffic_lights(e,inverval):
    while True:
        time.sleep(inverval)
        if e.is_set():
            e.clear() #e.is_set() ---->False
        else:
            e.set()

if __name__ == '__main__':
    e=Event()
    # for i in range(10):
    #     p=Process(target=car,args=(e,i,))
    #     p.start()

    for i in range(5):
        p = Process(target=police_car, args=(e, i,))
        p.start()
    t=Process(target=traffic_lights,args=(e,10))
    t.start()

    print('============》')

import queue

queue.Queue() #先进先出
q=queue.Queue(3)
q.put(1)
q.put(2)
q.put(3)
print(q.get())
print(q.get())
print(q.get())

queue.LifoQueue() #后进先出->堆栈
q=queue.LifoQueue(3)
q.put(1)
q.put(2)
q.put(3)
print(q.get())
print(q.get())
print(q.get())
queue.PriorityQueue() #优先级
q=queue.PriorityQueue(3) #优先级,优先级用数字表示,数字越小优先级越高
q.put((10,'a'))
q.put((-1,'b'))
q.put((100,'c'))
print(q.get())
print(q.get())
print(q.get())

Pool([numprocess  [,initializer [, initargs]]]):创建进程池 

numprocess:要创建的进程数，如果省略，将默认使用cpu_count()的值
initializer：是每个工作进程启动时要执行的可调用对象，默认为None
initargs：是要传给initializer的参数组

p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，必须从不同线程调用p.apply()函数或者使用p.apply_async()
p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。此方法的结果是AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。

p.close():关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
P.jion():等待所有工作进程退出。此方法只能在close（）或teminate()之后调用

方法apply_async()和map_async（）的返回值是AsyncResul的实例obj。实例具有以下方法
obj.get():返回结果，如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
obj.ready():如果调用完成，返回True
obj.successful():如果调用完成且没有引发异常，返回True，如果在结果就绪之前调用此方法，引发异常
obj.wait([timeout]):等待结果变为可用。
obj.terminate()：立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收，将自动调用此函数

## 同步调用apply
from multiprocessing import Pool
import os,time
def work(n):
    print('%s run' %os.getpid())
    time.sleep(3)
    return n**2

if __name__ == '__main__':
    p=Pool(3) #进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务
    res_l=[]
    for i in range(10):
        res=p.apply(work,args=(i,)) #同步调用，直到本次任务执行完毕拿到res，等待任务work执行的过程中可能有阻塞也可能没有阻塞，但不管该任务是否存在阻塞，同步调用都会在原地等着，只是等的过程中若是任务发生了阻塞就会被夺走cpu的执行权限
        res_l.append(res)
    print(res_l)

## 异步调用apply_async
from multiprocessing import Pool
import os,time
def work(n):
    print('%s run' %os.getpid())
    time.sleep(3)
    return n**2

if __name__ == '__main__':
    p=Pool(3) #进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务
    res_l=[]
    for i in range(10):
        res=p.apply_async(work,args=(i,)) #同步运行,阻塞、直到本次任务执行完毕拿到res
        res_l.append(res)

    #异步apply_async用法：如果使用异步提交的任务，主进程需要使用jion，等待进程池内任务都处理完，然后可以用get收集结果，否则，主进程结束，进程池可能还没来得及执行，也就跟着一起结束了
    p.close()
    p.join()
    for res in res_l:
        print(res.get()) #使用get来获取apply_aync的结果,如果是apply,则没有get方法,因为apply是同步执行,立刻获取结果,也根本无需get

#一：使用进程池（异步调用,apply_async）
#coding: utf-8
from multiprocessing import Process,Pool
import time

def func(msg):
    print( "msg:", msg)
    time.sleep(1)
    return msg

if __name__ == "__main__":
    pool = Pool(processes = 3)
    res_l=[]
    for i in range(10):
        msg = "hello %d" %(i)
        res=pool.apply_async(func, (msg, ))   #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
        res_l.append(res)
    print("==============================>") #没有后面的join，或get，则程序整体结束，进程池中的任务还没来得及全部执行完也都跟着主进程一起结束了

    pool.close() #关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束

    print(res_l) #看到的是<multiprocessing.pool.ApplyResult object at 0x10357c4e0>对象组成的列表,而非最终的结果,但这一步是在join后执行的,证明结果已经计算完毕,剩下的事情就是调用每个对象下的get方法去获取结果
    for i in res_l:
        print(i.get()) #使用get来获取apply_aync的结果,如果是apply,则没有get方法,因为apply是同步执行,立刻获取结果,也根本无需get

#二：使用进程池（同步调用,apply）
#coding: utf-8
from multiprocessing import Process,Pool
import time

def func(msg):
    print( "msg:", msg)
    time.sleep(0.1)
    return msg

if __name__ == "__main__":
    pool = Pool(processes = 3)
    res_l=[]
    for i in range(10):
        msg = "hello %d" %(i)
        res=pool.apply(func, (msg, ))   #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
        res_l.append(res) #同步执行，即执行完一个拿到结果，再去执行另外一个
    print("==============================>")
    pool.close()
    pool.join()   #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束

    print(res_l) #看到的就是最终的结果组成的列表
    for i in res_l: #apply是同步的，所以直接得到结果，没有get()方法
        print(i)

from socket import *

server=socket(AF_INET,SOCK_STREAM)
server.bind(('127.0.0.1',8082))
server.listen(5)

while True: #链接循环
    conn,client_addr=server.accept()
    print(client_addr)

    while True: #通信循环
        try:
            data=conn.recv(1024)
            if len(data) == 0:break
            conn.send(data.upper())
        except ConnectionResetError:
            break

    conn.close()

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8082))

while True:
    msg=input('>>>: ').strip()
    if len(msg) == 0:continue
    client.send(msg.encode('utf-8'))
    data=client.recv(1024)
    print(data.decode('utf-8'))

### 服务端
from socket import *
from threading import Thread

def communicate(conn):
    while True:  # 通信循环
        try:
            data = conn.recv(1024)
            if len(data) == 0: break
            conn.send(data.upper())
        except ConnectionResetError:
            break

    conn.close()

def server(ip,port,backlog=5):
    server = socket(AF_INET, SOCK_STREAM)
    server.bind((ip, port))
    server.listen(backlog)

    while True:  # 链接循环
        conn, client_addr = server.accept()
        print(client_addr)
        #通信
        t=Thread(target=communicate,args=(conn,))
        t.start()

if __name__ == '__main__':
    s=Thread(target=server,args=('127.0.0.1',8083))
    s.start()

### 客户端
from socket import *


client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8083))

while True:
    msg=input('>>>: ').strip()
    if len(msg) == 0:continue
    client.send(msg.encode('utf-8'))
    data=client.recv(1024)
    print(data.decode('utf-8'))

### 异步提交
## ProcessPoolExecutor  进程池
## ThreadPoolExecutor  线程池

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import time, random, os

def task(name):
    print('%s%s is running' %(name, os.getpid()))
    time.sleep(random.randint(1,3))

if __name__ == '__main__':
    # print(os.cpu_count())
    p = ProcessPoolExecutor(4)  # 传一个参数，max_workers 最大的进程数，如果不传递任何参数，或者None，则会根据系统的cpu核心数来创建
    ## 提交任务的两种方式：
    # 同步调用：提交完一个任务之后，就在原地等待，等待任务完完整整的拿到结果后，再执行下一行代码，会导致任务是串行执行的
    # 异步调用：提交完一个任务之后，不在原地等待，而是直接执行下一行代码，会导致任务是并发执行的。
    for i in range(20):
        p.submit(task,'进程pid：')

    print('主')

### 同步提交

## ProcessPoolExecutor  进程池

## ThreadPoolExecutor  线程池

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

import time, random, os


def task(name):
    print('%s%s is running' %(name, os.getpid()))
    time.sleep(random.randint(1,3))
    return 123


if __name__ == '__main__':
    # print(os.cpu_count())
    p = ProcessPoolExecutor(4)  # 传一个参数，max_workers 最大的进程数，如果不传递任何参数，或者None，则会根据系统的cpu核心数来创建
    ## 提交任务的两种方式：
    # 同步调用：提交完一个任务之后，就在原地等待，等待任务完完整整的拿到结果后，再执行下一行代码，会导致任务是串行执行的
    # 异步调用：提交完一个任务之后，不在原地等待，而是直接执行下一行代码，会导致任务是并发执行的。
    for i in range(20):
        # futrue=p.submit(task,'进程pid：')
        # print(futrue)
        # res=futrue.result()
        res=p.submit(task,'进程pid:').result()
        print(res)

    print('主')

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

import time, random, os


def task(name,n):
    print('%s%s is running' %(name, os.getpid()))
    time.sleep(random.randint(1,3))
    return n**2


if __name__ == '__main__':
    # print(os.cpu_count())
    p = ProcessPoolExecutor(4)  # 传一个参数，max_workers 最大的进程数，如果不传递任何参数，或者None，则会根据系统的cpu核心数来创建
    ## 提交任务的两种方式：
    # 同步调用：提交完一个任务之后，就在原地等待，等待任务完完整整的拿到结果后，再执行下一行代码，会导致任务是串行执行的
    # 异步调用：提交完一个任务之后，不在原地等待，而是直接执行下一行代码，会导致任务是并发执行的。
    for i in range(20):
        # futrue=p.submit(task,'进程pid：')
        # print(futrue)
        # res=futrue.result()
        res=p.submit(task,'进程pid：',i).result()
        print(res)

    print('主')

## ProcessPoolExecutor  进程池

## ThreadPoolExecutor  线程池

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

import time, random, os


def task(name,n):
    print('%s%s is running' %(name, os.getpid()))
    time.sleep(random.randint(1,3))
    return n**2


if __name__ == '__main__':
    # print(os.cpu_count())
    p = ProcessPoolExecutor(4)  # 传一个参数，max_workers 最大的进程数，如果不传递任何参数，或者None，则会根据系统的cpu核心数来创建
    ## 提交任务的两种方式：
    # 同步调用：提交完一个任务之后，就在原地等待，等待任务完完整整的拿到结果后，再执行下一行代码，会导致任务是串行执行的
    # 异步调用：提交完一个任务之后，不在原地等待，而是直接执行下一行代码，会导致任务是并发执行的。
    l=[]
    for i in range(10):
        # futrue=p.submit(task,'进程pid：')
        # print(futrue)
        # res=futrue.result()
        res=p.submit(task,'进程pid：',i)
        l.append(res)
    p.shutdown(wait=True)  #关闭进程池的入口，并在原地等待进程池内所有任务运行完毕
    for res in l:
        print(res.result())

    print('主')

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import time, random, os
import requests

def get(url):
    print('%s  GET %s' % (os.getpid(), url))
    time.sleep(random.randint(1,3))
    response=requests.get(url)
    if response.status_code == 200:
        return response.text
    else:
        return '下载失败了'

def  parse(res):
    print('%s 解析结果为： %s' %(os.getpid(),len(res)))

if __name__ == '__main__':
    urls=[
        'https://www.baidu.com',
        'https://www.sina.com',
        'https://www.jd.com',
        'https://www.driverzeng.com',
        'https://www.tmall.com',
        'https://www.aliyun.com'
    ]
    p=ProcessPoolExecutor(3)
    l=[]
    for url in urls:
        future=p.submit(get,url)
        l.append(future)
    p.shutdown(wait=True)
    for future in l:
        res=future.result()
        parse(res)
    print('主')

'''
1、协程：
    单线程实现并发
    在应用程序里控制多个任务的切换+保存状态
    优点：
        应用程序级别速度要远远高于操作系统的切换
    缺点：
        多个任务一旦有一个阻塞没有切，整个线程都阻塞在原地
        该线程内的其他的任务都不能执行了

        一旦引入协程，就需要检测单线程下所有的IO行为,
        实现遇到IO就切换,少一个都不行，以为一旦一个任务阻塞了，整个线程就阻塞了，
        其他的任务即便是可以计算，但是也无法运行了

2、协程序的目的：
    想要在单线程下实现并发
    并发指的是多个任务看起来是同时运行的
    并发=切换+保存状态
'''

#串行执行
import time

def func1():
    for i in range(10000000):
        i+1

def func2():
    for i in range(10000000):
        i+1

start = time.time()
func1()
func2()
stop = time.time()
print(stop - start)


#基于yield并发执行
import time
def func1():
    while True:
        yield

def func2():
    g=func1()
    for i in range(10000000):
        i+1
        next(g)

start=time.time()
func2()
stop=time.time()
print(stop-start)

import time
def func1():
    while True:
        print('func1')
        yield

def func2():
    g=func1()
    for i in range(10000000):
        i+1
        next(g)
        time.sleep(3)
        print('func2')
start=time.time()
func2()
stop=time.time()
print(stop-start)

#1. 可以控制多个任务之间的切换，切换之前将任务的状态保存下来，以便重新运行时，可以基于暂停的位置继续执行。

#2. 作为1的补充：可以检测io操作，在遇到io操作的情况下才发生切换

#1. python的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其他线程运行）
#2. 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率（！！！非io操作的切换与效率无关）

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

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

#安装
pip3 install greenlet

from greenlet import greenlet

def eat(name):
    print('%s eat 1' %name)
    g2.switch('zls')
    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('zls')#可以在第一次switch时传入参数，以后都不需要

#顺序执行
import time
def f1():
    res=1
    for i in range(100000000):
        res+=i

def f2():
    res=1
    for i in range(100000000):
        res*=i

start=time.time()
f1()
f2()
stop=time.time()
print('run time is %s' %(stop-start)) #10.985628366470337

#切换
from greenlet import greenlet
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)) # 52.763017892837524

#安装
pip3 install gevent

#用法
g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1，spawn括号内第一个参数是函数名，如eat，后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数eat的

g2=gevent.spawn(func2)

g1.join() #等待g1结束

g2.join() #等待g2结束

#或者上述两步合作一步：gevent.joinall([g1,g2])

g1.value#拿到func1的返回值

import gevent
def eat(name):
    print('%s eat 1' %name)
    gevent.sleep(2)
    print('%s eat 2' %name)

def play(name):
    print('%s play 1' %name)
    gevent.sleep(1)
    print('%s play 2' %name)


g1=gevent.spawn(eat,'zls')
g2=gevent.spawn(play,name='zls')
g1.join()
g2.join()
#或者gevent.joinall([g1,g2])
print('主')

from gevent import monkey;monkey.patch_all()

import gevent
import time
def eat():
    print('eat food 1')
    time.sleep(2)
    print('eat food 2')

def play():
    print('play 1')
    time.sleep(1)
    print('play 2')

g1=gevent.spawn(eat)
g2=gevent.spawn(play_phone)
gevent.joinall([g1,g2])
print('主')

from gevent import spawn,joinall,monkey;monkey.patch_all()

import time
def task(pid):
    """
    Some non-deterministic task
    """
    time.sleep(0.5)
    print('Task %s done' % pid)


def synchronous():
    for i in range(10):
        task(i)

def asynchronous():
    g_l=[spawn(task,i) for i in range(10)]
    joinall(g_l)

if __name__ == '__main__':
    print('Synchronous:')
    synchronous()

    print('Asynchronous:')
    asynchronous()
#上面程序的重要部分是将task函数封装到Greenlet内部线程的gevent.spawn。 初始化的greenlet列表存放在数组threads中，此数组被传给gevent.joinall 函数，后者阻塞当前流程，并执行所有给定的greenlet。执行流程只会在 所有greenlet执行完后才会继续向下走。

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))

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:
        while True:
            res=conn.recv(1024)
            print('client %s:%s msg: %s' %(addr[0],addr[1],res))
            conn.send(res.upper())
    except Exception as e:
        print(e)
    finally:
        conn.close()

if __name__ == '__main__':
    server('127.0.0.1',8080)

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))


while True:
    msg=input('>>: ').strip()
    if not msg:continue

    client.send(msg.encode('utf-8'))
    msg=client.recv(1024)
    print(msg.decode('utf-8'))

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()