Python3 多线程__thread.start_new_thread

线程分为两种：

1、内核线程：由操作系统内核创建和撤销

2、用户线程：不需要内核支持，在用户程序中实现

python3中线程的两个模块：

1、_thread

2、threading

一、创建线程

python中使用函数或类包装线程对象

1、函数式

使用_thread中的start_new_thread函数创建

语法：_thread.start_new_thread(function, args[, kwags])

参数说明：

function --线程函数

args --传递给线程函数的参数，必须为tuple元组类型

kwags --可选参数

import _thread
import time
 
#定义线程函数
def print_thread(threadName, delay):
    count = 0
    while count<5:
        time.sleep(delay)
        count += 1
        print("%s: %s" % (threadName, time.ctime(time.time()))) #打印当前时间
 
try:
    _thread.start_new_thread(print_thread, ("Thread-1", 2))
    _thread.start_new_thread(print_thread, ("Thread-2", 4))
except Exception:
    print("ERROR：无法创建线程")
 
while 1:
    pass

输出：

Thread-1: Wed Mar  9 19:41:10 2022
Thread-2: Wed Mar  9 19:41:12 2022
Thread-1: Wed Mar  9 19:41:12 2022
Thread-1: Wed Mar  9 19:41:14 2022
Thread-2: Wed Mar  9 19:41:16 2022
Thread-1: Wed Mar  9 19:41:16 2022
Thread-1: Wed Mar  9 19:41:18 2022
Thread-2: Wed Mar  9 19:41:20 2022

每隔2s、4s都会打印Thread-1、Thread-2，直到手动退出

2、线程模块

_thread中提供了低级别的、原始的线程以及一个简单的锁，相比于threading，功能比较有限。

threading除了提供_thread中所有的方法外，还提供了其他方法：

threading.currentThread()：返回当前线程变量。

threading.enumerate()：返回一个包含所有正在运行的线程list。正在运行是指：在启动后、结束前的线程，不包含还没有开始和已经结束的。

threading.activeCount()：返回当前正运行的线程数量，与len(threading.enumerate())效果一致。

除了使用方法外，线程模块还提供了Thread类来处理线程，包括以下方法：

（1）run()：用以表示线程活动的方法。

（2）start()：启动线程。

（3）join([time])：等待至线程终止。这阻塞线程至join方法被调用中止-正常退出或者抛出未处理的异常-或者可选的超时发生。time可选参数。

（4）isAlive()：返回线程是否还在活动。

（5）getName()：获取线程名称。

（6）setName()：设置线程名称。

使用threading创建线程：

创建一个类直接继承threading.Thread类，并实例化后调用start方法启动线程，run方法运行线程：

import threading
import time
 
exitFlag = 0
 
def print_time(name, delay, counter):
    while counter:
        if exitFlag:
            name.exit()
        time.sleep(delay)
        print("%s: %s"%(name, time.ctime(time.time())))
        counter -= 1
 
 
class myThread(threading.Thread):
    def __init__(self, threadId, name, delay):
        threading.Thread.__init__(self)
        self.threadId = threadId
        self.name = name
        self.delay = delay
 
    def run(self):
        print("开始线程：", self.name)
        print_time(self.name, self.delay, 5)
        print("退出线程：", self.name)
 
 
#创建线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
 
#开启线程
thread1.start()
thread2.start()
 
#运行线程
# thread1.run()
# thread2.run()
 
thread1.join()
thread2.join()
print("退出主线程")

输出：

开始线程： Thread-1
开始线程： Thread-2
Thread-1: Wed Mar  9 20:09:03 2022
Thread-2: Wed Mar  9 20:09:04 2022
Thread-1: Wed Mar  9 20:09:04 2022
Thread-1: Wed Mar  9 20:09:05 2022
Thread-2: Wed Mar  9 20:09:06 2022
Thread-1: Wed Mar  9 20:09:06 2022
Thread-1: Wed Mar  9 20:09:07 2022
退出线程： Thread-1
Thread-2: Wed Mar  9 20:09:08 2022
Thread-2: Wed Mar  9 20:09:10 2022
Thread-2: Wed Mar  9 20:09:12 2022
退出线程： Thread-2
退出主线程 

threading.Thread有三种参数传递方式：

1、使用元组传递， threading.Thread(target=方法名，args=（参数1,参数2, ...）)

mport time
import threading
 
def song(a,b,c):
    print(a, b, c)
    for i in range(5):
        print("song")
        time.sleep(1)
if __name__ == "__main__":
    threading.Thread(target=song,args=(1,2,3)).start()

2、使用字典传递，threading.Thread(target=方法名, kwargs={"参数名": 参数1, "参数名": 参数2, ...})

threading.Thread(target=song,kwargs={"a":1,"c":3,"b":2}).start() #参数顺序可以变

 3、混合使用元组和字典传递， threading.Thread(target=方法名，args=（参数1, 参数2, ...）, kwargs={"参数名": 参数1,"参数名": 参数2, ...})

threading.Thread(target=song,args=(1,),kwargs={"c":3,"b":2}).start()

二、线程同步

如果多个线程共同对某数据进行修改时，则会出现数据不一致的情况，需要线程直接进行同步。

多线程的优势在于可以同时执行多个任务，但当需要共享数据时，就可能会出现数据不一致的情况。比如：一个列表中所有元素一开始都是0，有一个线程“set”会将列表中的数据修改为1，同时有另一个线程“print”从前往后将列表中的数据打印出来， 此时当线程“set”刚开始修改时，线程“print”就开始打印了，输出数据就变成了一半0，一半1，造成数据不一致。为了避免这种情况，引入了锁概念。

锁有两种状态：锁定和未锁定。每当线程“set”要访问共享数据时，必须要获取锁定。如果此时已经有别的线程如线程“print”已经获得锁定，那么线程“set”则需要等待，即同步阻塞，线程“print”使用完后释放锁定，这时候线程“set”就可以获取到锁定，继续工作。

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

实例

import threading
import time
 
exitFlag = 0
#创建锁
threadLock = threading.Lock()
threas = []
 
def print_time(name, delay, counter):
    while counter:
        if exitFlag:
            name.exit()
        time.sleep(delay)
        print("%s: %s"%(name, time.ctime(time.time())))
        counter -= 1
 
 
class myThread(threading.Thread):
    def __init__(self, threadId, name, delay):
        threading.Thread.__init__(self)
        self.threadId = threadId
        self.name = name
        self.delay = delay
 
    def run(self):
        print("开始线程，获取锁：", self.name)
        #获取锁
        threadLock.acquire()
        print_time(self.name, self.delay, 5)
        #释放锁，开启下一个线程
        threadLock.release()
        print("释放锁，开启下一线程：", self.name)
 
 
#创建线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
 
#开启线程
thread1.start()
thread2.start()
 
#运行线程
# thread1.run()
# thread2.run()
# thread1.join()
# thread2.join()
 
#将线程添加到线程列表
threas.append(thread1)
threas.append(thread2)
 
#等待线程完成
for t in threas:
    t.join()
 
print("退出主线程")

输出：

开始线程，获取锁： Thread-1
开始线程，获取锁： Thread-2
Thread-1: Wed Mar  9 20:32:27 2022
Thread-1: Wed Mar  9 20:32:28 2022
Thread-1: Wed Mar  9 20:32:29 2022
Thread-1: Wed Mar  9 20:32:30 2022
Thread-1: Wed Mar  9 20:32:31 2022
释放锁，开启下一线程： Thread-1
Thread-2: Wed Mar  9 20:32:33 2022
Thread-2: Wed Mar  9 20:32:35 2022
Thread-2: Wed Mar  9 20:32:37 2022
Thread-2: Wed Mar  9 20:32:39 2022
Thread-2: Wed Mar  9 20:32:41 2022
释放锁，开启下一线程： Thread-2
退出主线程

 三、线程队列（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等待时间.
• 从队列中删除并返回一个item。 如果可选的args块为true且timeout为None（默认值），则在必要时阻止，直到某个项可用为止。 如果timeout是一个正数，它会阻止最多超时秒，如果在该时间内没有可用的项，则会引发Empty异常。反之（block为false），如果有item可以立即使用，则返回该tem，否则引发Empty异常（在这种情况下忽略超时）。
• Queue.get_nowait()  相当于Queue.get(False)，即当队列为空，不会等待，直接抛出异常
• Queue.put(item[,block[,timeout]) 写入队列。将item放入队列。如果可选参数block为true 且 timeout为None，则在必要时阻止，直到有空闲槽可用。如果 timeout是一个正数，它会阻止最大超时时间，如果在该时间内没有可用的空闲槽，则会引发Full异常。反之（block为false），如果有空闲槽可以立即使用，则将item放入队列，否则引发Full异常（在这种情况下忽略超时）。
• Queue.put_nowait(item) 相当Queue.put(item, False)
• Queue.task_done() 在完成一项工作后，向任务已完成的队列发送一个信号
• Queue.join() 等到队列为空时，再执行别的操作

实例

import threading
import queue
import time
 
exitFlag = 0
#创建锁
queueLock = threading.Lock()
#创建队列
workQueue = queue.Queue(10)
 
def process_data(name, q):
    while not exitFlag:
        #获取锁
        queueLock.acquire()
        if not workQueue.empty():
            data = q.get()
            #释放锁
            queueLock.release()
            print("%s processing %s" % (name, data))
        else:
            #队列空时释放锁
            queueLock.release()
 
        time.sleep(1)
 
 
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)
 
 
threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["one", "two", "three", "four", "five"]
threads = []
threadId = 1
#创建线程
for tname in threadList:
    thread = myThread(threadId, tname, workQueue) #实例化对象
    thread.start() #开启线程
    threads.append(thread) #将线程添加到线程列表
    threadId += 1
 
 
#填充队列
queueLock.acquire()
for work in nameList:
    workQueue.put(work)
queueLock.release()
 
#等待队列清空
while not workQueue.empty():
    pass
 
#通知线程退出
exitFlag = 1
 
#等待线程完成
for t in threads:
    t.join()
 
print("退出主线程")

 输出：

开始线程 Thread-1
开始线程 Thread-2
开始线程 Thread-3
Thread-3 processing one
Thread-2 processing twoThread-1 processing three

Thread-2 processing four
Thread-1 processing five
退出线程： Thread-2
退出线程： 退出线程： Thread-3Thread-1

退出主线程