GIL 的作用是：对于一个解释器，只能有一个thread在执行bytecode。所以每时每刻只有一条bytecode在被执行一个thread。GIL保证了bytecode 这层面上是thread safe的。
但是如果你有个操作比如 x += 1，这个操作需要多个bytecodes操作，在执行这个操作的多条bytecodes期间的时候可能中途就换thread了，这样就出现了data races的情况了。

Lock（指令锁）是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。Lock包含两种状态——锁定和非锁定，
以及两个基本的方法。可以认为Lock有一个锁定池，当线程请求锁定时，将线程至于池中，直到获得锁定后出池。
池中的线程处于状态图中的同步阻塞状态。
构造方法：Lock()
实例方法：
acquire([timeout]): 使线程进入同步阻塞状态，尝试获得锁定。
release(): 释放锁。使用前线程必须已获得锁定，否则将抛出异常。

#__author: greg

#date: 2017/9/17 21:38

# 线程死锁和递归锁

# Thread deadlocks and recursive locks

import threading,time

class myThread(threading.Thread):

    def doA(self):

        lockA.acquire()

        print(self.name,"gotlockA",time.ctime())

        time.sleep(3)

        lockB.acquire()

        print(self.name,"gotlockB",time.ctime())

        lockB.release()

        lockA.release()

    def doB(self):

        lockB.acquire()

        print(self.name,"gotlockB",time.ctime())

        time.sleep(2)

        lockA.acquire()

        print(self.name,"gotlockA",time.ctime())

        lockA.release()

        lockB.release()

    def run(self):

        self.doA()

        self.doB()

if __name__=="__main__":

    lockA=threading.Lock()

    lockB=threading.Lock()

    threads=[]

    for i in range(5):

        threads.append(myThread())

    for t in threads:

        t.start()

    for t in threads:

        t.join()#等待线程结束

#__author: greg

#date: 2017/9/17 21:49

import threading,time

class myThread(threading.Thread):

    def doA(self):

        lock.acquire()

        print(self.name,"gotlockA",time.ctime())

        # time.sleep(2)

        lock.acquire()

        print(self.name,"gotlockB",time.ctime())

        lock.release()

        lock.release()

    def doB(self):

        lock.acquire()

        print(self.name,"gotlockC",time.ctime())

        # time.sleep(3)

        lock.acquire()

        print(self.name,"gotlockD",time.ctime())

        lock.release()

        lock.release()

    def run(self):

        self.doA()

        self.doB()

if __name__=="__main__":

    # lockA=threading.Lock()

    # lockB=threading.Lock()

    lock = threading.RLock()

    threads=[]

    for i in range(5):

        threads.append(myThread())

    for t in threads:

        t.start()

    for t in threads:

        t.join()#等待线程结束

import threading

from time import ctime, sleep

class MyThread(threading.Thread):

    def __init__(self, func, args, name='', verb=False):

        threading.Thread.__init__(self)

        self.name = name

        self.func = func

        self.args = args

        self.verb = verb

    def getResult(self):

        return self.res

    def run(self):

        if self.verb:

            print('starting', self.name, 'at:', ctime())

        self.res = self.func(*self.args)

        if self.verb:

            print(self.name, 'finished at:', ctime())

def fib(x):

    sleep(0.005)

    if x < 2: return 1

    return (fib(x-2) + fib(x-1))

def fac(x):

    sleep(0.1)

    if x < 2: return 1

    return (x * fac(x-1))

def sum(x):

    sleep(0.1)

    if x < 2: return 1

    return (x + sum(x-1))

funcs = (fib, fac, sum)

n = 12

def main():

    nfuncs = range(len(funcs))

    print('*** SINGLE THREAD')

    for i in nfuncs:

        print('starting', funcs[i].__name__,'at:', ctime())

        print(funcs[i](n))

        print(funcs[i].__name__, 'finished at:',ctime())

    print('\n*** MULTIPLE THREADS')

    threads = []

    for i in nfuncs:

        t = MyThread(funcs[i], (n,),

        funcs[i].__name__)

        threads.append(t)

    for i in nfuncs:

        threads[i].start()

    for i in nfuncs:

        threads[i].join()

        print(threads[i].getResult())

    print('all DONE')

if __name__ == '__main__':

    main()

#__author: greg

#date: 2017/9/18 11:21

import threading

import time

product = None# 商品

con = threading.Condition()# 条件变量

def produce():# 生产者方法

    global product

    if con.acquire():

        while True:

            if product is None:

                print('produce...')

                product = 'anything'

                con.notify() # 通知消费者，商品已经生产

            con.wait()# 等待通知

            time.sleep(2)

def consume():# 消费者方法

    global product

    if con.acquire():

        while True:

            if product is not None:

                print('consume...')

                product = None

                con.notify()  # 通知生产者，商品已经没了

            con.wait()  # 等待通知

            time.sleep(2)

t1 = threading.Thread(target=produce)

t2 = threading.Thread(target=consume)

t2.start()

t1.start()

#__author: greg

#date: 2017/9/18 11:28

import threading

import time

semaphore = threading.Semaphore(2)# 计数器初值为2,比较4

# semaphore = threading.BoundedSemaphore(2)

def func():

    # 请求Semaphore，成功后计数器-1；计数器为0时阻塞

    print('%s acquire semaphore...' % threading.currentThread().getName())

    if semaphore.acquire():

        print('%s get semaphore' % threading.currentThread().getName())

        time.sleep(4)

        print('%s release semaphore' % threading.currentThread().getName())# 释放Semaphore，计数器+1

        semaphore.release()

t1 = threading.Thread(target=func)

t2 = threading.Thread(target=func)

t3 = threading.Thread(target=func)

t4 = threading.Thread(target=func)

t1.start()

t2.start()

t3.start()

t4.start()

time.sleep(2)

# 没有获得semaphore的主线程也可以调用release

# 若使用BoundedSemaphore，t4释放semaphore时将抛出异常

print('MainThread release semaphore without acquire')

semaphore.release()