精华内容
下载资源
问答
  • python threading模块
    2022-08-24 15:10:26
    # 引入多线程模块
    import threading
    # 引入线程池模块
    from multiprocessing.pool import ThreadPool
    
    
    pool = ThreadPool(4)  # 定义一个线程池,参数是线程池内线程数量
    def test_def(my_str):
        # 定义了一个用于线程池的函数,打印传入的字符串
        print(my_str)
    
    
    for i in range(10):
        my_str = "字符串:" + str(i)
        pool.apply_async(test_def, args=(my_str ,))  # 将线程加入线程池,并启动
    pool.close()  # 关闭线程池入口(关闭后将无法再想线程池内添加线程)
    pool.join()  # 添加阻塞,防止线程池内线程运行时主线程已结束
    
    

    说明:

    1.线程池需要先定义再使用,定义时需要设定线程池大小(即同时运行线程数量)。

    2.线程池内的线程根据进入的顺序执行,同时运行的线程数量不超过线程池大小。

    3.线程池内的线程在加入线程池时就开始排队运行(基于线程池大小),无需调用start()方法。

    4.在使用中,根据需要,可关闭线程池入口(pool.close()方法),关闭后无法再给线程池加入新的线程。

    5.最好添加pool.join()语句,防止线程池内的线程还在运行时主线程就结束了导致线程池内线程异常。

    更多相关内容
  • 主要介绍了Python THREADING模块中的JOIN()方法深入理解,本文用简洁易懂的语言总结了对JOIN()方法的理解,不同于其它文章,需要的朋友可以参考下
  •  threading模块里面主要是对一些线程的操作对象化了,创建了叫Thread的class。一般来说,使用线程有两种模式,一种是创建线程要执行的函数,把这个函数传递进Thread对象里,让它来执行;另一种是直接从Thread继承,...
  • python threading模块里args传递参数

    千次阅读 2019-09-11 17:12:36
    from threading import Thread def downloadFile(contents): for content in contents:  filename = content[0]  filename = content[1] ''' 此处为下载相关代码 ''' contents = [('1...

    以下为一部分代码:

    from threading import Thread

    def downloadFile(contents):

    for content in contents:

              filename = content[0]

             filename = content[1]

    '''

    此处为下载相关代码

    '''

    contents = [('1','https://xxxxxxxx'),  ('2','https://xxxxxxxxxxx'),   ('3','https://xxxxxxxxxxxxxxxxxxxxxx')]

    t1 =   Thread(target = downloadFile, args = contents  )

     

    这里报错显示,“args要一个参数,但是你给它了三个”,args参数为一个tuple,切传递过程中会去掉最外层的()

    如:args = (  [  ( '  a  '  ,   '   1'  )  ,  ( '  b  ',  '  2  ' )  ,  (  ' c  '  ,   '  3   ')  ]  )

    而它自动处理后赋值为:

    [  ( '  a  '  ,   '   1'  )  ,  ( '  b  ',  '  2  ' )  ,  (  ' c  '  ,   '  3   ')  ]

    展开全文
  • Lock原始锁代码 import threading lock = threading.Lock() lock.acquire() print(f"{lock}已被线程{threading.get_ident()}上锁了") def func(): lock.release() print(f"{lock}已被线程{threading.get_ident()}...

    1. Lock和RLock概念

    Lock:Lock被称为①原始锁,原始锁是一个②在锁定时不属于特定线程的同步基元组件,它是能用的最低级的同步基元组件。原始锁处于 "锁定" 或者 "非锁定" 两种状态之一。它被创建时为非锁定状态。它有两个基本方法, acquire() 和 release() 。当状态为非锁定时, acquire() 将状态改为锁定并立即返回。当状态是锁定时, acquire() 将阻塞至其他线程调用 release() 将其改为非锁定状态,然后 acquire() 调用重置其为锁定状态并返回。 release() 只在锁定状态下调用; 它将状态改为非锁定并立即返回。如果尝试释放一个非锁定的锁,则会引发 RuntimeError  异常。锁支持 上下文管理协议,即支持with语句,下文例子中会用到。

    RLock:RLock被称为重入锁,若要锁定锁,线程调用其 acquire() 方法;一旦线程拥有了锁,方法将返回。若要解锁,线程调用 release() 方法。 ③acquire()/release() 对可以嵌套,重入锁必须由获取它的线程释放。一旦线程获得了重入锁,同一个线程再次获取它将不阻塞。只有最终 release() (最外面一对的 release() ) 将锁解开,才能让其他线程继续处理 acquire() 阻塞。;线程必须在每次获取它时释放一次。

    两者使用的方法大部分还是相同的,下面根据以上红色强调部分描述一下二者的区别

    ①是名称的区别,一个叫原始锁,一个叫重入锁,这没啥好说的

    ②Lock在锁定时不属于特定线程,也就是说,Lock可以在一个线程中上锁,在另一个线程中解锁。而对于RLock来说,只有当前线程才能释放本线程上的锁,即解铃还须系铃人:

    2. Lock原始锁代码

    import threading
    
    lock = threading.Lock()
    lock.acquire()
    print(f"{lock}已被线程{threading.get_ident()}上锁了")
    
    
    def func():
        lock.release()
        print(f"{lock}已被线程{threading.get_ident()}释放了")
    
    
    t1 = threading.Thread(target=func)
    t1.start()
    

    上面代码中,在主线程中创建锁,并上锁,但是是在t线程中释放锁,结果正常输出,说明一个线程上的锁,可以由另外线程解锁。如果把上面的锁改为RLock则报错

    RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。也就是说,下面的情况对于RLock是允许的: 

    3. RLock重入锁代码

    import threading
    
    rlock = threading.RLock()
    
    
    def func():
        rlock.acquire()
        print(f"{rlock}上了第1把锁")
        rlock.acquire()
        print(f"{rlock}上了第2把锁")
        rlock.release()
        print(f"{rlock}释放了第2把锁")
        rlock.release()
        print(f"{rlock}释放了第1把锁")
    
    
    t1 = threading.Thread(target=func)
    t1.start()

    注意上面强调的同一线程中,因为对于RLock来说只有当前线程才能释放本线程上的锁,并不能在t1线程中已经执行rlock.acquire,且未释放锁的情况下,在另一个t2线程中还能执行rlock.acquire(这种情况会导致t2阻塞)

    那么,既然一个线程可以通过Lock来获得一把锁,干嘛还要使用RLock去锁上加锁?考虑一下这种情况: 

    3.  为何使用重入锁RLock

    import threading
    
    
    rlock = threading.RLock()
    
    
    def inner():
        with rlock:
            print(f"inner: {threading.current_thread()}")
    
    
    def outer():
        with rlock:
            print(f"outer: {threading.current_thread()}")
            inner()
    
    
    t1 = threading.Thread(target=outer)
    t2 = threading.Thread(target=outer)
    t1.start()
    t2.start()

    首先只看t1线程,当执行到outer函数时,首先打印outer function:<Thread(Thread-1, started 12892)>,然后用lock1给当前线程上了一把锁,然后执行inner函数,在inner里面又需要用lock1来上一把锁,如果此时用Lock的话,由于已经上了一把锁,程序会因为第二次无法获得锁而导致t1阻塞,程序阻塞之后又没法释放锁,所以会导致程序死锁。这种情况下,RLock就派上用场了。t2线程执行过程和t1一样,这里只是多加个线程看起来酷炫一些

    参考链接:https://www.cnblogs.com/olivertian/p/11295031.html

    展开全文
  • 主要介绍了Python线程threading模块用法,结合实例形式总结分析了Python线程threading模块基本功能、原理、相关函数使用方法与操作注意事项,需要的朋友可以参考下
  • Condition的处理流程如下: 首先acquire一个条件变量,然后判断一些条件。 如果条件不满足则wait; 如果条件满足,进行一些处理改变条件后,通过notify方法通知其他线程,其他处于wait状态的线程接到通知后会...
  • pythonthreading模块

    2022-08-05 20:01:01
    import threading class MYThread(threading . Thread) : #继承threading.Thread def __init__(self , num) : super(MYThread , self) . __init__() self . num = num def run(self) : #重写run方法 print(f"running...

    线程

    • 线程被称为轻量级进程(Lightweight Process,LWP),是cpu调度的基本单位
    • 组成:线程ID、当前指令指针(PC)、寄存器集合、堆栈组成
    • 在单个程序中同时运行多个线程完成不同的工作,称为多线程。

    threading功能

    threading用于提供线程相关的操作,线程是应用程序中工作的最小单元。
    ■ threading模块提供的常用类:

    • Thread:创建线程
    • Lock/RLock:互斥锁

    threading——Thread

    Thread构造方法
    • 构造方法: Thread(group=None, target=None, name=None, args=(), kwargs={})
    • group: 线程组,目前还没有实现,库引用中提示必须是None;
    • target: 要执行的方法;
    • name: 线程名;
    • args/kwargs: 要传入方法的参数

    ###计算主线程的运行时间
    import requests
    import time
    import functools
    import threading
    def runtime(func):#func要接收一个callable对象
        print("this is run time")
        @functools.wraps(func)  # 保留传递进来函数的元数据,将他的元数据赋值给inner
        def inner(*args,**kwargs):#所以把功能写在inner里就行
            start=time.time()
            result=func(*args,**kwargs)#要将原函数的返回值保存起来
            end=time.time()
            print(f"函数执行花了{end-start}s")
            return result
        return inner
    def get_content(url):
        text=requests.get(url).content
        time.sleep(0.5)
        print("get content")
    @runtime
    def main():
        for i in range(5):
            # get_content("https://www.baidu.com")
            #创建多线程,有六个线程---一个主线程五个子线程
            #target--->指定传入的方法名字,要做什么
            #args--->指定方法需要传入的参数(元组类型)
            t=threading.Thread(target=get_content,args=("https://www.baidu.com",))
            t.start()#启动线程-->自动的执行run方法
    main()
    输出:
    this is run time
    函数执行花了0.001995086669921875s#统计的是main线程创建子线程的时间
    get content
    get content
    get content
    get content
    get content
    
    
    ###若需要计算子线程的运行时间呢?
    #引入t.join()
    #**t.join([timeout])**: 阻塞当前上下文环境的线程,直到调用此方法的线程终止或到达指定的timeout(可选参数)。
    import requests
    import time
    import functools
    import threading
    def runtime(func):#func要接收一个callable对象
        print("this is run time")
        @functools.wraps(func)  # 保留传递进来函数的元数据,将他的元数据赋值给inner
        def inner(*args,**kwargs):#所以把功能写在inner里就行
            start=time.time()
            result=func(*args,**kwargs)#要将原函数的返回值保存起来
            end=time.time()
            print(f"函数执行花了{end-start}s")
            return result
        return inner
    def get_content(url):
        text=requests.get(url).content
        time.sleep(0.5)
        print("get content")
    @runtime
    def main():
        t_list=[]
        for i in range(5):
            # get_content("https://www.baidu.com")
            #创建多线程
            #target--->指定传入的方法名字,要做什么
            #args--->指定方法需要传入的参数(元组类型)
            t=threading.Thread(target=get_content,args=("https://www.baidu.com",))
            t_list.append(t)
            t.start()#启动线程-->自动的执行run方法
            # t.join()#若是join放在此处多线程将没有意义
        for t in t_list:
            #阻塞当前环境(谁执行join代码,谁就是当前环境)上下文,直到t线程执行完成(主线程去做)
            t.join()
        #只有当t的线程执行完成才会执行
        print("ending..............")
    main()
    输出:
    this is run time
    get content
    get content
    get contentget contentget content
    
    
    ending..............
    函数执行花了0.657221794128418s
    
    Thread实例方法

    t.name:获取或设置线程的名称
    t.getName()/setName(name): 获取/设置线程名。

    t.is_alive()、t.isAlive():判断线程是否为激活状态。返回线程是否在运行。正在运行指启动后、终止前。

    t.ident :获取线程的标识符。线程标识符是一个非零整数,只有在调用了start()方法之后该属性才有效,否则它只返回None

    t.run() :线程被cpu调度后自动执行线程对象的run方法

    t.start(): 线程准备就绪,等待CPU调度,start会自动调用t.run()

    t.join([timeout]): 阻塞当前上下文环境的线程,直到调用此方法的线程终止或到达指定的timeout(可选参数)。

    t.setDaemon(bool): 设置是后台线程(默认前台线程(False))。(在start之前设置)

    • Python3.10中,set.Daemon(aTrue)这种写法已经弃用了,正确的写法是.daemon=True
      举例:
      t=threading.Thread(target=h)
      t.daemon=True
      t.start()

    • 如果是后台线程,主线程执行过程中,后台线程也在进行,主线程执行完毕后,后台线程不论成功与否,主线程和后台线程均停止

    • 如果是前台线程,主线程执行过程中,前台线程也在进行,主线程执行完毕后,等待前台线程也执行完成后,程序停止

    t.isDaemon:判断是否为后台线程

    #设置是后台线程
    #t.daemon=True
    import requests
    import time
    import functools
    import threading
    def runtime(func):#func要接收一个callable对象
        print("this is run time")
        @functools.wraps(func)  # 保留传递进来函数的元数据,将他的元数据赋值给inner
        def inner(*args,**kwargs):#所以把功能写在inner里就行
            start=time.time()
            result=func(*args,**kwargs)#要将原函数的返回值保存起来
            end=time.time()
            print(f"函数执行花了{end-start}s")
            return result
        return inner
    def get_content(url):
        text=requests.get(url).content
        time.sleep(0.5)
        print("get content")
    @runtime
    def main():
        t_list=[]
        for i in range(5):
            # get_content("https://www.baidu.com")
            #创建多线程
            #target--->指定传入的方法名字,要做什么
            #args--->指定方法需要传入的参数(元组类型)
            t=threading.Thread(target=get_content,args=("https://www.baidu.com",))
            t_list.append(t)
            #默认为前台线程,主线程执行完了,等子线程执行完再退出
            #t.setDaemon=True#设置后台线程,主线程退出子线程就立马退出
            t.daemon=True
            t.start()#启动线程-->自动的执行run方法
            # t.join()#若是join放在此处多线程将没有意义
        # for t in t_list:
        #     #阻塞当前环境(谁执行join代码,谁就是当前环境)上下文,直到t线程执行完成(主线程去做)
        #     t.join()
        #只有当t的线程执行完成才会执行
        print("ending..............")
    main()
    输出:
    this is run time
    ending..............
    函数执行花了0.0029897689819335938s
    

    自定义线程类

    import threading
    class MYThread(threading.Thread):#继承threading.Thread
        def __init__(self,num):
            super(MYThread,self).__init__()
            self.num=num
        def run(self):#重写run方法
            print(f"running on numbers:{self.num}")
    
    t1=MYThread(1)
    t2=MYThread(2)
    t1.start()
    t2.start()
    输出:
    running on numbers:1
    running on numbers:2
    
    Process finished with exit code 0
    
    展开全文
  • 主要介绍了举例详解Pythonthreading模块的几个常用方法,threading模块用来创建和操作线程,是Python学习当中的重要知识,需要的朋友可以参考下
  • pythonthreading模块详解

    千次阅读 2021-02-03 10:03:40
    pythonthreading模块详解,threading提供了一个比thread模块更高层的API来提供线程的并发性。这些线程并发运行并共享内存。下面来看threading模块的具体用法:一、Thread的使用 目标函数可以实例化一个Thread对象...
  • pythonthreading 模块

    千次阅读 2021-02-03 00:50:52
    下面来看threading模块的具体用法:一、Thread的使用 目标函数可以实例化一个Thread对象,每个Thread对象代表着一个线程,可以通过start()方法,开始运行。这里对使用多线程并发,和不适用多线程并发做了一个比较:...
  • python threading模块

    2020-10-28 16:51:12
    import threading from time import ctime, sleep loops = [2,4,3] def loop(loop_num,sleep_time): print 'start loop',loop_num,'at:',ctime() sleep(sleep_time) print 'done loop',loop_num,'at',ctime() ...
  • Python中我们主要是通过thread和 threading这两个模块来实现的,其中Pythonthreading模块是对thread做了一些包装的,可以更加方便的被使用,所以我们使用 threading模块实现多线程编程。这篇文章我们主要来看看...
  • Python 多线程之 threading 模块

    千次阅读 2022-04-02 15:48:04
    使用 threading 模块创建线程通常有两种方式:1)使用 threading 模块中 Thread 类的构造器创建线程,即直接对类 threading.Thread 进行实例化,并调用实例化对象的start方法创建线程;2)继承 threading 模块中的 ...
  • 本文实例讲述了Pythonthreading模块join函数用法。分享给大家供大家参考。具体分析如下: join的作用是众所周知的,阻塞进程直到线程执行完毕。通用的做法是我们启动一批线程,最后join这些线程结束,例如: for ...
  • 2、python 线程对象的daemon属性继承自父线程,主线程的daemon属性是 False. 所谓 daemon 即父线程退出时,子线程立即退出。而非 deamon 子线程;父线程会等待子线程退出时才退出。 3、threading.Event 类,线程间...
  • 文章目录一、threading模块介绍二、:threading模块主要对象三、threading.Thread对象1、语法2、参数3、常用方法四、python开启线程的两种方法1、使用threading.Thread 线程对象2、继承父类threading.Thread五、...
  • 文章目录前言threading模块(一)简介(二)创建线程—start()方法(三)join()方法(四)setDaemon(bool) 前言 在日常的开发中经常会用到多线程和多进程编程,使用多线程编程可降低程序的复杂度,使程序更简洁高效...
  • threading模块创建线程,通过代码来了解具体的使用
  • python线程--threading模块

    千次阅读 2020-12-11 04:00:14
    渊源为了摆脱6点后加班 "等版本挂测升降级" 的宿命,python小白硬是写起了脚本。以下是用到的部分,惊喜。--bs4.BeautifulSoup (为了监测固件是否编译完成)--urllib.request.urlopen (为了自动下载固件)--hashlib...
  • import threading import time def tt(t): # 开启线程限制 with pool_sema: print(t) time.sleep(2) if __name__ == '__main__': # 并发的线程数设置 thread_nums = 2 pool_sema = threading....
  • 命令提示符如何打开并运行python文件链接 一、 1.active_count() , activeConut() 方法 功能 active_count() , activeConut() 返回处于alive状态的Thread对象数量 用法: import time import threading ...
  • Lock锁是Python的原始锁,在锁定时不属于任何一个线程。在调用了 lock.acquire() 方法后,进入锁定状态,lock.release()方法可以解锁。底层是通过一个函数来实现的,会根据不同的操作系统选择一个最有效的版本实例 ...
  • python threading获取返回值

    千次阅读 2022-04-22 18:31:10
    调用时可以获取线程的return返回值 """ # 定义一个MyThread.py线程类 class MyThread(threading.Thread): def __init__(self, func, args=()): super(MyThread, self).__init__() self.func = func self.args = args...
  • from threading import Thread ''' 多线程 控制线程退出方法 主线程启动多线程,若主线程退出则关闭启动的多线程 设置主线程的属性daemon = 1 主线程循环状态保持运行,并判断变量self.flag状态,用于退出标识 '''...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,021
精华内容 13,208
关键字:

python threading模块