精华内容
下载资源
问答
  • Threading

    2019-09-22 20:29:37
    new System.Threading.Thread(new System.Threading.ThreadStart(ReadState)).Start(); 转载于:https://www.cnblogs.com/pengde/p/4727135.html

      new System.Threading.Thread(new System.Threading.ThreadStart(ReadState)).Start();

    转载于:https://www.cnblogs.com/pengde/p/4727135.html

    展开全文
  • threading

    2018-02-27 17:58:31
    threading库1、Python实现多线程下载文件2、python-线程的暂停, 恢复, 退出
    展开全文
  • Threading-源码

    2021-03-10 16:01:27
    Threading
  • threading模块

    2020-01-06 19:35:15
    threading模块

    threading模块

    在这里插入图片描述

    展开全文
  • LinksPlatform的Platform.Threading类库。 命名空间: 自: NuGet程序包: 带有电子阅读器代码的。 取决于 依赖库
  • Threading.pdf

    2020-05-10 08:48:11
    C# Threading,线程。专门讲述线程知识的官方文档。
  • 我们进行程序开发的时候,肯定避免不了要处理并发的情况。...本文基于 Python3 讲解,Python 实现多线程编程需要借助于 threading 模块。 所以,我们要在代码中引用它。 import threading thread...

    我们进行程序开发的时候,肯定避免不了要处理并发的情况。

    一般并发的手段有采用多进程和多线程。

    但线程比进程更轻量化,系统开销一般也更低,所以大家更倾向于用多线程的方式处理并发的情况。

    Python 提供多线程编程的方式。

    本文基于 Python3 讲解,Python 实现多线程编程需要借助于 threading 模块。

    所以,我们要在代码中引用它。

    import threading
    

    threading 模块中最核心的内容是 Thread 这个类。

    我们要创建 Thread 对象,然后让它们运行,每个 Thread 对象代表一个线程,在每个线程中我们可以让程序处理不同的任务,这就是多线程编程。

    值得注意的是,程序运行时默认就是在主线程上

    创建 Thread 对象有 2 种手段。

    1. 直接创建 Thread ,将一个 callable 对象从类的构造器传递进去,这个 callable 就是回调函数,用来处理任务。
    2. 编写一个自定义类继承 Thread,然后复写 run() 方法,在 run() 方法中编写任务处理代码,然后创建这个 Thread 的子类。

    1. 直接创建 Thread 对象。

    class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
    

    Thread 的构造方法中,最重要的参数是 target,所以我们需要将一个 callable 对象赋值给它,线程才能正常运行。

    如果要让一个 Thread 对象启动,调用它的 start() 方法就好了。

    下面是代码示例。

    import threading
    import time
    
    def test():
    
        for i in range(5):
            print('test ',i)
            time.sleep(1)
    
    
    thread = threading.Thread(target=test)
    thread.start()
    
    for i in range(5):
        print('main ', i)
        time.sleep(1)
    

    上面代码很简单,在主线程上打印 5 次,在一个子线程上打印 5 次。

    运行结果如下:

    test  0
    main  0
    main  1
    test  1
    main  2
    test  2
    main  3
    test  3
    main  4
    test  4
    

    上面的 callable 没有参数,如果需要传递参数的话,args 是固定参数,kwargs 是可变参数。

    Thread 的名字

    每一个 Thread 都有一个 name 的属性,代表的就是线程的名字,这个可以在构造方法中赋值。

    如果在构造方法中没有个 name 赋值的话,默认就是 “Thread-N” 的形式,N 是数字。

    import threading
    import time
    
    def test():
    
        for i in range(5):
            print(threading.current_thread().name+' test ',i)
            time.sleep(1)
    
    
    thread = threading.Thread(target=test)
    thread.start()
    
    for i in range(5):
        print(threading.current_thread().name+' main ', i)
        time.sleep(1)
    

    通过 thread.current_thread() 方法可以返回线程本身,然后就可以访问它的 name 属性。

    上面代码运行结果如下:

    Thread-1 test  0
    MainThread main  0
    Thread-1 test  1
    MainThread main  1
    Thread-1 test  2
    MainThread main  2
    Thread-1 test  3
    MainThread main  3
    Thread-1 test  4
    MainThread main  4
    

    如果我们在 Thread 对象创建时,构造方法里面赋值。

    thread = threading.Thread(target=test,name='TestThread')
    

    那么,运行结果会变成这个样子。

    TestThread test  0
    MainThread main  0
    MainThread main  1
    TestThread test  1
    MainThread main  2
    TestThread test  2
    MainThread main  3
    TestThread test  3
    MainThread main  4
    TestThread test  4
    

    Thread 的生命周期

    1. 创建对象时,代表 Thread 内部被初始化。
    2. 调用 start() 方法后,thread 会开始运行。
    3. thread 代码正常运行结束或者是遇到异常,线程会终止。

    可以通过 Thread 的 is_alive() 方法查询线程是否还在运行。

    值得注意的是,is_alive() 返回 True 的情况是 Thread 对象被正常初始化,start() 方法被调用,然后线程的代码还在正常运行。

    import threading
    import time
    
    def test():
    
        for i in range(5):
            print(threading.current_thread().name+' test ',i)
            time.sleep(0.5)
    
    
    thread = threading.Thread(target=test,name='TestThread')
    # thread = threading.Thread(target=test)
    thread.start()
    
    for i in range(5):
        print(threading.current_thread().name+' main ', i)
        print(thread.name+' is alive ', thread.isAlive())
        time.sleep(1)
    

    在上面的代码中,我让 TestThread 比 MainThread 早一点结束,代码运行结果如下。

    TestThread test  0
    MainThread main  0
    TestThread is alive  True
    TestThread test  1
    MainThread main  1
    TestThread is alive  True
    TestThread test  2
    TestThread test  3
    MainThread main  2
    TestThread is alive  True
    TestThread test  4
    MainThread main  3
    TestThread is alive  False
    MainThread main  4
    TestThread is alive  False
    

    我们可以看到,主线程通过调用 TestThread 的 isAlive() 方法,准确查询到了它的存货状态。

    join() 提供线程阻塞手段。

    上面代码两个线程是同时运行的,但如果让一个先运行,一个后运行,怎么做呢?

    调用一个 Thread 的 join() 方法,可以阻塞自身所在的线程。

    import threading
    import time
    
    def test():
    
        for i in range(5):
            print(threading.current_thread().name+' test ',i)
            time.sleep(0.5)
    
    
    thread = threading.Thread(target=test,name='TestThread')
    thread.start()
    thread.join()
    
    for i in range(5):
        print(threading.current_thread().name+' main ', i)
        print(thread.name+' is alive ', thread.isAlive())
        time.sleep(1)
    

    主线程创建了 TestThread 对象后,让其 start,然后通过调用 join() 方法,实现等待。程序运行结果如下:

    TestThread test  0
    TestThread test  1
    TestThread test  2
    TestThread test  3
    TestThread test  4
    MainThread main  0
    TestThread is alive  False
    MainThread main  1
    TestThread is alive  False
    MainThread main  2
    TestThread is alive  False
    MainThread main  3
    TestThread is alive  False
    MainThread main  4
    TestThread is alive  False
    

    默认的情况是,join() 会一直等待对应线程的结束,但可以通过参数赋值,等待规定的时间就好了。

    def join(self, timeout=None):
    

    timeout 是一个浮点参数,单位是秒。

    如果我们更改上面的代码。

    thread.join(1.0)
    

    它的结果会是这样。

    TestThread test  0
    TestThread test  1
    MainThread main  0
    TestThread is alive  True
    TestThread test  2
    TestThread test  3
    MainThread main  1
    TestThread is alive  True
    TestThread test  4
    MainThread main  2
    TestThread is alive  False
    MainThread main  3
    TestThread is alive  False
    MainThread main  4
    TestThread is alive  False
    

    主线程只等待了 1 秒钟。

    Thread 中的 daemon 属性

    有同学可能会注意到,Thread 的构造方法中有一个 daemon 参数。默认是 None。

    那么,daemon 起什么作用呢?

    我们先看一段示例代码。

    import threading
    import time
    
    def test():
    
        for i in range(5):
            print(threading.current_thread().name+' test ',i)
            time.sleep(2)
    
    
    thread = threading.Thread(target=test,name='TestThread')
    # thread = threading.Thread(target=test,name='TestThread',daemon=True)
    thread.start()
    
    
    for i in range(5):
        print(threading.current_thread().name+' main ', i)
        print(thread.name+' is alive ', thread.isAlive())
        time.sleep(1)
    

    我们让主线程执行代码的时长比 TestThread 要短。

    程序运行结果如下。

    TestThread test  0
    MainThread main  0
    TestThread is alive  True
    MainThread main  1
    TestThread is alive  True
    TestThread test  1
    MainThread main  2
    TestThread is alive  True
    MainThread main  3
    TestThread is alive  True
    TestThread test  2
    MainThread main  4
    TestThread is alive  True
    TestThread test  3
    TestThread test  4
    

    MainThread 没有代码运行的时候,TestThread 还在运行。

    这是因为 MainThread 在等待其他线程的结束。

    TestThread 中 daemon 属性默认是 False,这使得 MainThread 需要等待它的结束,自身才结束。

    如果要达到,MainThread 结束,子线程也立马结束,怎么做呢?

    其实很简单,只需要在子线程调用 start() 方法之前设置 daemon 就好了。

    当然也可以在子线程的构造器中传递 daemon 的值为 True。

    thread = threading.Thread(target=test,name='TestThread',daemon=True)
    # thread.setDaemon(True)
    

    更改前面代码示例,运行结果如下

    TestThread test  0
    MainThread main  0
    TestThread is alive  True
    MainThread main  1
    TestThread is alive  True
    TestThread test  1
    MainThread main  2
    TestThread is alive  True
    MainThread main  3
    TestThread is alive  True
    TestThread test  2
    MainThread main  4
    TestThread is alive  True
    

    可以看到 MainThread 结束了 TestThread 也结束了。

    2.自定义类继承 Thread

    前面讲过,直接初始化一个 Thread,然后,现在还有一种方式就是自定义一个 Thread 的子类,然后复写它的 run() 方法。

    import threading
    import time
    
    
    class TestThread(threading.Thread):
    
        def __init__(self,name=None):
            threading.Thread.__init__(self,name=name)
    
        def run(self):
            for i in range(5):
                print(threading.current_thread().name + ' test ', i)
                time.sleep(1)
    
    
    thread = TestThread(name='TestThread')
    thread.start()
    
    
    for i in range(5):
        print(threading.current_thread().name+' main ', i)
        print(thread.name+' is alive ', thread.isAlive())
        time.sleep(1)
    

    上面的代码,我们自定义了 TestThread 这个类,然后继承了 threading.Thread。

    只有在 run() 方法中处理逻辑。最终代码运行结果如下:

    TestThread test  0
    MainThread main  0
    TestThread is alive  True
    TestThread test  1
    MainThread main  1
    TestThread is alive  True
    TestThread test  2
    MainThread main  2
    TestThread is alive  True
    MainThread main  3
    TestThread is alive  True
    TestThread test  3
    MainThread main  4
    TestThread test  4
    TestThread is alive  True
    

    这与之前的效果并无差异,但我还是推荐用这种方法,毕竟面向对象编程嘛。

    自此,Python 多线程编码技术就大致介绍完毕,大家可以进行实际代码编写了。

    但是,多线程编程的难点在于多个线程之间共享数据的同步,这是非常容易出错的地方,我将分别编写相应的博文去介绍一些高级的技术点。

    展开全文
  • 在进行爬虫系统开发的过程中遇到需要间隔一段时间就重复执行的任务的需求,就想实现一个线程服务在后台监控数据的抓取...在查找资料后发现可以使用 threading.Timer来实现这个代码如下:def func1(): print('Do som...
  • Efficient Android Threading

    2017-11-28 14:05:53
    Efficient Android Threading 作者: Anders Goransson 仅供学习,请勿商用
  • Python threading

    2018-05-11 11:35:44
    threading模块的多线程实现 两种方式. 第一种提供参数用threading.Thread去构造 import threading from time import sleep, ctime loops = [4, 2] def loop(nloop, nsec): print 'start loop', nllp, 'at:',.....
  • threading in C# 中英文

    2018-03-11 18:10:30
    threading in C#threading in C#threading in C#threading in C#
  • Python threading

    2020-11-19 15:56:18
    threading是python中的一个标准库。 import threading #导入threading库 一、threading库中的一些方法: threading.active_count() # 返回正在运行线程的数量,相当于len(threading.enumerate()) threading....
  • threading学习

    2018-11-18 22:37:30
    python threading有一个有趣的现象,起多个线程时,CPU 占用只有160%不到200%,这是由于GIL全局解释锁的原因,参考python基础之多线程锁机制 import time, threading n = 1 def loop(i): global n n = n + i n =...
  • threading

    2017-04-25 11:01:04
    之前学习过threading包,两个月过去了,基本也没用上;本次在于复习一遍threading包,记录学习路程,日后再用,也就省心不少.进程是操作系统分配资源的最小单位,线程是操作系统调度的最小单元.创建一个线程:threading....
  • Threading 多线程

    2020-05-18 18:15:33
    import threading print(threading.active_count()) #显示当前存在的线程数 print(threading.enumerate()) #显示当前存在的线程 print(threading.current_thread()) #显示正在工作的线程 threading.active_count...
  • C# Threading Handbook

    2014-03-08 15:45:47
    C# Threading Handbook 英文版
  • Python3 threading

    2021-04-11 08:38:11
    python2中的thread在python3中升级成了threading ,原先的thread变成了_thread ,建议大家使用threading ,Python中虽然有GIL的存在,并不能并行线程,但是对于IO密集型的应用还是挺方便快捷的。 这里需要注意一个点:...
  • threading.local

    2021-04-09 18:42:00
    import threading import time v = threading.local() def func(arg): v.phone = arg time.sleep(2) print(v.phone, arg) for i in range(10): t = threading.Thread(target=func, args=(i,)) t.start()
  • threading.Condition

    2020-08-11 15:20:36
    import threading # 创建一个 condition 对象 cond = threading.Condition() class kb(threading.Thread): def __init__(self,cond , name): threading.Thread.__init__(self,name = name) self.cond = cond ...
  • thread/threading

    2019-10-08 18:07:34
    thread/threading python内建模块线程练习 thread1. EXP1, thread简单调用2. EXP2, thread加入锁threading1. EXP1, threading 通过Threading.Thread构造线程2. EXP2, threading 通过从 Thread 继承,并重写 ...
  • 本文实例讲述了Python线程threading模块用法。分享给大家供大家参考,具体如下: threading-更高级别的线程接口 源代码:Lib/threading.py 该模块在较低级别thread模块之上构建更高级别的线程接口。另请参见mutex和...
  • 1.1 什么是多线程 Threading 多线程可简单理解为同时执行多个任务。 多进程和多线程都可以执行多个任务,线程是进程的一部分。线程的特点是线程之间可以共享内存和变量,资源消耗少(不过在Unix环境中,多进程和多...
  • Mbedtls Thread Safety and Multi Threading: concurrency issues If you want to use multi threading in mbedtls, You must first open the Macro switch MBEDTS_THREADING_PTHREAD and MBEDTLS_THREADING_C. Or ...
  • threading模块中,定义两种类型的锁:threading.Lock和threading.RLock。它们之间有一点细微的区别,通过比较下面两段代码来说明: import threading lock = threading.Lock() #Lock对象 lock.acquire()...
  • 本篇文章给大家介绍了Python中Threading的详细用法,需要的朋友跟着小编一起学习下吧。
  • python threading模块

    2019-04-30 17:04:39
    文章目录threading模块threading简单介绍案例一 threading模块 threading简单介绍 """ threading 是线程模块 可以使你的程序加快运行速度 使你多线程运行 如果不用这么模块 你的程序使一步一步的运行 用了这个模块你...
  • Threading In .NET

    2019-09-30 19:44:15
    1、Beginners Guide To Threading In .NET Part 1 of 2、Beginners Guide To Threading In .NET Part 2 of n 3、Beginners Guide To Threading In .NET Part 3 of n 4、Beginners Gui...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,314
精华内容 22,525
关键字:

threading