您现在的位置是：首页 > Python

当前栏目

Python 多线程

Python 模块线程执行

2023-03-02 11:11:28 时间

Python中的多线程与Java，C++中的思想是比较接近的，作用也一样：

*  使用线程可以把占据长时间的程序中的任务放到后台去处理。
 *  用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度
 *  程序的运行速度可能加快
 *  在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。

**Python通过两个标准库thread和threading提供对线程的支持。**

### 使用thread模块创建线程 ###

函数式：调用thread模块中的start\_new\_thread()函数来产生新线程。语法如下:

thread.start_new_thread ( function, args[, kwargs] )

*  function - 线程函数。
 *  args - 传递给线程函数的参数,他必须是个tuple类型。
 *  kwargs - 可选参数。

#-*-coding: utf-8 -*-
    import thread
    import time
    #定义线程函数
    def print_time(threadName,delay):
        count = 0
        while count<5:
            time.sleep(delay)
            count += 1
            print "%s: %s" % (threadName,time.ctime(time.time()))
    #创建两个线程
    def test():
        thread.start_new_thread(print_time, ("Thread-1", 1,))
        thread.start_new_thread(print_time, ("Thread-2", 2,))
    if __name__=="__main__":
        test()
        """
        防止Unhandled exception in thread started by Error in sys.excepthook问题。
        启动线程之后，须确保主线程等待所有子线程返回结果后再退出，如果主线程比子线程早结束，无论其子线程是否是后台线程，都将会中断，抛出这个异常 。
        """
        time.sleep(30)

### 使用Threading模块创建线程 ###

使用Threading模块创建线程，直接从threading.Thread继承，然后重写**init**方法和run方法：

#-*- coding:utf-8 -*-
    import random
    
    import threading
    import time
    """
    注意文件名不要与python保留字一样，会出现AttributeError：'module' object has no attribute 'Thread'
    threading模块中包含方法和Thread类:
    """
    #使用Threading模块创建线程，直接从threading.Thread继承，然后重写__init__方法和run方法
    exitFlag = 0
    class myThread(threading.Thread):
        def __init__(self,threadID,threadName,delay):
            #调用父类的构造方法
            threading.Thread.__init__(self)
            self.threadID = threadID
            self.threadName = threadName
            self.delay = delay
        def run(self):
            print "Starting" + self.threadName
            print_time(self.threadName,self.delay,5)
            print "Exiting" + self.threadName
    def print_time(threadName,delay,counter):
        while counter:
            if exitFlag:
                threading.Thread.exit()
            time.sleep(delay)
            print "%s: %s" % (threadName,time.ctime(time.time()))
            counter -= 1
    #创建线程
    thread1 = myThread(1,"Thread-1",1)
    thread2 = myThread(2,"Thread-2",2)
    #开启线程
    thread1.start()
    thread2.start()
    
    print "Exiting Main Thread"

### 线程的同步问题 ###

多线程同步知识点：  
一：  
当一个进程启动之后，会默认产生一个主线程，因为线程是程序执行流的最小单元，当设置多线程时，  
主线程会创建多个子线程，在python中，默认情况下（其实就是setDaemon(False)），  
主线程执行完自己的任务以后，就退出了，此时子线程会继续执行自己的任务，直到自己的任务结束。  
二：  
当我们使用setDaemon(True)方法(默认为False)，设置子线程为守护线程时，主线程一旦执行结束，则全部线程  
全部被终止执行，可能出现的情况就是，子线程的任务还没有完全执行结束，就被迫停止，例如：

for t in thread_list:
            t.setDaemon(True)
            t.start()

三：  
此时join的作用就凸显出来了，join所完成的工作就是线程同步，即主线程任务结束之后，  
进入阻塞状态，一直等待其他的子线程执行结束之后，主线程在终止。

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

#-*- coding: utf-8 -*-
    import threading
    import time
    
    class myThread(threading.Thread):
        def __init__(self,threadID,threadName,delay):
            threading.Thread.__init__(self)
            self.threadID = threadID
            self.threadName = threadName
            self.delay = delay
        def run(self):
            print "Starting" + self.threadName
            #获得锁，成功获得锁后返回True
            #可选的timeout不填时将一直阻塞
            #否则超时后将返回False
            threadLock.acquire()
            print_time(self.threadName,self.delay,3)
            #释放锁
            threadLock.release()
    
    def print_time(threadName,delay,counter):
        while counter:
            time.sleep(delay)
            print "%s: %s" % (threadName, time.ctime(time.time()))
            counter -= 1
    
    
    threadLock = threading.Lock()
    threads = []
    start_time = time.time()
    print('Main Thread', threading.current_thread().name)
    #创建线程
    thread1 = myThread(1,"Thread-1",1)
    thread2 = myThread(2,"Thread-2",2)
    
    #开启新线程
    thread1.start()
    thread2.start()
    
    #添加线程到线程列表
    threads.append(thread1)
    threads.append(thread2)
    
    #等待所有线程完成
    """
    join关键点：
    1.我们的计时是对主线程计时，主线程结束，计时随之结束，打印出主线程的用时。
    2.主线程的任务完成之后，主线程随之结束，子线程继续执行自己的任务，直到全部的子线程的任务全部结束，程序结束。
    """
    for t in threads:
        t.join()
    #可以看到，主线程一直等待全部的子线程结束之后，主线程自身才结束，程序退出。
    print "Exiting Main Thread"
    print('Main Thread Over' , threading.current_thread().name)
    print('the all time', time.time()-start_time)

### 优先级队列Queue ###

#-*- coding:utf-8 -*-
    import Queue
    import threading
    import time
    
    exitFlag = 0
    class myThread(threading.Thread):
        def __init__(self,ThreadID,name,q):
            threading.Thread.__init__(self)
            self.ThreadID = ThreadID
            self.name = name
            self.q = q
        def run(self):
            print "Starting: " + self.name
            process_data(self.name,self.q)
            print "Exiting: " + self.name
    #取出队列中的元素
    def process_data(threadName,q):
        while not exitFlag:
            queueLock.acquire()
            if workQueue.empty():
                queueLock.release()
            else:
                data = workQueue.get()
                queueLock.release()
                print "%s processing %s" % (threadName,data)
            time.sleep(1)
    
    
    threadList = ["Thread-1","Thread-2","Thread-3"]
    nameList = ["One","Two","Three","Four","Five"]
    queueLock = threading.Lock()
    workQueue = Queue.Queue(10)
    threads = []
    threadID = 1
    #创建线程
    for tName in threadList:
        thread =  myThread(threadID,tName,workQueue)
        thread.start()
        threads.append(thread)
        threadID += 1
    #填充队列
    queueLock.acquire()
    for word in nameList:
        workQueue.put(word)
    queueLock.release()
    #等待清空队列
    while not workQueue.empty():
        pass
    #通知线程退出
    exitFlag = 1
    #等待所有线程退出
    for t in threads:
        t.join()
    print "Exiting Main Thread"

猜你喜欢

C/C++ 定位文件 .text 区段地址
C/C++ HOOK 全局 API
C/C++ IAT HOOK MessageBoxW
C/C++ 获取线程入口地址模块等
只有技术人才能看懂的幽默
C/C++ 查询系统日志
C/C++ 遍历窗口标题类名
C/C++ 实现COM转换到接口
C/C++ 查找指定文件HEX特征
MySQL创建数据库基础篇
C/C++ 遍历进程内存块
C/C++ 实现模拟键盘鼠标
C/C++遍历某进程的模块
C/C++ PeView 结构解析器
C/C++ 使用 cryptopp 加密解密
C/C++ 异或加密实现代码
Python 原生Socket实现端口扫描
软件测试|Jenkins 多任务管理
C/C++ 实现获取Linux系统参数
C# 通过VMI接口获取硬件ID

zl程序教程

当前栏目

Python 多线程

相关文章