多线程编程

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密集型：多进程（多用来做运算）

python 多线程