精华内容
下载资源
问答
  • Python 多线程实例详解

    2020-09-21 09:44:13
    主要介绍了Python 多线程实例详解的相关资料,需要的朋友可以参考下
  • python多线程实例

    2019-01-14 18:34:42
    多线程  Thread是线程类,有两种使用方法,直接传入要运行的方法或 1.从Thread继承并覆盖run(): import threading import time class MyThread(threading.Thread): def __init__(self, n): super(MyThread, ...

    多线程 

    Thread是线程类,有两种使用方法,直接传入要运行的方法或

    1.从Thread继承并覆盖run()

    import threading
    import time
    class MyThread(threading.Thread):
        def __init__(self, n):
            super(MyThread, self).__init__()
            self.n = n
        def run(self):
            print("runnint task", self.n)
    t1 = MyThread("t1")
    t2 = MyThread("t2")
    t1.start()  # runnint task t1
    #t1.join()
    t2.start()  # runnint task t2
    #t2.join()

    1.当用继承的方式去创建线程时,一定要重写父类的Run()方法
    2.当线程的run()方法结束的时候,线程也结束
    3.我们认为是无法完全控制线程的,但是我们可以通过一些方式来影响线程的调用
    4.线程的几种状态 新建----就绪----运行-----死亡 等待(阻塞)主要出现就绪与运行之间

    5.在UNIX平台上,当某个进程终结之后,该进程需要被其父进程调用wait,否则进程成为僵尸进程(Zombie)。所以,有必要对每个Process对象调用join()方法 (实际上等同于wait)。对于多线程来说,由于只有一个进程,所以不存在此必要性。

    2.直接传入要运行的方法

    """
    例1:
    # 假定这是你的银行存款:
    balance = 0
    lock = threading.Lock()
    def change_it(n):
        # 先存后取,结果应该为0:
        global balance
        balance = balance + n
        balance = balance - n
    
    def run_thread(n):
        #lock = threading.Lock()
        global lock
        for i in range(100000):
            lock.acquire()
            try:
                # 放心地改吧:
                change_it(n)
            finally:
                # 改完了一定要释放锁:
                lock.release():
    t1 = threading.Thread(target=run_thread, args=(5,))
    t2 = threading.Thread(target=run_thread, args=(8,))
    t1.start()
    t2.start()
    #t1.join()
    #t2.join()
    print balance
    
    例2:
    #新线程执行的代码:
    def loop(fn,a,b):
        print fn,a,b
        print 'thread %s is running...',threading.current_thread().name
        n = 0
        while n < 5:
            n = n + 1
            print "thread %s>>>%s",threading.current_thread().name,n
            time.sleep(1)
        print "thrad %s end",threading.current_thread().name
    print "thread %s is running...",threading.current_thread().name
    filename = "tgets.csv"
    t = threading.Thread(target=loop,name="LoopThread",args=(filename,5,5))
    t.start()
    t.join()
    print "thread %s ended.",threading.current_thread().name
    
    例3:
    hehe=6
    def f():
        global hehe
        print(hehe)
        hehe=3
    f()
    print(hehe)
    """

     

    展开全文
  • Python多线程实例教程

    2021-01-20 05:08:37
    在早期的Python多线程实现中,采用了thread模块。例如:  from time import ctime,sleep from thread import start_new_thread def loop1(): print enter loop1:,ctime(); sleep(3); print leave loop1
  • 主要介绍了Python多线程和队列操作实例,本文直接给给实例代码,需要的朋友可以参考下
  • 今天小编就为大家分享一篇对Python多线程读写文件加锁的实例详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 一、多线程共享全局变量 首先我们来回忆下在函数中修改全局变量的情况。 在一个函数中,对全局变量进行修改的时候,到底是否需要使用 global 进行说明,要看是否对全局变量的执行指向进行了修改。 如果修改了执行...
  • 今天小编就为大家分享一篇python 多线程将大文件分开下载后在合并的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 主要介绍了python多线程并发实例及其优化,threading是扩展模块,在thread的基础上进行了封装及改进。所以只需要使用threading这个模块就能完成并发的测试,需要的朋友可以参考下
  • 今天小编就为大家分享一篇python 多线程串行和并行的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Python多线程例子

    万次阅读 2017-07-26 11:28:25
    Python多线程例子1、在主线程中创建子线程 下面的代码一共创建了三个线程:主线程、coding 线程和music 线程,最后使用thread_list 装载线程 from time import ctime import threadingdef coding(language): for...

    Python多线程小例子

    1、在主线程中创建子线程

    下面的代码一共创建了三个线程:主线程、coding 线程和music 线程,最后使用thread_list 装载线程

    from time import ctime
    import threading
    
    def coding(language):
        for i in range(5):
            print('I\'m coding ',language, ' program at ', ctime() )
    
    def music():
        for i in range(5):
            print('I\'m listening music at ', ctime())
    
    if __name__ == '__main__':
    
        print('thread %s is running...' % threading.current_thread().name)
    
        thread_list = []
        t1 = threading.Thread(target=coding, args=('Python',))
        t2 = threading.Thread(target=music)
        thread_list.append(t1)
        thread_list.append(t2)
    
        for t in thread_list:
            t.setDaemon(True)  # 设置为守护线程
            t.start()
            t.join()  # 在这个子线程完成运行之前,主线程将一直被阻塞
    
        print('thread %s ended.' % threading.current_thread().name)

    运行效果如下:

    这里写图片描述

    t.join()的作用是:在子线程完成运行前,主线程将处于阻塞的状态,否则主线程会一直运行,并且主线程运行结束后,子线程也一同结束。

    如果我们把join去掉,则运行结果可能为:

    这里写图片描述

    2、lock 锁

    在多线程中,变量由各个线程共享,对共享变量,需要加锁。

    举一个最常见的例子:我们经常在银行存钱、取款,其中一个线程负责存钱,另一个线程负责取款。如果不加控制,很容易就把钱数算错了。我们看看银行是怎么算错钱数的:

    import threading
    
    money = 0 # 变量 money 被 t1和 t2 两个线程共享
    
    # 存钱
    def put_money(sum):
        global money
        money += sum
    
    # 取钱
    def get_money(sum):
        global money
        money -= sum
    
    def run_thread(sum):
        for i in range(1000000): #执行的次数要足够多
            # 先存sum,后取sum,钱数应当为0
            put_money(sum) 
            get_money(sum)
    
    t1 = threading.Thread(target=run_thread, args=(100,))
    t2 = threading.Thread(target=run_thread, args=(1000,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print(money)

    在上面的例子中,我们先存sum元钱,再取sum元钱,总钱数应当一直为0。这在单线程中没有问题。

    然而在多线程中,操作系统交叉执行赋值语句,导致全局变量被一个线程修改了,另一个线程却不知情的情况。

    因为在操作系统中,money += sum,是被拆成两条语句执行的:
      x = money + sum
      money = x

    这两条语句的执行顺序 很可能是乱序的,我们看看下面的表格就理解了,最后你会惊奇地发现 少了5元钱!:-(

    这里写图片描述

    实际结果也验证了这一问题:

    这里写图片描述

    哈哈哈,我们居然多出了2900元。很显然,银行家们肯定不能允许这种情况发生,所以,他们也在学习如何使用lock :-)

    可以通过lock解决这个问题:

    def run_thread(sum):
        for i in range(1000000):
            lock.acquire() # 改动1...........加锁
            try:
                put_money(sum)
                get_money(sum)
            finally:
                lock.release()  # 改动2......别忘了释放锁:

    “当多个线程同时执行lock.acquire()时,只有一个线程能成功地获取锁,然后继续执行代码,其他线程就继续等待直到获得锁为止。”————引用自多线程-廖雪峰的官方网站

    其实和上厕所一个道理,一个人蹲坑,另一个人只能等着 :-)

    这下好了,银行家们在 run_thread 方法中添加了lock,这次程序运行的结果如下,我们看到钱数始终为0:

    这里写图片描述

    除了多线程外,Python 多进程也经常使用,参见:
    http://blog.csdn.net/u010429424/article/details/76147368

    参考:
    http://www.cnblogs.com/fnng/p/3670789.html
    https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/00143192823818768cd506abbc94eb5916192364506fa5d000

    See u ~

    这里写图片描述

    展开全文
  • 它的实例是能够延迟执行目标函数的线程,在真正执行目标函数之前,都可以cancel它。 Timer源码: class Timer(Thread): def __init__(self, interval, function, args=None, kwargs=None): Thread.__init__(self)...
  • 主要介绍了Python多线程经典问题之乘客做公交车算法,简单描述了乘客坐公交车问题并结合实例形式分析了Python多线程实现乘客坐公交车算法的相关技巧,需要的朋友可以参考下
  • 本文实例讲述了Python多线程应用于自动化测试操作。分享给大家供大家参考,具体如下: 多线程执行测试用例 实例: import threading from time import sleep,ctime from selenium import webdriver #测试用例1 def ...
  • Python多线程实例

    千次阅读 2018-11-03 18:11:47
    Python多线程的实现和原理 线程与进程 线程是进程内一个执行单元,也是进程内的可调度实体。 线程与进程的区别: 地址空间,进程独立空间,线程共享进程内的地址空间 资源分配,进程是系统资源调度及分派的基本单位...

    相关文档

    Python多线程的实现和原理

    线程与进程

    线程是进程内一个执行单元,也是进程内的可调度实体。

    线程与进程的区别:

    1. 地址空间,进程独立空间,线程共享进程内的地址空间
    2. 资源分配,进程是系统资源调度及分派的基本单位
    3. 线程是处理器调度的基本单位
    4. 二者均可实现并发

    多线程:
    线程的划分小,并行的效率高;
    多线程共享内存单元,极大地提高了程序运行效率

    Python线程模块

    Python3支持线程的模块主要有thread和threading两个模块,thread是比较底层的模块,threading是对thread的一个封装的模块,threading比较方便以及好用。

    Python3.x通过Threading模块创建新的线程有两种方法:

    1. 通过threading.Thread(target=executable Method),即通过传递给Thread对象一个可执行方法或对象;
    2. 继承threading.Thread定义子类并重写run()方法。

    第2种方法中,唯一必须重写的方法是run()

    (1) 通过threading.Thread() 进行创建多线程,即通过传递给thread对象一个可执行的方法(或对象)

    import threading
    import time
    
    def target():
        print(threading.current_thread().name, "1")
        time.sleep(2)
        
        print(threading.current_thread().name, "2")
        
    # 当前主线程在运行    
    print(threading.current_thread().name, "3")
    
    # 开启线程t, 一般按顺序赋予:Thread-1
    t = threading.Thread(target=target)
    t.start()
    
    # join()是阻塞当前线程,此处的当前线程是主线程,
    # 主线程直到Thread-1结束之后才结束, 所以最后结束的是主线程
    t.join()
    
    print(threading.current_thread().name, "4")
    
    

    运行结果:
    MainThread 3
    Thread-1 1
    Thread-1 2
    MainThread 4

    (2) 通过继承 threading.Thread 定义子类创建多线程
    使用 threading 模块创建多线程,直接从 threading.Thread 继承,然后重写__init__() 方法和 run() 方法

    import threading
    import time
    
    class MyThread(threading.Thread):   #继承父类threading.Thread
        def __init__(self, threadID, name, counter):
            threading.Thread.__init__(self)
            self.threadID = threadID
            self.name = name
            self.counter = counter
    
        def run(self):    #把要执行的代码写到run函数里面,线程在创建后会直接运行run
            print("开始运行:" + self.name)
            print(self.name, self.counter, 5)
            print("结束运行:" + self.name)
    
    
    def print_time(threadName, delay, counter):
        while counter:
            time.sleep(delay)
            print("%s 进程 在:" % (threadName, time.ctime(time.time())))
            counter -= 1
    
    
    #创建新线程
    thread_1 = MyThread(1, "Thread-1", 1)
    thread_2 = MyThread(2, "Thread-2", 2)
    
    #开启线程
    thread_1.start()
    thread_2.start()
    
    #等待线程结束
    thread_1.join()
    thread_2.join()
    
    

    运行结果:
    开始运行:Thread-1
    开始运行:Thread-2
    Thread-1 1 5
    Thread-2 2 5
    结束运行:Thread-1
    结束运行:Thread-2

    这个结果有一定的变化。可以使用线程同步进行控制。

    线程同步

    ​ 如果多个线程共同对某个数据修改,则可能出现不可预料的结果,为了保证数据的正确性,需要对多个线程进行同步。

    ​ 使用Thread对象的Lock和Rlock可以实现简单的线程同步,这两个对象都有acquire方法和release方法,对于那些需要每次只允许一个线程操作的数据,可以将其操作放到acquire和release方法之间。

    ​ 需要注意的是,Python有一个GIL(Global Interpreter Lock)机制,任何线程在运行之前必须获取这个全局锁才能执行,每当执行完100条字节码,全局锁才会释放,切换到其他线程执行。

    多线程实现同步有四种方法:
    1、锁机制
    2、信号量
    3、条件判断
    4、同步队列

    1、锁机制实现示例
    threading的Lock类,用该类的 acquire 函数进行加锁,用 realease 函数进行解锁

    
    

    未完待续…

    展开全文
  • 主要介绍了Python单线程多线程和多进程效率对比,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了Python实现基于多线程、多用户的FTP服务器与客户端功能,结合完整实例形式分析了Python多线程、多用户FTP服务器端与客户端相关实现技巧与注意事项,需要的朋友可以参考下
  • 多线程和queue配合使用,实现子线程和主线程相互通信的例子 ''' import threading __author__ = "Kenny.Li" import Queue import time import random q = Queue.Queue() class MyThread(threading.Thread): def __...
  • 主要介绍了Python多线程及其基本使用方法,结合实例形式分析了Python相关概念、原理、使用方法及操作注意事项,需要的朋友可以参考下
  • 所以弄了个多线程的爬虫。 这次的思路和之前的不一样,之前是一章一章的爬,每爬一章就写入一章的内容。这次我新增加了一个字典用于存放每章爬取完的内容,最后当每个线程都爬取完之后,再将所有信息写入到文件中。 ...
  • 主要介绍了Python基于多线程实现抓取数据存入数据库的方法,结合实例形式分析了Python使用数据库类与多线程类进行数据抓取与写入数据库操作的具体使用技巧,需要的朋友可以参考下
  • 主要介绍了python多线程案例之多任务copy文件,结合完整实例形式分析了Python使用multiprocessing模块实现基于多线程的文件拷贝相关操作技巧,需要的朋友可以参考下
  • python多线程 python中提供两个标准库thread和threading用于对线程的支持,python3中已放弃对前者的支持,后者是一种更高层次封装的线程库,接下来均以后者为例。 创建线程 python中有两种方式实现线程: 1.实例化...
  • 这篇文章主要介绍了Python多线程获取返回值代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 在使用多线程的时候难免想要获取其操作完的返回值进行其他...
  • 本文实例讲述了Python多线程下载文件的方法。分享给大家供大家参考。具体实现方法如下: import httplib import urllib2 import time from threading import Thread from Queue import Queue from time import ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 106,413
精华内容 42,565
关键字:

python多线程实例

python 订阅