day 32 网络编程——线程

认识线程

一、什么是线程

在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程

线程顾名思义，就是一条流水线工作的过程（流水线的工作需要电源，电源就相当于cpu），而一条流水线必须属于一个车间，一个车间的工作过程是一个进程，车间负责把资源整合到一起，是一个资源单位，而一个车间内至少有一条流水线。

所以，进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位。

多线程（即多个控制线程）的概念是，在一个进程中存在多个线程，多个线程共享该进程的地址空间，相当于一个车间内有多条流水线，都共用一个车间的资源。例如，北京地铁与上海地铁是不同的进程，而北京地铁里的13号线是一个线程，北京地铁所有的线路共享北京地铁所有的资源，比如所有的乘客可以被所有线路拉。

二、线程与进程的区别

1. Threads share the address space of the process that created it; processes have their own address space.
2. Threads have direct access to the data segment of its process; processes have their own copy of the data segment of the parent process.
3. Threads can directly communicate with other threads of its process; processes must use interprocess communication to communicate with sibling processes.
4. New threads are easily created; new processes require duplication of the parent process.
5. Threads can exercise considerable control over threads of the same process; processes can only exercise control over child processes.
6. Changes to the main thread (cancellation, priority change, etc.) may affect the behavior of the other threads of the process; changes to the parent process does not affect child processes.

总结上述区别，无非两个关键点，这也是我们在特定的场景下需要使用多线程的原因：

1. 同一个进程内的多个线程共享该进程内的地址资源
2. 创建线程的开销要远小于创建进程的开销（创建一个进程，就是创建一个车间，涉及到申请空间，而且在该空间内建至少一条流水线，但创建线程，就只是在一个车间内造一条流水线，无需申请空间，所以创建开销小）

三、多线程应用举例

开启一个字处理软件进程，该进程肯定需要办不止一件事情，比如监听键盘输入，处理文字，定时自动将文字保存到硬盘，这三个任务操作的都是同一块数据，因而不能用多进程。只能在一个进程里并发地开启三个线程,如果是单线程，那就只能是，键盘输入时，不能处理文字和自动保存，自动保存时又不能输入和处理文字。

开启线程的两种方式

threading模块介绍

multiprocess模块的完全模仿了threading模块的接口，二者在使用层面，有很大的相似性，因而不再详细介绍。

注意：线程没有子线程的概念，以下只是为了方便区分。

方式一

from threading import Thread
import time
import random


def thread(name):
    print('this is 线程 %s' % name)
    time.sleep(random.randrange(1, 3))
    print('end')

if __name__ == '__main__':
    t = Thread(target=thread,args=('ysg',))
    t.start()
    print('主线程')

方式二

from threading import Thread
import time
import random


class Threads(Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print('this is thread')
        time.sleep(random.randrange(1, 3))
        print('end')

if __name__ == '__main__':
    t = Threads('ysg')
    t.start()
    print('主线程')

Thread对象的其他属性或方法

介绍

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

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

from threading import Thread, currentThread, enumerate,active_count
import time

def func():
    print('Name:%s' % currentThread().getName())
    time.sleep(3)
    print('end')


if __name__ == '__main__':
    t = Thread(target=func, name='线程 1')    # 开启线程时，设置线程名；存在默认值
    t.start()
    print(t.getName())          # 获取线程名；结果：线程 1
    t.setName('线程 A')         # 修改线程名
    print(t.getName())          # 结果：线程 A
    print(enumerate())          # 以列表的方式获取线程信息；结果：[<_MainThread(MainThread, started 2436)>, <Thread(线程 A, started 8292)>]
    print(t.is_alive())         # 判断线程是否存活，返回值 True、False；结果：True
    print(active_count())       # 获取存活进程数；结果：2

进程与线程的区别

1.开进程远比开线程的开销大

from multiprocessing import Process
from threading import Thread
import time
import random


def thread(name):
    print('开启 %s' % name)
    time.sleep(random.randrange(1, 3))
    print('end')


if __name__ == '__main__':
    # p = Process(target=thread, args=('ysg',))
    # p.start()

    t = Thread(target=thread, args=('ysg',))
    t.start()
    print('主')

执行结果：可见进程执行完毕后子进程才开启，线程在主线程执行完毕前，子线程就已经开启了；实际开进程远比开线程开销大。

# 进程执行结果
# 主
# 开启 ysg
# end

# 线程执行结果
# 开启 ysg
# 主
# end

2.同一进程内的多个线程共享该进程的地址空间

由于同一进程内的线程共享改进程内的空间，所以子线程更改了 n = 0。

n = 100


def func():
    global n
    n = 0


if __name__ == '__main__':
    # 进程输出结果：100
    p = Process(target=func,)
    p.start()

    # 线程输出结果：0
    # t = Thread(target=func)
    # t.start()
    print('主,%s' % n)

3.查看pid

def func():
    print('子：%s' % (os.getpid()))


if __name__ == '__main__':
    p = Process(target=func,)
    p.start()

    # t = Thread(target=func,)
    # t.start()
    print('主 %s'% os.getpid())

执行结果：

# 进程
主 6276
子：7244

#线程
子：6952
主 6952

守护线程

无论是进程还是线程，都遵循：守护xxx会等待主xxx运行完毕后被销毁

需要强调的是：运行完毕并非终止运行

1、对主进程来说，运行完毕指的是主进程代码运行完毕

2、对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕

详细解释：

1、主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，

2、主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。

单线程

from threading import Thread
import time

def func():
    time.sleep(1)
    print('123')


if __name__ == '__main__':
    t = Thread(target=func,)
    t.daemon = True     # 必须在t.start()之前设置，t.setDaemon(True) 两者效果一致
    t.start()
    print('主线程')
    print(t.isAlive())

# 执行结果
# 123
# True

多线程

def func():
    print('123')
    time.sleep(1)
    print('end 123')

def func2():
    print('123')
    time.sleep(1)
    print('end 123')


if __name__ == '__main__':
    t = Thread(target=func,)
    t2 = Thread(target=func2,)

    t.daemon = True

    t.start()
    t2.start()
    print('主线程')


# 执行结果
    # 123
    # 123
    # 主线程
    # end 123
    # end 123