python 线程 小笔记（1）

线程：操作系统进行运算调度的最小单位，是一串单一顺序指令的集合。在python中的线程是C语言原生线程（操作系统），由操作系统管理。

　　由于GIL的存在，使任何时刻同一进程里只能有一个线程正在运行。

　　python里是不能多线程并发的，无论cpu是多少核的！

python 线程知识点：

（1）线程的创建  ：

　　方法一

import  threading，time

def run(n):
    print(n, 'start',threading.get_ident)
    time.sleep(1)
    print(n, 'done')

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

print(threading.current_thread())

　　方法二

import threading,time

class Mythread(threading.Thread):
    def __init__(self,n):
        super(Mythread, self).__init__()
        self.n  =  n

    def run(self):
        print("xxxx %s"%self.n)

t1= Mythread('t1')
t2= Mythread('t2')
t1.start()
t2.start()

　　

（2）线程锁：

import threading,time
num = 0
lock = threading.Lock()
def run(n):
    global num
    start =time.time()
    lock.acquire()   #进程锁(互斥锁)
    for i in range(1000000):
         num +=1
    time.sleep(1)
    lock.release()
    print(n,time.time()-start)
  

t_obj =[]

for i in range(2):
    t = threading.Thread(target=run,args=(i,))
    t.start()
    t_obj.append(t)

for t in t_obj:
   t.join()

print("num",num)

　　递归锁

import threading, time


def run1():
    print("grab the first part data")
    lock.acquire()
    global num
    num += 1
    lock.release()
    return num


def run2():
    print("grab the second part data")
    lock.acquire()
    global num2
    num2 += 1
    lock.release()
    return num2


def run3():
    lock.acquire()
    res = run1()
    print('--------between run1 and run2-----')
    res2 = run2()
    lock.release()
    print(res, res2)




num, num2 = 0, 0
lock = threading.RLock()#递归锁
for i in range(1):
    t = threading.Thread(target=run3)
    t.start()

while threading.active_count() != 1:
    print(threading.active_count())
else:
    print('----all threads done---')
    print(num, num2)

　　

（3）守护进程：

for i in range(50):
    t = threading.Thread(target=run,args=(i,))
    t.setDaemon(True)#设置守护进程，主线程不需要等子线程执行完毕，程序完毕
    t.start()

　　

（4）信号量：

import threading, time


def run(n,a):
    semaphore.acquire()
    print("run the thread: %s\n" % n)
    time.sleep(a)
    semaphore.release()

if __name__ == '__main__':
    semaphore = threading.BoundedSemaphore(5)  # 最多允许5个线程同时运行
    for i in range(22):
        t = threading.Thread(target=run, args=(i,i))
        t.start()
while threading.active_count() != 1:
    pass  # print threading.active_count()
else:
    print('----all threads done---')
    #print(num)

　　

（5）队列：

queue.Queue(n)先进先出
queque.LifiQueue(n)后进先出
queue.PriorityQueue(n)可设置优先级的队列  n允许放多少个数据

queue.put(maxsize,block,timeout)放数据  block 是否堵塞  timeout 堵塞时间
queue.get(block,timeout)取数据
queue.size

import queue

q = queue.Queue(3)

q.put(1)
q.put(2)
q.put(3)
print(q.qsize())

print(q.get())
print(q.get())
print(q.get())


try:
    print(q.get(block=False))
except queue.Empty  as e:
    print("queue is empty")

　　（6）事件

事件，线程之间用来同步的工具
even.set()设定标志位
even.clear()清除标志位
even.is_set()判断是否设置
even = threading.Even()

import threading,time
state_list = ['red','yellow','green']
state =''
lock = threading.Lock()
even = threading.Event()
even1 = threading.Event()

def run():
    count =0
    while True:
        if count <10:
            even.clear()
            print('led state is: \033[41;1m red \033[0m \n')
        elif count >=10 and count <15:
            print('led state is: \033[43;1m yellow \033[0m \n')
        elif count >=15 and count <25:
            even.set()
            print('led state is:  \033[42;1m green \033[0m \n')
        else:
            count = 0

        count +=1
        time.sleep(1)

def run1():
    global state
    while True:
        if even.is_set():
            print("i am go\n")
            time.sleep(1)
        else:
            print("i am stop\n")
            even.wait()

t = threading.Thread(target=run)
t.start()

t1 = threading.Thread(target=run1)
t1.start()