简单的多线程

一个简单的小实例

import time
import threading

def run(n):
    time.sleep(1)
    print('task:',n)

ls = []

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

for t in ls:
    t.join()#等待该线程完成后继续执行主线程


print('-----all threads has done-----')

线程锁

一个进程下可以启动多个线程，多个线程共享父进程的内存空间，也就意味着每个线程可以访问同一份数据，此时，如果2个线程同时要修改同一份数据，则可能是数据出错。

import threading

num = 0

def run():
    global num
    num += 1

for i in range(1000):
    t = threading.Thread(target=run)
    t.start()


while threading.active_count() != 1:
    pass
else:
    print(num)

守护线程

一些线程执行后台任务，例如发送Keepalive数据包，或执行定期垃圾回收等。 这些仅在主程序运行时才有用，一旦其他非守护进程线程退出，就可以将其关闭。没有守护进程线程，你必须跟踪他们，并告诉他们退出，在你的程序可以完全退出之前。 通过将它们设置为守护进程线程，可以让它们运行并忘记它们，当程序退出时，任何守护进程线程都会自动终止。

import threading
import time

def run(n):
    print('task:',n)
    time.sleep(1)
    print('task %s has done'%n)

for i in range(50):
    t= threading.Thread(target=run,args=(i,))
    t.setDaemon(True)
    t.start()


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

信号量

互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据

import threading
import time

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

def run(n):
    semaphore.acquire()
    time.sleep(1)
    print('task:',n)
    semaphore.release()

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

while threading.active_count() != 1:
    pass
    # print('当前线程数量:',threading.active_count())
else:
    print('---all threads done----')

事件

事件是一个简单的同步对象;
该事件代表一个内部标志和线程
可以等待标志被设置，或者自己设置或清除标志。
创建事件
event = threading.Event（）
客户端线程可以等待标志被设置
event.wait（）
服务器线程可以设置或重置它
event.set（）
event.clear（）
如果标志被设置，等待方法不会做任何事情。
如果标志被清除，等待将被阻塞直到它再次被设置。
任何数量的线程都可能等待相同的事件。

import threading
import time

event = threading.Event()

def light():
    count = 0
    event.set()

    while True:
        count += 1
        if count < 5:
            print('\033[42;1mgreen light is on...\033[0m')
        elif count <10:
            event.clear()
            print('\033[41;1mred light is on...\033[0m')
        else:
            event.set()
            count = 0

        
        time.sleep(1)

def car(name,seconds):
    while True:
        if event.isSet():
            print('%s is running...'%name)
            time.sleep(seconds)
        else:
            print('%s sees the red light,waiting...'%name)
            event.wait()
            print("\033[34;1m[%s] green light is on, start going...\033[0m" %name)





l = threading.Thread(target=light)
l.start()
c1 = threading.Thread(target=car,args=('Tesla',1))
c2 = threading.Thread(target=car,args=('Baoma',2))
c1.start()
c2.start()

生产者消费者模型

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

import threading
import queue
import time

q = queue.Queue(maxsize=10)

def produce():
    count = 1
    while True:
        q.put('包子%s'%count)
        print('生产了包子',count)
        count += 1
        time.sleep(3)

        


def consume(name):
    while True:
        print('%s拿到%s,并吃了它'%(name,q.get()))
        time.sleep(0.5)


p = threading.Thread(target=produce)
c1 = threading.Thread(target=consume,args=('alex',))
c2 = threading.Thread(target=consume,args=('Pater',))
p.start()
c1.start()
c2.start()