Python多线程编程详解：从基础模块到Socket实战

Hazel

发布时间：2026-10-12| 3人浏览过

原创

本文深入解析Python中多线程的创建与管理。重点介绍threading模块的优势及Thread类的两种创建方式，对比线程与进程在PID、启动效率及内存共享上的差异。同时讲解Thread实例方法，并通过多线程Socket服务端与客户端代码示例，展示实际应用场景。

一、Python线程相关模块概览

1. thread与threading模块基础

thread模块提供了基础的线程支持和锁机制。
threading模块则提供了更高级别且功能更完善的线程管理功能。

2. Queue模块的作用

Queue模块允许用户创建用于多线程间共享数据的队列数据结构。

3. 模块选择注意事项

建议避免使用thread模块。
原因在于threading模块更为先进，对线程的支持更加完善。
此外，使用thread模块中的属性可能会与threading模块产生冲突。
其次，底层thread模块的同步原语极少（实际上仅有一个），而threading模块提供了丰富的同步机制。
再者，当主线程结束时，thread模块会强制终止所有子线程，不发出警告且无正常清理工作；而threading模块能确保重要子线程退出后进程才退出。

注意：thread模块不支持守护线程，主线程退出时所有子线程无论工作状态如何都会被强行终止。而threading模块支持守护线程，通常用于等待客户请求的服务器线程，若未设定为守护线程，进程退出时不会等待该线程结束。

二、Threading模块详解

multiprocess模块完全模仿了threading模块的接口，两者在使用层面具有高度相似性，此处不再赘述。

三、通过Threading.Thread类创建线程

1. 创建线程的方式一：直接调用

直接通过Threading.Thread类来创建线程。

from threading import Thread
import time

def task(name):
    print(f'子线程{name} is running')
    time.sleep(1)
    print(f'子线程{name} is end')
    
# 因为创建线程不需要重新开辟内存空间，所以不用写main，创建线程只是单独把启动线程函数里面的代码拿出来用
t = Thread(target=task,args=('小明',))
t.start()
print('主线程结束')

2. 创建线程的方式二：继承类

通过自定义类继承Thread类来创建线程。

from threading import Thread
import time

class MyDic(Thread,name):
    def __init__(self,name)
    	super().__init__()
        self.name = name
    
    def run(self):
        print(f'子线程{name} is running')
        time.sleep(1)
        print(f'子线程{name} is end')

       
t = Mydic('小明')
t.start()
print('主进程结束')

四、多线程与多进程的比较

1. PID（进程ID）的比较

'''
学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：711312441
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
from threading import Thread
from multiprocessing import  Process
import time
import os

def task(name):
    print(f'子线程{name} is running')
    time.sleep(1)
    print(f'子线程{name} is end')
    print(f'子线程{name}的pid：{os.getpid()}')


def task1(name):
    print(f'进程{name} is running')
    time.sleep(1)
    print(f'进程{name} is end')
    print(f'进程的{name}pid：{os.getpid()}')


if __name__ == '__main__':
    # part1:在主进程下开启多个线程,每个线程都跟主进程的pid一样
    t = Thread(target=task, args=('小明',))
    t.start()
    t.join()
    print(f'主线程的pid：{os.getpid()}')

    
    # 开多个进程，每一个进程的pid号都不一样
    p = Process(target=task1,args=('zhangsan',))
    p1 = Process(target=task1,args=('zhang',))
    p.start()
    p1.start()
    p.join()
    p1.join()
    print(f'主进程的pid：{os.getpid()}')

2. 线程与进程开启效率的对比

from threading import Thread
from multiprocessing import Process
import time

def task(name):
    print(f'{name} is running')
    time.sleep(2)
    print(f'{name} is end')


if __name__ == '__main__':
    t = Thread(target=task,args=('子线程',))
    p = Process(target=task,args=('子进程',))
    t.start()
    # p.start()
    print('主')

（1. 开启线程的速度：

子线程 is running

主

子线程 is end

（2. 开启进程的速度：

主

子进程 is running

子进程 is end

3. 内存数据共享问题

from threading  import Thread
from multiprocessing import  Process
import time,os

x = 100
def task():
    global x
    x = 50 # 此时线程是在拿全局的x的值
    print(os.getpid()) # 因为开启线程是不需要操作系统给线程分配内存空间的，所以线程用的是它当前所在的进程的进程号


if __name__ == '__main__':
    # 线程
    t = Thread(target=task)
    t.start()
    time.sleep(2)
    print(x) # 50，这里说明线程他是共享他所在进程下的所有资源，对资源进行一系列的操作
    print(os.getpid())

    # 进程
   # p = Process(target=task)
   # p.start() 
   # print(x) # 这里的x还是主进程的x 100

五、Thread类的其他方法

Thread实例对象的方法包括：

isAlive()：返回线程是否处于活动状态。
getName()：返回线程名称。
setName()：设置线程名称。

threading模块提供的一些方法包括：

threading.currentThread()：返回当前的线程变量。
threading.enumerate()：返回一个包含正在运行的线程的列表。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.activeCount()：返回正在运行的线程数量，结果与len(threading.enumerate())相同。

1. 代码实例

from threading import Thread,currentThread,enumerate,activeCount
import time

def task():
    print('子线程 start')
    time.sleep(2)
    print('子线程 end')
    print(enumerate())# 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
    print(currentThread(),'子线程') # 返回当前的线程变量
    print(activeCount())

if __name__ == '__main__':
   t1 = Thread(target=task)
   t2 = Thread(target=task)
   t1.start()
   t2.start()
   t2.setName('小明')
   print(t2.getName()) # 得到t2的线程名字，是我们设置好的小明
   print(t1.getName()) # 得到t1的线程名子 Thread-1
   print(t1.is_alive()) # True

2. join方法说明

'''
学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：711312441
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
from threading import Thread
import time
def task():
    print('子线程 start')
    time.sleep(2)
    print('子线程 end')

t = Thread(target=task)
t.start()
t.join() # 等待子线程运行结束
print('主线程')

六、多线程实现Socket通信

1. 服务端代码

import socket
from threading import Thread

socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
socket.bind(('192.168.11.78',8004))
socket.listen(5)

def action(conn,addr):
    while True:
        try:

            msg = (conn.recv(1024)).decode('utf8').upper()
            print(f'客户端{addr}发送的数据为：{msg.lower()}')
            print(f'向客户端{addr}发送数据为',msg)
            conn.send(msg.encode('utf8'))
        except:
            break


if __name__ == '__main__':
    print('等待客户端连接:')
    while True:
        try:
            conn,addr = socket.accept()
            print(f'客户端已连接{addr}')
            t = Thread(target=action,args=(conn,addr))
            t.start()
        except:
            print(f'客户端{addr}断开连接 ！！')
            break

2. 客户端代码

import  socket

client = socket.socket()
client.connect(('192.168.11.78',8004))

while True:
    msg = input('输入：')
    if msg == 'q':
        break
    client.send(msg.encode('utf8'))
    flag = client.recv(1024)
    print('接收服务端的数据为：',flag.decode('utf8'))

到此这篇关于Python中如何创建多线程的文章就介绍到这了，更多相关Python创建多线程内容请搜索本站以前的文章或继续浏览下面的相关文章，希望大家以后多多支持本站！