（1.）直接导入
from multiprocessing import Process
import os
import time
def info(name):
    print("name:",name)
    print(‘parent process:‘, os.getppid())
    print(‘process id:‘, os.getpid())
    print("------------------")
def foo(name):
    info(name)
    time.sleep(50)
if __name__ == ‘__main__‘:
    info(‘main process line‘)
    p1 = Process(target=info, args=(‘alvin‘,))
    p2 = Process(target=foo, args=(‘egon‘,))
    p1.start()
    p2.start()

    p1.join()
    p2.join()

    print("ending")
time.sleep(100)
>>
name: main process line
parent process: 16976
process id: 18456
------------------
name: alvin
parent process: 18456
process id: 19884
------------------
name: egon
parent process: 18456
process id: 19112
------------------
ending

yield是最基本的携程函数
没有办法监听到IO，进行切换
可以保存到数据的状态通过send方法来运行
import time
# 注意到consumer函数是一个generator（生成器）:
# 任何包含yield关键字的函数都会自动成为生成器(generator)对象

def consumer():
    r = ‘‘
    while True:
        n = yield r
        if not n:
            return
        print(‘[CONSUMER] ←← Consuming %s...‘ % n)
        time.sleep(1)
        r = ‘200 OK‘
def produce(c):
    # 1、首先调用c.next()启动生成器
    next(c)
    n = 0
    while n < 5:
        n = n + 1
        print(‘[PRODUCER] →→ Producing %s...‘ % n)
        # 2、然后，一旦生产了东西，通过c.send(n)切换到consumer执行；
        cr = c.send(n)
        # 4、produce拿到consumer处理的结果，继续生产下一条消息；
        print(‘[PRODUCER] Consumer return: %s‘ % cr)
    # 5、produce决定不生产了，通过c.close()关闭consumer，整个过程结束。
    c.close()
if __name__==‘__main__‘:
    # 6、整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。
    c = consumer()
    produce(c)

#服务端

import select

import socket

sock=socket.socket()#产生一个套接字

sock.bind(("127.0.0.1",8080))

sock.listen(5)

sock.setblocking(False)

inputs=[sock,]

while 1:

    r,w,e=select.select(inputs,[],[])#监听有变化的套接字sock

    #wait for data

    for obj in r:

        if obj==sock:

            conn,addr=obj.accept()#从内核copy信息到用户态

            print("conn",conn)

            inputs.append(conn)#监听列表添加客户conn

        else:

            data=http://www.mamicode.com/obj.recv(1024)#接收信息"utf8"))

            send_data=http://www.mamicode.com/input(">>")#发送信息

            obj.send(send_data.encode("utf8"))

#客户端

import socket

sock=socket.socket()

sock.connect(("127.0.0.1",8080))

while 1:

    data=http://www.mamicode.com/input("input>>")

    sock.send(data.encode("utf8"))

    recv_data=http://www.mamicode.com/sock.recv(1024)"utf8"))

 

sock.close()

import selectors
import socket
sock=socket.socket()
sock.bind(("127.0.0.1",8080))
sock.listen(5)
sock.setblocking(False)
sel=selectors.DefaultSelector()#根据具体平台选择最佳IO多路机制
def read(conn,mask):
    try:
        data=http://www.mamicode.com/conn.recv(1024)"utf8"))
        data2=input(">>")
        conn.send(data2.encode("utf8"))
    except Exception:
        sel.unregister(conn)
def accept(sock,mask):
    sel.register(sock,selectors.EVENT_READ,accept)
    conn,addr=sock.accept()
    sel.register(conn,selectors.EVENT_READ,read)
sel.register(sock,selectors.EVENT_READ,accept)#注册功能
while 1:
    events=sel.select()
    for key,mask in events:
        print(key.data)#定义的函数
        print(key.fileobj)#socket对象
        func=key.data
        obj=key.fileobj
        func(obj,mask)

break


import socket
sock=socket.socket()
sock.connect(("127.0.0.1",8080))
while 1:
    data=http://www.mamicode.com/input("input>>")
    sock.send(data.encode("utf8"))
    recv_data=http://www.mamicode.com/sock.recv(1024)"utf8"))

sock.close()

import queue
q=queue.Queue(3)#默认是先进先出
q.put(111)
q.put("hello")
q.put(222)
print(q.get())
print(q.get())
print(q.get())
>>
111
hello
222

import queue
q=queue.Queue(3)#默认是先进先出
q.put(111)
q.put("hello")
q.put(222)
q.put(223,False)#q=queue.Queue(3)队列定义只能放3个值，
# #超过限额时，返回错误信息
print(q.get())
print(q.get())
print(q.get())

q.get()#没有数据的时候不会报错，只会等待
q.get(False)#数据为空，报错

先进后出
import queue
q=queue.LifoQueue()
q.put(111)
q.put(5)
q.put(43)
print(q.get())

优先级
import queue
q=queue.PriorityQueue()
q.put([4,"hello"])
q.put([1,"hello5"])
print(q.get())