python——多线程

多线程-threading

import  time
from threading import Thread
#如果多个线程执行的是同一个函数的话，各自之间不会有影响
def test():
    print("哈哈哈哈哈哈哈")
    time.sleep(1)

for i in range(5):
    t = Thread(target = test)
    t.start()
哈哈哈哈哈哈哈
哈哈哈哈哈哈哈
哈哈哈哈哈哈哈
哈哈哈哈哈哈哈
哈哈哈哈哈哈哈

子类完成创建多线程

import  time
import threading
class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(3)
            msg = "I am "+self.name +'@'+str(i)
            print(msg)
        
if __name__ == '__main__':
    t = MyThread()
    t.start()
I am Thread-1@0
I am Thread-1@1
I am Thread-1@2

image.png

线程的执行顺序也是主线程和各个子线程随机执行，顺序不确定

线程对全局变量的修改

线程之间是共享全局变量的，进程间不共享变量，可以加一个flag来避免全局变量被修改。

使用互斥锁避免全局变量被修改

两个线程同时抢着上锁，如果有1方成功的上锁，那么导致另外一方会堵塞，一直等待这个锁被解开为止。所以叫互斥锁。
一般加锁会导致运行效率变低，所以，只在必要的地方加锁。以提高效率

#创建锁
mutex = threading.Lock()
#上锁
mutex.acquire()
#释放锁
mutex.release()

线程之间不共享全局变量

from threading import Thread
import  time
import threading

def test1():
    name = threading.current_thread().name
    print("thread name is %s"%name)
    g_num = 100
    if name == "Thread-1":
        g_num += 1
    else:
        time.sleep(2)
    print("thread name is %s----g_num=%d"%(name,g_num))

p1 = Thread(target=test1)
p1.start()
p2 = Thread(target=test1)
p2.start()
____________________________________________________
thread name is Thread-1
thread name is Thread-1----g_num=101
thread name is Thread-2
thread name is Thread-2----g_num=100

死锁

要尽量避免死锁
设置超时

生产者与消费者模式

队列就是给生产者和消费者解耦用

import threading
import time
from queue import Queue

class Producer(threading.Thread):
    def run(self):
        global queue
        count = 0
        while True:
            if queue.qsize() < 1000:
                for i in range(100):
                    count = count +1
                    msg = '生成产品'+str(count)
                    queue.put(msg)
                    print(msg)
            time.sleep(0.5)
 
class Consumer(threading.Thread):
    def run(self):
        global queue
        while True:
            if queue.qsize() > 100:
                for i in range(3):
                    msg = self.name + '消费了 '+queue.get()
                    print(msg)
            time.sleep(1)
 
 
if __name__ == '__main__':
    queue = Queue()
 
    for i in range(500):
        queue.put('初始产品'+str(i))
    for i in range(2):
        p = Producer()
        p.start()
    for i in range(5):
        c = Consumer()
        c.start()

异步

GIL问题（全局解释器锁）

python中多进程的效率远远大于多线程