进程与线程（3）- python实现多线程

参考链接：

https://www.jianshu.com/p/415976668b97?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation

https://morvanzhou.github.io/tutorials/python-basic/threading/ 

python多线程的实现

Python的标准库：threading模块块。

threading 模块提供的常用方法：

• 导入模块：

import threading

• 获取已激活的线程数

threading.active_count()
# 2

• 查看正在运行的所有线程信息

threading.enumerate()
# [<_MainThread(MainThread, started 140736011932608)>, <Thread(SockThread, started daemon 123145376751616)>]
输出的结果是一个<_MainThread(...)>带多个<Thread(...)>。

• 查看现在正在运行的线程

threading.current_thread()
# <_MainThread(MainThread, started 140736011932608)>

 

1、Thread类

• 构造方法：

添加线程 ：Thread(group=None, target=None, name=None, args=(), kwargs={})

group: 线程组，目前还没有实现，库引用中提示必须是None；

target: 要执行的方法，代表这个线程要完成的任务，需自定义；

name: 线程名；

args/kwargs: 要传入方法的参数。

• 实例方法：

　　isAlive()：返回线程是否在运行。正在运行指启动后、终止前。
　　get/setName(name)：获取/设置线程名。
　　is/setDaemon(bool)：获取/设置是后台线程（默认前台线程（False））。（在start之前设置）。

• 如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，主线程和后台线程均停止；
• 如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止

　　start(): 启动线程。
　　join([timeout]): 阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout（可选参数）。

• 例子：

import threading

def thread_job():
    print('This is a thread of %s' % threading.current_thread())

def main():
    thread = threading.Thread(target=thread_job,) # 定义线程 
    thread.start() # 让线程开始工作

if __name__ == '__main__':
　　main()

2、join()

线程中调用该函数，实现该线程执行完后，才继续执行主线程或其他线程上的内容。Join可以控制多个线程的执行顺序。

import threading
import time

def thread_job():
    print("T1 start
")
    for i in range(10):
        time.sleep(0.1) # 任务间隔0.1s
    print("T1 finish
")

added_thread = threading.Thread(target=thread_job, name='T1')
added_thread.start()
added_thread.join()
print("all done
")

3、Queue

#代码实现功能，将数据列表中的数据传入，使用四个线程处理，将结果保存在Queue中，线程执行完后，从Queue中获取存储的结果
import threading
import time
from queue import Queue

def job(l,q):
    for i in range (len(l)):
        l[i] = l[i]**2
    q.put(l)        #多线程调用的函数不能用return返回值

def multithreading():
    q =Queue()        #q中存放返回值，代替return的返回值
    threads = []
    data = [[1,2,3],[3,4,5],[4,4,4],[5,5,5]]
    for i in range(4):     #定义四个线程
        t = threading.Thread(target=job,args=(data[i],q)) #Thread首字母要大写，被调用的job函数没有括号，只是一个索引，参数在后面
        t.start()#开始线程
        threads.append(t) #把每个线程append到线程列表中
    for thread in threads:
        thread.join()    #分别join四个线程到主线程
    results = []
    for _ in range(4):
        results.append(q.get())    #q.get()按顺序从q中拿出一个值
    print(results)

if __name___=='__main__':
    multithreading() 

4、线程锁Lock

lock在不同线程使用同一共享内存时，能够确保线程之间互不影响，使用lock的方法是， 在每个线程执行运算修改共享内存之前，执行lock.acquire()将共享内存上锁， 确保当前线程执行时，内存不会被其他线程访问，执行运算完毕后，使用lock.release()将锁打开， 保证其他的线程可以使用该共享内存。

import threading

def job1():
    global A,lock
    lock.acquire()
    for i in range(10):
        A+=1
    print('job1',A)
    lock.release()

def job2():
    global A,lock
    lock.acquire()
    for i in range(10):
        A+=10
    print('job2',A)
    lock.release()

if __name__== '__main__':
    lock=threading.Lock()
    A=0
    t1=threading.Thread(target=job1)
    t2=threading.Thread(target=job2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()