python_进程和线程

python多线程和多进程

**大部分操作系统(如Windows、Linux)的任务调度是采用时间片轮转的抢占式调度方式，也就是说一个任务执行一小段时间后强制暂停去执行下一个任务，每个任务轮流执行。任务执行的一小段时间叫做时间片，任务正在执行时的状态叫运行状态，任务执行一段时间后强制暂停去执行下一个任务，被暂停的任务就处于就绪状态等待下一个属于它的时间片的到来。这样每个任务都能得到执行，由于CPU的执行效率非常高，时间片非常短，在各个任务之间快速地切换，给人的感觉就是多个任务在“同时进行”，这也就是我们所说的并发(一个时间间隔内,多个任务同时进行).**

进程

 	**计算机的核心是CPU，承担所有计算任务；操作系统是计算机管理者，负责任务的调度、资源的分配和管理，统领整个计算机硬件；应用程序侧是具有某种功能的程序，程序是运行于操作系统之上的。 
进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的载体。
进程是一种抽象的概念，从来没有统一的标准定义。进程一般由程序、数据集合和进程控制块三部分组成。程序用于描述进程要完成的功能，是控制进程执行的指令集；数据集合是程序在执行时所需要的数据和工作区；程序控制块(Program Control Block，简称PCB)，包含进程的描述信息和控制信息，是进程存在的唯一标志。 

进程具有的特征： 动态性：进程是程序的一次执行过程，是临时的，有生命期的，是动态产生，动态消亡的； 并发性：任何进程都可以同其他进程一起并发执行；
独立性：进程是系统进行资源分配和调度的一个独立单位；
结构性：进程由程序、数据和进程控制块三部分组成。**

线程和进程的区别：

区别1：

区别2：

模拟单线程

import time
import threading
def music(name,loop):
    for i in range(loop):
        print('listen music %s %s'%(name,time.ctime()))
        time.sleep(1)
def moive(name,loop):
    for i in range(loop):
        print('listen music %s %s'%(name,time.ctime()))
        time.sleep(1)
music('可能否',3)
moive('肖申克的救赎',4)

执行结果：
listen music 可能否 Fri Mar 15 09:25:08 2019
listen music 可能否 Fri Mar 15 09:25:09 2019
listen music 可能否 Fri Mar 15 09:25:10 2019
listen music 肖申克的救赎 Fri Mar 15 09:25:11 2019
listen music 肖申克的救赎 Fri Mar 15 09:25:12 2019
listen music 肖申克的救赎 Fri Mar 15 09:25:13 2019
listen music 肖申克的救赎 Fri Mar 15 09:25:14 2019

多线程模拟

import time
import threading
def music(name,loop):
    for i in range(loop):
        print('listen music %s %s'%(name,time.ctime()))
        time.sleep(1)
def moive(name,loop):
    for i in range(loop):
        print('listen music %s %s'%(name,time.ctime()))
        time.sleep(1)
t1=threading.Thread(target=music,args=('可能否',4))
t2=threading.Thread(target=moive,args=('肖申克的救赎',4))
#开启线程。
t1.start()
t2.start()

输出结果：
listen music 可能否 Fri Mar 15 09:34:26 2019
listen music 肖申克的救赎 Fri Mar 15 09:34:26 2019
listen music 可能否 Fri Mar 15 09:34:27 2019listen music 肖申克的救赎 Fri Mar 15 09:34:27 2019
listen music 肖申克的救赎 Fri Mar 15 09:34:28 2019listen music 可能否 Fri Mar 15 09:34:28 2019
listen music 可能否 Fri Mar 15 09:34:29 2019
listen music 肖申克的救赎 Fri Mar 15 09:34:29 2019
注：这个执行顺序不能确定。

join：如在一个线程B中调用thread1.join()，则thread1结束后，线程B才会接着threada.join()往后运行。

阻塞主线程，先听歌再看电影，最后执行主线程。

import time
import threading
def music(name,loop):
    for i in range(loop):
        print('listen music %s %s'%(name,time.ctime()))
        time.sleep(1)
def moive(name,loop):
    for i in range(loop):
        print('listen music %s %s'%(name,time.ctime()))
        time.sleep(1)
t1=threading.Thread(target=music,args=('可能否',4))
t2=threading.Thread(target=moive,args=('肖申克的救赎',4))
#开启线程。
t1.start()
t2.start()

t1.join()
t2.join()
print(time.ctime())

输出结果：
listen music 可能否 Fri Mar 15 09:43:47 2019
listen music 肖申克的救赎 Fri Mar 15 09:43:47 2019
listen music 肖申克的救赎 Fri Mar 15 09:43:48 2019listen music 可能否 Fri Mar 15 09:43:48 2019
listen music 肖申克的救赎 Fri Mar 15 09:43:49 2019listen music 可能否 Fri Mar 15 09:43:49 2019
listen music 可能否 Fri Mar 15 09:43:50 2019listen music 肖申克的救赎 Fri Mar 15 09:43:50 2019
Fri Mar 15 09:43:51 2019

setDaemon：主线程A启动了子线程B，调用B.setDaemaon(True)，则主线程结束时，会把子线程B也杀死。必须在运行线程之前设置.

import time
import threading
def music(name,loop):
    for i in range(loop):
        print('listen music %s %s'%(name,time.ctime()))
        time.sleep(1)
def moive(name,loop):
    for i in range(loop):
        print('listen music %s %s'%(name,time.ctime()))
        time.sleep(1)
t1=threading.Thread(target=music,args=('可能否',4))
t2=threading.Thread(target=moive,args=('肖申克的救赎',4))
#开启线程。
t1.setDaemon(True)
t2.setDaemon(True)
t1.start()
t2.start()
# t1.join()
# t2.join()
print(time.ctime())

输出结果：listen music 可能否 Fri Mar 15 09:50:48 2019
listen music 肖申克的救赎 Fri Mar 15 09:50:48 2019Fri Mar 15 09:50:48 2019

进程写文件—单线程

def work_1(f,n):
    print('work_1 start')
    for i in range(n):
        with open(f,'a') as fs:
            fs.write('come on baby\n')
            time.sleep(1)
    print('work_1 end')
def work_2(f,n):
    print('work_2 start')
    for i in range(n):
        with open(f,'a') as fs:
            fs.write('come111 on222 baby222\n')
            time.sleep(1)
    print('work_2 end')
work_1('file.txt',3)
work_2('file.txt',3)

输出：
work_1 start
work_1 end
work_2 start
work_2 end

进程写文件—多进程

import multiprocessing
def work_1(f,n):
    print('work_1 start')
    for i in range(n):
        with open(f,'a') as fs:
            fs.write('come on baby\n')
            time.sleep(1)
    print('work_1 end')
def work_2(f,n):
    print('work_2 start')
    for i in range(n):
        with open(f,'a') as fs:
            fs.write('come111 on222 baby222\n')
            time.sleep(1)
    print('work_2 end')
if __name__=='__main__':
    p1=multiprocessing.Process(target=work_1,args=('file.txt',3))
    p2=multiprocessing.Process(target=work_2,args=('file.txt',3))
    p1.start()
    p2.start()

work_1 start
work_2 start
work_1 end
work_2 end

进程的通信

进程彼此之间互相隔离，要实现进程间通信（IPC）,multiprocessing模块支持两种形式：队列Queue和管道Pipe，这两种方式都是使用消息传递的