33、线程与全局解释器锁（GIL）

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、线程可以直接访问其进程的数据段;进程有它们自己的父进程数据段的副本。
3、线程可以直接与进程的其他线程通信;进程必须使用进程间通信来与兄弟进程通信。
4、新线程很容易创建;新进程需要复制父进程。
5、线程可以对同一进程的线程进行相当大的控制;进程只能对子进程执行控制。
6、对主线程的更改(取消、优先级更改等)可能会影响该进程的其他线程的行为;对父进程的更改不会影响子进程。

from threading import Thread
#from  multiprocessing  import  Process
import os
def talk():
    print(‘%s is running‘ %os.getpid())

if __name__ == ‘__main__‘:
    t=Thread(target=talk)
    # t=Process(target=talk)
    t.start()
    print(‘主‘,os.getpid())

#开启线程
from threading import Thread
import os
class MyThread(Thread):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        print(‘pid:%s name:[%s]is running‘ %(os.getpid(),self.name))

if __name__ == ‘__main__‘:
    t=MyThread(‘lln‘)
    t.start()
    print(‘主T‘,os.getpid())

#开启进程
from multiprocessing import Process
import os
class MyProcess(Process):
    def __init__(self,name):
        super().__init__()
        self.name=name
    def run(self):
        print(‘pid:%s name:[%s]is running‘ % (os.getpid(), self.name))
if __name__ == ‘__main__‘:
    t=MyProcess(‘lll‘)
    t.start()
    print(‘主P‘,os.getpid())

from threading import Thread
from multiprocessing import Process
import os

def work():
    print(‘hello‘)

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

    #在主进程下开启子进程
    t=Process(target=work)
    t.start()
    print(‘主线程/主进程‘)

from threading import Thread
from multiprocessing import Process
import os

def work():
    print(‘我的pid：‘,os.getpid())

if __name__ == ‘__main__‘:
    #part1:在主进程下开启多个线程,每个线程都跟主进程的pid一样
    t1=Thread(target=work)
    t2=Thread(target=work)
    t1.start()
    t2.start()
    print(‘主线程/主进程pid：‘,os.getpid())

    #part2:开多个进程,每个进程都有不同的pid
    p1=Process(target=work)
    p2=Process(target=work)
    p1.start()
    p2.start()
    print(‘主线程/主进程pid：‘,os.getpid())

from  threading import Thread
from multiprocessing import Process
def work():
    global n
    n -= 1
n = 100  #主进程数据
if __name__ == ‘__main__‘:
    # p=Process(target=work)
    # p.start()
    # p.join()
    # print(‘主‘,n) #毫无疑问子进程p已经将自己的全局的n改成了99,但改的仅仅是它自己的,查看父进程的n仍然为100

    t=Thread(target=work)
    t.start()
    t.join()
    print(‘主‘,n) #查看结果为99,因为同一进程内的线程之间共享进程内的数据

from threading import Thread
msg = []
msg_fort = []
def Inp():
    while True :
        msg_l = input(‘>>:‘)
        if not msg_l : continue
        msg.append(msg_l)
def Fort():
    while True :
        if msg :
            res = msg.pop()
            msg_fort.append(res.upper())
def Save():
    with open(‘db.txt‘,‘a‘) as f :
        while True :
            if msg_fort :
                f.write(‘%s\n‘ %msg_fort.pop())
                f.flush()  #强制将缓冲区中的数据发送出去,不必等到缓冲区满
if __name__ == ‘__main__‘:
    p1 = Thread(target=Inp)
    p2 = Thread(target=Fort)
    p3 = Thread(target=Save)
    p1.start()
    p2.start()
    p3.start()

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

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

from threading import Thread,currentThread,activeCount
import os,time,threading
def talk():
    time.sleep(2)
    print(‘%s is running‘ %currentThread().getName())

if __name__ == ‘__main__‘:
    t=Thread(target=talk)
    t.start()
    t.join()
    print(‘主‘)

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once.

在CPython中，全局解释器锁是一个互斥锁，或GIL，它可以防止多个本地线程执行Python字节码。

This lock is necessary mainly because CPython’s memory management is not thread-safe.

这个锁是必需的，主要是因为CPython的内存管理不是线程安全的。

(However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

然而，由于GIL存在，其他的特性已经发展到依赖于它的保证。

‘‘‘
#验证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解释器的所有代码）
#2 所有线程的任务，都需要将任务的代码当做参数传给解释器的代码去执行，即所有的线程要想运行自己的任务，首先需要解决的是能够访问到解释器的代码。

#1. cpu到底是用来做计算的，还是用来做I/O的？
#2. 多cpu，意味着可以有多个核并行完成计算，所以多核提升的是计算性能
#3. 每个cpu一旦遇到I/O阻塞，仍然需要等待，所以多核对I/O操作没什么用处 

#分析：
我们有四个任务需要处理，处理方式肯定是要玩出并发的效果，解决方案可以是：
方案一：开启四个进程
方案二：一个进程下，开启四个线程
#单核情况下，分析结果: 
如果四个任务是计算密集型，没有多核来并行计算，方案一徒增了创建进程的开销，方案二胜
如果四个任务是I/O密集型，方案一创建进程的开销大，且进程的切换速度远不如线程，方案二胜
#多核情况下，分析结果：
如果四个任务是计算密集型，多核意味着并行计算，在python中一个进程中同一时刻只有一个线程执行用不上多核，方案一胜
如果四个任务是I/O密集型，再多的核也解决不了I/O问题，方案二胜
#结论：
现在的计算机基本上都是多核，python对于计算密集型的任务开多线程的效率并不能带来多大性能上的提升，甚至不如串行(没有大量切换)，但是，对于IO密集型的任务效率还是有显著提升的。