Python锁

#A reentrant lock must be released by the thread that #acquired it. Once a thread has acquired a reentrant lock, the #same thread may acquire it again without blocking; the #thread must release it once for each time it has acquired it.
#递归锁-->为了嵌套锁而设计的
#计数器Counter、字典dict的key存储线程名字，value存储锁标识
#owner = _active[owner].name
#acquire: me = get_ident()  if self._owner == me: 
#                                             self.count+=1
#release：if self._owner != get_ident(): raise
#                else: self._count -= 1
#get_ident():
#Return a non-zero integer that uniquely identifies the #current thread amongst other threads that exist #simultaneously. This may be used to identify per-thread #resources. Even though on some platforms threads #identities may appear to be allocated consecutive #numbers starting at 1, this behavior should not be relied #upon, and the number should be seen purely as a magic #cookie.
#A thread's identity may be reused for another thread #after it exits.

#Condition
#Class that implements a condition variable. A condition #variable allows one or more threads to wait until they are
#notified by another thread. If the lock argument is given 
#and not None, it must be a Lock or RLock object, and it is #used as the underlying lock. Otherwise, a new RLock object #is created and used as the underlying lock.

#wait(self, timeout=None)
#wait_for(self, predicate, timeout=None) wait无参数，wait_for的参数是一个布尔表达式
#notify(self)
#notify_all(self)

import threading, time
from random import randint
class Producer(threading.Thread):
    def run(self):
        global L
        while True:
            val = randint(0, 100)
            print('生产者', self.name,':Append'+str(val))
            if lock_con.acquire():
                L.append(val)
                print(L)
                lock_con.notify()
                lock_con.release()
class Consumer(threading.Thread):
    def run(self):
        global L
        while True:
            lock_con.acquire()
            if len(L) == 0:
                lock_con.wait()
            print('消费者'， self.name,  ":Delete" + str(L[0]), L)
            del L[0]
            lock_con.release()
if __name__ == '__main__':
    L = []
    lock_con = threading.Condition()
    threads = []
    for i in range(5):
        threads.append(Producer())
    threads.append(Consumer())
    for t in threads:
        t.start()
    for t in threads:
        t.join()

关于start与run
#start
#Start the thread's activity.
#It must be called at most once per thread object.
#It arranges for the object's run() method to be invoked in a #separate thread of control.
#This method will raise a RuntimeError if called more than #once on the same thread object.
#开启一个新的线程来运行run方法，若被多次调用报错
#run
#Method representing the thread's activity.
#You may override this method in a subclass. 
#The standard run() method invokes the callable object #passed to the object's constructor as the target 
#argument, if any, with sequential and keyword arguments #taken from the args and kwargs arguments, respectively.

Python中多线程的两种方式：

继承Thread类，重写run方法

直接调用Thread，传入函数名和参数

Java中多线程的两种方式：

继承Thread类，覆盖run方法

实现Runnable接口，覆盖run方法

用start()来启动线程，实现了真正意义上的启动线程，此时会出现异步执行的效果，结果的随机性。‘ 
而如果使用run()来启动线程，就不是异步执行了，而是同步执行，不会达到使用线程的意义。是用main这个主线程去调用不同的run方法。

Semaphore  本质上是 若干个Condition Lock  Counter：释放锁的次数-获取锁的次数+初始值
This class implements semaphore objects. Semaphores 
manage a counter representing the number of release() calls 
minus the number of acquire() calls, plus an initial value. The 
acquire() method blocks if necessary until it can return 
without making the counter negative. If not given, value 
defaults to 1.

BoundedSemaphore（Semphore） 本质上就是信号量+counter（上界）
A bounded semaphore checks to make sure its current value
doesn't exceed its initial value. If it does, ValueError is raised.
In most situations semaphores are used to guard resources 
with limited capacity.

Event： flag  condition(Lock)
Class implementing event objects.
Events manage a flag that can be set to true with the set() method and reset to false with the clear() method. 
The wait() method blocks until the flag is true.  
The flag is initially false.
isSet():返回一个布尔值
set():设置为True  实现的是notify_all()
clear():设置为False
wait()

Lock锁的底层实现：
1.test-and-set
    value = 0
    while (test-and-set(value)):
        ;//spin 忙等
    如果value=0 跳出while循环，否则自旋
    release时，将value设置为0

    无忙等
    class Lock{
        value = 0;
        WaitQueue q;
    }
    Lock Acquire(){
        while(test-and-set(value)){
            add this TCB to wait queue q;
            schedule();
        }
    }
    Lock Release(){
        value = 0
        remove one thread t from q;
        wakeup(t)
    }
2.exchange
    int lock = 0
    int key = 0
    do{
        key = 1
        while key == 1  exchange(lock, key);
            critical section
        lock = 0
            remainder section
    }