Python 进程和线程详解（daemon/non-daemon/join/threading.local）

1、进程和线程概念

在实现了线程的操作系统中，线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运行单位。一个程序的执行实例就是一个进程。

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。

进程和线程的关系：程序是源代码编译后的文件，而这些文件存放在磁盘上。当程序被操作系统加载到内存中，就是进程，进程中存放着指令和数据（资源），它也是线程的容器。

Linux进程有父进程、子进程。Windows的进程是平等关系。

线程，有时被称为轻量级进程（Lightweight Process,LWP），是程序执行流的最小单元，一个标准的线程由线程ID、当前指令指针PC、寄存器集合和堆栈组成。

在许多系统中，创建一个线程比创建一个进程块10-100倍。

进程和线程的理解：

• 现代操作系统提出进程的概念，每一个进程都认为自己独占所有的计算机硬件资源
• 进程就是独立的王国，进程之间不可以随便的共享数据
• 线程就是省份，同一个进程内的线程可以共享进程的资源，每一个线程拥有自己独立的堆栈。

2、线程的状态

3、Python中的进程和线程

进程会启动一个解释器进程，线程共享一个解释器进程。

3.1 Python的线程开发

Python的线程开发使用标准库threading。
进程靠线程执行代码，至少有一个主线程，其它线程是工作线程。
主线程是第一个启动的线程。

• 父线程：如果线程A中启动了一个线程B，A就是B的父线程
• 子线程：B就是A的子线程

3.2 Thread 类

3.2.1 线程创建、启动

class threading.Thread(group=None, target=None, name=None,
					    args=(), kwargs={
   }, *, daemon=None)

通过threading.Thread创建一个线程对象，target是目标函数，可以使用name为线程指定名称。但是线程没有启动，需要调用start方法。
线程之所以执行函数，是因为线程中就是要执行代码的，而最简单的封装就是函数，所以还是函数调用。函数执行完，线程也就退出了。

import threading
import time


def worker():
    print('I am working.')
    print('Work done.')

t = threading.Thread(target=worker)

print('main_thread start')
time.sleep(1)
t.start()
time.sleep(2)
print('main_thread stop')

main_thread start
I am working.
Work done.
main_thread stop

3.2.2 线程退出、线程传参

Python没有提供线程退出的方法，线程在下面情况时退出：

• 1、线程函数内语句执行完毕
• 2、线程函数中抛出未处理的异常

Python的线程没有优先级，没有线程组的概念，也不能被销毁、停止、挂起，那也就没有恢复、中断了。

线程传参和函数传参没有什么区别，本质上就是函数传参。

注意：
1、工作线程的异常和主线程的执行没关系，状态执行码与主线程有关。
2、Python的线程只有执行完和崩溃两种方式，不能通过其它方式进行终止。
3、进程状态码非常有用，平时一定要注意观察。

# 线程异常退出，不会影响主进程
# 注意主线程的 exit-code
import threading
import time

def worker():
    count = 0
    while True:
        if count > 5:
            raise RuntimeError(count)
        time.sleep(0.5)
        count += 1
        print('I am working.')
    print('Finished.')

threading.Thread(target=worker).start()

print('main_thread end =======')

main_thread end =======
I am working.
I am working.
I am working.
I am working.
I am working.
Exception in thread Thread-1:
Traceback (most recent call last):
  File "D:/PycharmProjects/pythonProject/202108089/multiprocessing/5.py", line 9, in worker
    raise RuntimeError(count)
RuntimeError: 6
I am working.

Process finished with exit code 0

import threading
import time


def add(x, y):
    print('{} + {} = {}，{}_线程ID = {}'.format(x, y, x + y, threading.current_thread().name, threading.current_thread().ident))


print('begin ~~~~~~~~~')
print('{}_ID = {}'.format(threading.current_thread().name, threading.current_thread().ident))
t1 = threading.Thread(target=add, name='add1', args=(4, 5))
t1.start()

time.sleep(1)

t2 = threading.Thread(target=add, name='add2', args=(4,), kwargs={
   'y': 5})
t2.start()

time.sleep(1)

t3 = threading.Thread(target=add, name='add3', kwargs={
   'x': 4, 'y': 5})
t3.start()

time.sleep(1)

print('end ~~~~~~~~~')

begin ~~~~~~~~~
MainThread_ID = 18404
4 + 5 = 9，add1_线程ID = 45784
4 + 5 = 9，add2_线程ID = 33984
4 + 5 = 9，add3_线程ID = 46024
end ~~~~~~~~~

3.2.3 threading的属性和方法

threading.active_count() 、threading.enumerate() 方法返回值还包含主线程。

threading.currentThread() 等函数结果都是线程对象，可以进行一些属性操作。

# 线程异常退出，不会影响主进程
import threading
import time


def showthreadinfo():
    print("current_thread = {}\nmain_thread = {}\nactive_count = {}".format(
        threading.current_thread(), threading.main_thread(), threading.active_count()
    ))

def worker():
    showthreadinfo()
    for i in range(5):
        time.sleep(1)
        print('I am working.')
    print('Finished.')

t = threading.Thread(target=worker, name='worker')
showthreadinfo()
time.sleep(1)
print('threading start ~~~~~~~~~')
t.start()

current_thread = <_MainThread(MainThread, started 45268)>
main_thread = <_MainThread(MainThread, started 45268)>
active_count = 1
threading start ~~~~~~~~~
current_thread = <Thread(worker, started 42784)>
main_thread = <_MainThread(MainThread, started 45268)>
active_count = 2
I am working.
I am working.
I am working.
I am working.
I am working.
Finished.

Process finished with exit code 0

3.2.3 Thread实例的属性和方法

注意：线程的name这是一个名称，可以重复；ID必须唯一，但可以在线程退出后再利用。

import threading
import time


def worker():
    for i in range(5):
        time.sleep(1)
        print('I am working. I am in thread {}.\n'.format(threading.current_thread().ident), end='')
    print('Finished.\n', end='')
# print是线程不安全的，所以可以把换行符放在字符串内，end为空
# 打印一个完整的字符串，是原子操作，一定会打印完成

t = threading.Thread(target=worker, name='worker')
print('t.name = {}'.format(t.name))
print('t.getName() = {}'.format(t.getName()))
t.setName('new-worker')
print('After setting name ~~~~~~~~~~~~')
print('t.name = {}'.format(t.name))
print('t.getName() = {}'.format(t.getName()))
t.start()
print('=' * 55)

while True:
    time.sleep(1)
    print('{} {} {}\n'.format(t.name, t.ident, 'alive' if t.is_alive() else 'dead'), end='')
    if not t.is_alive():
        break

t.name = worker
t.getName() = worker
After setting name ~~~~~~~~~~~~
t.name = new-worker
t.getName() = new-worker
============