调试
python3 -m pdb xxx.py 执行进入第一行
命令 | 简写命令 | 作用 |
---|---|---|
break | b | 设置断点 |
continue | c | 继续执行程序 |
list | l | 查看当前行的代码段 |
step | s | 进入函数 |
return | r | 执行代码直到从当前函数返回 |
quit | q | 中止并退出 |
next | n | 执行下一行 |
p | 打印变量的值 | |
help | h | 帮助 |
args | a | 查看传入参数 |
回车 | 重复上一条命令 | |
break | b | 显示所有断点 |
break lineno | b lineno | 在指定行设置断点 |
break file:lineno | b file:lineno | 在指定文件的行设置断点 |
clear num | 删除指定断点 | |
bt | 查看函数调用栈帧 |
并发和并行
并发是指一个时间段内,有几个程序都在同一个CPU上运行,但任意一个时刻点上只有一个程序在处理机上运行。
并行是指一个时间段内,有几个程序都在几个CPU上运行,任意一个时刻点上,有多个程序在同时运行,并且多道程序之间互不干扰。 两者区别如下图
如果是多核也是一样,如果任务数量多于核数,就会出现单核上面的并发设计,5个任务,四个核,还有个肯定通过分配到某个核里面去时间片轮转,优先级的算法进行时间片夺取执行
并行是多个程序在多个CPU上同时运行,任意一个时刻可以有很多个程序同时运行,互不干扰。
并发是多个程序在一个CPU上运行,CPU在多个程序之间快速切换,微观上不是同时运行,任意一个时刻只有一个程序在运行,但宏观上看起来就像多个程序同时运行一样,因为CPU切换速度非常快,时间片是64ms(每64ms切换一次,不同的操作系统有不同的时间),人类的反应速度是100ms,你还没反应过来,CPU已经切换了好几个程序了。
举个例子吧,并行就是,多个人,有人在扫地,有人在做饭,有人在洗衣服,扫地,做饭,洗衣服都是同时进行的。
并发就是,有一个人,这个人一会儿扫地,一会儿做饭,一会儿洗衣服,他在这3件事中来回做,同一时刻只做一件事,不是同时做的,但最后3件事都可以做完。
时间片大小的选取
时间片取的小,假设是20ms,切换耗时假设是 10ms。
那么用户感觉不到多个程序之间会卡,响应很快,因为切换太快了,但是CPU的利用率就低了,20 / (20 + 10) = 66% 只有这么多,33%都浪费了。
时间片取的大,假设是200ms,切换耗时是 10ms
那么用户会觉得程序卡,响应慢,因为要200ms后才轮到我的程序运行,但是CPU利用率就高了,200 / (200 + 10) = 95% 有这么多被利用的。
所以时间片取太大或者太小都不好,一般在 10 - 100 ms 之间。
CPU调度策略
在并发运行中,CPU需要在多个程序之间来回切换,那么如何切换就有一些策略
3.1 先来先服务 - 时间片轮转调度
这个很简单,就是谁先来,就给谁分配时间片运行,缺点是有些紧急的任务要很久才能得到运行。
3.2 优先级调度
每个线程有一个优先级,CPU每次去拿优先级高的运行,优先级低的等等,为了避免等太久,每等一定时间,就给线程提高一个优先级
3.3 最短作业优先
把线程任务量排序,每次拿处理时间短的线程运行,就像我去银行办业务一样,我的事情很快就处理完了,所以让我插队先办完,后面时间长的人先等等,时间长的人就很难得到响应了。
3.4 最高响应比优先
用线程的等待时间除以服务时间,得到响应比,响应比小的优先运行。这样不会造成某些任务一直得不到响应。
3.5 多级反馈队列调度
有多个优先级不同的队列,每个队列里面有多个等待线程。
CPU每次从优先级高的遍历到低的,取队首的线程运行,运行完了放回队尾,优先级越高,时间片越短,即响应越快,时间片就不是固定的了。
队列内部还是用先来先服务的策略。
进程和线程
- 进程,能够完成多任务,比如 在一台电脑上能够同时运行多个QQ
- 线程,能够完成多任务,比如 一个QQ中的多个聊天窗口
定义
进程是系统进行资源分配和调度的一个独立单位.
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
区别
一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程(资源比进程少),使得多线程程序的并发性高。
进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率
线线程不能够独立执行,必须依存在进程中
线程和进程在使用上各有优缺点:线程执行开销小,但不利于资源的管理和保护;而进程正相反。
程序就是一坨代码,进程就是把程序加载到内存,有资源分配的单位,线程就是进程内真正执行代码的东西,程序运行期起来,进程必定会有一个主线程。就是iOS里面的主线程Runloop,子线程如果启动之后,不开启Runloop就会退出
进程(fork)
import os
rpid = os.fork()
if rpid<0:
print("fork调用失败。")
elif rpid == 0:
print("我是子进程(%s),我的父进程是(%s)"%(os.getpid(),os.getppid()))
x+=1
else:
print("我是父进程(%s),我的子进程是(%s)"%(os.getpid(),rpid))
print("父子进程都可以执行这里的代码")
我是父进程(19360),我的子进程是(19361)
父子进程都可以执行这里的代码
我是子进程(19361),我的父进程是(19360)
父子进程都可以执行这里的代码
进程可以理解为去银行,本来一个窗口,服务一群人,要等,现在多开了窗口,可以同时服务多个人,
fork炸弹
import os
while True:
os.fork()
#include <unistd.h>
int main()
{
while(1)
fork();
return 0;
}
fork炸弹以极快的速度创建大量进程(进程数呈以2为
底数
的
指数
增长趋势),并以此消耗系统分配予进程的可用空间使
进程表
饱和,而系统在进程表饱和后就无法运行新程序,除非进程表中的某一进程终止;但由于fork炸弹程序所创建的所有实例都会不断探测空缺的进程槽并尝试取用以创建新进程,因而即使在某进程终止后也基本不可能运行新进程。fork炸弹生成的子程序在消耗进程表空间的同时也会占用
CPU
和
内存
,从而导致系统与现有进程运行速度放缓,响应时间也会随之大幅增加,以致于无法正常完成任务,从而使系统的正常运作受到严重影响
。
跨平台多进程(multiprocessing)
from multiprocessing import Process
import time
def test():
while True:
print("sub process")
time.sleep(1)
# 创建进程 执行target函数
p = Process(target=test)
# 进程开始执行
p.start()
# 方案一
# while True:
# print("main process")
# time.sleep(1)
# 方案二
print("main process")
这个和fork不同的是,fork之后主进程运行完会直接退出,不会关心子进程是否结束。Process模块方案是跨平台的,而且主进程会等待所有子进程的结束之后才会退出
Process语法结构如下:
Process([group [, target [, name [, args [, kwargs]]]]])
target:表示这个进程实例所调用对象;
args:表示调用对象的位置参数元组;
kwargs:表示调用对象的关键字参数字典;
name:为当前进程实例的别名;
group:大多数情况下用不到;
Process类常用方法:
is_alive():判断进程实例是否还在执行;
join([timeout]):是否等待进程实例执行结束,或等待多少秒;
start():启动进程实例(创建子进程);
run():如果没有给定target参数,对这个对象调用start()方法时,就将执行对象中的run()方法;
terminate():不管任务是否完成,立即终止;
Process类常用属性:
name:当前进程实例别名,默认为Process-N,N为从1开始递增的整数;
pid:当前进程实例的PID值;
process子类
from multiprocessing import Process
import time
import os
#继承Process类
class Process_Class(Process):
#因为Process类本身也有__init__方法,这个子类相当于重写了这个方法,
#但这样就会带来一个问题,我们并没有完全的初始化一个Process类,所以就不能使用从这个类继承的一些方法和属性,
#最好的方法就是将继承类本身传递给Process.__init__方法,完成这些初始化操作
def __init__(self,interval):
Process.__init__(self)
self.interval = interval
#重写了Process类的run()方法
def run(self):
print("子进程(%s) 开始执行,父进程为(%s)"%(os.getpid(),os.getppid()))
t_start = time.time()
time.sleep(self.interval)
t_stop = time.time()
print("(%s)执行结束,耗时%0.2f秒"%(os.getpid(),t_stop-t_start))
if __name__=="__main__":
t_start = time.time()
print("当前程序进程(%s)"%os.getpid())
p1 = Process_Class(2)
#对一个不包含target属性的Process类执行start()方法,就会运行这个类中的run()方法,所以这里会执行p1.run()
p1.start()
p1.join()
t_stop = time.time()
print("(%s)执行结束,耗时%0.2f"%(os.getpid(),t_stop-t_start))
进程池(pool)
当需要创建的子进程数量不多时,可以直接利用multiprocessing中的Process动态成生多个进程,但如果是上百甚至上千个目标,手动的去创建进程的工作量巨大,此时就可以用到multiprocessing模块提供的Pool方法。
from multiprocessing import Pool
import os,time,random
def worker(msg):
t_start = time.time()
print("%s开始执行,进程号为%d"%(msg,os.getpid()))
#random.random()随机生成0~1之间的浮点数
time.sleep(random.random()*2)
t_stop = time.time()
print(msg,"执行完毕,耗时%0.2f"%(t_stop-t_start))
po=Pool(3) #定义一个进程池,最大进程数3
for i in range(0,10):
#Pool.apply_async(要调用的目标,(传递给目标的参数元祖,))
#每次循环将会用空闲出来的子进程去调用目标
po.apply_async(worker,(i,))
print("----start----")
po.close() #关闭进程池,关闭后po不再接收新的请求
po.join() #等待po中所有子进程执行完成,必须放在close语句之后
print("-----end-----")
进程间通信(Process)
from multiprocessing import Process, Queue
import os,time,random
def write(tempQ):
for value in ["a","b","c"]:
print("put value(%s) in Queue"%value)
tempQ.put(value)
time.sleep(random.randint(0,5))
def read(tempQ):
while True:
if not tempQ.empty():
value = tempQ.get()
print("get value(%s) in Queue"%value)
time.sleep(random.randint(0,5))
else:
break
if __name__ == "__main__":
# 可以理解为全局容器,共享参数
q = Queue()
pw = Process(target=write,args=(q,))
pr = Process(target=read,args=(q,))
pw.start()
pw.join()
pr.start()
pr.join()
print("*"*50)
print("数据读写完毕")
进程间通信(Pool)
#修改import中的Queue为Manager
from multiprocessing import Manager,Pool
import os,time,random
def reader(q):
print("reader启动(%s),父进程为(%s)"%(os.getpid(),os.getppid()))
for i in range(q.qsize()):
print("reader从Queue获取到消息:%s"%q.get(True))
def writer(q):
print("writer启动(%s),父进程为(%s)"%(os.getpid(),os.getppid()))
for i in "dongGe":
q.put(i)
if __name__=="__main__":
print("(%s) start"%os.getpid())
q=Manager().Queue() #使用Manager中的Queue来初始化
po=Pool()
#使用阻塞模式创建进程,这样就不需要在reader中使用死循环了,可以让writer完全执行完成后,再用reader去读取
po.apply(writer,(q,))
po.apply(reader,(q,))
po.close()
po.join()
print("(%s) End"%os.getpid())
线程(Thread)
from threading import Thread
import time
def log():
print("9999")
time.sleep(1)
if __name__ == "__main__":
for i in range(1,10):
t = Thread(target=log)
t.start()
线程子类
import threading
import time
class MyThread(threading.Thread):
def run(self):
for i in range(3):
time.sleep(1)
msg = "I'm "+self.name+' @ '+str(i) #name属性中保存的是当前线程的名字
print(msg)
if __name__ == '__main__':
t = MyThread()
t.start()
多线程访问数据需要同步锁(互斥锁)iOS中的锁介绍
两种锁的加锁原理:
互斥锁:线程会从sleep(加锁)——>running(解锁),过程中有上下文的切换(主动出让时间片,线程休眠,等待下一次唤醒),cpu的抢占,信号的发送等开销。
自旋锁:线程一直是running(加锁——>解锁),死循环(忙等 do-while)检测锁的标志位,机制不复杂。
互斥无非就是锁等待的时候是休眠的,等待通知唤醒,减少CPU的占用,还有一张是自旋锁,一直在轮询(while 1),占用cpu,因此互斥效率低,但是占cpu少,自旋效率高,占cpu多
from threading import Thread, Lock
import time
g_num = 0
def test1():
global g_num
for i in range(1000000):
#True表示堵塞 即如果这个锁在上锁之前已经被上锁了,那么这个线程会在这里一直等待到解锁为止
#False表示非堵塞,即不管本次调用能够成功上锁,都不会卡在这,而是继续执行下面的代码
mutexFlag = mutex.acquire(True)
if mutexFlag:
g_num += 1
mutex.release()
print("---test1---g_num=%d"%g_num)
def test2():
global g_num
for i in range(1000000):
mutexFlag = mutex.acquire(True) #True表示堵塞
if mutexFlag:
g_num += 1
mutex.release()
print("---test2---g_num=%d"%g_num)
#创建一个互斥锁
#这个所默认是未上锁的状态
mutex = Lock()
p1 = Thread(target=test1)
p1.start()
p2 = Thread(target=test2)
p2.start()
print("---g_num=%d---"%g_num)
通过超时可以解决互斥锁,例如网络请求设置超时可以进行下一步展示,互斥锁也一样,长时间导致死锁,可以通过超时来重启。
还有一个就是从头解决问题,银行家算法
异步
- 同步调用就是你 喊 你朋友吃饭 ,你朋友在忙 ,你就一直在那等,等你朋友忙完了 ,你们一起去
- 异步调用就是你 喊 你朋友吃饭 ,你朋友说知道了 ,待会忙完去找你 ,你就去做别的了。
from multiprocessing import Pool
import time
import os
def test():
print("---进程池中的进程---pid=%d,ppid=%d--"%(os.getpid(),os.getppid()))
for i in range(3):
print("----%d---"%i)
time.sleep(1)
return "hahah"
def test2(args):
print("---callback func--pid=%d"%os.getpid())
print("---callback func--args=%s"%args)
pool = Pool(3)
pool.apply_async(func=test,callback=test2)
time.sleep(5)
print("----主进程-pid=%d----"%os.getpid())
以上重点知识点,和iOS中一样
1.线程,进程
2.并发并行
3.死锁
4.线程同步
Python3基础(1)
Python3面向对象(2)