python多线程(一)

原文:http://www.pythonclub.org/python-basic/threading

一、python多线程thread和threading实现

python是支持多线程的,并且是native的线程。主要是通过thread和threading这两个模块来实现的。

python的thread模块是比较底层的模块,python的threading模块是对thread做了一些包装的,可以更加方便的被使用。

这里需要提一下的是python对线程的支持还不够完善,不能利用多CPU,但是下个版本的python中已经考虑改进这点,让我们拭目以待吧。

threading模块里面主要是对一些线程的操作对象化了,创建了叫Thread的class。

一般来说,使用线程有两种模式,一种是创建线程要执行的函数,把这个函数传递进Thread对象里,让它来执行;另一种是直接从Thread继承,创建一个新的class,把线程执行的代码放到这个新的 class里。

我们来看看这两种做法吧。

http://blog.csdn.net/guopengzhang/article/details/5458091

一)线程基础

1、创建线程:

thread模块提供了start_new_thread函数,用以创建线程。start_new_thread函数成功创建后还可以对其进行操作。

其函数原型:

start_new_thread(function,atgs[,kwargs])

其参数含义如下:

function: 在线程中执行的函数名

args:元组形式的参数列表。

kwargs: 可选参数,以字典的形式指定参数

方法一:通过使用thread模块中的函数创建新线程。

>>> import thread
>>> def run(n):
    for i in range(n):
        print i

>>> thread.start_new_thread(run,(4,))   #注意第二个参数一定要是元组的形式
53840

1
>>>
2
3
KeyboardInterrupt
>>> thread.start_new_thread(run,(2,))
17840

1
>>>
thread.start_new_thread(run,(),{‘n‘:4})
39720

1
>>>
2
3
thread.start_new_thread(run,(),{‘n‘:3})
32480

1
>>>
2

方法二:通过继承threading.Thread创建线程

>>> import threading
>>> class mythread(threading.Thread):
    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num = num
    def run(self):               #重载run方法
        print ‘I am‘, self.num

>>> t1 = mythread(1)
>>> t2 = mythread(2)
>>> t3 = mythread(3)
>>> t1.start()           #运行线程t1
I am
>>>  1
t2.start()
I am
>>>  2
t3.start()
I am
>>>  3

方法三:使用threading.Thread直接在线程中运行函数。

import threading
>>> def run(x,y):
    for i in range(x,y):
        print i

>>> t1 = threading.Thread(target=run,args=(15,20)) #直接使用Thread附加函数args为函数参数

>>> t1.start()
15
>>>
16
17
18
19

二)Thread对象中的常用方法:

1、isAlive方法:

>>> import threading
>>> import time
>>> class mythread(threading.Thread):
    def __init__(self,id):
        threading.Thread.__init__(self)
        self.id = id
    def run(self):
        time.sleep(5)    #休眠5秒
        print self.id

>>> t = mythread(1)
>>> def func():
    t.start()
    print t.isAlive()    #打印线程状态

>>> func()
True
>>> 1

2、join方法:

原型:join([timeout])

timeout: 可选参数,线程运行的最长时间

import threading
>>> import time     #导入time模块
>>> class Mythread(threading.Thread):
    def __init__(self,id):
        threading.Thread.__init__(self)
        self.id = id
    def run(self):
        x = 0
        time.sleep(20)
        print self.id

>>> def func():
    t.start()
    for i in range(5):
        print i

>>> t = Mythread(2)
>>> func()
0
1
2
3
4
>>> 2
def func():
    t.start()
    t.join()
    for i in range(5):
        print i

>>> t = Mythread(3)
>>> func()
3
0
1
2
3
4
>>> 

3、线程名:

>>> import threading
>>> class mythread(threading.Thread):
    def __init__(self,threadname):
        threading.Thread.__init__(self,name=threadname)
    def run(self):
        print self.getName()

>>>
>>> t1 = mythread(‘t1‘)
>>> t1.start()
t1
>>> 

4、setDaemon方法

在脚本运行的过程中有一个主线程,如果主线程又创建了一个子线程,那么当主线程退出时,会检验子线程是否完成。如果子线程未完成,则主线程会在等待子线程完成后退出。

当需要主线程退出时,不管子线程是否完成都随主线程退出,则可以使用Thread对象的setDaemon方法来设置。

三)线程同步

1.简单的线程同步

使用Thread对象的Lock和RLock可以实现简单的线程同步。对于如果需要每次只有一个线程操作的数据,可以将操作过程放在acquire方法和release方法之间。如:

# -*- coding:utf-8 -*-
import threading
import time
class mythread(threading.Thread):
    def __init__(self,threadname):
        threading.Thread.__init__(self,name = threadname)
    def run(self):
        global x                #设置全局变量
#        lock.acquire()          #调用lock的acquire方法
        for i in range(3):
            x = x + 1
        time.sleep(2)
        print x
#        lock.release()          #调用lock的release方法
#lock = threading.RLock()        #生成Rlock对象
t1 = []
for i in range(10):
    t = mythread(str(i))
    t1.append(t)
x = 0                   #将全局变量的值设为0
for i in t1:
    i.start()

E:/study/python/workspace>xianchengtongbu.py
3
6
9
12
15
18
21
24
27
30

如果将lock.acquire()和lock.release(),lock = threading.Lock()删除后保存运行脚本,结果将是输出10个30。30是x的最终值,由于x是全局变量,每个线程对其操作后进入休眠状态,在线程休眠的时候,python解释器就执行了其他的线程而是x的值增加。当所有线程休眠结束后,x的值已被所有线修改为了30,因此输出全部为30。

2、使用条件变量保持线程同步。

Python的Condition对象提供了对复制线程同步的支持。使用Condition对象可以在某些事件触发后才处理数据。Condition对象除了具有acquire方法和release的方法外,还有wait方法、notify方法、notifyAll方法等用于条件处理。

# -*- coding:utf-8 -*-
import threading
class Producer(threading.Thread):
    def __init__(self,threadname):
        threading.Thread.__init__(self,name = threadname)
    def run(self):
        global x
        con.acquire()
        if x == 1000000:
            con.wait()
        #    pass
        else:
            for i in range(1000000):
                x = x + 1
            con.notify()
        print x
        con.release()
class Consumer(threading.Thread):
    def __init__(self,threadname):
        threading.Thread.__init__(self,name = threadname)
    def run(self):
        global x
        con.acquire()
        if x == 0:
            con.wait()
            #pass
        else:
            for i in range(1000000):
                x = x - 1
            con.notify()
        print x
        con.release()
con = threading.Condition()
x = 0
p = Producer(‘Producer‘)
c = Consumer(‘Consumer‘)
p.start()
c.start()
p.join()
c.join()
print x

E:/study/python/workspace>xianchengtongbu2.py
1000000
0
0

线程间通信:

Event对象用于线程间的相互通信。他提供了设置信号、清除信宏、等待等用于实现线程间的通信。

1、设置信号。Event对象使用了set()方法后,isSet()方法返回真。

2、清除信号。使用Event对象的clear()方法后,isSet()方法返回为假。

3、等待。当Event对象的内部信号标志为假时,则wait()方法一直等到其为真时才返回。还可以向wait传递参数,设定最长的等待时间。

# -*- coding:utf-8 -*-
import threading
class mythread(threading.Thread):
    def __init__(self,threadname):
        threading.Thread.__init__(self,name = threadname)
    def run(self):
        global event
        if event.isSet():
            event.clear()
            event.wait()   #当event被标记时才返回
            print self.getName()
        else:
            print self.getName()
            event.set()
event = threading.Event()
event.set()
t1 = []
for i in range(10):
    t = mythread(str(i))
    t1.append(t)
for i in t1:
    i.start()

python多线程(一)

时间: 2024-09-29 05:34:07

python多线程(一)的相关文章

python多线程

http://blog.csdn.net/pipisorry/article/details/45306973 CPU-bound(计算密集型) 和I/O bound(I/O密集型) I/O bound 指的是系统的CPU效能相对硬盘/内存的效能要好很多,此时,系统运作,大部分的状况是 CPU 在等 I/O (硬盘/内存) 的读/写,此时 CPU Loading 不高.CPU bound 指的是系统的 硬盘/内存 效能 相对 CPU 的效能 要好很多,此时,系统运作,大部分的状况是 CPU Lo

Python多线程实现方法有几种

目前python多线程实现方式有很多种比如:thread,threading,multithreading ,其中thread模块比较底层,而threading模块是对thread做了一些包装,可以更加方便的被使用. 2.7 版本之前python对线程的支持还不够完善,不能利用多核CPU,但是2.7版本的python中已经考虑改进这点,出现了 multithreading模块.threading模块里面主要是对一些线程的操作对象化,创建Thread的class.一般来说,使用线程有两种 模式:

python多线程、多进程以及GIL

多线程 使用threading模块创建线程 传入一个函数 这种方式是最基本的,即调用threading中的Thread类的构造函数,然后指定参数target=func,再使用返回的Thread的实例调用start()方法,即开始运行该线程,该线程将执行函数func,当然,如果func需要参数,可以在Thread的构造函数中传入参数args=(-).示例代码如下 import threading #用于线程执行的函数 def counter(n): cnt = 0; for i in xrange

Python多线程锁

[Python之旅]第六篇(四):Python多线程锁 python lock 多线程 多线程使用方法 多线程锁 摘要:   在多线程程序执行过程中,为什么需要给一些线程加锁以及如何加锁,下面就来说一说. 1.给线程加锁的原因     我们知道,不同进程之间的内存空间数据是不能够共享的,试想一下,如果可以随意共享,谈何安全?但是一个进程中的多个线程是可以共享这个进程的内存空间中的数据的,比如多个线程可以同时调用某一... 在多线程程序执行过程中,为什么需要给一些线程加锁以及如何加锁,下面就来说一

python多线程学习记录

1.多线程的创建 import threading t = t.theading.Thread(target, args--) t.SetDeamon(True)//设置为守护进程 t.start(),启动线程 t.join(),阻塞当前线程,即使得在当前线程结束时,不会退出.会等到子线程结束之后才退出. 如果不加join语句,主线程不会等到子线程结束才结束,但却不会立即杀死该线程. 但是如果添加了SetDaemon(True),如果不加join,则会在主线程结束后马上杀死子线程. 如果join

python多线程实现抓取网页

Python实现抓取网页 下面的Python抓取网页的程序比较初级,只能抓取第一页的url所属的页面,只要预定URL足够多,保证你抓取的网页是无限级别的哈,下面是代码: ##coding:utf-8 ''' 无限抓取网页 @author wangbingyu @date 2014-06-26 ''' import sys,urllib,re,thread,time,threading ''' 创建下载线程类 ''' class download(threading.Thread): def __

Python多线程(threading)学习总结

注:此文除了例子和使用心得是自己写的,很多都是Python核心编程中的原文.原文文风应该能看出来,就不每个地方单独表明出处了. 线程(有时被称为轻量级进程)跟进程有些相似,不同的是,所有的线程运行在同一个进程中,共享相同的运行环境.它们可以想像成是在主进程或"主线程"中并行运行的"迷你进程". 线程有开始,顺序执行和结束三部分.它有一个自己的指令指针,记录自己运行到什么地方.线程的运行可能被抢占(中断),或暂时的被挂起(也叫睡眠),让其它的线程运行,这叫做让步.一个

python多线程ssh爆破如何实现与防范?

本文和大家分享的主要是python多线程的ssh**与防范相关内容,一起来看看吧,希望对大家学习python多线程有所帮助. 0x01.About 这几天发现朋友的服务器22被人爆了,于是想想,也想去爆别人服务器. 爆弱口令时候写的一个python小脚本,主要功能是实现使用字典多线程**ssh,支持ip表导入,字典数据导入. 主要使用到的是python的paramiko模块和多线程threading模块. 那么,首先要准备的是字典dict.服务器ip表. 东西很简单,主要默认目录如下: |--s

python 多线程探索

前面已经了解过了,python多线程效率较低的主要原因是存在GIL,即Global Interpreter Lock(全局解释器锁).这里继续详细的看下GIL的说明与如何避免GIL的影响,从而提高python多线程的执行效率.什么是GIL首先需要明确的一点是GIL并不是Python的特性,它是在实现Python解析器(CPython)时所引入的一个概念.就好比C++是一套语言(语法)标准,但是可以用不同的编译器来编译成可执行代码.有名的编译器例如GCC,INTEL C++,Visual C++等

python 多线程编程

一)线程基础 1.创建线程: thread模块提供了start_new_thread函数,用以创建线程.start_new_thread函数成功创建后还能够对其进行操作. 其函数原型: start_new_thread(function,atgs[,kwargs]) 其參数含义例如以下: function: 在线程中运行的函数名 args:元组形式的參数列表. kwargs: 可选參数,以字典的形式指定參数 方法一:通过使用thread模块中的函数创建新线程. >>> import th