多线程

发表于 | 分类于

添加线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import threading

def main1():
    print(threading.active_count())   # 获取已激活的线程数
    print(threading.enumerate()) # 查看所有线程信息
    print(threading.current_thread())  # 查看现在正在运行的线程

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__':
    main1()
    main()

join功能

使用join()主线程一直等待全部的子线程结束之后，主线程自身才结束( print('all done\n'))，程序退出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import threading
import time
def T1_job():
    print('T1 start\n')
    for i in range(10):
        time.sleep(0.1)
    print('T1 finish\n')

def T2_job():
    print('T2 start\n')
    print('T2 finish\n')

def main():
    T1_thread = threading.Thread(target=T1_job, name='T1')
    T2_thread = threading.Thread(target=T2_job, name='T2')
    T1_thread.start()
    T2_thread.start()
    T1_thread.join()
    T2_thread.join()

    print('all done\n')
    
if __name__ == '__main__':
    main()

线程锁

不使用线程锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import threading

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

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

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()

打印结果,很杂乱

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
job1 job21
11job1
 job212
22job1
job2  3323

job2job1  4344

job2job1  5554

job2job1  6566

job2job1  7677

job2job1  8788

job2job1  9899

job2job1  110109

使用线程锁

lock在不同线程使用同一共享内存时，能够确保线程之间互不影响

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import threading

def job1():
    global A,lock
    lock.acquire()  # 在每个线程执行运算修改共享内存之前，执行lock.acquire()将共享内存上锁， 确保当前线程执行时，内存不会被其他线程访问
    for i in range(10):
        A+=1
        print('job1',A)
    lock.release() # 执行运算完毕后，使用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()

打印结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
job1 1
job1 2
job1 3
job1 4
job1 5
job1 6
job1 7
job1 8
job1 9
job1 10
job2 20
job2 30
job2 40
job2 50
job2 60
job2 70
job2 80
job2 90
job2 100
job2 110

储存进程结果 Queue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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的返回值
    data = [[1,2,3],[3,4,5],[4,4,4],[5,5,5]]
    threads = []
    
    for i in range(4):
        t = threading.Thread(target=job,args=(data[i],q)) # 被调用的job函数没有括号，只是一个索引，参数在后面
        t.start()  # 开始线程
        threads.append(t)  # 把每个线程append到线程列表中
        
    for thread in threads:
        thread.join()  # 分别join四个线程到主线程
        
    results = []  # 定义一个空的列表results，将四个线运行后保存在队列中的结果返回给空列表results
    for _ in range(4):
        results.append(q.get())
    print(results)

if __name___=='__main__':
    multithreading()