python中的多线程【转】

转载自: http://c4fun.cn/blog/2014/05/06/python-threading/

python中关于多线程的操作可以使用thread和threading模块来实现,其中thread模块在Py3中已经改名为_thread,不再推荐使用。而threading模块是在thread之上进行了封装,也是推荐使用的多线程模块,本文主要基于threading模块进行介绍。在某些版本中thread模块可能不存在,要使用dump_threading来代替threading模块。

线程创建

threading模块中每个线程都是一个Thread对象,创建一个线程有两种方式,一种是将函数传递到Thread对象中执行,另一种是从Thread继承,然后重写run方法(是不是跟Java很像)。

下面使用这两种方法分别创建一个线程并同时执行

 1 import random, threading
 2 def threadFunction():
 3     for i in range(10):
 4         print ‘ThreadFuction - %d‘%i
 5         time.sleep(random.randrange(0,2))
 6
 7
 8 class ThreadClass(threading.Thread):
 9     def __init__(self):
10         threading.Thread.__init__(self);
11
12     def run(self):
13         for i in range(10):
14             print ‘ThreadClass - %d‘%i
15             time.sleep(random.randrange(0,2))
16
17 if __name__ == ‘__main__‘:
18     tFunc = threading.Thread(target = threadFunction);
19     tCls  = ThreadClass()
20     tFunc.start()
21     tCls.start()

执行结果如下,可以看到两个线程在交替打印。至于空行和一行多个输出,是因为Py的print并不是线程安全的,在当前线程的print打印了部分内容后,准备打印换行之前,被别的线程中的print抢先,在换行之前打印了其它的内容。

ThreadFuction - 0
ThreadFuction - 1
ThreadFuction - 2
ThreadClass - 0
ThreadFuction - 3
ThreadClass - 1
ThreadFuction - 4
ThreadClass - 2
ThreadClass - 3
ThreadClass - 4ThreadFuction - 5

ThreadClass - 5
ThreadClass - 6
ThreadClass - 7
ThreadClass - 8
ThreadFuction - 6ThreadClass - 9

ThreadFuction - 7
ThreadFuction - 8
ThreadFuction - 9

Thread类的构造函数定义如下

class threading.Thread(group=None, target=None, name=None, args=(), kwargs={})
group: 留作ThreadGroup扩展使用,一般没什么用
target:新线程的任务函数名
name:  线程名,一般也没什么用
args:  tuple参数
kwargs:dictionary参数

Thread类的成员变量和函数如下

start()         启动一个线程
run()           线程执行体,也是一般要重写的内容
join([timeout]) 等待线程结束
name            线程名
ident           线程ID
daemon          是否守护线程
isAlive()、is_alive()    线程是否存活
getName()、setName()     Name的get&set方法
isDaemon()、setDaemon()  daemon的get&set方法

这里的守护线程与Linux中的守护进程并不是一个概念。这里是指当所有守护线程退出后主程序才会退出,否则即使线程任务没有结束,只要不是守护线程,都会跟着主程序一起退出。而Linux中的守护进程定义正好相反,守护进程已经脱离父进程,不会随着父进程的结束而退出。

线程同步

线程同步是多线程中的一个核心问题,threading模块对线程同步有着良好的支持、包括线程特定数据、信号量、互斥锁、条件变量等。

线程特定数据

简而言之,线程特定数据就是线程独自持有的全局变量,相互之间的修改不会造成影响。

threading模块中使用local()方法生成一个线程独立对象,举例如下,其中sleep(1)是为了保证让子线程先运行完再运行接下来的语句。

 1 data = threading.local()
 2 def threadFunction():
 3     global data
 4     data.x = 3
 5     print threading.currentThread(), data.x
 6
 7 if __name__ == ‘__main__‘:
 8     data.x = 1
 9     tFunc = threading.Thread(target = threadFunction).start();
10     time.sleep(1)
11     print threading.current_thread(), data.x
<Thread(Thread-1, started 36208)> 3
<_MainThread(MainThread, started 35888)> 1

输出如上,可以看到,Thread-1中对data.x的修改并没有影响到主线程中data.x的值。

互斥锁

threading中定义了两种锁:threading.Lock和threading.RLock。两者的不同在于后者是可重入锁,也就是说在一个线程内重复LOCK同一个锁不会发生死锁,这与POSIX中的PTHREAD_MUTEX_RECURSIVE也就是可递归锁的概念是相同的。

关于互斥锁的API很简单,只有三个函数————分配锁,上锁,解锁。

threading.Lock()        分配一个互斥锁
acquire([blocking=1])   上锁(阻塞或者非阻塞,非阻塞时相当于try_lock,通过返回False表示已经被其它线程锁住。)
release()               解锁

下面通过一个例子来说明互斥锁的使用。在之前的例子中,多线程print会造成混乱的输出,这里使用一个互斥锁,来保证每行一定只有一个输出。

 1 def threadFunction(arg):
 2     while True:
 3         lock.acquire()
 4         print ‘ThreadFuction - %d‘%arg
 5         lock.release()
 6
 7 if __name__ == ‘__main__‘:
 8     lock = threading.Lock()
 9     threading.Thread(target = threadFunction, args=(1,)).start();
10     threading.Thread(target = threadFunction, args=(2,)).start();

条件变量

条件变量总是与互斥锁一起使用的,threading中的条件变量默认绑定了一个RLock,也可以在初始化条件变量的时候传进去一个自己定义的锁。

可用的函数如下

threading.Condition([lock])  分配一个条件变量
acquire(*args)               条件变量上锁
release()                    条件变量解锁
wait([timeout])              等待唤醒,timeout表示超时
notify(n=1)                  唤醒最大n个等待的线程
notifyAll()、notify_all()    唤醒所有等待的线程

下面这个例子使用条件变量来控制两个线程交替运行

 1 num = 0
 2 def threadFunction(arg):
 3     global num
 4     while num < 10:
 5         cond.acquire()
 6         while num % 2 != arg:
 7             cond.wait()
 8         print ‘Thread %d - %d‘ %(arg, num)
 9         num += 1
10         cond.notify()
11         cond.release()
12
13 if __name__ == ‘__main__‘:
14     cond = threading.Condition()
15     threading.Thread(target = threadFunction, args=(0,)).start();
16     threading.Thread(target = threadFunction, args=(1,)).start();

输出如下

Thread 0 - 0
Thread 1 - 1
Thread 0 - 2
Thread 1 - 3
Thread 0 - 4
Thread 1 - 5
Thread 0 - 6
Thread 1 - 7
Thread 0 - 8
Thread 1 - 9
Thread 0 - 10

其实上面这个程序是有问题的,我们想打印的是0~9,但实际上10也被打印了出来,原因很简单,因为两个线程交替打印,使得num在一个线程中可能加2,从而导致10被打印出来,所以必须在打印前再次check。

python中的多线程【转】

时间: 2024-10-19 02:11:27

python中的多线程【转】的相关文章

python中的多线程

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

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

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

python中threading多线程

python中有两个处理多线程的模块thread和threading.其中thread提供了多线程底层支持的模块,以低级原始的发那个是来处理和控制线程,使用起来较为复杂:而threading基于thread进行包装,将线程操作对象化. 最基础的的多线程 我们先看一个最最基础的多线程例子 import threading import time class test(threading.Thread): def __init__(self,name,delay): threading.Thread

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

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

python中的线程(zz)

引言 一.线程 1.1 普通的多线程1.2 自定义线程类1.3 线程锁1.3.1 未使用锁1.3.2 普通锁Lock和RLock1.3.3 信号量(Semaphore)1.3.4 事件(Event)1.3.5 条件(condition)1.3 全局解释器锁(GIL)1.4 定时器(Timer)1.5 队列1.5.1 Queue:先进先出队列1.5.2 LifoQueue:后进先出队列1.5.3 PriorityQueue:优先级队列1.5.4 deque:双向队列1.6 生产者消费者模型1.7

Python中的线程与进程

进程与线程 在多任务处理中,每一个任务都有自己的进程,一个任务会有很多子任务,这些在进程中开启线程来执行这些子任务.一般来说,可以将独立调度.分配的基本单元作为线程运行,而进程是资源拥有的基本单位. python支持多进程multiprocessing,以及多线程threading. 多进程 os.fork()函数可以开启一个进程.该函数会返回两次值,分别在父进程中返回子进程的ID,而在子进程中永远返回0. os.getpid()函数可以返回进程的ID.os.getppid()则可以返回父进程的

python之路-----多线程与多进度

一.进程和线程的概念 1.进程(最小的资源单位): 进程:就是一个程序在一个数据集上的一次动态执行过程.进程一般由程序.数据集.进程控制块三部分组成. 程序:我们编写的程序用来描述进程要完成哪些功能以及如何完成: 数据集;则是程序在执行过程中所需要使用的资源: 进程控制块:用来记录进程的外部特征,描述进程的执行变化过程,系统可以利用它来控制和管理进程,它是系统感知进程存在的唯一标志. 进程比线程更早出现,计算机早期处理代码时,使用的是串行的方法,假设计算机在运行A,B,C三个软件,需要A运行完了

Python系列之多线程、多进程

一.python多线程 线程是操作系统直接支持的执行单元,因此,高级语言通常都内置多线程的支持,Python也不例外,并且,Python的线程是真正的Posix Thread,而不是模拟出来的线程. Python的标准库提供了两个模块:_thread和threading,_thread是低级模块,threading是高级模块,对_thread进行了封装.绝大多数情况下,我们只需要使用threading这个高级模块. import threading import time def f1(num)

python中的轻量级定时任务调度库:schedule

提到定时任务调度的时候,相信很多人会想到芹菜celery,要么就写个脚本塞到crontab中.不过,一个小的定时脚本,要用celery的话太“重”了.所以,我找到了一个轻量级的定时任务调度的库:schedule. 库的安装还是最简单的pip install schedule,使用起来也是很容易理解的.我们从最简单的栗子看起: import schedule import time def job(): print("I'm working...") schedule.every(10)