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对象的其他属性或方法

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