python中threading多线程

python中有两个处理多线程的模块thread和threading。其中thread提供了多线程底层支持的模块,以低级原始的发那个是来处理和控制线程,使用起来较为复杂;而threading基于thread进行包装,将线程操作对象化。

最基础的的多线程

我们先看一个最最基础的多线程例子

import threading
import time
class test(threading.Thread):
    def __init__(self,name,delay):
        threading.Thread.__init__(self)
        self.name = name
        self.delay = delay

    def run(self):
        print "%s is running"%self.name
        for x in range(self.delay):
           time.sleep(1)
           print "%s is saying hello %d"%(self.name,x)

def main():
    t1 = test(‘Thread 1‘,3)
    t2 = test(‘Thread 2‘,2)
    t1.start()
    t2.start()

if __name__ == ‘__main__‘:
    main()
    print "End of main"

输出结果如下:

Thread 1 is running
 End of mainThread 2 is running

Thread 1 is saying hello 0
Thread 2 is saying hello 0
Thread 1 is saying hello 1
Thread 2 is saying hello 1
Thread 1 is saying hello 2

可以看出Thread1 和Thread2基本上轮流执行的,这就是多线程的好处,否则如果顺序执行2个程序会需要2倍的时间。

start是对thread的run()的封装,在调用start()的时候,会执行run()函数。

如果把代码中的一段改成下面这样呢?

def main():
    t1 = test(‘Thread 1‘,3)
    t2 = test(‘Thread 2‘,2)
    t1.start()
    print "wait for thread1 end"
    t1.join()
    t2.start()

输出结果为:

wait for thread1 endThread 1 is running

Thread 1 is saying hello 0
Thread 1 is saying hello 1
Thread 1 is saying hello 2
End of mainThread 2 is running

Thread 2 is saying hello 0
Thread 2 is saying hello 1

从上面可以看出,调用了t1.join()后,t2会一直等到t1执行完毕才会开始执行。

使用Queue进行多线程编程

使用线程队列

如前所述,当多个线程需要共享数据或者资源的时候,可能会使得线程的使用变得复杂。线程模 块提供了许多同步原语,包括信号量、条件变量、事件和锁。当这些选项存在时,最佳实践是转而关注于使用队列。相比较而言,队列更容易处理,并且可以使得线 程编程更加安全,因为它们能够有效地传送单个线程对资源的所有访问,并支持更加清晰的、可读性更强的设计模式。

import threading
import time
import Queue
import urllib2
import os
class test(threading.Thread):
    def __init__(self,queue):
        threading.Thread.__init__(self)
        self.queue = queue

    def run(self):
        while 1:
            url = self.queue.get()
            print self.name+"begin download"+url+"..."
            self.download(url)
            self.queue.task_done()
            print self.name+"download completed"

    def download(self,url):
        urlHandle = urllib2.urlopen(url)
        with open(os.path.basename(url)+".html","wb")as fp:
            while 1:
                contents=urlHandle.read(1024)
                if not contents:
                    break
                else:
                    fp.write(contents)
def main():
    ulrs = ["http://wiki.python.org/moin/Webprograming",
    "https://www.baidu.com",
    "http://wiki.python.org/moin/Documendation"]

    q = Queue.Queue(5)
    for each in ulrs:
      q.put(each)

    for i in range(5):
        t = test(q)
        t.setDaemon(True)
        t.start()

    q.join()

if __name__ == ‘__main__‘:
    main()

join()

保持阻塞状态,直到处理了队列中的所有项目为止。在将一个项目添加到该队列时,未完成的任务的总数就会增加。当使用者线程调用 task_done() 以表示检索了该项目、并完成了所有的工作时,那么未完成的任务的总数就会减少。当未完成的任务的总数减少到零时,join() 就会结束阻塞状态。

每个线程运行的时候就从队列里get一个url,这时候队列的长度就缩小1,然后完成的时候发送通知。直到队列为空的时候表示全部执行完毕。

调试的时候发现即使不要task_done()也可以得到一样的结果。但是主线程会一直阻塞着无法继续执行,所以task_done的任务是告诉主线程的当前任务完成了,并递减未完成的任务数,这样主线程才知道什么时候所有的任务都完成了,好继续执行。

时间: 2024-10-08 00:17:19

python中threading多线程的相关文章

python中threading模块详解(一)

python中threading模块详解(一) 来源 http://blog.chinaunix.net/uid-27571599-id-3484048.html threading提供了一个比thread模块更高层的API来提供线程的并发性.这些线程并发运行并共享内存. 下面来看threading模块的具体用法: 一.Thread的使用 目标函数可以实例化一个Thread对象,每个Thread对象代表着一个线程,可以通过start()方法,开始运行. 这里对使用多线程并发,和不适用多线程并发做

python中的多线程【转】

转载自: http://c4fun.cn/blog/2014/05/06/python-threading/ python中关于多线程的操作可以使用thread和threading模块来实现,其中thread模块在Py3中已经改名为_thread,不再推荐使用.而threading模块是在thread之上进行了封装,也是推荐使用的多线程模块,本文主要基于threading模块进行介绍.在某些版本中thread模块可能不存在,要使用dump_threading来代替threading模块. 线程创

14-08-07 关于程序、进程、线程,以及python中实现多线程的办法

考核题目中涉及到多线程编程,于是复习了一下系统编程里面的各种概念. 首先,程序是代码,没有活动.通过编译连接之后被加载到内存里运行时,内存活动的就是进程,这里的进程不仅仅是代码段,还包括涉及的数据等.而线程是在同一个进程下的小程序,它们可以"同时"地运行,其中会有一个主线程来控制. 接下来是多线程或着多进程的实现,两者原理基本一样,都是把CPU的时间分片然后进行分配给某个进程或者线程,也就是说在同一个时间只会有一个线程在使用CPU,但是CPU切换线程的频率非常快使得它们看上去是在同一个

python中的多线程

一个程序可以理解为一个进程,这个进程有其代号,可以依据这个代号将其杀死. 一个进程肯定有且只有一个主线程,他可以有很多子线程. 运行一个任务如果可以有许多子线程同时去做,当然会提高效率. 但是,在python中,多线程其实不是严格意义上的多线程. 因为,python有一个全局锁的概念,它保证在某一个时间节点上,只能存在一个线程在运行,只是这个时间节点非常短,人类意识不到. 所以说,Python的多线程其实就是不断地切换进程,而没有把所有的进程在同一时间同时运行. 注意,切换进程并不是依据什么顺序

python中threading的用法

摘自:http://blog.chinaunix.net/uid-27571599-id-3484048.html 以及:http://blog.chinaunix.net/uid-11131943-id-2906286.html threading提供了一个比thread模块更高层的API来提供线程的并发性.这些线程并发运行并共享内存. 下面来看threading模块的具体用法: 一.Thread的使用 目标函数可以实例化一个Thread对象,每个Thread对象代表着一个线程,可以通过sta

Python中threading的join和setDaemon的区别及用法

Python多线程编程时经常会用到join()和setDaemon()方法,基本用法如下: join([time]): 等待至线程中止.这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生. setDaemon,将该线程标记为守护线程或用户线程 1.join ()方法:主线程A中,创建了子线程B,并且在主线程A中调用了B.join(),那么,主线程A会在调用的地方等待,直到子线程B完成操作后,才可以接着往下执行,那么在调用这个线程时可以使用被调

python中的多线程和多进程编程

注意:多线程和多线程编程是不同的!!! 第一点:一个进程相当于一个要执行的程序,它会开启一个主线程,多线程的话就会再开启多个子线程:而多进程的话就是一个进程同时在多个核上进行: 第二点:多线程是一种并发操作(伪并行),它相当于把CPU的时间片分成一段一段很小的片段,然后分给各个线程交替进行,由于每个片段都很短,所以看上去像平行操作: (1)多线程操作案例: import threading class MyThread(threading.Thread): def __init__(self ,

python 通过threading多线程ssh

#!/usr/bin/env python#coding=utf-8import paramikoimport time,datetime,threading def ssh(ip,user,passwd,command):    ssh = paramiko.SSHClient()    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())    try:        ssh.connect(ip,port=16333,usern

Python中threading.local方法

#coding=utf-8 import threading # 创建全局ThreadLocal对象: localVal = threading.local() localVal.val = "Main-Thread" def process_student(): print '%s (in %s)' % (localVal.val, threading.current_thread().name) def process_thread(name): #赋值 localVal.val