目录：

一、线程

    1.线程基本操作 

        1.创建线程的方式

        2.线程锁

        3.信号量以及事件

        4.条件以及定时器

    2.队列的使用

        1.队列的使用

        2.生产者消费者模型

    3.自定义线程池

二、进程   

    1.进程基本操作

        1.创建进程

        2.进程锁

    2.进程池

三、协程

   1.greenlet

    2.gevent

四、缓存    

    1.python操作memcache

    2.python操作redis

  1.线程基本操作

      1.创建线程的方式

#创建线程方法一（最常见）
import threading

def f1(args):
    print(args)
t = threading.Thread(target=f1,args=(123,))
t.start()   #线程开启，等待cpu调用

‘‘‘
t.run() 方法：
    当cpu调度的时候，就执行Thread里边的run方法
    t.run() #是由cpu替我们调度执行的
‘‘‘

#创建线程方法二 (通过创建类创建线程) (自定义方式)
import threading
class MyThread(threading.Thread):
    def __init__(self,func,args): #定义init，就不执行父类的方法了，执行自己的
        self.func = func
        self.args = args
        super(MyThread,self).__init__()
    def run(self):
        self.func(self.args)

def f2(arg):
    print(arg)
obj = MyThread(f2,123)            #func = f2  args=123
obj.start()

      2.线程锁

线程锁分类：
    1.
        l.acquire()
        l.release()
        lock = threading.Lock()     #只能锁一次
    2.
        l.acquire()
        l.release()
        lock = threadingRLock()    #可以递归锁，可以锁多层，可以嵌套。 （常用）

例子：
当有一个数字10，如果同时10个线程去减1，
那么就会产生脏数据，输出结果都输出为0。

#例1
import threading
import time
NUM = 10

def func(l):
    global NUM
    NUM -= 1
    time.sleep(2)           #会产生脏数据，造成输出都是0
    print(NUM)
lock = threading.Lock()     #只能锁一次
for i in range(10):
    t = threading.Thread(target=func,args=(lock,))
    t.start()

#解决此问题就是加锁，同时只允许一个线程进入取值。；(单层锁)
#例2
import threading
import time
NUM = 10

def func(l):
    global NUM
    l.acquire()             #上锁 使同一时刻只有一个进程使用
    NUM -= 1
    time.sleep(2)           #会产生脏数据，造成输出都是0
    print(NUM)
    l.release()             #开锁
lock = threading.Lock()     #只能锁一次
for i in range(10):
    t = threading.Thread(target=func,args=(lock,))
    t.start()
    
#例3 多层锁
import threading
import time
NUM = 10

def func(l):
    global NUM
    #上锁               #使同一时刻只有一个进程使用
    l.acquire()
    NUM -= 1
    l.acquire()     #多层锁
    time.sleep(2)       #会产生脏数据，造成输出都是0
    l.release()     #多层锁
    print(NUM)
    l.release()     #开锁
#lock = threading.Lock()     #只能锁一次
lock = threading.RLock()    #可以递归锁，可以锁多层，可以嵌套。
for i in range(10):
    t = threading.Thread(target=func,args=(lock,))
    t.start()

      3.信号量以及事件

      4.条件以及定时器

  2.队列的使用

  3.自定义线程池