1.进程回顾
之前已经了解了操作系统中进程的概念，程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程。程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念。在多道编程中，我们允许多个程序同时加载到内存中，在操作系统的调度下，可以实现并发地执行。这是这样的设计，大大提高了CPU的利用率。进程的出现让每个用户感觉到自己独享CPU，因此，进程就是为了在CPU上实现多道编程而提出的。
2.有了进程为什么还需要线程？
进程有很多优点，它提供了多道编程，让我们感觉我们每个人都拥有自己的CPU和其他资源，可以提高计算机的利用率。很多人就不理解了，既然进程这么优秀，为什么还要线程呢？其实，仔细观察就会发现进程还是有很多缺陷的，主要体现在两点上： 1.进程只能在一个时间干一件事，如果想同时干两件事或多件事，进程就无能为力了。 2.进程在执行的过程中如果阻塞，例如等待输入，整个进程就会挂起，即使进程中有些工作不依赖于输入的数据，也将无法执行,浪费系统资源。
3.线程的基本概念
线程是进程中的一个单位 进程：计算机中最小的资源分配单位 线程：计算机中被CPU调度的最小单位
4.为什么要使用线程？
1.线程也叫轻量级的进程，最大的特点是同一个进程中的多个子线程是共享一部分数据(一个进程的多个子进程和父进程相互隔离，没有关系)2.线程的创建\销毁\上线文切换要比进程高效
5.进程和线程的区别？
进程：数据隔离(但也可以使用Manager模块实现数据共享)，使用开销大 线程：数据共享(全局变量)，使用开销小 通过小的细节来体现进程和线程的区别： 1.os.getpid() 进程：父进程和子进程的pid都不同，所以都各自有自己的内存空间 2.if __name_- == '__main__' 进程和线程的创建原理不同，所以不需要if __name__ == '__main__' 因为新的线程是在主线程的内存中，所以新的线程和主线程共享同一段代码，不需要import导入，也就不存在子线程中又重复一次创建线程的过程
在cpython中多进程可以使用多核，但是多线程不能使用多核是cpython解释器的原因造成的，因为cpython存在GIL全局解释器锁，导致同一时间内只能有一个线程访问cpu，保证数据安全，但是jpython和pypy就能访问多核的cpu
正常的多个线程和多个进程可不可以利用多核(多个cpu )？
可以，因为cpu执行的是进程中的线程
解释性语言不能多个线程同时访问多个cpu，这样做能保证数据不出错
6.Python中的线程模块
threading 和 multiprocessing在使用上基本相同 先有的threading模块，没有池的功能 multiprocessing完全模仿threading模块完成的，实现了池的功能 concurrent.futures，实现了线程池\进程池
如何开启一个线程
from threading import Thread
import os
def func():
print('in fucn ',os.getpid())
print('in main ',os.getpid())
Thread(target=func).start()
#两个打印pid是一样的，说明线程是由进程产生的
方法1
from threading import Thread
import time
class Sayhi(Thread):
def __init__(self,name):
super().__init__()
self.name=name
def run(self):
time.sleep(2)
print('%s say hello' % self.name)
if __name__ == '__main__':
t = Sayhi('kobe')
t.start()
print('主线程')
方法2
开启一个多线程
import time
from threading import Thread
import os
def func(i):
time.sleep(1)
print('in fucn',i,os.getpid())
print('in main',os.getpid())
for i in range(20):
#Thread(target=func,args=(i,)).start() #问题：多个线程在同一个进程中处理数据的时候，数据需不需要锁？
当然需要，这就是GIL锁存在的意义：同一进程内的同一时刻只能有一个线程访问cpu来修改同一个数据，导致Python中的多线程是‘伪多线程’，所以cpython解释器不能使用多核
线程的其他方法
Thread实例对象的方法
isAlive(): 返回线程是否活动的。
getName(): 返回线程名。
setName(): 设置线程名。
threading模块提供的一些方法：
threading.currentThread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行子线程启动后、结束前，不包括启动前和终止后的线程。
threading.active_count(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果
主线程也是一个线程，每个线程没有被start()的时候们不会被执行
判断主线程是否结束了
线程有terminate么?
没有terminate 不能强制结束
所有的子线程都会在执行完所有的任务之后自动结束
# 返回一个存储着所有线程对象的列表
from threading import enumerate,Thread
def func():
print('in son thread')
Thread(target=func).start()
print(enumerate())
通过dis模块查看机器码
from dis import dis
def func():
a =[]
a.append(1)
dis(func)
注意：cpu在0.9ms内可以处理450w机器码
python解释器 --> 字节码 --> 机器码
7.线程中守护进程
import time
from threading import Thread,activeCount
#守护线程守护的
def daemon_func():
while True:
time.sleep(0.5)
print('守护线程')
def son_func():
print('start son')
time.sleep(10)
print('end son')
print('子线程:',time.time()-start)
start= time.time()
#子线程
t = Thread(target=daemon_func)
t.daemon = True
t.start()
#子线程
Thread(target=son_func).start()
#主线程
print(activeCount())
time.sleep(3)
print('主线程结束')
print('主线程：',time.time()-start)
线程中的守护线程
无论是进程还是线程，都遵循：守护xx会等待主xx运行完毕后被销毁。需要强调的是：运行完毕并非终止运行
1.对主进程来说，运行完毕指的是主进程代码运行完毕
2.对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕
如果你设置一个线程为守护线程，就表示你在说这个线程是不重要的，在进程退出的时候，不用等待这个线程退出。如果你的主线程在退出的时候，不用等待那些子线程完成，那就设置这些线程的daemon属性。
1.主线程会等待子线程的结束而结束，主线程不会管守护线程的线程是否执行完毕2.守护线程会随着主线程的结束而结束，注意是运行完毕，并非终止运行，守护线程会守护主线程和所有的子线程3.整个Python会在所有的非守护线程退出后才会结束，即进程中没有非守护线程存在的时候才结束。(主进程会随着主线程的结束而结束)
问题 1.主线程需不需要回收子线程的资源 # 不需要,线程资源属于进程,所以进程结束了,线程的资源自然就被回收了 2.主线程为什么要等待子线程结束之后才结束 # 主线程结束意味着进程进程,进程结束,所有的子线程都会结束，要想让子线程能够顺利执行完,主线程只能等 3.守护线程到底是怎么结束的 # 主线程结束了,主进程也结束,守护线程被主进程的结束(运行完毕)给杀死了
8.思考：有了GIL锁，线程中还需要锁么？
有必要理论上有了GIL锁会保证同一时间内只有一个线程执行cpu指令，但是运行多线程不加锁的话，会产生数据不安全的情况有下列代码： 当tt里面的第一个线程在执行的时候，假如说执行到count =count+1 但是还没来得及把count放回去的时候，cpu就切换到下一个线程执行，此时的count并没有 修改，还是0 ，于是就将coun加1，count=1，在切换到上一个线程继续执行，cpu寄存器里面 存放的上一个线程的状态是要将count+1的结果存回给count，所以在两个线程运行的时候只加了一次 造成count值不对，也就造成了数据不安全的问题。所以要加上锁 这种情况主要是由于是cpu切换线程造成的 ''' coun = 0 def func(): count +=1 for i in range(2): tt = Thread(target=func) tt.start() '''线程中不安全现象： 1.对全局变量进行修改 2.对某个值进行+=，-=，*=，/+，%=等等操作 产生的原因是cpu切换线程造成的 为什么某个值进行+=，-=，*=，/+，%=在cpu切换的时候造成数据不安全的现象？ 因为在count +=1等操作，在cpu的机器码中执行是可再分的，分成两步执行，count +1，count=count+1 所以在 cpu切换线程的时候，有可能出现两个线程分别对一个数据进行修改，而返回的时候只是返回一个 但是Python中常用的数据类型，list dict tuple set等修改或增加的方法都具有原子性(不是增加就是修改，就算cpu切换也无所谓) 具有原子性也是在cpu底层机器码中体现出来的 注意： 队列(queue)的原子性比以上的数据类型更强，因为队列的queue.get()获取不到数据的时候回阻塞住，而列表的list.pop()在没有数据时会报错
9.锁
互斥锁：在同一个线程中连续acquire两次，并且可以做到多个线程被锁的代码同时只有一个线程执行，中就是互斥锁，就是死锁 递归锁：在同一个线程中可以连续acquire多次，并且可以做到多个线程被锁的代码同时只有一个线程执行，但是大部分时候递归锁的情况都能使用互斥锁来解决(通常使用递归锁的代码都是有逻辑上问题的) 一般情况互斥锁的性能和时间复杂度要比递归所低，但是递归锁一把锁就可以打天下 递归锁最大的特点是：在同一个线程和进程不会出现死锁现象，并且能连续acquire两次，这是最大的特点
死锁现象;创建了两把锁以上，并且交替使用就可能出现死锁 只要是1把锁，递归锁永远不会死锁 只要是2把锁以及以上，都有可能产生死锁现象 r1 = r2 = RLock() 这是同一把锁 只要是2把锁以上，交替使用，递归锁和互斥锁都会产生死锁
1.gil 保证线程同一时刻只能一个线程访问CPU,不可能有两个线程同时在CPU上执行指令2.lock 锁 保证某一段代码 在没有执行完毕之后,不可能有另一个线程也执
from threading import Lock,Thread
import time
noodle_lock = Lock()
fork_lock = Lock()
def eat1(name):
noodle_lock.acquire() # 阻塞等面
time.sleep(0.5)
print('%s拿到面了'%name)
fork_lock.acquire()
print('%s拿到叉子了' % name)
print('%s吃面'%name)
fork_lock.release()
print('%s放下叉子了' % name)
noodle_lock.release()
print('%s放下面了' % name)
def eat2(name):
fork_lock.acquire() # 阻塞等叉子
print('%s拿到叉子了' % name)
noodle_lock.acquire()
print('%s拿到面了'%name)
print('%s吃面'%name)
noodle_lock.release()
print('%s放下面了' % name)
fork_lock.release()
print('%s放下叉子了' % name)
Thread(target=eat1,args = ('admin',)).start()
Thread(target=eat2,args = ('kobe',)).start()
Thread(target=eat1,args = ('jordan',)).start()
死锁
from threading import RLock,Thread
fork_lock = noodle_lock = RLock()
def eat1(name):
noodle_lock.acquire() # 阻塞 宝元等面
print('%s拿到面了'%name)
fork_lock.acquire()
print('%s拿到叉子了' % name)
print('%s吃面'%name)
fork_lock.release()
print('%s放下叉子了' % name)
noodle_lock.release()
print('%s放下面了' % name)
def eat2(name):
fork_lock.acquire() # 阻塞 wusir等叉子
print('%s拿到叉子了' % name)
noodle_lock.acquire()
print('%s拿到面了'%name)
print('%s吃面'%name)
noodle_lock.release()
print('%s放下面了' % name)
fork_lock.release()
print('%s放下叉子了' % name)
Thread(target=eat1,args = ('alex',)).start()
Thread(target=eat2,args = ('wusir',)).start()
Thread(target=eat1,args = ('baoyuan',)).start()
递归锁
10.队列
Queue就是一个线程队列的类,自带lock锁,实现了线程安全的数据类型队列是一个线程安全的数据类型，队列在多线程中占有重要的安全位置from queue import Queue:是线程安全的，和进程无关，进程通信是ipc，线程是共享内存的，二者通信方式不同
from queue import Queue
#Queue就是一个线程队列的类,自带lock锁,实现了线程安全的数据类型
#队列是一个线程安全的数据类型，只有几个特点的属性不是安全的
q = Queue() # 先进先出队列
# 在多线程下都不准
# q.empty() 判断是否为空
# q.full() 判断是否为满
# q.qsize() 队列的大小
#在多进程下都是数据安全的
q.put({1,2,3})
q.put_nowait('abc')
print(q.get_nowait())
print(q.get())
先进先出队列
# 先进后出的队列 last in first out
from queue import LifoQueue #线程安全的队列 栈和后进先出的场景都可以用
lfq = LifoQueue()
lfq.put(1)
lfq.put('abc')
lfq.put({'})
print(lfq.get())
print(lfq.get())
print(lfq.get())
后进先出队列
from queue import PriorityQueue # 优先级队列 pq = PriorityQueue() pq.put((10,'askdhiu')) #前面的数字就是优先级，越小越优先 pq.put((2,'asljlg')) pq.put((20,'asljlg')) print(pq.get()) print(pq.get()) print(pq.get())
优先级队列