YANG JIYI
0%

线程

Posted on

看了一遍排在前面的答案，类似”进程是资源分配的最小单位，线程是CPU调度的最小单位“这样的回答感觉太抽象，都不太容易让人理解。

做个简单的比喻：进程=火车，线程=车厢

线程在进程下行进（单纯的车厢无法运行）
一个进程可以包含多个线程（一辆火车可以有多个车厢）
不同进程间数据很难共享（一辆火车上的乘客很难换到另外一辆火车，比如站点换乘）
同一进程下不同线程间数据很易共享（A车厢换到B车厢很容易）
进程要比线程消耗更多的计算机资源（采用多列火车相比多个车厢更耗资源）
进程间不会相互影响，一个线程挂掉将导致整个进程挂掉（一列火车不会影响到另外一列火车，但是如果一列火车上中间的一节车厢着火了，将影响到所有车厢）
进程可以拓展到多机，进程最多适合多核（不同火车可以开在多个轨道上，同一火车的车厢不能在行进的不同的轨道上）
进程使用的内存地址可以上锁，即一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。（比如火车上的洗手间）－”互斥锁”
进程使用的内存地址可以限定使用量（比如火车上的餐厅，最多只允许多少人进入，如果满了需要在门口等，等有人出来了才能进去）－“信号量”

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
import threading
import time
import random
 
 
def takeSleep(id, name):
    print(name+'-'+id+':线程开始运行...')
    time.sleep(random.randint(0, 3))
    print(name+'-'+id+':线程任务结束')
 
 
print('主程序开始运行...')
threads = []
for i in range(0, 5):
    t = threading.Thread(target=takeSleep, args=(str(i), 'zhangphil'))
    threads.append(t)
    t.start()
 
print('主程序运行中...')
 
#等待所有线程任务结束。
for t in threads:
    t.join()
 
print("所有线程任务完成")

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

主程序开始运行...
zhangphil-0:线程开始运行...
zhangphil-1:线程开始运行...
zhangphil-0:线程任务结束zhangphil-2:线程开始运行...
zhangphil-3:线程开始运行...
 
zhangphil-1:线程任务结束
zhangphil-4:线程开始运行...主程序运行中...
 
zhangphil-4:线程任务结束
zhangphil-2:线程任务结束
zhangphil-3:线程任务结束
所有线程任务完成
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from multiprocessing import  Process

def fun1(name):
    print('测试%s多进程' %name)

if __name__ == '__main__':
    process_list = []
    for i in range(5):  #开启5个子进程执行fun1函数
        p = Process(target=fun1,args=('Python',)) #实例化进程对象
        p.start()
        process_list.append(p)

    for i in process_list:
        p.join()

    print('结束测试')
1
2
3
4
5
6
测试Python多进程
测试Python多进程
测试Python多进程
测试Python多进程
测试Python多进程
结束测试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import threading
import time


def child_thread1():
    for i in range(100):
        time.sleep(1)
        print('child_thread1_running...')


def parent_thread():
    print('parent_thread_running...')
    thread1 = threading.Thread(target=child_thread1)
    thread1.start()
    print('parent_thread_exit...')


if __name__ == "__main__":
    parent_thread()
1
2
3
4
5
6
7
parent_thread_running...
parent_thread_exit...
child_thread1_running...
child_thread1_running...
child_thread1_running...
child_thread1_running...
...

获取返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import concurrent.futures
_pool = concurrent.futures.ThreadPoolExecutor()

def func1():
    for i in range(0, 100000000):
        pass
    return 'abc'
    
def func2():
    for i in range(0, 100000000):
        pass
    return 'xyz'
    
if __name__=='__main__':
    p1 = _pool.submit(func1)
    p2 = _pool.submit(func2)

    print(p1.result(), p2.result())