8 并发编程-(线程)-多线程与多进程的区别&Thread对象的其他属性或方法

1、开启速度  在主进程下开启线程比 开启子进程快

# 1 在 主进程下开启线程
from threading import Thread
def work():
print('hello')
if __name__ == '__main__':
t = Thread(target=work)
t.start()
print('主线程/主进程')
#-------------------------------
执行结果如下，几乎是t.start ()的同时就将线程开启了，然后先打印出了hello，证明线程的创建开销极小
hello
主线程/主进程

# 2 在主进程下 开启子进程
from multiprocessing import Process
def work():
print('hello')
if __name__ == '__main__':
p = Process(target=work)
p.start()
print('主线程/主进程')

主线程/主进程
hello
执行结果如下，p.start ()将开启进程的信号发给操作系统后，操作系统要申请内存空间，让好拷贝父进程地址空间到子进程，开销远大于线程

2、pid 对比：在主进程下开启多个线程（进程和线程pid相同）；在主进程下开启子进程（pid不相同）

在主进程下开启多个线程,每个线程都跟主进程的pid一样
from threading import Thread
import os
def work():
print('hello',os.getpid())
if __name__ == '__main__':
t1 = Thread(target=work)
t2 = Thread(target=work)
t1.start()
t2.start()
print('主线程/主进程',os.getpid())

hello 8500
hello 8500
主线程/主进程 8500

# 4 开多个进程,每个进程都有不同的pid
from multiprocessing import Process
import os
def work():
print('hello',os.getpid())
if __name__ == '__main__':
t1 = Process(target=work)
t2 = Process(target=work)
t1.start()
t2.start()
print('主线程/主进程',os.getpid())

主线程/主进程 9144
hello 3412
hello 4800

3、同一进程内的线程共享该进程的数据（进程之间的地址是隔离的；同一进程内的线程共享该进程的地址空间）

# 1、进程之间地址空间是隔离的

from multiprocessing import Process
import os
def work():
global  n
n=0

if __name__ == '__main__':
n=100
p = Process(target=work)
p.start()
p.join()
print('主',n)

主 100

from threading import Thread
def work():
global  n
n=0

if __name__ == '__main__':
n=100
t = Thread(target=work)
t.start()
t.join()
print('主',n)

主 0

 4、Thread对象的其他属性或方法

[code]Thread实例对象的方法
# isAlive(): 返回线程是否活动的。
# getName(): 返回线程名。
# setName(): 设置线程名。

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

from threading import Thread
import threading
from multiprocessing import Process
import os

def work():
import time
time.sleep(3)
print(threading.current_thread().getName())

if __name__ == '__main__':
#在主进程下开启线程
t=Thread(target=work)
t.start()

print(threading.current_thread().getName())
print(threading.current_thread()) #主线程
print(threading.enumerate()) #连同主线程在内有两个运行的线程
print(threading.active_count())
print('主线程/主进程')

MainThread
<_MainThread(MainThread, started 140735268892672)>
[<_MainThread(MainThread, started 140735268892672)>, <Thread(Thread-1, started 123145307557888)>]
主线程/主进程
Thread-1

主线程等待子线程结束

from  threading import Thread
import threading
import time

def task():
print(f"{threading.currentThread().getName()} is running")
time.sleep(2)
print(f"{threading.currentThread().getName()} is done")
if __name__ == '__main__':
t = Thread(target=task)
t.start()
print(f"主 {threading.currentThread().getName()}")# getName():返回线程名
print(f"主 {threading.currentThread()}")#返回当前的线程变量
print(threading.enumerate()) #连同主线程在内有两个运行的线程
print(threading.active_count()) # 活跃的线程数
print('主线程/主进程')
print(t.isAlive())  #  isAlive 和 is_alive 表现效果相同
print(t.is_alive())

Thread-1 is running
主 MainThread
主 <_MainThread(MainThread, started 6476)>
[<_MainThread(MainThread, started 6476)>, <Thread(Thread-1, started 7588)>]
2
主线程/主进程
True
True
Thread-1 is done