一 : 科普一分钟

线程是操作系统能够运算调度的最小单位,它被包含在进程中,是进程中实际的运作单位,一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务.

进程 : 我们所用的应该程序,在执行时候可以简单理解为一个'进程',也就是说,进程就是一个暴露给操作系统管理,其包含对各种资源的调用.
线程:是操作系统最小的调动单位,是一串指令的集合

二 : 多线程创建和使用

创建子线程

import  threading
import  time

# 子线程调用方法
def run:
    print("Run Start",n)
    time.sleep(1)
    print("Run done")

#创建子线程实例对象 
 t1 = threading.Thread(target=run, args=("TZ",))

#启动线程,执行子线程任务
t1.start()

守护线程

 #把当前线程设置为守护线程 在start之前
    t1.setDaemon(True)

用类实例化子线程

#创建自定义线程类
class MYThread(threading.Thread):
    def __init__(self,n):
        super(MYThread,self).__init__()
        self.n = n

    def run(self):
        print("runnint task : ",self.n)
        time.sleep(2)

#实例化类
t1 = MYThread("t1")
t2 = MYThread("t2")

#启动线程
t1.start()
t2.start()

join
如果我们在两个字线程执行时候 ,调用第一个线程的join方法会有什么结果呢,相当于两个线程为串行线程,执行完第一个再执行第二个

t1.start()
t1.join() #等待t1结束 进行t2  变成串行了
t2.start()

信号量
最大允许线程同时进行的数量,当一条线程结束,新的线程插入,保持子线程不超过规定的信号量.

import  threading,time

#执行函数
def run(n):
    semaphore.acquire()
    time.sleep(1)
    print("run the thread : %s\n" %n)
    semaphore.release()

num = 0
#允许最多5个线程同时运行
semaphore = threading.BoundedSemaphore(5)

#循环创建20条线程
for i in range(20):
    t = threading.Thread(target=run,args=(i,))
    t.start()

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

三 : 线程锁

意义: 在挂锁时期,让子线程串行执行.
为什么要有线程锁:当多个线程执行,并且访问同一块内存num = 0,有两个线程线程A,线程B执行+1操作
变量时候,A线程读取变量为0,并且放入缓存区,当A线程想执行+1操作时候,线程B启动,并且执行完+1操作,num = 1回到线程A,此时读取缓存区数据 0执行+1操作,num = 1

所以便存在问题了,所以线程锁的作用就是,让锁住部分串行执行.

import  threading

#执行函数
def run(n):

#获取锁
   lock.acquire()
   global num
   num += 1
#释放锁
   lock.release()

lock = threading.Lock()
num = 0

for i in range(50):
    t1 = threading.Thread(target=run, args=(i,))
    t1.start()
print("所有线程都执行完了: ",num)

四 : 队列

我们使用队列来帮助我们自动的处理任务,只需要关注 取出 和 放入即可,一定程度上解耦了冗余的操作流程

基本操作

import queue


#存入
q = queue.Queue(maxsize=3)
q.put("d1")
q.put("d2")
q.put("d3")

#查看队列成员大小
# q.qsize()

#取出
print(q.get())
print(q.get())
print(q.get())

结果是 d1,d2,d3 先入先出

后入先出

q1 = queue.LifoQueue()
q1.put(1)
q1.put(2)
q1.put(3)
print(q1.get())
print(q1.get())
print(q1.get())

按照优先级取出

q2 = queue.PriorityQueue()
q2.put(1,"tz")
q2.put(2,"雪芙")
q2.put(3,"百百")
print(q2.get())
print(q2.get())
print(q2.get())

生产者消费者模型

通过多线程和队列创造 生产者,消费者 模型
消费者不必关系 生成者的变化和多少,只需要专注于自己的消费行为,生产者也不必关注消费者的变化,专注于自己的生产行为,是一种解耦合的模型

import  threading,time
import queue


q = queue.Queue(maxsize=10)

#生产者模型
def Producer(name):
    count = 1
    while True:
        q.put("馒头%s" % count)
        print("生产了馒头 :",count)
        count += 1
        time.sleep(0.5)

#消费者模型
def Consumer(name):
    # while q.qsize() > 0:
    while True:
        print("%s 取到 %s 并且吃了它" %(name,q.get()))
        time.sleep(1)


p = threading.Thread(target=Producer,args=("TZ",))
C = threading.Thread(target=Consumer, args=("BAIBAI",))
C1 = threading.Thread(target=Consumer, args=("ZK",))

p.start()
C.start()
C1.start()

五 : 总结

python提供了两个模块来实现多线程thread 和 threading ，thread 有些缺点，我们通常用 threading ,其实对于多线程,并行开发 ,其实在python这只是一种假象,因为CPU在快速的切换,似乎是并行的,即使是多核CPU在python中在同一时间内也只有一个线程在执行,也许这是python 在初期设计开发上的缺陷.也有人尝修改过,结果也差强人意,但是这比不妨碍这门优秀的语言,被我们广泛的使用.