#!/usr/bin/env python

# -*- coding:utf-8 -*-

import threading

import time

def show(arg):

    time.sleep(1)

    print 'thread'+str(arg)

for i in range(10):

    t = threading.Thread(target=show, args=(i,))

    t.start()

print 'main thread stop'

import threading

import time

class MyThread(threading.Thread):

    def __init__(self,num):

        threading.Thread.__init__(self)

        self.num = num

    def run(self):#定义每个线程要运行的函数

        print("running on number:%s" %self.num)

        time.sleep(3)

if __name__ == '__main__':

    t1 = MyThread(1)

    t2 = MyThread(2)

    t1.start()

    t2.start()

自定义线程类

#!/usr/bin/env python

#-*-coding:utf-8-*-

import threading

import time

NUM=10

def func(i,l):

    global NUM

    #上锁

    l.acquire()

    NUM -= 1

    time.sleep(5)

    print(NUM)

    #开锁

    l.release()

#lock=threading.Lock()

# lock=threading.RLock()

lock=threading.BoundedSemaphore(5)

for i in range(10):

    # t=threading.Thread(target=func,args=(lock,))

    t=threading.Thread(target=func,args=(i,lock,))

    t.start()

lock、Rlock

#!/usr/bin/env python

#-*-coding:utf-8-*-

import threading

def func(i,e):

    print(i)

    e.wait()#检测是什么灯，

    print(i+100)

event=threading.Event()

for i in range(10):

    t=threading.Thread(target=func,args=(i,event,))

    t.start()

#--------------

event.clear()#设置成红灯

inp=input('>>>')

if inp == "":

    event.set()#设置成绿灯

event锁

#!/usr/bin/env python

#-*-coding:utf-8-*-

#第一种

import threading

def condition():

    ret = False

    r = input('>>>')

    if r == 'true':

        ret = True

    else:

        ret = False

    return ret

def func(i,con):

    print(i)

    con.acquire()

    con.wait_for(condition)

    print(i+100)

    con.release()

c = threading.Condition()

for i in range(10):

    t = threading.Thread(target=func, args=(i,c,))

    t.start()

#第二种

import threading

def func(i,con):

    print(i)

    con.acquire()

    con.wait()

    print(i+100)

    con.release()

c = threading.Condition()

for i in range(10):

    t = threading.Thread(target=func, args=(i,c,))

    t.start()

while True:

    inp = input('>>>')

    if inp == 'q':

        break

    c.acquire()

    c.notify(int(inp))

    c.release()

from threading import Timer

def hello():

    print("hello, world")

t = Timer(1, hello)

t.start()  # after 1 seconds, "hello, world" will be printed

条件 Condition

#互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。

import threading,time

def run(n):

    semaphore.acquire()

    time.sleep(1)

    print("run the thread: %s" %n)

    semaphore.release()

if __name__ == '__main__':

    num= 0

    semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行

    for i in range(20):

        t = threading.Thread(target=run,args=(i,))

        t.start()

信号量（Semaphore）

from multiprocessing import Process

import threading

import time

def foo(i):

    print 'say hi',i

for i in range(10):

    p = Process(target=foo,args=(i,))

    p.start()

#!/usr/bin/env python

#-*-coding:utf-8-*-

#第一种multiprocessing,queues

# from multiprocessing import Process

# from multiprocessing  import queues

# import multiprocessing

#

# def foo(i,arg):

#     arg.put(i)

#     print('say hi',i,arg.qsize())

#

# if __name__=='__main__':

#     li = queues.Queue(20,ctx=multiprocessing)

#     for i in range(10):

#         p = Process(target=foo,args=(i,li,))

#         p.start()

#第二种Array

# from multiprocessing import Process

# from multiprocessing import queues

# import multiprocessing

# from multiprocessing import Array

# def foo(i,arg):

#     arg[i]=i+100

#     for item in arg:

#         print(item)

#     print('==========')

# if __name__=='__main__':

#     li=Array('i',10)

#     for i in range(10):

#         p=Process(target=foo,args=(i,li,))

#         p.start()

#第三种

from multiprocessing import Process

from multiprocessing import queues

import multiprocessing

from multiprocessing import Manager

def foo(i,arg):

    # arg.put(i)

    # print('say hi',i,arg.qsize())

    # arg[i] = i + 100

    # for item in arg:

    #     print(item)

    # print('==========')

    arg[i]  = i + 100

    print(arg.values())

if __name__ == '__main__':

    #li = []

    #li = queues.Queue(20,ctx=multiprocessing)

    obj = Manager()

    li = obj.dict()

    #li = Array('i',10)

    for i in range(10):

        p = Process(target=foo,args=(i,li,))

        #p.daemon = True

        p.start()

        #p.join()

        import time

        time.sleep(0.1)

    'c': ctypes.c_char,  'u': ctypes.c_wchar,

    'b': ctypes.c_byte,  'B': ctypes.c_ubyte,

    'h': ctypes.c_short, 'H': ctypes.c_ushort,

    'i': ctypes.c_int,   'I': ctypes.c_uint,

    'l': ctypes.c_long,  'L': ctypes.c_ulong,

    'f': ctypes.c_float, 'd': ctypes.c_double

Array_类型对应表

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from multiprocessing import Process, Array, RLock

def Foo(lock,temp,i):

    """

    将第0个数加100

    """

    lock.acquire()

    temp[0] = 100+i

    for item in temp:

        print i,'----->',item

    lock.release()

lock = RLock()

temp = Array('i', [11, 22, 33, 44])

for i in range(20):

    p = Process(target=Foo,args=(lock,temp,i,))

    p.start()

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from  multiprocessing import Process,Pool

import time

def Foo(i):

    time.sleep(2)

    return i+100

def Bar(arg):

    print arg

pool = Pool(5)

#print pool.apply(Foo,(1,))

#print pool.apply_async(func =Foo, args=(1,)).get()

for i in range(10):

    pool.apply_async(func=Foo, args=(i,),callback=Bar)

print 'end'

pool.close()

pool.join()#进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。

#!/usr/bin/env python

# -*- coding:utf-8 -*-

from greenlet import greenlet

def test1():

    print 12

    gr2.switch()

    print 34

    gr2.switch()

def test2():

    print 56

    gr1.switch()

    print 78

gr1 = greenlet(test1)

gr2 = greenlet(test2)

gr1.switch()

import gevent

def foo():

    print('Running in foo')

    gevent.sleep(0)

    print('Explicit context switch to foo again')

def bar():

    print('Explicit context to bar')

    gevent.sleep(0)

    print('Implicit context switch back to bar')

gevent.joinall([

    gevent.spawn(foo),

    gevent.spawn(bar),

])

#!/usr/bin/env python

#-*-coding:utf-8-*-

import queue,time

#先进先出队列

#put放数据，是否阻塞，阻塞时的超时时间

#get取数据（默认阻塞），是否阻塞，阻塞时的超时时间

#队列最大长度

#qsize()真是个数

#maxsize最大支持个数

#join,task_done,阻塞进程，当队列中的任务执行完毕后，不再阻塞

# q=queue.Queue(2)

# print(q.empty())#判断队列有没有元素，有返回True

# q.put(11)

# q.put(22)

# print(q.empty())

# print(q.qsize())

# q.put(22)

# q.put(33,block=False)

# q.put(33,block=False,timeout=2)

# print(q.get())

# print(q.get())

# print(q.get(timeout=2))

import  queue               #先进先出

# q = queue.LifoQueue()

# q.put(123)

# q.put(456)

# print(q.get())

# q = queue.PriorityQueue()   #根据优先级处理

# q.put((1,"alex1"))

# q.put((2,"alex2"))

# q.put((3,"alex3"))

# print(q.get())

# q= queue.deque()          #双向队列

# q.append((123))

# q.append(234)

# q.appendleft(456)

# print(q.pop())

# print(q.popleft())

# q=queue.Queue(5)

# q.put(123)

# q.put(456)

# q.get()

# q.task_done()

# q.get()

# time.sleep(5)

# q.task_done()

# q.join()

wget http://memcached.org/latest

tar -zxvf memcached-1.x.x.tar.gz

cd memcached-1.x.x

./configure && make && make test && sudo make install

PS：依赖libevent

       yum install libevent-devel

       apt-get install libevent-dev

启动memcache

memcached -d -m 10    -u root -l 10.211.55.4 -p 12000 -c 256 -P /tmp/memcached.pid

参数说明:

    -d 是启动一个守护进程

    -m 是分配给Memcache使用的内存数量，单位是MB

    -u 是运行Memcache的用户

    -l 是监听的服务器IP地址

    -p 是设置Memcache监听的端口,最好是1024以上的端口

    -c 选项是最大运行的并发连接数，默认是1024，按照你服务器的负载量来设定

    -P 是设置保存Memcache的pid文件

命令

存储命令: set/add/replace/append/prepend/cas

获取命令: get/gets

其他命令: delete/stats..

python -m pip install python-memcache

#!/usr/bin/env python

#-*-coding:utf-8-*-

# python3 -m pip install --upgrade pip

# python3 -m pip install python-memcached

import memcache

# mc=memcache.Client(['192.168.144.135:12000'],debug=True)

# mc.set("foo","bar")#set存储

# ret=mc.get("foo")#get获取

# print(ret)#debug = True 表示运行出现错误时，现实错误信息，上线后移除该参数。

#add添加一条键值对，如果已经存在的 key，重复执行add操作异常

# mc=memcache.Client(['192.168.144.135:12000'],debug=True)

# mc.add('k1', 'v1')

# mc.add('k1', 'v2')#会报错

# replace 修改某个key的值，如果key不存在，则异常

# mc=memcache.Client(['192.168.144.135:12000'],debug=True)

# mc.set('k1', 'v1')

# mc.replace('k1','999')#替换的是v值,v1变成了999

# # 如果memcache中存在key值，则替换成功，否则异常

# ret=mc.get('k1')

# print(ret)

# set 和 set_multi

# set       设置一个键值对，如果key不存在，则创建，如果key存在，则修改

# set_multi 设置多个键值对，如果key不存在，则创建，如果key存在，则修改

# mc=memcache.Client(['192.168.144.135:12000'],debug=True)

# mc.set('key1','zrz')

# mc.set('key1','zkk')#如果k存在则更改，不存在则创建

# mc.set_multi({'key1': 'val1', 'key2': 'val2'})#多个一起设置

# ret=mc.get('key2')

# print(ret)

# delete 和 delete_multi

# delete             在Memcached中删除指定的一个键值对

# delete_multi    在Memcached中删除指定的多个键值对

# mc=memcache.Client(['192.168.144.135:12000'],debug=True)

# mc.set_multi({'key1': 'val1', 'key2': 'val2'})

# mc.delete('key1')#如果存在则删除，不存在也不报异常

# ret=mc.get('key1')

# print(ret)

# get 和 get_multi

# get            获取一个键值对

# get_multi   获取多一个键值对

# mc=memcache.Client(['192.168.144.135:12000'],debug=True)

# mc.set_multi({'key1': 'val1', 'key2': 'val2'})

# ret1=mc.get('key1')

# dic_ret=mc.get_multi(['key1','key2'])#获取的是一个字典

# print(dic_ret,type(dic_ret))

# append 和 prepend

# append    修改指定key的值，在该值 后面 追加内容

# prepend   修改指定key的值，在该值 前面 插入内容

# mc=memcache.Client(['192.168.144.135:12000'],debug=True)

# mc.set('k1','v1')

# mc.append('k1','v2')#在v1后添加v2

# mc.prepend('k1','v3')#在v1前添加v2

# r=mc.get('k1')

# print(r)

# decr 和 incr　　

# incr  自增，将Memcached中的某一个值增加 N （ N默认为1 ）

# decr 自减，将Memcached中的某一个值减少 N （ N默认为1 ）

# mc=memcache.Client(['192.168.144.135:12000'],debug=True)

# mc.set('k1',77)

# while True:

#     mc.incr('k1',10)#将Memcached中的某一个值增加10

#     mc.decr('k1')#将Memcached中的某一个值减少 N （ N默认为1 ）

#     r=mc.get('k1')

#     print(r)

# gets 和 cas

# 如商城商品剩余个数，假设改值保存在memcache中，product_count = 900

# A用户刷新页面从memcache中读取到product_count = 900

# B用户刷新页面从memcache中读取到product_count = 900

# 如果A、B用户均购买商品

# A用户修改商品剩余个数 product_count＝899

# B用户修改商品剩余个数 product_count＝899

# 如此一来缓存内的数据便不在正确，两个用户购买商品后，商品剩余还是 899

# 如果使用python的set和get来操作以上过程，那么程序就会如上述所示情况！

# 如果想要避免此情况的发生，只要使用 gets 和 cas 即可，如：

# mc=memcache.Client(['192.168.144.135:12000'],debug=True)

# mc.gets('product_count')

# mc.set('product_count',111)

# a=mc.get('product_count')

# mc.cas('product_count', 777)

# mc.incr('product_count',222)

# # ...

# # 如果有人在gets之后和cas之前修改了product_count，那么，下面的设置将会执行失败，剖出异常，从而避免非正常数据的产生

# mc.cas('product_count', 899)

# r=mc.get('product_count')

# print(a)#感觉并没什么卵用

安装：

wget http://download.redis.io/releases/redis-3.0.6.tar.gz

tar xzf redis-3.0.6.tar.gz

cd redis-3.0.6

make

启动服务端：src/redis-server

启动客户端：src/redis-cli

python -m pip install redis

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import redis

r = redis.Redis(host='10.211.55.4', port=6379)

r.set('foo', 'Bar')

print r.get('foo')

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import redis

pool = redis.ConnectionPool(host='10.211.55.4', port=6379)

r = redis.Redis(connection_pool=pool)

r.set('foo', 'Bar')

print r.get('foo')

在Redis中设置值，默认，不存在则创建，存在则修改

参数：

     ex，过期时间（秒）

     px，过期时间（毫秒）

     nx，如果设置为True，则只有name不存在时，当前set操作才执行

     xx，如果设置为True，则只有name存在时，岗前set操作才执行