并发编程之线程

Posted 2021-01-07 st-st

一、进程创建的机制

进程是计算机中最小的资源分配单位

进程对于操作系统来说还是有一定的负担

创建一个进程，操作系统要分配的资源大致：代码、数据、文件

存放代码到内存，存储数据到内存空间，文件，系统分配需要时间，占用的空间也比较大

 

二、线程

随着对并发的要求越来越高，无限开启进程是不现实的，解决高并发下进程的问题，使用线程。

线程是轻量级的概念，它没有属于自己的进程资源

一条线程只负责执行代码，没有自己独立的代码、变量、文件资源，线程都是共享资源

线程是计算机中被CPU调度的最小单位，计算机当中的CPU都是执行线程中的代码

 

三、进程和线程之间的关系

每一个进程中都有至少一条线程在工作，一个进程可以有多个线程

 

四、线程的特点：

① 同一个进程中的所有线程的内存空间、资源都是共享的

② 轻量级，没有自己的资源

③ 线程之间的切换很近，也很快，进程之间切换比较慢，进程占用资源多

④ 轻型实体

⑤ 独立调度和分配的基本单位

⑥ 共享进程资源

⑦ 并发执行

 

五、线程的分类

用户级线程：操作线程，操作系统的内核只能通过进程去执行线程

内核级线程：操作系统能够直接调度线程

混合实现：用户能查看调度线程，内核也能调度线程

 

六、进程和线程之间的区别

① 占用的资源

② 调度的效率

③ 资源是否共享

 

七、python中的线程

一个线程中的多个线程不能并线，由于python是解释型语言，所有的解释型语言都不能并行多个进程。

GIL锁：全局解释器锁，为了线程的安全

由于CPython解释器的原因，内部有一个全局解释器锁，所以线程不能充分的利用多核，只能同一时刻同一个进程中的线程只有一个能被CPU执行

GIL锁目前是能够提高线程切换的效率，但也确实限制了程序的效率

 

八、线程的创建

Thread模块比较老，Threading模块比较新，而且更高级，两个模块不能一起使用

import os
from threading import Thread

def func():
    print(‘子线程‘,os.getpid())

print(‘主线程‘,os.getpid())
for i in range(2):
    t = Thread(target=func)         # 创建子线程
    t.start()
    
‘‘‘
主线程 8076
子线程 8076
子线程 8076
‘‘‘

 

轻量级

线程比进程的运行效率高

import os,time
from multiprocessing import Process
from threading import Thread

def func():
    print(‘进程号:‘,os.getpid())

if __name__ == ‘__main__‘:
    # 创建线程
    start = time.time()
    t_lis = []
    for i in range(100):
        t = Thread(target=func)
        t.start()
        t_lis.append(t)
    for t in t_lis:t.join()     # 保障线程全部执行完毕
    tt = time.time() - start

    # 创建进程
    start = time.time()
    p_lis = []
    for i in range(100):
        p = Process(target=func)
        p.start()
        p_lis.append(p)
    for p in p_lis:p.join()
    pt = time.time() - start

    print(tt,pt)            # 统计线程和进程所运行的时间

    # 0.02799248695373535 2.422297239303589

 

数据共享

from threading import Thread

count = 100
def func():
    global count
    count -= 1

t_lis = []
for i in range(100):
    t = Thread(target=func)
    t.start()
    t_lis.append(t)
for t in t_lis:t.join()
print(count)        # 0