高级编程技巧——线程与进程

8.1 互斥锁

互斥锁

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

import time
import threading

num=100
def demo1(nums,mutex):
    global num
    # 2.加锁
    mutex.acquire()
    for i in range(nums):
        num += 1
    # 3.解锁
    mutex.release()
    print(f'demo1---{num}')

def demo2(nums,mutex):
    global num
    mutex.acquire()
    for i in range(nums):
        num += 1
    mutex.release()
    print(f'demo2---{num}')

def main():
    # 1.创建锁
    mutex=threading.Lock()

    t1=threading.Thread(target=demo1,args=(100000,mutex))
    t2=threading.Thread(target=demo2,args=(100000,mutex))

    t1.start()
    # time.sleep(1)

    t2.start()
    # time.sleep(1)

    '''
    线程执行  demo1 与 demo2 时 在解锁的时候，可能还没有执行完毕 就执行主线程了
    1.等待子线程执行完毕 再执行主线程
    2.给 main 延迟 1s
    '''
    t1.join()
    t2.join()

    print(f'mainThread---{num}')

if __name__=='__main__':
    main()

• 创建互斥锁 mutex=threading.Lock()
• 加锁 mutex.acquire()
• 解锁 mutex.release()

死锁

• 在线程间共享多个资源的时候，如果两个线程分别占用一部分资源并且同时等待对方的资源，就会造成死锁。
• 1.在线程中使用多把锁能造成死锁（增加锁的数量应该和解锁的数量一致）。
• 2.创建锁 mutex=threading.RLock() 也能造成死锁。

避免死锁

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

8.2 线程同步

• 我们使用 threading.Condition（）完成线程同步。

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

# 等待
cond.wait()

# 唤醒
cond.notify

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

import time
import threading
from threading import Condition
'''
1.__enter__ 以及 __exit__ 上下文管理器 with
2.wait.() --> 等待
3.notify() ---> 唤醒
'''

class XiaoAi(threading.Thread):
    def __init__(self,mutex,cond):
        super().__init__(name='小爱同学')
        self.mutex=mutex
        self.cond=cond
    def run(self):
        with self.cond:
            # 1.等待
            self.cond.wait()
            print(f'{self.name}:在')
            # 4.唤醒
            self.cond.notify()

            # 5.等待
            self.cond.wait()
            print(f'{self.name}:你猜猜现在几点')

class TianMao(threading.Thread):
    def __init__(self,mutex,cond):
        super().__init__(name='天猫精灵')
        self.mutex = mutex
        self.cond=cond

    def run(self):
        with self.cond:
            print(f'{self.name}:小爱同学')
            # 2.唤醒
            self.cond.notify()

            # 3.等待
            self.cond.wait()
            print(f'{self.name}:现在几点了')
            # 6.唤醒
            self.cond.notify()
if __name__=='__main__':
    # 1.加锁
    mutex=threading.RLock()
    # 2.线程同步
    cond = threading.Condition()

    xa=XiaoAi(mutex,cond)
    tm=TianMao(mutex,cond)

    xa.start()
    tm.start()

8.3 多任务版聊天

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

import socket
import threading

# 4. 接收数据
def recv_msg(upd_s):
    while True:
        recv_data = upd_s.recvfrom(1024)
        print(recv_data)
# 5.发送数据
def send_msg(upd_s,dest_ip,dest_port):
    while True:
        send_data=input('请输入要发送的数据：')
        upd_s.sendto(send_data.encode('gbk'),(dest_ip,dest_port))
def main():
    # 1.创建套接字
    upd_s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

    # 2.绑定本地 ip 以及 port
    upd_s.bind(('',7890))

    # 3.获取对方的 ip 和 port
    dest_ip=input('请输入对方的IP：')
    dest_port=int(input('请输入对方的port：'))

    # 使用线程
    t_recv=threading.Thread(target=recv_msg,args=(upd_s,))
    t_send=threading.Thread(target=send_msg,args=(upd_s,dest_ip,dest_port))

    t_recv.start()
    t_send.start()
if __name__=='__main__':
    main()

8.4 进程

进程定义

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

进程概念

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

进程与程序区别

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

进程状态介绍

Python实现多进程

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

import time
import threading
import multiprocessing

def demo1():
    while True:
        print('---1---')
        time.sleep(1)

def demo2():
    while True:
        print('---2---')
        time.sleep(1)

def main():

    # t1=threading.Thread(target=demo1)
    # t2=threading.Thread(target=demo2)
    #
    # t1.start()
    # t2.start()
    p1=multiprocessing.Process(target=demo1)
    p2=multiprocessing.Process(target=demo2)
    # 创建进程 实现多任务
    p1.start()
    p2.start()

    '''
    通过执行结果，多个进程同时执行顺序是随机的
    '''
if __name__=='__main__':
    main()

import time
import threading
import multiprocessing
class Demo1(multiprocessing.Process):
    def run(self):
        while True:
            print('---1---')
            time.sleep(1)
class Demo2(multiprocessing.Process):
    def run(self):
        while True:
            print('---2---')
            time.sleep(1)

def main():
    p1=Demo1()
    p2=Demo2()

    # 保护主进程
    # p1.daemon=True
    # p2.daemon=True

    p1.start()
    p2.start()

    # 等待子线程结束 在执行主程序
    p1.join()
    p2.join()
    print('主线程')

if __name__ =='__main__':
    main()

进程与线程的区别

• 根本区别

  • 进程：操作系统资源分配的基本单位。
  • 线程：任务调度和执行的基本单位。

• 开销

  • 进程：通过复制代码+资源创建子进程，每个进程都有独立的代码和数据空间，程序之间的切换会有较大的开销。
  • 线程：在同一份代码里 创建线程 共享内存 开销较小。

• 分配内存

  • 进程：系统在运行的时候为每个进程分配不同的内存呢空间。
  • 线程：线程所使用的资源是它所属的进程的资源。

• 包含关系

  • 进程：系统在运行的时候为每个进程分配不同的内存空间
  • 线程：线程是进程的一部分。