Python多线程之线程创建和终止

python主要是通过thread和threading这两个模块来实现多线程支持。python的thread模块是比较底层的模块,python的threading模块是对thread做了一些封装,可以更加方便的被使用。但是python(cpython)由于GIL的存在无法使用threading充分利用CPU资源,如果想充分发挥多核CPU的计算能力需要使用multiprocessing模块。

如果在对线程应用有较高的要求时可以考虑使用Stackless Python来完成。Stackless Python是Python的一个修改版本,对多线程编程有更好的支持,提供了对微线程的支持。微线程是轻量级的线程,在多个线程间切换所需的时间更多,占用资源也更少。

通过threading模块创建新的线程有两种方法:一种是通过threading.Thread(Target=executable Method)-即传递给Thread对象一个可执行方法(或对象);第二种是继承threading.Thread定义子类并重写run()方法。第二种方法中,唯一必须重写的方法是run(),可根据需要决定是否重写__init__()。值得注意的是,若要重写__init__(),父类的__init__()必须要在函数第一行调用,否则会触发错误“AssertionError:
Thread.__init__() not called”

Python threading模块不同于其他语言之处在于它没有提供线程的终止方法,通过Python threading.Thread()启动的线程彼此是独立的,若在线程A中启动了线程B,那么A、B是彼此独立运行的线程。若想终止线程A的同时强力终止线程B,一个简单的方法是通过在线程A中调用B.setDaemon(True)实现。但这样带来的问题是:线程B中的资源(打开的文件、数据传输等)可能会没有正确的释放。所以setDaemon()并非一个好方法,更为妥当的方式是通过Event机制。下面这段程序体现了setDaemon()和Event机制终止子线程的区别。

import threading
import time
class mythread(threading.Thread):
    def __init__(self,stopevt = None,File=None,name = 'subthread',Type ='event'):
        threading.Thread.__init__(self)
        self.stopevt = stopevt
        self.name = name
        self.File = File
        self.Type = Type   

    def Eventrun(self):
        while not self.stopevt.isSet():
            print self.name +' alive\n'
            time.sleep(2)
        if self.File:
            print 'close opened file in '+self.name+'\n'
            self.File.close()
        print self.name +' stoped\n'   

    def Daemonrun(self):
        D = mythreadDaemon(self.File)
        D.setDaemon(True)
        while not self.stopevt.isSet():
            print self.name +' alive\n'
            time.sleep(2)
        print self.name +' stoped\n'
    def run(self):
        if self.Type == 'event': self.Eventrun()
        else: self.Daemonrun()
class mythreadDaemon(threading.Thread):
    def __init__(self,File=None,name = 'Daemonthread'):
        threading.Thread.__init__(self)
        self.name = name
        self.File = File
    def run(self):
        while True:
            print self.name +' alive\n'
            time.sleep(2)
        if self.File:
            print 'close opened file in '+self.name+'\n'
            self.File.close()
        print self.name +' stoped\n'   

def evtstop():
    stopevt = threading.Event()
    FileA = open('testA.txt','w')
    FileB = open('testB.txt','w')
    A = mythread(stopevt,FileA,'subthreadA')
    B = mythread(stopevt,FileB,'subthreadB')
    print repr(threading.currentThread())+'alive\n'
    print FileA.name + ' closed? '+repr(FileA.closed)+'\n'
    print FileB.name + ' closed? '+repr(FileB.closed)+'\n'
    A.start()
    B.start()
    time.sleep(1)
    print repr(threading.currentThread())+'send stop signal\n'
    stopevt.set()
    A.join()
    B.join()
    print  repr(threading.currentThread())+'stoped\n'
    print 'after A stoped, '+FileA.name + ' closed? '+repr(FileA.closed)+'\n'
    print 'after A stoped, '+FileB.name + ' closed? '+repr(FileB.closed)+'\n'
def daemonstop():
    stopevt = threading.Event()
    FileA = open('testA.txt','r')
    A = mythread(stopevt,FileA,'subthreadA',Type = 'Daemon')
    print repr(threading.currentThread())+'alive\n'
    print FileA.name + ' closed? '+repr(FileA.closed)+'\n'
    A.start()
    time.sleep(1)
    stopevt.set()
    A.join()
    print  repr(threading.currentThread())+'stoped\n'
    print 'after A stoped, '+FileA.name + ' closed? '+repr(FileA.closed)+'\n'
    if not FileA.closed:
        print 'You see the differents, the resource in subthread may not released with setDaemon()'
        FileA.close()
if __name__ =='__main__':
    print '-------stop subthread example with Event:----------\n'
    evtstop()
    print '-------Daemon stop subthread example :----------\n'
    daemonstop()  

运行结果是:

-------stop subthread example with Event:----------
<_MainThread(MainThread, started 2436)>alive
testA.txt closed? False
testB.txt closed? False
subthreadA alive
subthreadB alive   

<_MainThread(MainThread, started 2436)>send stop signal
close opened file in subthreadA
close opened file in subthreadB   

subthreadA stoped
subthreadB stoped   

<_MainThread(MainThread, started 2436)>stoped
after A stoped, testA.txt closed? True
after A stoped, testB.txt closed? True
-------Daemon stop subthread example :----------
<_MainThread(MainThread, started 2436)>alive
testA.txt closed? False
subthreadA alive
subthreadA stoped
<_MainThread(MainThread, started 2436)>stoped
after A stoped, testA.txt closed? False
You see the differents, the resource in subthread may not released with setDaemon()  
时间: 2024-10-11 16:08:07

Python多线程之线程创建和终止的相关文章

Java基础加强之多线程篇(线程创建与终止、互斥、通信、本地变量)

线程创建与终止 线程创建 Thread类与Runnable接口的关系 public interface Runnable { public abstract void run(); } public class Thread implements Runnable { /* What will be run. */ private Runnable target; ...... /** * Causes this thread to begin execution; the Java Virtu

Python 多线程 使用线程 (二)

Python中实现多线程需要使用到 threading 库,其中每一个 Thread类 的实例控制一个线程. Thread类 #类签名 def __init__(self, group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None): 简单介绍一些初始化参数: target: 指定线程由 run () 方法调用的可调用对象.默认为 None, 意味着不调用任何内容. name: 指定该线程的名称. 在默认情况

线程---创建,终止

Q: what is thread  ? A:一个正在运行的函数----是运行函数咯----多线程共享内存空间咯 posix线程是一套标准,而不是实现 线程标识: pthread_t 类型不确定:结构体?or指针?or整型数,想啥是啥,可以自己定义咯 [email protected]:~$ ps axm [email protected]:~$ ps ax -L // LWP 进程就是容器  内部装载线程 函数: int pthread_equal(pthread_t t1, pthread_

Java多线程系列-线程创建

1.怎样创建多线程? Java从语言级别实现多线程,因此实现一个多线程程序很easy.有两种方法能够实现多线程,即继承Thread类和实现Runnable接口.由于Java不支持多继承的原因,建议尽可能通过实现Runnable接口实现多线程. 使用Runnable接口实现多线程有例如以下长处: 1.能够避免由于Java的单继承特性而带来的局限. 2.增强程序的健壮性.代码能够被多个线程共享.代码与数据是独立的: 3.适合多个同样程序代码的线程区处理同一资源的情况. 两者之间的不同: *Threa

Java多线程之线程创建

一.程序.进程与线程的理解: 1.程序(program): 是为完成特定任务.用某种语言编写的一组指令的集合.即指一段静态的代码,静态对象. 2.进程(process): 是程序的一次执行过程, 或是正在运行的一个程序.是一个动态的过程:有它自身的产生.存在和消亡的过程,即生命周期.(1)例如:运行中的QQ,运行中的MP3播放器.(2)程序是静态的,进程是动态的.(3)进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域. 3.线程(thread): 进程可进一步细化为线程,是一个

python 多线程和线程池

1 代码Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1 #coding:utf-8 2 3 #Python的线程池实现 4 5 import Queue 6 import threading 7 import sys 8 import time 9 import urllib 10 11 #替我们工作的线程池中的线程 12 class MyTh

python 多线程中子线程和主线程相互通信

主线程开启多个线程去干活,每个线程需要完成的时间不同,干完活以后都要通知给主线程,下面代码说明该应用: 代码块: import threading import queue import time import random ''' 需求:主线程开启了多个线程去干活,每个线程需要完成的时间 不同,但是在干完活以后都要通知给主线程 多线程和queue配合使用,实现子线程和主线程相互通信的例子 ''' q = queue.Queue() threads=[] class MyThread(threa

python note 29 线程创建

1.线程 import time import threading def task(a1,a2,a3): time.sleep(2) print('拿快递') def play(): print('和女朋友去耍') def wm(): print('去拿外卖') # 创建一个线程 # 让该线程去执行任务:函数 t1 = threading.Thread(target=task,args=(1,2,3,)) # 去执行吧 t1.start() # 创建一个线程 # 让该线程去执行任务:函数 t2

python多线程之线程锁二(同一时间一个线程获得2把线程锁)

#coding:utf-8 '''线程锁''' import threading import time num = 0 #全局变量 num2 = 0 def runs():     time.sleep(1)     global num #在函数内部要对全局变量进行更改,需要进行声明     global num2     lock.acquire() #在操作时锁住,防止其他线程在同一时间对num变量进行加1,从而确保数据在同一时间确保只有一个线程对它进行更改,不然造成数据不正确