def walk(name):
    print(‘%s is walk‘%name)

t1=threading.Thread(target=walk,args=(‘small‘,))  #target传入要执行的函数名，arges传入参数
t1.start()    #启动线程

class walk(threading.Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):  #必须有run方法
        print(‘%s is walking‘%self.name)

t1=walk(‘small‘)
t1.start()

import threading,time
l=[]
def run():
    print(‘run %s‘%time.ctime())
    time.sleep(3)
    print(‘run end %s‘ % time.ctime())
def walk():
    print(‘walk %s‘ % time.ctime())
    time.sleep(5)
    print(‘walk end %s‘ % time.ctime())
s1=threading.Thread(target=run)
s2=threading.Thread(target=walk)
l.append(s1)
l.append(s2)
print(time.ctime())
for t  in l:
    #t.setDaemon(True) 注意:一定在start之前设置
    t.start()
    #t.join()
#s1.join()
#s2.join()
print(‘end %s‘%time.ctime())

daemon
A boolean value indicating whether this thread is a daemon thread (True) or not (False). This must be set before start() is called, otherwise RuntimeError is raised. Its initial value is inherited from the creating thread; the main thread is not a daemon thread and therefore all threads created in the main thread default to daemon = False.

The entire Python program exits when no alive non-daemon threads are left.

当daemon被设置为True时，如果主线程退出，那么子线程也将跟着退出，

反之，子线程将继续运行，直到正常退出。

def sum(n):
    res=0
    for i in range(n):
        res+=1
l=[]
s=time.time()
for i in range(10):
    t=threading.Thread(target=sum,args=(3000000,))
    l.append(t)
    t.start()
    #t.join() 串行 2.19s
for t in l:  #并行   2.22s
    t.join()
print(‘total time:%s‘%(time.time()-s))

from multiprocessing import Process

def sum(n):
    res=0
    for i in range(n):
        res+=1
if __name__==‘__main__‘:
    l=[]
    s=time.time()
    for i in range(10):
        t=Process(target=sum,args=(3000000,))
        l.append(t)
        t.start()
        #t.join() #串行 5s
    for t in l:  #并行   2.4s
        t.join()
    print(‘total time:%s‘%(time.time()-s))

import threading

R=threading.Lock()

R.acquire()
‘‘‘
对公共数据的操作
‘‘‘
R.release()

‘‘‘
1、为什么有了GIL，还需要线程同步？

多线程环境下必须存在资源的竞争,那么如何才能保证同一时刻只有一个线程对共享资源进行存取?

加锁, 对, 加锁可以保证存取操作的唯一性, 从而保证同一时刻只有一个线程对共享数据存取.

通常加锁也有2种不同的粒度的锁:

    coarse-grained(粗粒度)： python解释器层面维护着一个全局的锁机制,用来保证线程安全。
                            内核级通过GIL实现的互斥保护了内核的共享资源。

    fine-grained(细粒度)：   那么程序员需要自行地加,解锁来保证线程安全，
                            用户级通过自行加锁保护的用户程序的共享资源。

 2、GIL为什么限定在一个进程上？
 
 你写一个py程序，运行起来本身就是一个进程，这个进程是有解释器来翻译的，所以GIL限定在当前进程；
 如果又创建了一个子进程，那么两个进程是完全独立的，这个字进程也是有python解释器来运行的，所以
 这个子进程上也是受GIL影响的                


‘‘‘

import threading
import time

mutexA = threading.Lock()
mutexB = threading.Lock()

class MyThread(threading.Thread):

    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        self.fun1()
        self.fun2()

    def fun1(self):

        mutexA.acquire()  # 如果锁被占用,则阻塞在这里,等待锁的释放

        print ("I am %s , get res: %s---%s" %(self.name, "ResA",time.time()))

        mutexB.acquire()
        print ("I am %s , get res: %s---%s" %(self.name, "ResB",time.time()))
        mutexB.release()
        mutexA.release()


    def fun2(self):

        mutexB.acquire()
        print ("I am %s , get res: %s---%s" %(self.name, "ResB",time.time()))
        time.sleep(0.2)

        mutexA.acquire()
        print ("I am %s , get res: %s---%s" %(self.name, "ResA",time.time()))
        mutexA.release()

        mutexB.release()

if __name__ == "__main__":

    print("start---------------------------%s"%time.time())

    for i in range(0, 10):
        my_thread = MyThread()
        my_thread.start()

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG, format=‘(%(threadName)-10s) %(message)s‘,)

def worker(event):
    logging.debug(‘Waiting for redis ready...‘)
    event.wait()
    logging.debug(‘redis ready, and connect to redis server and do some work [%s]‘, time.ctime())
    time.sleep(1)

def main():
    readis_ready = threading.Event()
    t1 = threading.Thread(target=worker, args=(readis_ready,), name=‘t1‘)
    t1.start()

    t2 = threading.Thread(target=worker, args=(readis_ready,), name=‘t2‘)
    t2.start()

    logging.debug(‘first of all, check redis server, make sure it is OK, and then trigger the redis ready event‘)
    time.sleep(3) # simulate the check progress
    readis_ready.set()

if __name__=="__main__":
    main()

‘‘‘

此包中的常用方法(q = Queue.Queue()):

q.qsize() 返回队列的大小
q.empty() 如果队列为空，返回True,反之False
q.full() 如果队列满了，返回True,反之False
q.full 与 maxsize 大小对应
q.get([block[, timeout]]) 获取队列，timeout等待时间
q.get_nowait() 相当q.get(False)非阻塞 
q.put(item) 写入队列，timeout等待时间
q.put_nowait(item) 相当q.put(item, False)
q.task_done() 在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号
q.join() 实际上意味着等到队列为空，再执行别的操作

‘‘‘

‘‘‘

Python Queue模块有三种队列及构造函数: 

1、Python Queue模块的FIFO队列先进先出。  class queue.Queue(maxsize) 
2、LIFO类似于堆，即先进后出。           class queue.LifoQueue(maxsize) 
3、还有一种是优先级队列级别越低越先出来。 class queue.PriorityQueue(maxsize) 


import queue

#先进后出

q=queue.LifoQueue()

q.put(34)
q.put(56)
q.put(12)

#优先级
q=queue.PriorityQueue()
q.put([5,100])
q.put([7,200])
q.put([3,"hello"])
q.put([4,{"name":"alex"}])

while 1:
  data=http://www.mamicode.com/q.get()>‘‘‘

import time,random
import queue,threading

q = queue.Queue()

def Producer(name):
  count = 0
  while count <10:
    print("making........")
    time.sleep(random.randrange(3))
    q.put(count)
    print(‘Producer %s has produced %s baozi..‘ %(name, count))
    count +=1
    #q.task_done()
    #q.join()
    print("ok......")
def Consumer(name):
  count = 0
  while count <10:
    time.sleep(random.randrange(4))
    if not q.empty():
        data = q.get()
        #q.task_done()
        #q.join()
        print(data)
        print(‘\033[32;1mConsumer %s has eat %s baozi...\033[0m‘ %(name, data))
    else:
        print("-----no baozi anymore----")
    count +=1

p1 = threading.Thread(target=Producer, args=(‘A‘,))
c1 = threading.Thread(target=Consumer, args=(‘B‘,))
# c2 = threading.Thread(target=Consumer, args=(‘C‘,))
# c3 = threading.Thread(target=Consumer, args=(‘D‘,))
p1.start()
c1.start()
# c2.start()
# c3.start()

from  multiprocessing import Process
def cale(n):
    sum=0
    for i in range(n):
        sum+=i
    print(sum)
if __name__==‘__main__‘:
    ‘‘‘
    在 Windows 上，子进程会自动 import 启动它的这个文件，而在 import 的时候是会执行这些
    语句的。如果你这么写的话就会无限递归创建子进程报错。所以必须把创建子进程的部分用那个
     if 判断保护起来，import 的时候 __name__ 不是 __main__ ，就不会递归运行了。
    ‘‘‘
    p=Process(target=cale,args=(1000,))
    p.start()

import multiprocessing
class MyProcess(multiprocessing.Process):
    def __init__(self,n):
        super().__init__()
        self.n=n
        self.sum=0
    def run(self):
        for i  in range(self.n):
            self.sum+=i
        print(self.sum)
if __name__==‘__main__‘:
    p=MyProcess(1000)
    p.start()

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("------------------")
    time.sleep(1)

def foo(name):

    info(name)

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

import time

"""
传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁。
如果改用协程，生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高。
"""
# 注意到consumer函数是一个generator（生成器）:
# 任何包含yield关键字的函数都会自动成为生成器(generator)对象

def consumer():
    r = ‘‘
    while True:
        # 3、consumer通过yield拿到消息，处理，又通过yield把结果传回；
        #    yield指令具有return关键字的作用。然后函数的堆栈会自动冻结(freeze)在这一行。
        #    当函数调用者的下一次利用next()或generator.send()或for-in来再次调用该函数时，
        #    就会从yield代码的下一行开始，继续执行，再返回下一次迭代结果。通过这种方式，迭代器可以实现无限序列和惰性求值。
        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 gevent
import time

def foo():
    print("running in foo")
    gevent.sleep(2)
    print("switch to foo again")

def bar():
    print("switch to bar")
    gevent.sleep(5)
    print("switch to bar again")

start=time.time()

gevent.joinall(
    [gevent.spawn(foo),
    gevent.spawn(bar)]
)

print(time.time()-start)

gevent是一个基于协程（coroutine）的Python网络函数库，通过使用greenlet提供了一个在libev事件循环顶部的高级别并发API。

主要特性有以下几点：

<1> 基于libev的快速事件循环，Linux上面的是epoll机制

<2> 基于greenlet的轻量级执行单元

<3> API复用了Python标准库里的内容

<4> 支持SSL的协作式sockets

<5> 可通过线程池或c-ares实现DNS查询

<6> 通过monkey patching功能来使得第三方模块变成协作式

gevent.spawn()方法spawn一些jobs，然后通过gevent.joinall将jobs加入到微线程执行队列中等待其完成，设置超时为2秒。执行后的结果通过检查gevent.Greenlet.value值来收集。


＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝二
1、关于Linux的epoll机制：

epoll是Linux内核为处理大批量文件描述符而作了改进的poll，是Linux下多路复用IO接口select/poll的
增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。epoll的优点：

（1）支持一个进程打开大数目的socket描述符。select的一个进程所打开的FD由FD_SETSIZE的设置来限定，而epoll没有这个限制，它所支持的FD上限是
最大可打开文件的数目，远大于2048。

（2）IO效率不随FD数目增加而线性下降：由于epoll只会对“活跃”的socket进行操作，于是，只有”活跃”的socket才会主动去调用 callback函数，其他
idle状态的socket则不会。

（3）使用mmap加速内核与用户空间的消息传递。epoll是通过内核于用户空间mmap同一块内存实现的。

（4）内核微调。

2、libev机制

提供了指定文件描述符事件发生时调用回调函数的机制。libev是一个事件循环器：向libev注册感兴趣的事件，比如socket可读事件，libev会对所注册的事件
的源进行管理，并在事件发生时触发相应的程序。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝三


‘’‘

import gevent

            from gevent import socket

            urls = [‘www.google.com.hk’,’www.example.com’, ‘www.python.org’ ]

            jobs = [gevent.spawn(socket.gethostbyname, url) for url in urls]

            gevent.joinall(jobs, timeout=2)

            [job.value for job in jobs]


[‘74.125.128.199’, ‘208.77.188.166’, ‘82.94.164.162’]

            ’‘’

gevent.spawn()方法spawn一些jobs，然后通过gevent.joinall将jobs加入到微线程执行队列中等待其完成，设置超时为2秒。执行后的结果通过检查gevent.Greenlet.value值来收集。gevent.socket.gethostbyname()函数与标准的socket.gethotbyname()有相同的接口，但它不会阻塞整个解释器，因此会使得其他的greenlets跟随着无阻的请求而执行。

Monket patching

Python的运行环境允许我们在运行时修改大部分的对象，包括模块、类甚至函数。虽然这样做会产生“隐式的副作用”，而且出现问题很难调试，但在需要修改Python本身的基础行为时，Monkey patching就派上用场了。Monkey patching能够使得gevent修改标准库里面大部分的阻塞式系统调用，包括socket,ssl,threading和select等模块，而变成协作式运行。



from gevent import monkey ;

monkey . patch_socket ()

import urllib2



通过monkey.patch_socket()方法，urllib2模块可以使用在多微线程环境，达到与gevent共同工作的目的。

事件循环

不像其他网络库，gevent和eventlet类似， 在一个greenlet中隐式开始事件循环。没有必须调用run()或dispatch()的反应器(reactor)，在twisted中是有 reactor的。当gevent的API函数想阻塞时，它获得Hub实例(执行时间循环的greenlet),并切换过去。如果没有集线器实例则会动态 创建。

libev提供的事件循环默认使用系统最快轮询机制，设置LIBEV_FLAGS环境变量可指定轮询机制。LIBEV_FLAGS=1为select， LIBEV_FLAGS = 2为poll， LIBEV_FLAGS = 4为epoll,LIBEV_FLAGS = 8为kqueue。

Libev的API位于gevent.core下。注意libev API的回调在Hub的greenlet运行，因此使用同步greenlet的API。可以使用spawn()和Event.set()等异步API。

协程的好处：

无需线程上下文切换的开销
无需原子操作锁定及同步的开销
方便切换控制流，简化编程模型
高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。
缺点：

无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

import time
import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.setsockopt
sk.bind((‘127.0.0.1‘,6667))
sk.listen(5)
sk.setblocking(False)
while True:
    try:
        print (‘waiting client connection .......‘)
        connection,address = sk.accept()   # 进程主动轮询
        print("+++",address)
        client_messge = connection.recv(1024)
        print(str(client_messge,‘utf8‘))
        connection.close()
    except Exception as e:
        print (e)
        time.sleep(4)

#############################client

import time
import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

while True:
    sk.connect((‘127.0.0.1‘,6667))
    print("hello")
    sk.sendall(bytes("hello","utf8"))
    time.sleep(2)
    break

import select
import socket
s=socket.socket()
s.bind((‘127.0.0.1‘,8080))
s.setblocking(False)
s.listen(5)
inputs = [s, ]
while True:
    r, w, e = select.select(inputs, [], [])  #阻塞状态
    for item in r:
        if  item==s:
            server,addr=s.accept()
            inputs.append(server)
        else:
            data=item.recv(1024)
            item.send(data.upper())


#===================客户端===================
import socket
c=socket.socket()
c.connect((‘127.0.0.1‘,8080))
while True:
    com=input(‘>>:‘)
    c.send(com.encode(‘utf8‘))
    data=c.recv(1024)
    print(data.decode(‘utf8‘))

import selectors
import socket

sel = selectors.DefaultSelector()  #获取该系统下最优的异步模块，windows为select，linux为epoll

def accept(sock, mask):
    conn, addr = sock.accept()  # Should be ready
    print(‘accepted‘, conn, ‘from‘, addr)
    conn.setblocking(False)
    sel.register(conn, selectors.EVENT_READ, read)   #注册任务

def read(conn, mask):
    data = conn.recv(1000)  # Should be ready
    if data:
        print(‘echoing‘, repr(data), ‘to‘, conn)
        conn.send(data)  # Hope it won‘t block
    else:
        print(‘closing‘, conn)
        sel.unregister(conn)
        conn.close()

sock = socket.socket()
sock.bind((‘localhost‘, 1234))
sock.listen(100)
sock.setblocking(False)
sel.register(sock, selectors.EVENT_READ, accept)  #注册任务

while True:
    events = sel.select()   #开始监听
    for key, mask in events:
        callback = key.data       #key.fileobj 当前链接对象；#key.data  执行的函数
        callback(key.fileobj, mask)