Python框架django并发

并行和并发的区别

学习多线程的时候会遇到一个名词：并发。这是属于操作系统中的词汇，需要了解并发和并行的区别，从网上搜集了几种说法帮助理解。
一：
并发是指一个处理器同时处理多个任务。
并行是指多个处理器或者是多核的处理器同时处理多个不同的任务。
并发是逻辑上的同时发生（simultaneous），而并行是物理上的同时发生。
来个比喻：并发是一个人同时吃三个馒头，而并行是三个人同时吃三个馒头。
二：
并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。就好像两个人各拿一把铁锨在挖坑，一小时后，每人一个大坑。所以无论从微观还是从宏观来看，二者都是一起执行的。

并发(concurrency)：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。这就好像两个人用同一把铁锨，轮流挖坑，一小时后，两个人各挖一个小一点的坑，要想挖两个大一点得坑，一定会用两个小时。

并行在多处理器系统中存在，而并发可以在单处理器和多处理器系统中都存在，并发能够在单处理器系统中存在是因为并发是并行的假象，并行要求程序能够同时执行多个操作，而并发只是要求程序假装同时执行多个操作（每个小时间片执行一个操作，多个操作快速切换执行）。
三：
当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程,它只能把CPU运行时间划分成若干个时间段,再将时间段分配给各个线程执行,在一个时间段的线程代码运行时,其它线程处于挂起状态.这种方式我们称之为并发(Concurrent)。

当系统有一个以上CPU时,则线程的操作有可能非并发.当一个CPU执行一个线程时,另一个CPU可以执行另一个线程,两个线程互不抢占CPU资源,可以同时进行,这种方式我们称之为并行(Parallel)。

进程和线程的区别

1. 先来看没有引入线程概念的执行情况，总耗时6秒钟

from time import sleep,ctime,time
import logging

logging.basicConfig(level=logging.INFO)

def loop0():
    logging.info("start loop0 at" + ctime())
    sleep(4)
    logging.info("end loop0 at"+ctime())

def loop1():
    logging.info("start loop1 at" + ctime())
    sleep(2)
    logging.info("end loop1 at"+ctime())

def main():
    logging.info("start all at"+ctime())
    loop0()
    loop1()
    logging.info("end all at"+ctime())

# print(ctime(),time())

if __name__ == '__main__':
    main()

2.这里引入线程并行执行，总耗时4秒钟

# -*- coding:utf-8 -*-
#@time:2021-08-15 15:47:15
#@Author:Anonymous
#@file:main.py
import _thread
from time import sleep,ctime,time
import logging

logging.basicConfig(level=logging.INFO)

def loop0():
    logging.info("start loop0 at" + ctime())
    sleep(4)
    logging.info("end loop0 at"+ctime())

def loop1():
    logging.info("start loop1 at" + ctime())
    sleep(2)
    logging.info("end loop1 at"+ctime())

def main():
    logging.info("start all at"+ctime())
    _thread.start_new_thread(loop0,())
    _thread.start_new_thread(loop1,())
    sleep(4)#这里需要加sleep，不然主线程退出，所有的子线程都会被强制杀掉。_thread的缺点，它没有守护线程的概念。
    logging.info("end all at"+ctime())

# print(ctime(),time())

if __name__ == '__main__':
    main()

3.从上面我们可以看见主函数这里需要加sleep等待时间，有时候我们不知道要等待多久，需要使用到加锁

import _thread
from time import sleep,ctime,time
import logging

logging.basicConfig(level=logging.INFO)

loops=[2,4]
def loop(nloop,nsec,lock): #nloop第几个loop,nsec,循环多久，lock 锁
    logging.info("start loop"+str(nloop)+" at" + ctime())
    sleep(nsec)
    logging.info("end loop"+str(nloop)+" at" +ctime())
    lock.release()

def main():
    logging.info("start all at"+ctime())
    locks=[]
    nloops=range(len(loops)) #算出长度为2
    for i in nloops:
        lock=_thread.allocate_lock()    #生成一个锁
        lock.acquire()  #把这个锁给锁上
        locks.append(lock) #加锁操作
    for i in nloops:
        _thread.start_new_thread(loop,(i,loops[i],locks[i]))    #依次取出二个锁，每开启一个线程启用一个锁，和第一个循环分开。
    for i in nloops:
        while locks[i].locked():pass  #判断锁是否被释放，如果锁上，返回True，如果未锁上返回false退出循环

    logging.info("end all at"+ctime())

# print(ctime(),time())

if __name__ == '__main__':
    main()

4.以上是_thread,我们来看一下threading写法

import threading
from time import sleep,ctime,time
import logging

logging.basicConfig(level=logging.INFO)

loops=[2,4]
def loop(nloop,nsec): #nloop第几个loop,nsec,循环多久，lock 锁
    logging.info("start loop"+str(nloop)+" at" + ctime())
    sleep(nsec)
    logging.info("end loop"+str(nloop)+" at" +ctime())

def main():
    logging.info("start all at"+ctime())
    threads=[]
    nloops=range(len(loops)) #算出长度为2

    for i in nloops:
        t=threading.Thread(target=loop,args=(i,loops[i]))   #执行loop函数
        threads.append(t)
    for i in nloops:
        threads[i].start()
    for i in nloops:
        threads[i].join()    #判断是否结束，未结束一直阻碍主进程

    logging.info("end all at"+ctime())

# print(ctime(),time())

if __name__ == '__main__':
    main()

5.threading重新构造类的写法

# -*- coding:utf-8 -*-
#@time:2021-08-15 15:47:15
#@Author:Anonymous
#@file:main.py
import _thread
import threading
from time import sleep,ctime,time
import logging

logging.basicConfig(level=logging.INFO)

loops=[2,4]
class MyThread(threading.Thread):   #继承类，重写构造类，函数，参数，名字
    def __init__(self,func,args,name=''):
        threading.Thread.__init__(self)
        self.func=func
        self.args=args
        self.name=name
    def run(self):
        self.func(*self.args)

def loop(nloop,nsec): #nloop第几个loop,nsec,循环多久
    logging.info("start loop"+str(nloop)+" at" + ctime())
    sleep(nsec)
    logging.info("end loop"+str(nloop)+" at" +ctime())

def main():
    logging.info("start all at"+ctime())
    threads=[]
    nloops=range(len(loops)) #算出长度为2
    print(nloops)

    for i in nloops:
        t=MyThread(loop,(i,loops[i]))
        threads.append(t)
    for i in nloops:
        threads[i].start()
    for i in nloops:
        threads[i].join()    #判断是否结束，未结束一直阻碍主进程

    logging.info("end all at"+ctime())

# print(ctime(),time())

if __name__ == '__main__':
    main()

更深入可以去了解原语（锁，信号量）