day 32 并发编程——认识线程（上）

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
```
互斥锁

不加锁
```
from threading import Thread
import time

n = 100
def func():
    global n
    tem = n
    time.sleep(0.5)
    n = tem - 1

if __name__ == '__main__':
    t_l = []
    for i in range(100):
        t = Thread(target=func, )
        t_l.append(t)
        t.start()

    for i in t_l:
        i.join()

    print('主线程 %s' % n)     # 执行结果：主线程 99
```
加锁
```
from threading import Thread, Lock
import time

n = 100


def func():
    global n
    mexty.acquire()
    tem = n
    time.sleep(0.01)
    n = tem - 1
    mexty.release()


if __name__ == '__main__':
    mexty = Lock()
    t_l = []
    for i in range(100):
        t = Thread(target=func)
        t_l.append(t)
        t.start()

    for i in t_l:
        i.join()

    print('主线程 %s' % n)    # 执行结果：主线程 0
```
GIL

一、引子

定义：
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple
native threads from executing Python bytecodes at once. This lock is necessary mainly
because CPython’s memory management is not thread-safe. (However, since the GIL
exists, other features have grown to depend on the guarantees that it enforces.)

结论：在Cpython解释器中，同一个进程下开启的多线程，同一时刻只能有一个线程执行，无法利用多核优势
首先需要明确的一点是GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。就好比C++是一套语言（语法）标准，但是可以用不同的编译器来编译成可执行代码。>有名的编译器例如GCC，INTEL C++，Visual C++等。Python也一样，同样一段代码可以通过CPython，PyPy，Psyco等不同的Python执行环境来执行。像其中的JPython就没有GIL。然而因为CPython是大部分环境下默认的Python执行环境。所以在很多人的概念里CPython就是Python，也就想当然的把GIL归结为Python语言的缺陷。所以这里要先明确一点：GIL并不是Python的特性，Python完全可以不依赖于GIL

二、GIL介绍

GIL本质就是一把互斥锁，既然是互斥锁，所有互斥锁的本质都一样，都是将并发运行变成串行，以此来控制同一时间内共享数据只能被一个任务所修改，进而保证数据安全。

可以肯定的一点是：保护不同的数据的安全，就应该加不同的锁。

要想了解GIL，首先确定一点：每次执行python程序，都会产生一个独立的进程。例如python test.py，python aaa.py，python bbb.py会产生3个不同的python进程

验证 python test.py 只会产生一个进程
```
#test.py内容
import os,time
print(os.getpid())
time.sleep(1000)

#打开终端执行
python3 test.py

#在windows下查看
tasklist |findstr python

#在linux下下查看
ps aux |grep python
```
在一个python的进程内，不仅有test.py的主线程或者由该主线程开启的其他线程，还有解释器开启的垃圾回收等解释器级别的线程，总之，所有线程都运行在这一个进程内，毫无疑问

1、所有数据都是共享的，这其中，代码作为一种数据也是被所有线程共享的（test.py的所有代码以及Cpython解释器的所有代码）
例如：test.py定义一个函数work（代码内容如下图），在进程内所有线程都能访问到work的代码，于是我们可以开启三个线程然后target都指向该代码，能访问到意味着就是可以执行。

2、所有线程的任务，都需要将任务的代码当做参数传给解释器的代码去执行，即所有的线程要想运行自己的任务，首先需要解决的是能够访问到解释器的代码。
综上：

如果多个线程的target=work，那么执行流程是

多个线程先访问到解释器的代码，即拿到执行权限，然后将target的代码交给解释器的代码去执行

解释器的代码是所有线程共享的，所以垃圾回收线程也可能访问到解释器的代码而去执行，这就导致了一个问题:对于同一个数据100，可能线程1执行x=100的同时，而垃圾回收执行的是回收100的操作，解决这种问题没有什么高明的方法，就是加锁处理，如下图的GIL，保证python解释器同一时间只能执行一个任务的代码

三、GIL与Lock

机智的同学可能会问到这个问题：Python已经有一个GIL来保证同一时间只能有一个线程来执行了，为什么这里还需要lock?

首先，我们需要达成共识：锁的目的是为了保护共享的数据，同一时间只能有一个线程来修改共享的数据

然后，我们可以得出结论：保护不同的数据就应该加不同的锁。

最后，问题就很明朗了，GIL 与Lock是两把锁，保护的数据不一样，前者是解释器级别的（当然保护的就是解释器级别的数据，比如垃圾回收的数据），后者是保护用户自己开发的应用程序的数据，很明显GIL不负责这件事，只能用户自定义加锁处理，即Lock，如下图

分析：

1、100个线程去抢GIL锁，即抢执行权限
2、肯定有一个线程先抢到GIL（暂且称为线程1），然后开始执行，一旦执行就会拿到lock.acquire()
3、极有可能线程1还未运行完毕，就有另外一个线程2抢到GIL，然后开始运行，但线程2发现互斥锁lock还未被线程1释放，于是阻塞，被迫交出执行权限，即释放GIL
4、直到线程1重新抢到GIL，开始从上次暂停的位置继续执行，直到正常释放互斥锁lock，然后其他的线程再重复2 3 4的过程

代码示范
```
from threading import Thread,Lock
import os
import time
def work():
    global n
    lock.acquire()
    temp=n
    time.sleep(0.1)
    n=temp-1
    lock.release()
if __name__ == '__main__':
    lock=Lock()
    n=100
    l=[]
    for i in range(100):
        p=Thread(target=work)
        l.append(p)
        p.start()
    for p in l:
        p.join()

    print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全，不加锁则结果可能为99
```
四、GIL与多线程

有了GIL的存在，同一时刻同一进程中只有一个线程被执行

听到这里，有的同学立马质问：进程可以利用多核，但是开销大，而python的多线程开销小，但却无法利用多核优势，也就是说python没用了，php才是最牛逼的语言？

别着急啊，老娘还没讲完呢。

要解决这个问题，我们需要在几个点上达成一致：
```
1、cpu到底是用来做计算的，还是用来做I/O的？

2、多cpu，意味着可以有多个核并行完成计算，所以多核提升的是计算性能

3、每个cpu一旦遇到I/O阻塞，仍然需要等待，所以多核对I/O操作没什么用处
```
一个工人相当于cpu，此时计算相当于工人在干活，I/O阻塞相当于为工人干活提供所需原材料的过程，工人干活的过程中如果没有原材料了，则工人干活的过程需要停止，直到等待原材料的到来。

如果你的工厂干的大多数任务都要有准备原材料的过程（I/O密集型），那么你有再多的工人，意义也不大，还不如一个人，在等材料的过程中让工人去干别的活，

反过来讲，如果你的工厂原材料都齐全，那当然是工人越多，效率越高

结论：
```
1、对计算来说，cpu越多越好，但是对于I/O来说，再多的cpu也没用
2、当然对运行一个程序来说，随着cpu的增多执行效率肯定会有所提高（不管提高幅度多大，总会有所提高），这是因为一个程序基本上不会是纯计算或者纯I/O，所以我们只能相对的去看一个程序到底是计算密集型还是I/O密集型，从而进一步分析python的多线程到底有无用武之地
```
假设我们有四个任务需要处理，处理方式肯定是要玩出并发的效果，解决方案可以是：
```
方案一：开启四个进程
方案二：一个进程下，开启四个线程
```
单核情况下，分析结果:
```
如果四个任务是计算密集型，没有多核来并行计算，方案一徒增了创建进程的开销，方案二胜
如果四个任务是I/O密集型，方案一创建进程的开销大，且进程的切换速度远不如线程，方案二胜
```
多核情况下，分析结果：
```
如果四个任务是计算密集型，多核意味着并行计算，在python中一个进程中同一时刻只有一个线程执行用不上多核，方案一胜
如果四个任务是I/O密集型，再多的核也解决不了I/O问题，方案二胜
```
结论：

现在的计算机基本上都是多核，python对于计算密集型的任务开多线程的效率并不能带来多大性能上的提升，甚至不如串行(没有大量切换)，但是，对于IO密集型的任务效率还是有显著提升的。

五、多线程性能测试

如果并发的多个任务是计算密集型：多进程效率高
```
from threading import Thread
from multiprocessing import Process
import os
import time


def func():
    res = 0
    for i in range(100000000):
        res *= i


if __name__ == '__main__':
    lis = []
    print(os.cpu_count())  # 8 核
    start_time = time.time()
    for i in range(8):
        # p = Process(target=func, )
        p = Thread(target=func, )
        lis.append(p)
        p.start()

    for i in lis:
        i.join()
    ent_time = time.time()
    print('使用的时间为：%s' % (ent_time - start_time))

# 多进程花费时间为：7.568458557128906
# 多线程花费时间为：34.62424421310425
```
如果并发的多个任务是I/O密集型：多线程效率高
```
from threading import Thread
from multiprocessing import Process
import os
import time


def func():
    time.sleep(2)

if __name__ == '__main__':
    lis = []
    start_time = time.time()
    for i in range(8):
        # p = Process(target=func, )
        p = Thread(target=func, )
        lis.append(p)
        p.start()
    for i in lis:
        i.join()
    end_time = time.time()
    print('使用的时间为：%s' % (end_time - start_time))

# 多进程花费时间为：2.2403011322021484
# 多线程花费时间为：2.0028250217437744
```
应用：

多线程用于IO密集型，如socket，爬虫，web
多进程用于计算密集型，如金融分析
相关阅读:
Git常用操作命令
 android快速入门
 使用Jsoup 抓取页面的数据
 js面向对象组件
 js事件详解
 图解TCP-IP协议
 error: linking with `cc` failed: exit code: 1
git——'fatal: cannot do a partial commit during a merge'
git add 而未 commit 的文件丢失后找回
 为rust配置国内/科大源
原文地址：https://www.cnblogs.com/ysging/p/12329308.html

day 32 并发编程——认识线程（上）

认识线程

一、什么是线程

二、线程与进程的区别

三、多线程应用举例

开启线程的两种方式

threading模块介绍

Thread对象的其他属性或方法

介绍

进程与线程的区别

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

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

3.查看pid

守护线程

互斥锁

GIL

一、引子

二、GIL介绍

三、GIL与Lock

四、GIL与多线程

五、多线程性能测试