多任务&线程_thread 活跃的线程数-CSDN博客

本文链接：https://blog.csdn.net/weixin_43973956/article/details/113795056

多任务&线程

线程方法补充&守护线程

这里主要介绍两个关于线程的方法
- active_count
  - 显示当前活跃的线程数量
- current_thread
  - 显示当前的线程信息（名称，ID等）
下面通过一段代码来具体看看这两个方法的作用

import threading
import os
import time


def demo1():
    print(f"--demo1--")
    print('demo1:',os.getpid(),threading.current_thread())
    time.sleep(1)


def demo2():
    print(f"--demo2--")
    print('demo2:', os.getpid(),threading.current_thread())
    time.sleep(1)


def main():
    t1 = threading.Thread(target=demo1)
    t2 = threading.Thread(target=demo2)
    t1.start()
    print('1',os.getpid(),threading.active_count(),threading.current_thread())
    t2.start()
    print('2',os.getpid(),threading.active_count(),threading.current_thread())



if __name__ == '__main__':
    main()

其运行结果如下
通过上述结果我们进行分析，可以看到首先active_thread方法显示的是活跃的进程数，t1启动之后数量为2，一个主线程再加t1子线程，t2启动之后显示为3，两个子线程和一个主线程，current_thread显示的是当前线程的信息，可以看到在主线程下面的打印输出是一样的，都是主线程的信息，而在两个子线程内的打印则分别是各自子线程的名称及ID，最后导入了OS模块，是为了查看当前进程的ID，通过结果可以看出，所有的进程ID都是一样的，说明线程是包含在进程之内的，不管是主线程还是子线程都在同一个进程之下。
接下来介绍一个关于守护线程的特殊案例，代码如下：

import threading
import time


def demo1():
    print(f"--demo1--")
    time.sleep(1)
    print('end-demo1')


def demo2():
    print(f"--demo2--")
    time.sleep(1)
    print('end-demo2')


def main():
    t1 = threading.Thread(target=demo1,daemon=True)
    t2 = threading.Thread(target=demo2)
    t1.start()
    t2.start()
    print('主')



if __name__ == '__main__':
    main()

加入了守护线程之后，主线程便不会等待子线程结束，直接结束，这里在t1中加入守护线程，而t2不加，两个子线程均延时一秒，那么会是什么结果呢？
通过上述结果我们可以看到，虽然t1加入了守护进程，正常情况下，主线程应该不会等待子线程延时一秒，而直接结束，那么最后的print语句应该不会输出，但这里由于t2没有加入守护线程，所以主线程虽然不会等待t1但会等待t2子线程结束，而两个子线程的延时时间刚好一样，故而全部打印了出来，守护线程其实并没有起到作用。
那么如果我们更改两个子线程的延时时间，就会看到守护线程的效果，例如t1变为2秒，其结果如下：

多线程共享全局变量&参数

在Python中，多个线程之间是可以共享全局变量和参数的，在证明这个结论之前，我们先介绍一下，线程如何传参
我们通过Threading.thread方法来建立线程，这个方法的参数args即为我们要传递的参数，例如 t1 = threading.Thread(target=demo1, args=(num,))，传递的参数要用元组来表示。
接下来通过一段代码来展示多线程是共享全局变量的：

import threading
import time

num = 100

def demo1():
    global num      # 2.声明为全局变量
    num += 1        # 1.函数作用域 访问不到外边的num 所以报错 找不到 
    print(f"demo----{num}")


def demo2():
    print(f"demo1----{num}")


def main():
    t1 = threading.Thread(target=demo1)
    t2 = threading.Thread(target=demo2)
    t1.start()
    time.sleep(1)
    t2.start()
    time.sleep(1)
    
    
if __name__ == '__main__':
    main()

其运行结果如下：在这里插入图片描述

我们可以看到num的初始值为100，在demo方法里将其定义为全局变量，而后加一，并传给了demo1，最后的输出结果显示，demo1线程继承了这个全局变量，输出结果同样是101.
接下来我们用一段代码来展示多线程之间可以共享参数：

import threading
import time


num = [11, 22]


def demo1(num):
    num.append(33)
    print(f"demo----{num}" )


def demo2(num):
    print(f"demo1----{num}")


def main():
    t1 = threading.Thread(target=demo1, args=(num,))
    t2 = threading.Thread(target=demo2, args=(num,))
    t1.start()
    time.sleep(1)
    t2.start()
    time.sleep(1)

    print(f"main----{num}")

其运行结果如下：
我们可以看到num的初始值为[11,22]，将其当做参数传给t1线程，而后加33，接着又将num传给了demo1，最后的输出结果显示，demo1线程继承了这个参数，输出结果同样是[11,22,33].

多任务udp聊天

通过多线程的方式来实现udp聊天器。代码如下：

import threading
import socket
import time



def send(udp_socket):
    while True:
        time.sleep(1)
        send_data = input('请输入要发送的内容：')
        udp_socket.sendto(send_data.encode('utf-8'), ('192.168.0.104', 8080))


def recv(udp_socket):
    while True:
        recv_data = udp_socket.recvfrom(1024)
        print('%s:%s' % (recv_data[1]), (recv_data[0].decode()))


def main():
    udp_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

    udp_socket.bind(('192.168.0.104',8080))

    t1 = threading.Thread(target=send, args=(udp_socket,))

    t1.start()

    t2 = threading.Thread(target=recv, args=(udp_socket,))

    t2.start()




if __name__ == '__main__':
    main()

多任务tcp服务端

前面的文章里有写过一个服务端多次客户端的tcp聊天器，了解了多线程之后，我们可以通过多线程同时建立几个服务端来为客户端服务，而不再想前面那样只有当前客户端断开连接，下一个客户端才能接入，代码如下：
客户端

import socket


def main():
    tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    tcp_client_socket.bind(("192.168.0.104", 8090))

    tcp_client_socket.connect(('192.168.0.104',8080))
    while True:
        send_data = input('请输入要发送的内容：')

        tcp_client_socket.send(send_data.encode('utf-8'))

        recv_data = tcp_client_socket.recv(1024)

        print(recv_data.decode('utf-8'))



if __name__ == '__main__':
    main()

服务端

import threading
import socket

tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

tcp_server_socket.bind(('192.168.0.104', 8080))

def main():
    while True:
        print('等待客户端连接。。。')
        tcp_server_socket.listen(128)

        new_socket, addr = tcp_server_socket.accept()

        recv_data = new_socket.recv(1024)
        while True:
            try:
                print(recv_data.decode())
                if recv_data:

                     new_socket.send('haha'.encode('utf-8'))
            except Exception as e:
                print('客户端断开连接')
                break

        new_socket.close()

    tcp_server_socket.close()





if __name__ == '__main__':
    for i in range(3):
        t1 = threading.Thread(target=main)

        t1.start()

增加几个线程，就是建立了几个服务器

多线程资源竞争&互斥锁

当多个线程几乎同时修改某一个共享数据时，就需要进行控制，不然会出现数据异常，例如下面的情况：

import threading
num = 0
def demo(nums):
    global num
    for i in range(nums):
        num += 1
    print('demo', num)

def demo1(nums):
    global num
    for i in range(nums):
        num += 1
    print('demo1', num)

def demo2(nums):
    global num
    for i in range(nums):
        num += 1
    print('demo2', num)

def main():
    t1 = threading.Thread(target=demo, args=(10000000,))
    t1.start()
    t2 = threading.Thread(target=demo1, args=(10000000,))
    t2.start()
    t3 = threading.Thread(target=demo2, args=(10000000,))
    t3.start()

if __name__ == '__main__':
    main()

运行的结果为：
从结果可以看出，当多个线程同时修改一个共享变量的时候，有可能会出现这种资源竞争的现象，导致数据错误，而解决方法就是加入互斥锁。
互斥锁
- 某个线程要更改共享数据时，先将其锁定，此时资源的状态为"锁定",其他线程不能改变，只到该线程释放资源，将资源的状态变成"非锁定"，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

# 创建锁
mutex = threading.Lock()

# 锁定
mutex.acquire()

# 解锁
mutex.release()

我们对每一个线程进行上锁：

import threading
num = 0
mutex = threading.Lock()
def demo(nums):
    mutex.acquire()
    global num
    for i in range(nums):
        num += 1
    print('demo', num)
    mutex.release()

def demo1(nums):
    mutex.acquire()
    global num
    for i in range(nums):
        num += 1
    print('demo1', num)
    mutex.release()

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

def main():
    t1 = threading.Thread(target=demo, args=(10000000,))
    t1.start()
    t2 = threading.Thread(target=demo1, args=(10000000,))
    t2.start()
    t3 = threading.Thread(target=demo2, args=(10000000,))
    t3.start()

if __name__ == '__main__':
    main()

得到的运行结果如下：

死锁&线程同步

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

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()

接下来使用一段代码来实现如下对话
天猫精灵:小爱同学
小爱同学:在
天猫精灵:现在几点了？
小爱同学：你猜猜现在几点了

import threading
mutex = threading.Lock()
cond = threading.Condition()
class XIAOAI(threading.Thread):
    def __init__(self,con,name):
        self.con = con
        super(XIAOAI, self).__init__(name=name)
    def run(self):
        self.con.acquire()

        self.con.wait()
        print('{}:在。'.format(self.name))
        self.con.notify()

        self.con.wait()
        print('{}:你猜猜现在几点了？'.format(self.name))
        self.con.release()

class TIANMAO(threading.Thread):
    def __init__(self,con,name):
        self.con = con
        super(TIANMAO, self).__init__(name=name)
    def run(self):
        self.con.acquire()

        print('{}:小爱同学。'.format(self.name))
        self.con.notify()

        self.con.wait()
        print('{}:现在几点了？'.format(self.name))
        self.con.notify()
        self.con.release()


def main():
    xiaoai = XIAOAI(con=cond,name='小爱同学')
    tianmao = TIANMAO(con=cond, name='天猫精灵')
    xiaoai.start()
    tianmao.start()


if __name__ == '__main__':
    main()