12、Python多线程

最新推荐文章于 2024-01-17 16:35:13 发布
最新推荐文章于 2024-01-17 16:35:13 发布
阅读量364 收藏
点赞数 1
分类专栏： Python3入门 快速入门Python 文章标签：  Python快速入门   Python基础 
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zengraoli/article/details/81320356
版权

目录

使用threading

Python中threading中的Thread类用来创建和管理线程对象，可以通过两种形式来使用多线程：直接使用Thread类、继承Thread类重写init和run方法；创建了Thread对象后可以调用start来启动，该方法会自动调用run，调用后处于alive状态直到线程结束
构造方法：
Thread(group=None, target=None, name=None, args=(), kwargs={})
其中
　　group: 线程组，目前还没有实现，库引用中提示必须是None；
　　target: 要执行的方法；
　　name: 线程名；
　　args/kwargs: 要传入方法的参数。
对象成员
这里写图片描述

实例方法：
　　isAlive(): 返回线程是否在运行。正在运行指启动后、终止前。
　　get/setName(name): 获取/设置线程名。
　　start(): 线程准备就绪，等待CPU调度
　　is/setDaemon(bool): 获取/设置是后台线程（默认前台线程（False））。（在start之前设置）
如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，主线程和后台线程均停止
如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
　　start(): 启动线程。
　　join([timeout]): 阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout（可选参数）。

直接使用Thread类创建线程

# !/usr/bin/env python
# encoding: utf-8

import threading

def do_soming(what):
    print("what value:{0}, threading ident:{1}".format(what, threading.get_ident()))

if __name__ == '__main__':
    for i in range(4):
        t = threading.Thread(target=do_soming, args=(i, ))
        t.start()
print("main end.")

继承Thread类重写init和run方法创建多个线程

# !/usr/bin/env python
# encoding: utf-8

import threading
import time

class MyThread(threading.Thread):
    def __init__(self, arg):
        super(MyThread, self).__init__() #一定要调用父类的初始化
        self._arg = arg

    def run(self): #run是线程跑起来之后调用的函数
        time.sleep(1)
        print('arg value is {0}, the ident is {1}'.format(self._arg, self._ident))

if __name__ == '__main__':
    for i in range(4):
        t = MyThread(i)
        t.start()

    print("main end.")

设置线程的daemon属性

线程的daemon属性默认为False，如果创建子线程的时候，给子线程的daemon属性设置了True。则主线程结束时候把所有的子线程都给带走了，因此你不会看到子线程的输出

# !/usr/bin/env python
# encoding: utf-8

import threading
import time

class MyThread(threading.Thread):
    def __init__(self, arg):
        super(MyThread, self).__init__() #一定要调用父类的初始化
        self._arg = arg

    def run(self): #run是线程跑起来之后调用的函数
        time.sleep(10)
        print('arg value is {0}, the ident is {1}, 我会在main end.下面输出'.format(self._arg, self._ident))

if __name__ == '__main__':
    for i in range(4):
        t = MyThread(i)
        t.setDaemon(True)
        t.start()

    print("main end.")

反之，则会等待子线程结束，主线程才会退出，所以线程中的输出语句会出现在main end.下边

# !/usr/bin/env python
# encoding: utf-8

import threading
import time

class MyThread(threading.Thread):
    def __init__(self, arg):
        super(MyThread, self).__init__() #一定要调用父类的初始化
        self._arg = arg

    def run(self): #run是线程跑起来之后调用的函数
        time.sleep(10)
        print('arg value is {0}, the ident is {1}, 我会在main end.下面输出'.format(self._arg, self._ident))

if __name__ == '__main__':
    for i in range(4):
        t = MyThread(i)
        t.setDaemon(False)
        t.start()

    print("main end.")

线程的同步

没做线程同步之前的，可能会出现问题，比如输出挤在一起

# !/usr/bin/env python
# encoding: utf-8

import threading

def do_soming(what):
    print("what value:{0}, threading ident:{1}".format(what, threading.get_ident()))

if __name__ == '__main__':
    for i in range(10):
        t = threading.Thread(target=do_soming, args=(i, ))
        t.start()

    print("main end.")

Lock/RLock对象

一个锁有两种状态：locked和unlocked，如果一个锁处于unlocker状态，acquire()将其修改成locked并立即返回，如果处于locked状态，那么阻塞等待其他线程释放锁，然后将其修改成locked并立即返回

RLock是递归锁，RLock对象的acquire()和release()调用可以嵌套

在前面的例子中使用Lock/RLock

# !/usr/bin/env python
# encoding: utf-8

import threading
import time

def do_soming(what, lock):
    lock.acquire()
    print("what value:{0}, threading ident:{1}".format(what, threading.get_ident()))
    time.sleep(2)#为了以示区分而加上
    lock.release()

if __name__ == '__main__':
    lock = threading.Lock()
    # 也可以改成
    # lock = threading.RLock()
    for i in range(10):
        t = threading.Thread(target=do_soming, args=(i, lock))
        t.start()

    print("main end.")

Condition对象

我们可以用Condition对象来轻易的模拟计算机操作系统一个常用的线程的例子—生产者消费者问题，Condition对象不值在获取了对象后，可以进入等待状态

当队列为空时，消费者进行等待，生产者进行生产，完成生产后唤醒所有的消费者，让所有的消费者进行“消费”；反过来则是生产者等待消费者唤醒

# !/usr/bin/env python
# encoding: utf-8

import threading
import time

#生产者
class Producer(threading.Thread):
    def __init__(self, thread_name, condition_object, container):
        threading.Thread.__init__(self, name=thread_name)
        self._condition_object = condition_object
        self._container = container

    def run(self):
        #判断当前的Queue是否满，如果满了就wait等待唤醒
        #如果没有满，则锁定当前的Queue，往Queue里面添加数据
        value = 1
        while True:
            self._condition_object.acquire()#获取对象
            if self._container.__len__() > 4:
                self._condition_object.wait()
                print("producter waitring...")
            else:
                print("producter making...")
                self._container.append(value)
                value += 1
                print("producter making end.")
                self._condition_object.notify_all()
            self._condition_object.release()#释放对象
            time.sleep(2)
#消费者
class Consumer(threading.Thread):
    def __init__(self, thread_name, condition_object, container):
        threading.Thread.__init__(self, name=thread_name)
        self._condition_object = condition_object
        self._container = container

    def run(self):
        self._condition_object.acquire()#获取对象
        #判断当前的Queue是否空，如果空就wait等待唤醒
        #如果没有满，则锁定当前的Queue，往Queue里面添加数据
        while True:
            if not self._container:#队列为空
                self._condition_object.wait()
                print("{0} waitring...".format(self.getName()))
            else:
                print("{0} making...".format(self.getName()))
                print("x.pop() value is {0}".format(self._container.pop()))
                print("{0} making end...".format(self.getName()))
                self._condition_object.notify_all()
        self._condition_object.release()#释放对象
        time.sleep(2)

if __name__ == '__main__':
    container = []
    condition_object = threading.Condition()
    producer = Producer('producer', condition_object, container)
    consumer1 = Consumer('consumer1', condition_object, container)
    consumer2 = Consumer('consumer2', condition_object, container)
    producer.start()
    consumer1.start()
    consumer2.start()

    print("main end.")

Event对象

用Event对象来实现生产者、消费者之间的同步操作，但由于event没有锁，没办法实现多线程的同步阻塞，不过刚好能用在两个进程之间的同步中

# !/usr/bin/env python
# encoding: utf-8

import threading
import time

#生产者
class Producer(threading.Thread):
    def __init__(self, thread_name, event, container):
        threading.Thread.__init__(self, name=thread_name)
        self._container = container
        self._event = event

    def run(self):
        value = 1
        while True:
            if not self._event.isSet():#没有被设置
                self._container.append(value)
                value += 1
                print("producer making end...")
                self._event.set()
            else:
                print("producer waitting...")
                time.sleep(2)

#消费者
class Consumer(threading.Thread):
    def __init__(self, thread_name, event, container):
        threading.Thread.__init__(self, name=thread_name)
        self._event = event
        self._container = container

    def run(self):
        while True:
            if self._event.isSet():#没有被设置
                self._event.wait()
                print("consumer making x value {0}...".format(self._container.pop()))
                self._event.clear()
            else:
                print("consumer waitting...")
                time.sleep(2)

if __name__ == '__main__':
    container = []
    event = threading.Event()
    producer = Producer('producer', event, container)
    consumer = Consumer('consumer', event, container)
    producer.start()
    consumer.start()

    print("main end.")

其他一些类

timer类

threading中的定时器的意思，作用就是能够实现让一个函数被延迟调用

# !/usr/bin/env python
# encoding: utf-8

import threading

def do_soming(what):
    print("what value:{0}".format(what))

if __name__ == '__main__':
    timer = threading.Timer(5, do_soming, args=("zeng", ))
    timer.start()

local类

假如使用了threading下的local类，在thread中做出的修改是不会生效的

# !/usr/bin/env python
# encoding: utf-8

import threading
import time

local = threading.local()
local.tname = 'main'
name = "zeng"

def do_soming(what):
    # local.tname = 'child'
    global local
    global name
    local.tname = 'zengraoli'#虽然local被做成了全局，但依旧无法改变
    name = "zengraoli" #为了对比，这里的name的的确确被改变了
    print("what value:{0}, local value:{1}, name value:{2}".format(what, local.tname, name))#what value:zeng, local value:zengraoli, name value:zengraoli
    time.sleep(2)

if __name__ == '__main__':
    print("local value:{0}, name value:{1}".format(local.tname, name))#local value:main, name value:zeng
    t = threading.Thread(target=do_soming, args=("zeng", ))
    t.start()
    t.join()#阻塞等待线程
    print("local value:{0}, name value:{1}".format(local.tname, name))#local value:main, name value:zengraoli
    print("main end.")#main end.

更多使用请查看
https://www.cnblogs.com/tkqasn/p/5700281.html

使用线程池

需要安装其他模块，如果需要使用到，请参考
https://blog.csdn.net/hehe123456zxc/article/details/52258358
或者使用下面的map来取代这里的进程池

map实现多线程

map在Python一般都会自动开启多线程、多进程的形式来处理分布式的应用，在Python中有两个库包含了map函数，一个是multiprocessing另外一个是multiprocessing.dummy，唯一的不同是前者使用的是进程，后者使用的是线程
下面的例子，使用了multiprocessing.dummy

# !/usr/bin/env python
# encoding: utf-8

from multiprocessing.dummy import Pool as ThreadPool
import time

def do_soming(what):
    print("what value is {0}".format(what))
    time.sleep(3)
    return "what value is {0}".format(what)

if __name__ == '__main__':
    urls = ['http://www.baidu.com', 'http://www.sina.com', 'http://www.qq.com']
    pool = ThreadPool()
    results = pool.map(do_soming, urls)
    print(results)#['what value is http://www.baidu.com', 'what value is http://www.sina.com', 'what value is http://www.qq.com']
    pool.close()
    pool.join()
    print("main end.")

还有使用multiprocessing的map，会开启N个多进程

# !/usr/bin/env python
# encoding: utf-8

import multiprocessing
import time

def do_soming(what):
    print("what value is {0}".format(what))
    time.sleep(30)
    return "what value is {0}".format(what)

if __name__ == '__main__':
    urls = ['http://www.baidu.com', 'http://www.sina.com', 'http://www.qq.com']
    pool = multiprocessing.Pool(processes=3)
    results = pool.map(do_soming, urls)
    print(results)#['what value is http://www.baidu.com', 'what value is http://www.sina.com', 'what value is http://www.qq.com']
    pool.close()
    pool.join()
    print("main end.")

Python多线程的缺陷

在Python中因为有GIL全局所，所以当你以为是多线程在并发运行的时候，其实当前只有一个线程在工作。因此，更建议去使用多进程

Python多线程的应用场景

在IO密集型任务中更适合使用多线程，如果IO密集型任务中使用的是多进程，则进程的切换涉及到IO的操作，会比较慢；
在计算密集型任务中适合使用多进程，毕竟可以并发。

每天看一遍，防止恋爱&&堕落
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python多线程，3 -- 最常用的，继承threading.Thread, 如果需要的话重写run()
m0_46699540的博客
06-01 196
从threading.Thread类派生子类，将线程相关代码放在这个子类里面，而且。这和之前用过的C++ pthread 貌似是一致的。
python多线程
qq_38889350的博客
07-13 3263
python多线程
Python多线程详解
千山暮彩
10-30 5万+
现代计算机CPU物理核心普遍比较多，我们在编写程序时经常会用到多线程技术来提高程序运行的效率。作为python萌新，我在掌握基本语法后就很想摆弄一下python的多线程，使用起来确实很有python的特点，代码量少、操作方便。之后断断续续写了一些多线程程序，直到今天下午逛论坛，看到很多人说python多线程机制的一些内情，我才意识到自己有多愚蠢哈哈。我把自己学到的内容系统的整理一下，以备后忘，也帮帮后来者。
Python多线程顺序运行
qq_55627126的博客
10-18 1812
某些时候我们需要线程顺序运行，在网络上找了些代码，功能能实现，但是对于大量线程来说，需要手动修改多处，用户调用不便，于是自己基于网络上的一些代码进行优化，实现便于增加线程和修改线程顺序的代码。 from threading import Thread,Lock import time class mythread(Thread): def __init__(self): Thread.__init__(self) self.num = 1 ...
python的多线程
weixin_61805348的博客
05-28 7万+
python多线程 一、线程的概念 线程是CPU分配资源的基本单位。当一程序开始运行，这个程序就变成了一个进程，而一个进程相当于一个或者多个线程。当没有多线程编程时，一个进程相当于一个主线程；当有多线程编程时，一个进程包含多个线程（含主线程）。使用线程可以实现程序大的开发。 多个线程可以在同一个程序中运行，并且每一个线程完成不同的任务。 多线程实现后台服务程序可以同时处理多个任务，并不发生阻塞现象。 多线程的程序设计的特点就是能够提高程序执行效率和处理速度。python程序可以同时并行运行多个相对独立的线
Python多线程爬虫——数据分析项目实现详解
最新发布
Why_does_it_work的博客
01-17 5万+
爬虫和池是爬虫领域中不可或缺的概念，池能够提高爬虫的稳定性和效率，同时帮助爬虫更好地适应目标的反爬虫策略。
python多线程详解（超详细）
热门推荐
世俗的眼光
03-30 21万+
python中的多线程是一个非常重要的知识点，今天为大家对多线程进行详细的说明，代码中的注释有多线程的知识点还有测试用的实例。 import threading from threading import Lock,Thread import time,os ''' python多线程详解 什么是线程？ ...
Python多线程之gevent
Time_xiaoxia的博客
09-01 1064
python多线程只gevent 因为python线程的性能问题，在python中使用多线程运行代码经常不能达到预期的效果。而有些时候我们的逻辑中又需要开更高的并发，或者简单的说，就是让我们的代码跑的更快，在同样时间内执行更多的有效逻辑、减少无用的等待。gevent就是一个现在很火、支持也很全面的python第三方协程库。 gevent是python的一个并发框架，以微线程greenlet为核心，使用了epoll事件监听机制以及诸多其他优化而变得高效。而且其中有个monkey类，将现有基于Python线程直
python多线程端口扫描
qq_41679358的博客
07-16 2348
利用python多线程的性质，写了一个扫描目标主机开放端口的程序 程序功能： 输入目标ip地址，程序执行扫描，讲扫描到的端口，存入test.tst文件 附上代码： import telnetlib import threading def get_port(ip, port): server = telnetlib.Telnet() try: server.open(ip, port) #print('{0} 的 {1} 端口是打开的 '.form
Python多线程同时处理多个文件
qq_36478718的博客
01-11 5601
Python多线程处理多个文件 Multi Threads
python 多线程重启方法
09-19
Python的多线程编程在处理并发任务时非常实用，但线程可能会因各种异常而停止运行，这将影响程序的稳定性。本篇文章主要探讨的是如何在Python中实现多线程的自动重启机制，以确保即使有线程崩溃，程序也能继续执行。...
详解Python多线程下的list
09-16
本篇文章主要探讨了Python多线程下对列表(list)进行操作时的安全性问题。 首先，我们要明确一个概念：线程安全。线程安全指的是在多线程环境中，一个数据结构或函数在任何时候都能正确地处理多个线程的并发访问，...
python多线程接口案例
12-21
在这个特定的“python多线程接口案例”中，我们看到一个脚本被设计用来模拟50个或更多的用户并发访问某个内控公司的业务接口，并生成Excel报告记录结果。以下是对整个脚本的详细解析： 1. **获取Cookie**： 通过...
python多线程定时器
03-11
总结起来，`python多线程定时器`的实现涉及到Python的`threading`和`time`模块，通过`Thread`和`Timer`类来创建和管理线程，使用定时器控制线程的启动时间。主程序`main.py`使用这些工具来安排多个任务按设定的间隔...
windows win7配置pyspider
孤独的糖三角
09-02 3227
windows win7配置pyspider
3、Python中的高级数据类型
孤独的糖三角
06-30 1232
目录 目录 序列类型 元组tuple 命名的元组 列表list 集合类型set 映射类型 字典 字典内涵 *默认字典与有序字典 *有序字典 组合数据类型的迭代 组合数据类型的复制 序列类型 序列的类型支持成员关系操作符(in)，大小计算函数(len())、分片([]) Python有5中内置的序列类型：bytearray、bytes、list、str与tuple ...
《Python编程快速上手,让繁琐工作自动化》读书笔记
孤独的糖三角
03-06 934
文章目录组织文件shutil模块复制文件和文件夹文件和文件夹的移动与改名删除文件和文件夹os.unlink(filename)删除文件os.rmdir(foldname)删除空目录shutil.rmtree(foldname)删除文件夹send2trash模块把文件放入回收站中遍历目录树发送电子邮件处理屏幕控制鼠标移动鼠标并按下鼠标获取鼠标坐标位置获取鼠标坐标位置以前当前像素掉的RGB值获取屏幕快...
11、Python高级程序设计
孤独的糖三角
07-31 575
目录 目录 回忆闭包 没有装饰器的情况下可能需要这么来做 有了装饰器之后，只需要这么来做 对应函数单个参数的装饰器 对应函数多个参数的装饰器 带参数的装饰器 基于类实现的装饰器 几个比较重要的内置装饰器 在使用property经常是这么使用 @staticmethod声明一个方法为静态方法 @classmethod 更高级使用 使用functiontools模块decorator来优化装...
Python多线程编程详解
"本资源是关于Python多线程编程的学习教程，适合进阶学习者，涵盖了多线程基础知识、threading模块的使用、线程创建、线程管理、线程安全以及线程间通信等内容，旨在帮助读者掌握Python的并发执行能力。" 在Python...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值