多线程编程

Thread方式

# 导包
import threading
import time


# 创建方法
def work(msg):
    print(f"当前线程:{threading.current_thread().name}", msg)
    time.sleep(1)


# 创建对象
for i in range(10):
    t = threading.Thread(target=work, args=(i,))
    t.start()

Thread类继承

import threading


# 创建一个类继承线程
class NewThread(threading.Thread):
    def __init__(self, name):
        # 调用父类的init方法
        super(NewThread, self).__init__()
        self.name = name


    # run方法必须写
    def run(self):
        print(f"{self.name}好吃")


for i in ["包子", "牛肉", "鸡肉"]:
    # 实例化对象
    t = NewThread(i)
    t.start()

线程和进程

线程：调度单元具体做事的那个人 共享内存空间 修改全局变量会影响 线程不安全 需要互斥锁

进程：程序的代码，其他的一些资源 每增加一个进程就会创建一份内存空间 修改全局变量不会有影响 通信麻烦 需要用队列

线程共享内存空间

import threading

num = 1


def write():
    global num
    num += 1
    print(f"write里面的{num}")


def read():
    global num
    num += 1
    print(f"read里面的{num}")


# 实例化
tw = threading.Thread(target=write)
tr = threading.Thread(target=read)
tw.start()
tr.start()
print("main里面的", num)

线程安全

import threading

num = 0


def write():
    global num
    for i in range(100000):
        num += 1
    print(f"write里面的{num}")


def read():
    global num
    for i in range(100000):
        num += 1
    print(f"read里面的{num}")


# 实例化
tw = threading.Thread(target=write)
tr = threading.Thread(target=read)
tw.start()
#tw.join()
tr.start()
#tr.join()
print("main里面的", num)

结果不等于200000

个人看法：进程的join方法，线程里面同样有，这样出来的结果就是200000

解决线程安全加互斥锁

某个线程要更改共享数据时，先将其锁定，此时资源的状态为”锁定“，其他线程不能更改；直到该线程释放资源，将资源的状态变成”非锁定“，其他线程才能再次锁定该资源。互斥锁保证了多线程下数据的正确性

import threading

num = 0


def write():
    global num
    #加锁
    l.acquire()
    for i in range(100000):
        num += 1
    #解锁
    l.release()
    print(f"write里面的{num}")


def read():
    global num
    #加锁
    l.acquire()
    for i in range(100000):
        num += 1
    #解锁
    l.release()
    print(f"read里面的{num}")
#创建一把锁
l = threading.Lock()

# 实例化
tw = threading.Thread(target=write)
tr = threading.Thread(target=read)
tw.start()
tr.start()

死锁

#coding=utf-8
import threading
import time

class MyThread1(threading.Thread):
    def run(self):
        if mutexA.acquire():
            print(self.name+'----do1---up----')
            time.sleep(1)

            if mutexB.acquire():
            #if mutexB.acquire(timeout=2):
                print(self.name+'----do1---down----')
                mutexB.release()
            mutexA.release()

class MyThread2(threading.Thread):
    def run(self):
        if mutexB.acquire():
            print(self.name+'----do2---up----')
            time.sleep(1)
            if mutexA.acquire():
                print(self.name+'----do2---down----')
                mutexA.release()
            mutexB.release()

mutexA = threading.Lock()
mutexB = threading.Lock()

if __name__ == '__main__':
    t1 = MyThread1()
    t2 = MyThread2()
    t1.start()
    t2.start()

解决：添加超时时间

进程与线程

进程：独立内存空间，资源分配的单元

线程：共享内存空间 大大减少内存的使用 线程不安全 调试单元 最后做事的那个人

一个程序至少一个进程，至少一个线程

什么时候使用多进程，什么时候使用多线程

IO密集型：多线程（输入 输出 多用于数据传输）

CPU密集型：多进程（多用来做运算）