Python3多进程与多线程区别及使用（2.线程）

分手后的思念是犯贱 2022-01-06 21:19 315阅读 0赞

# threading模块 #

### 简述： ###

threading模块

*  threading.currentThread(): 返回当前的线程变量。
 *  threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
 *  threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

thread类

*  **run():** 用以表示线程活动的方法。
 *  **start():**启动线程活动。
 *   **join(\[time\]):** 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
 *   **isAlive():** 返回线程是否活动的。
 *   **getName():** 返回线程名。
 *   **setName():** 设置线程名。

## ##

### 开启线程的两种方式： ###

一：

1 from threading import Thread
     2 
     3 
     4 def sayhi(name):
     5     print('%s say hello' % name)
     6 
     7 
     8 if __name__ == '__main__':
     9     t = Thread(target=sayhi, args=('hh',))
    10     t.start()
    11     print('主线程')

二：

from threading import Thread
    import time
    class Sayhi(Thread):
        def __init__(self,name):
            super().__init__()
            self.name=name
        def run(self):
            time.sleep(2)
            print('%s say hello' % self.name)
    
    
    if __name__ == '__main__':
        t = Sayhi('hh')
        t.start()
        print('主线程')

### 线程同步： ###

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

import threading
    import time
    
    class myThread (threading.Thread):
        def __init__(self, threadID, name, counter):
            threading.Thread.__init__(self)
            self.threadID = threadID
            self.name = name
            self.counter = counter
        def run(self):
            print ("开启线程： " + self.name)
            # 获取锁，用于线程同步
            threadLock.acquire()
            print_time(self.name, self.counter, 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 = []
    
    # 创建新线程
    thread1 = myThread(1, "Thread-1", 1)
    thread2 = myThread(2, "Thread-2", 2)
    
    # 开启新线程
    thread1.start()
    thread2.start()
    
    # 添加线程到线程列表
    threads.append(thread1)
    threads.append(thread2)
    
    # 等待所有线程完成
    for t in threads:
        t.join()
    print ("退出主线程")

## 线程优先级队列（ Queue） ##

Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列 PriorityQueue。

这些队列都实现了锁原语，能够在多线程中直接使用，可以使用队列来实现线程间的同步。

Queue 模块中的常用方法:

*  Queue.qsize() 返回队列的大小
 *  Queue.empty() 如果队列为空，返回True,反之False
 *  Queue.full() 如果队列满了，返回True,反之False
 *  Queue.full 与 maxsize 大小对应
 *  Queue.get(\[block\[, timeout\]\])获取队列，timeout等待时间
 *  Queue.get\_nowait() 相当Queue.get(False)
 *  Queue.put(item) 写入队列，timeout等待时间
 *  Queue.put\_nowait(item) 相当Queue.put(item, False)
 *  Queue.task\_done() 在完成一项工作之后，Queue.task\_done()函数向任务已经完成的队列发送一个信号
 *  Queue.join() 实际上意味着等到队列为空，再执行别的操作

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 ("开启线程：" + self.name)
            process_data(self.name, self.q)
            print ("退出线程：" + self.name)
    
    def process_data(threadName, q):
        while not exitFlag:
            queueLock.acquire()
            if not workQueue.empty():
                data = q.get()
                queueLock.release()
                print ("%s processing %s" % (threadName, data))
            else:
                queueLock.release()
            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 ("退出主线程")

转载于:https://www.cnblogs.com/IMWU/p/10857278.html