线程理论

一、什么是进程？

进程是：

　　1、计算机中最小的资源分配单位

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

　　3、创建一个进程错做系统要分配的资源大致有:

        # 代码
        # 数据
        # 文件
二、什么是线程？

线程是：

　　1、线程是计算机中被cpu调度的最小单位

　　2、你的计算机当中的cpu都是执行的线程中的代码
三、为什么要有线程？

1、轻量级的概念

2、他没有属于自己的进程资源：一条线程只负责执行代码，没有自己独立的代码、变量、文件资源
四 、线程与进程之间的关系

     1、每一个进程中都有至少一条线程在工作

五、进程与线程之间的区别

     1、占用的资源共享
     2、调度的效率
     3、资源是否共享

六、线程的特点

     1、同一个进程中的所有线程的资源是共享的
     2、轻量级 没有自己的资源

七、python 中的线程

    1、一个进程中的多个线程能够并行么？不行
     python是一个解释型语言
         为什么不行？
         Cpython解释器 内部有一把全局解释器锁 GIL
             所以线程不能充分的利用多核
             同一时刻用一个进程中的线程只有一个能被cpu执行
         GIL锁 缺实时限制了你的程序效率
         GIL锁 目前 是能够帮助你在线程的切换中提高效率
    2、 是不是python 就没有前途
         cpu -- 计算型
         web 爬虫 金融分析(基本在IO等待中)
    3、就是想写高计算型
         开启多进程
         换一个解释器，pypy jpy

八、线程的并发

import os
import time
from threading import Thread
def func(i):
    time.sleep(1)
    print('zi',i,os.getpid())
print('zhu', os.getpid())
for i in range(10):
    t1 = Thread(target=func,args=(i,))
    t1.start()

九、线程的轻量级

import os
import time
from threading import Thread
from multiprocessing import Process
def func(i):
    print('zi',i,os.getpid())
if __name__ == '__main__':
    start = time.time()
    t_lst = []
    for i in range(100):
        t = Thread(target=func,args=(i,))
        t.start()
        t_lst.append(t)
    for t in t_lst:t.join()
    tt = time.time() - start

    start = time.time()
    t_lst = []
    for i in range(100):
        t = Process(target=func, args=(i,))
        t.start()
        t_lst.append(t)
    for t in t_lst: t.join()
    pt = time.time() - start
    print(tt,pt)
结果为：
0.018921375274658203 4.373299598693848

十、线程的数据共享

from threading import Thread
num = 100
def func():
    global num
    num -=1
t_lst = []
for i in range(100):
    t = Thread(target=func)
    t.start()
    t_lst.append(t)
for t in t_lst: t.join()
print(num)
结果为：
0

十一、守护线程

import time
from threading import Thread
def func1():
    while True:
        time.sleep(0.5)
        print(123)
def func2():
    print('func2 start')
    time.sleep(3)
    print('func2 end')
t1 = Thread(target=func1)
t2 = Thread(target=func2)
t1.setDaemon(True)
t1.start()
t2.start()
print('主线程的代码结束')

守护线程的特点：

1、守护线程 是在主线程代码结束之后，还在等待了子线程执行结束才结束
2、主线程结束 就意味着主进程结束
3、主线程等待所有的线程结束
4、主线程结束了之后，守护线程随着主进程的结束自然结束了