一、執行緒

Threading用於提供執行緒相關的操作，執行緒是應用程式中工作的最小單元。

#!/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'

上述程式碼建立了10個“前臺”執行緒，然後控制器就交給了CPU，CPU根據指定演算法進行排程，分片執行指令。

更多方法：

• start            執行緒準備就緒，等待CPU排程
• setName      為執行緒設定名稱
• getName      獲取執行緒名稱
• setDaemon   設定為後臺執行緒或前臺執行緒（預設）
                     如果是後臺執行緒，主執行緒執行過程中，後臺執行緒也在進行，主執行緒執行完畢後，後臺執行緒不論成功與否，均停止
                      如果是前臺執行緒，主執行緒執行過程中，前臺執行緒也在進行，主執行緒執行完畢後，等待前臺執行緒也執行完成後，程式停止
• join              逐個執行每個執行緒，執行完畢後繼續往下執行，該方法使得多執行緒變得無意義
• run              執行緒被cpu排程後自動執行執行緒物件的run方法

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

執行緒鎖（Lock、RLock）

由於執行緒之間是進行隨機排程，並且每個執行緒可能只執行n條執行之後，當多個執行緒同時修改同一條資料時可能會出現髒資料，所以，出現了執行緒鎖 - 同一時刻允許一個執行緒執行操作。

#!/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()

#!/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 == "1":
    event.set()#設定成綠燈

#!/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

#互斥鎖 同時只允許一個執行緒更改資料，而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()

二、程序

 注意：由於程序之間的資料需要各自持有一份，所以建立程序需要的非常大的開銷。

程序間的資料共享

    '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

程序鎖例項:

 程序池

程序池內部維護一個程序序列，當使用時，則去程序池中獲取一個程序，如果程序池序列中沒有可供使用的進程序，那麼程式就會等待，直到程序池中有可用程序為止。

程序池中有兩個方法：

• apply
• apply_async

 三、協程

 執行緒和程序的操作是由程式觸發系統介面，最後的執行者是系統；協程的操作則是程式設計師。

協程存在的意義：對於多執行緒應用，CPU通過切片的方式來切換執行緒間的執行，執行緒切換時需要耗時（儲存狀態，下次繼續）。協程，則只使用一個執行緒，在一個執行緒中規定某個程式碼塊執行順序。

協程的適用場景：當程式中存在大量不需要CPU的操作時（IO），適用於協程；

四、佇列

 五、python-memcache

Memcached安裝，使用：