python进阶之 线程编程

from threading import Thread
import os
def func():
    print('in fucn ',os.getpid())
print('in main ',os.getpid())
Thread(target=func).start()
#两个打印pid是一样的，说明线程是由进程产生的

from threading import Thread
import time
class Sayhi(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        time.sleep(2)
        print('%s say hello' % self.name)

if __name__ == '__main__':
    t = Sayhi('kobe')
    t.start()
    print('主线程')

import time
from threading import Thread
import os
def func(i):
    time.sleep(1)
    print('in fucn',i,os.getpid())
print('in main',os.getpid())
for i in range(20):
#Thread(target=func,args=(i,)).start()  #问题：多个线程在同一个进程中处理数据的时候，数据需不需要锁？
当然需要，这就是GIL锁存在的意义：同一进程内的同一时刻只能有一个线程访问cpu来修改同一个数据，导致Python中的多线程是‘伪多线程’，所以cpython解释器不能使用多核

Thread实例对象的方法
    isAlive(): 返回线程是否活动的。
    getName(): 返回线程名。
    setName(): 设置线程名。

threading模块提供的一些方法：
    threading.currentThread(): 返回当前的线程变量。
    threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行子线程启动后、结束前，不包括启动前和终止后的线程。
    threading.active_count(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果
        主线程也是一个线程，每个线程没有被start()的时候们不会被执行
        判断主线程是否结束了    

线程有terminate么?
    没有terminate 不能强制结束
    所有的子线程都会在执行完所有的任务之后自动结束

# 返回一个存储着所有线程对象的列表
from threading import enumerate,Thread
def func():
    print('in son thread')
Thread(target=func).start()
print(enumerate()) 

import time
from threading import Thread,activeCount

#守护线程守护的
def daemon_func():
    while True:
        time.sleep(0.5)
        print('守护线程')
def son_func():
    print('start son')
    time.sleep(10)
    print('end son')
    print('子线程:',time.time()-start)

start= time.time()
#子线程
t = Thread(target=daemon_func)
t.daemon = True
t.start()
#子线程
Thread(target=son_func).start()
#主线程
print(activeCount())
time.sleep(3)
print('主线程结束')
print('主线程：',time.time()-start)

from threading import Lock,Thread
import time

noodle_lock = Lock()
fork_lock = Lock()

def eat1(name):
    noodle_lock.acquire()   # 阻塞等面
    time.sleep(0.5)
    print('%s拿到面了'%name)
    fork_lock.acquire()
    print('%s拿到叉子了' % name)
    print('%s吃面'%name)
    fork_lock.release()
    print('%s放下叉子了' % name)
    noodle_lock.release()
    print('%s放下面了' % name)

def eat2(name):
    fork_lock.acquire()    # 阻塞等叉子
    print('%s拿到叉子了' % name)
    noodle_lock.acquire()
    print('%s拿到面了'%name)
    print('%s吃面'%name)
    noodle_lock.release()
    print('%s放下面了' % name)
    fork_lock.release()
    print('%s放下叉子了' % name)

Thread(target=eat1,args = ('admin',)).start()
Thread(target=eat2,args = ('kobe',)).start()
Thread(target=eat1,args = ('jordan',)).start()

from threading import RLock,Thread
fork_lock = noodle_lock = RLock()
def eat1(name):
    noodle_lock.acquire()   # 阻塞 宝元等面
    print('%s拿到面了'%name)
    fork_lock.acquire()
    print('%s拿到叉子了' % name)
    print('%s吃面'%name)
    fork_lock.release()
    print('%s放下叉子了' % name)
    noodle_lock.release()
    print('%s放下面了' % name)

def eat2(name):
    fork_lock.acquire()    # 阻塞 wusir等叉子
    print('%s拿到叉子了' % name)
    noodle_lock.acquire()
    print('%s拿到面了'%name)
    print('%s吃面'%name)
    noodle_lock.release()
    print('%s放下面了' % name)
    fork_lock.release()
    print('%s放下叉子了' % name)

Thread(target=eat1,args = ('alex',)).start()
Thread(target=eat2,args = ('wusir',)).start()
Thread(target=eat1,args = ('baoyuan',)).start()

from queue import Queue
#Queue就是一个线程队列的类,自带lock锁,实现了线程安全的数据类型
#队列是一个线程安全的数据类型，只有几个特点的属性不是安全的

q = Queue()   # 先进先出队列
# 在多线程下都不准
# q.empty() 判断是否为空
# q.full()  判断是否为满
# q.qsize() 队列的大小
#在多进程下都是数据安全的
q.put({1,2,3})
q.put_nowait('abc')
print(q.get_nowait())
print(q.get())

# 先进后出的队列 last in first out
from queue import LifoQueue   #线程安全的队列  栈和后进先出的场景都可以用
lfq = LifoQueue()
lfq.put(1)
lfq.put('abc')
lfq.put({'})
print(lfq.get())
print(lfq.get())
print(lfq.get())

from queue import PriorityQueue  # 优先级队列
pq = PriorityQueue()
pq.put((10,'askdhiu'))  #前面的数字就是优先级，越小越优先
pq.put((2,'asljlg'))
pq.put((20,'asljlg'))
print(pq.get())
print(pq.get())
print(pq.get())