Python之线程与进程(互斥锁、死锁、线程同步、多任务版udp聊天、进程)

互斥锁

当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制
某个线程要更改共享数据时，先将其锁定，此时资源的状态为"锁定",其他线程不能改变，只到该线程释放资源，将资源的状态变成"非锁定"，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

# 创建锁
mutex = threading.Lock()

# 锁定
mutex.acquire()

# 解锁
mutex.release()

死锁

在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。

import threading
import time

class MyThread1(threading.Thread):
    def run(self):
        # 对mutexA上锁
        mutexA.acquire()

        # mutexA上锁后，延时1秒，等待另外那个线程 把mutexB上锁
        print(self.name+'----do1---up----')
        time.sleep(1)

        # 此时会堵塞，因为这个mutexB已经被另外的线程抢先上锁了
        mutexB.acquire()
        print(self.name+'----do1---down----')
        mutexB.release()

        # 对mutexA解锁
        mutexA.release()

class MyThread2(threading.Thread):
    def run(self):
        # 对mutexB上锁
        mutexB.acquire()

        # mutexB上锁后，延时1秒，等待另外那个线程 把mutexA上锁
        print(self.name+'----do2---up----')
        time.sleep(1)

        # 此时会堵塞，因为这个mutexA已经被另外的线程抢先上锁了
        mutexA.acquire()
        print(self.name+'----do2---down----')
        mutexA.release()

        # 对mutexB解锁
        mutexB.release()

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

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

避免死锁

• 程序设计时要尽量避免
• 添加超时时间等

线程同步

我们使用 threading.Condition() 完成线程同步。

# 线程同步
cond = threading.Condition()

# 等待
cond.wait()

# 唤醒
cond.notify()

实现：
天猫精灵:小爱同学
小爱同学:在
天猫精灵:现在几点了？
小爱同学：你猜猜现在几点了

多任务版udp聊天

• 创建套接字
• 绑定本地信息
• 获取对方IP和端口
• 发送、接收
• 创建两个线程，去执行功能

进程

进程定义

进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。并且进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

进程概念

• 进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。
• 进程是一个“执行中的程序”。
• 进程是操作系统中最基本、重要的概念。

进程与程序区别

• 进程：正在执行的程序。动态的，暂时的
• 程序：没有执行的代码，是一个静态的，永久的

进程状态介绍

Python实现多进程

通过 multiprocessing.Process模块

• group：参数未使用，默认值为None。
• target：表示调用对象，即子进程要执行的任务。
• args：表示调用的位置参数元祖。
• kwargs：表示调用对象的字典。
• name：子进程名称

import multiprocessing
import time


def demo():
    while True:
        print("--1--")
        time.sleep(1)
        
        
if __name__ == '__main__':
    p1 = multiprocessing.Process(target=demo)
    p1.start()

注意：多个进程同时执行的顺序是随机的。
通过继承Process类创建进程

class Demo(multiprocessing.Process):
    def run(self):
        while True:
            print("--1--")
            time.sleep(1)
            
            
if __name__ == '__main__':
    p1 = Demo()
    p1.start()

• 守护主线程

class Demo(multiprocessing.Process):
    def run(self):
        while True:
            print("--1--")
            time.sleep(1)
            
            
if __name__ == '__main__':
    p1 = Demo()
    p1.daemon = True
    p1.start()
    print("1")

• 子线程结束，再执行主线程

lass Demo(multiprocessing.Process):
    def run(self):
        while True:
            print("--1--")
            time.sleep(1)
            
            
if __name__ == '__main__':
    p1 = Demo()
    p1.start()
    p1.join()
    print("1")

进程与线程区别

• 根本区别
  进程：操作系统资源分配的基本单位
  线程：任务调度和执行的基本单位
• 开销
  进程：通过复制代码+资源创建子进程 每个进程都有独立的代码和数据空间，程序之间的切换会有较大的开销
  线程：在同一份代码里 创建线程 共享内存 开销较小
• 分配内存
  进程：系统在运行的时候为每个进程分配不同的内存空间
  线程：线程所使用的资源是它所属的进程的资源
• 包含关系
  进程：一个进程可以拥有多个线程
  线程：线程是进程的一部分