调试

python3 -m pdb xxx.py 执行进入第一行

并发和并行

参考链接

并发是指一个时间段内，有几个程序都在同一个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;
}

跨平台多进程（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")

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）