顾名思义，进程即正在执行的一个过程。进程是对正在运行程序的一个抽象。

进程的概念起源于操作系统，是操作系统最核心的概念，也是操作系统提供的最古老也是最重要的抽象概念之一。操作系统的其他所有内容都是围绕进程的概念展开的。

即使可以利用的cpu只有一个（早期的计算机确实如此），也能保证支持（伪）并发的能力。将一个单独的cpu变成多个虚拟的cpu（多道技术：时间多路复用和空间多路复用+硬件上支持隔离），没有进程的抽象，现代计算机将不复存在。

进程的概念：
　　进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。　　在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。

　狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。
　广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。

线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。
    1.新建状态(New)：
        当用new操作符创建一个线程时， 例如new Thread(r)，线程还没有开始运行，此时线程处在新建状态。 当一个线程处于新生状态时，程序还没有开始运行线程中的代码
     2.就绪状态(Runnable)
        一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。
        处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。
    3.运行状态(Running)
        当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法.

    4. 阻塞状态(Blocked)
        线程运行过程中，可能由于各种原因进入阻塞状态:
        1>线程通过调用sleep方法进入睡眠状态；
        2>线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
        3>线程试图得到一个锁，而该锁正被其他线程持有；
        4>线程在等待某个触发条件；
           ......
        所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态。

    5. 死亡状态(Dead)
        有两个原因会导致线程死亡：
         1) run方法正常退出而自然死亡，
         2) 一个未捕获的异常终止了run方法而使线程猝死。
        为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态且不是可运行的， 或者线程死亡了，则返回false.

进程三种状态间的转换
一个进程在运行期间，不断地从一种状态转换到另一种状态，它可以多次处于就绪状态和执行状态，也可以多次处于阻塞状态。 
A. 就绪—>执行
处于就绪状态的进程，当进程调度程序为之分配好了处理机后，该进程便由就绪状态转换为执行状态；
B. 执行—>就绪 
处于执行状态的进程在其执行过程中，因分配给它的一个时间片已经用完而不得不让出处理机，于是进程从执行状态转换为就绪状态；
C. 执行—>阻塞
正在执行的进程因等待某种事件发生而无法继续执行时，便从执行状态变成阻塞状态；
D. 阻塞—>就绪
处于阻塞状态的进程，若其等待的事件已经发生，于是进程便从阻塞状态转变为就绪状态。

1 p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
2 p.name:进程的名称
3 p.pid：进程的pid
4 p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
5 p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）

在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制)，在创建子进程的时候会自动 import 启动它的这个文件，而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ ==‘__main__’ 判断保护起来，import 的时候  ，就不会递归运行了。

p.start()：启动进程，并调用该子进程中的p.run()    #异步非阻塞
p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁    异步非阻塞
p.is_alive():如果p仍然运行，返回True
p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程   同步阻塞

方法介绍

import time
import os
from multiprocessing import Process
def func ():
    time.sleep(1)
    print(1,os.getpid(),os.getppid())

if __name__ == '__main__':
    #异步执行func,在一秒钟的时间通过生成多个子进程来执行多个func
    #1.先实例化
    #2.实例化对象.start()
    # 目标函数：target=
    Process(target=func).start()   #process类通知操作系统要为当前代码快在开辟一个进程，是异步过程

import time
from multiprocessing import Process
class Myprocess(Process): #继承Process类
    def __init__(self,name):  #重新父类的__init__方法
        super().__init__()
        self.name =name

    def run(self):  #必须是run函数名
        print(os.getpid(),os.getppid(),'我爱你%s' % self.name)
        time.sleep(3)
if __name__ == '__main__':
    start_time = time.time()
    p1 = Myprocess('kobe')
    p2 = Myprocess('kobe')
    p3 = Myprocess('kobe')
    p1.start()
    p2.start()
    p3.start()
    p1.join()  #阻塞，直到p1对应的进程结束之后，才结束阻塞，是异步阻塞，阻塞等待一个子进程结束
    p2.join()
    p3.join()
    print(time.time()-start_time)
    ##阻塞一个子进程：p.join()
    #阻塞多个子进程，将子进程加入到列表，然后分别阻塞
'''
10600 9384 我爱你kobe
10448 9384 我爱你kobe
10032 9384 我爱你kobe
1.1659998893737793
从上面结果来看，我们知道join也是异步阻塞的，在同一秒钟分别执行了p1,p2,p3的time.sleep()
和我本来预想的要阻塞3s+是结果是不同的
'''

import time
import random
from multiprocessing import Process

def send_mail(name):
    time.sleep(random.uniform(1,3))
    print('已经给%s发送邮件完毕'%name)

if __name__ == '__main__':
    lst = ['kobe','jordan','admin','t-mac']
    #阻塞等待一个子进程结束
    p = Process(target=send_mail, args=('alex',))
    p.start()
    p.join()   # 阻塞,直到p对应的进程结束之后才结束阻塞
    print('所有的信息都发送完毕了')

    #阻塞多个子进程，将子进程加入到列表，然后分别阻塞
    p_l = []
    for name in lst:
        p = Process(target=send_mail,args=(name,))  #args必须是元组类型
        p.start()
        # p.join()   #这种就是同步阻塞
        p_l.append(p)
    for p in p_l : p.join()  #异步阻塞
    print('所有的信息都发送完毕了')

#守护进程       #主进程结束 守护进程也结束  然后子进程结束
import time
from multiprocessing import Process
def func():
    while True:
    # for i in range(20):
        time.sleep(0.5)
        print('in func')
def func2():
    print('start: func2')
    time.sleep(5)
    print('end: func2')

if __name__ == '__main__':
    p = Process(target=func)

    p.daemon = True         #表示设置p为一个守护进程
    p.start()               #结束主代码，结束  不管子进程
    p2 = Process(target=func2)
    p2.start()
    print('in main')
    time.sleep(3)
    print('finished')
    # p.join()           # 这样可以 子进程 。阻塞在这  可以等到子进程也结束

#为什么主进程要等待子进程结束之后再结束那？
    #守护进程首先是子进程，守护的是主进程
    #因为主进程要负责给子进程回收一些系统资源
    #p.daemon= True
    #p.start()
#守护进程的结束条件是主进程的代码全部结束之后再结束子进程,而不是等待主进程结束全部，因为主进程也要给守护进程回收资源

#将所有的进程都join住，守护进程就能在所有的子进程执行完毕之后再退出

import json
import time
from multiprocessing import Process,Lock
def search_ticket(name):
    with open('ticket',encoding='utf-8') as f:
        dic = json.load(f)
        print('%s查询余票为%s'%(name,dic['count']))

def buy_ticket(name):
    with open('ticket',encoding='utf-8') as f:
        dic = json.load(f)
    time.sleep(2)
    if dic['count'] >= 1:
        print('%s买到票了'%name)
        dic['count'] -= 1
        time.sleep(2)
        with open('ticket', mode='w',encoding='utf-8') as f:
            json.dump(dic,f)
    else:
        print('余票为0,%s没买到票' % name)

def use(name,lock):
    search_ticket(name)
    print('%s在等待'%name)
    # lock.acquire()   #得到锁
    # print('%s开始执行了'%name)
    # buy_ticket(name)
    # lock.release()  #将锁归还
    with lock:    #lock的with上下文管理，，lock是互斥锁，其中Lock()方法里面包含acquire()方法和release()方法，使用装饰器也能完成此功能！
        print('%s开始执行了'%name)
        buy_ticket(name)

if __name__ == '__main__':
    lock = Lock()
    l = ['admin','kebi','and0ne','jordan']
    for name in l:
        Process(target=use,args=(name,lock)).start()

from multiprocessing import Queue, Process  #导入队列模块和多进程模块

def son(q):
    print(q.get())   #用户接受一个数据

if __name__ == '__main__':
    q = Queue()   #实例化一个队列对象
    print(q)
    Process(target=son, args=(q,)).start()
    q.put('wahaha')  #队列存入一个数据

import time
import random
from multiprocessing import Process,Queue
def producer(q):   #生产者
    for i in range(10):
        time.sleep(random.random())     #用来模拟爬虫子在爬取资料的时间
        food = '泔水%s'%i
        print('%s生产了%s'%('taibai',food))
        q.put(food)                     #将资料加入队列里面，以后会加入到redis或者rbMQ里面做分布式

def consumer(q,name): #消费者
    while True:
        food = q.get()   # food = 食物/None
        if not food : break           #判断时候为空，为空说明队列已经没数据了，就退出
        time.sleep(random.uniform(1,2))     #模拟客户端出来数据的时间
        print('%s 吃了 %s'%(name,food))   #模拟出来好的数据展示，以后可能存入数据库

if __name__ == '__main__':
    q = Queue()                      #创建一个队列
    p1 = Process(target=producer,args=(q,))           #创建一个生产者对象
    p1.start()
    c1 = Process(target=consumer,args=(q,'kobe'))    #创建消费者对象p1
    c1.start()
    c2 = Process(target=consumer,args=(q,'admin'))   #创建消费者对象p2
    c2.start()
    c3 = Process(target=consumer,args=(q,'james'))   #创建消费者对象p3
    c3.start()
    p1.join()
    #将p1 join住，如果p1对象执行完毕，说明生产者数据已经生产完毕，在等待消费者消费,并且生产者应该发送一个结束信号none
    # 如果不加p1.join()和不发送None信号，此时的问题是主进程永远不会结束，原因是：生产者p在生产完后就结束了，但是消费者c在取空了q之后，
    # 则一直处于死循环中且卡在q.get()这一步。
    # 解决方式无非是让生产者在生产完毕后，往队列中再发一个结束信号，这样消费者在接收到结束信号后就可以break出死循环。
    #比较笨的方法是有几个消费者对象就要发几个None
    q.put(None)
    q.put(None)
    q.put(None)

生产者和消费者模型

#也是多进程并发的实现
import time
import random
from multiprocessing import JoinableQueue,Process
def consumer(jq,name):
    while True:
        food = jq.get()
        time.sleep(random.uniform(1,2))
        print('%s 吃完了 %s'%(name,food))
        jq.task_done()  #通知producer里面的jq.join()，要将队列里面的计数器-1，因为有一个数据被取走了，当所有的任务处理完之后，队列的计数器为0
                        #当生产者的队列为空时，while True会hold住，等待队列中进入数据，再次读取！
                        #怎么来退出此子进程那？，通过守护进程
def producer(jq):
    for item in range(10):
        time.sleep(random.random())
        food = '香肠%s'%item
        print('%s生产了 %s'%('jordan',food))
        jq.put(food)
    jq.join()          # 队列的join结束，说明队列里面的数据已经被消费者消费完了，producer函数运行完毕，不在继续生产了，
                       # 当jq.join()结束之后，说明下面阻塞的p1.join()也结束了，因为p1.join()在等待子进程执行完毕

if __name__ == '__main__':
    jq = JoinableQueue()  #实例化对象
    c1 = Process(target=consumer,args=(jq,'kobe'))
    c2 = Process(target=consumer,args=(jq,'admin'))
    p1 = Process(target=producer,args=(jq,))
    c1.daemon = True  #将c1设置成守护进程，在主进程的全部代码都执行完之后，才关闭
    c2.daemon = True  #将c2设置成守护进程，在主进程的全部代码都执行完之后，才关闭
    c1.start()
    c2.start()
    p1.start()
    p1.join()   #p1的进程阻塞结束之后，c1的守护进程就结束了，
                # 因为执行到主程序代码的最后了，所以守护进程c1,c2都在主进程代码执行结束之后就退出了
                #所以当守护进程退出时候，while True退出！

#c1.daemon= True  #将consumer设置成守护进程，在主进程的全部代码都执行完之后，才关闭
#jq.task_donw()通知producer，要将队列里面的计数器-1，当所有的任务处理完之后，队列的计数器为0
#jq.join()  队列的join结束，producer函数运行完毕
#p1.join()  p1的进程阻塞结束之后，c1的守护进程就结束了

JoinableQueue的实例p除了与Queue对象相同的方法之外，还具有以下方法：

q.task_done()
使用者使用此方法发出信号，表示q.get()返回的项目已经被处理。如果调用此方法的次数大于从队列中删除的项目数量，将引发ValueError异常。

q.join()
生产者将使用此方法进行阻塞，直到队列中所有项目均被处理。阻塞将持续到为队列中的每个项目均调用q.task_done()方法为止。
下面的例子说明如何建立永远运行的进程，使用和处理队列上的项目。生产者将项目放入队列，并等待它们被处理

import os
import time
from concurrent.futures import ProcessPoolExecutor
def make(i):
    time.sleep(1)
    print('%s 制作螺丝%s'%(os.getpid(),i))
    return i**2

if __name__ == '__main__':
    p = ProcessPoolExecutor(4)   # 创建一个进程池
    for i in range(100):
        p.submit(make,i)   # 向进程池中提交任务，submit返回值是一个Future对象!使用result从中取值!
    p.shutdown()  # 阻塞 直到池中的任务都完成为止
    print('所有的螺丝都制作完了')
    p.map(make,range(100)) # submit的简便用法

import os
import time
from concurrent.futures import ProcessPoolExecutor
def make(i):
    time.sleep(1)
    print('%s 制作螺丝%s'%(os.getpid(),i))
    return i**2

if __name__ == '__main__':
    p = ProcessPoolExecutor(4)   # 创建一个进程池
    ret = p.map(make, range(100))  #是for循环的简便写法，一般只用于传递一个参数
    #ret=返回的是返回的是生成器，再循环就可以了
    for i in ret:
        print(i)
    #为什么ret返回的是一个对象？
        # 如果返回一个结果，就要在返回结果的时候阻塞了

if __name__ == '__main__':主要作用就是查看文件的运行方式
在python中，每个文件a.py(模块)都包含内置的变量__name__
1.作为脚本直接执行
    a.py的__name__默认等于__main__，也就是此时文件的名字a.py,此时if __name__ == '__main__'下的所有代码都会执行
2.当被inport其他文件中时
    a.py的__name__等于这个这个文件的名字a，不包含.py后缀，此时if __name__ == '__main__'下的代码不会执行

windows创建多线程
   需要注意的是windows创建多线程和linux上是不同的。
   windows上子进程启动的时候会自动的import启动其文件。如果不加上if __name__ == '__main__':的话，子进程会无限循环的import
   所以必须使用if __name__ == '__main__'将子进程启动保护起来，当import的时候，第一次的__name__=='__mian__'中的name是等于
   __main__也就是等于import的文件的名字(包含)后缀，当inport之后，__name__就等于文件的名字(不包含后缀),所以只是执行一次

Linux创建进程
   https://blog.csdn.net/wujiafei_njgcxy/article/details/77116175

def func():
    pass
from multiprocessing import Process
if __name__ == '__main__':  #主要用来区分脚本的运行方式
    c = Process(target=func).start()
    a = 1
    print(__name__)
print(a)

通过运行上述代码，会得到 name a not defined ，并且会打印1
因为在执行的时候子进程会import 这个文件到其自己的内存空间，当执行到if __name__ == '__main__':的时候会得出
__name__ 等于的是import的名字，并不等于__main__
所以不会执行 if语句，但是后面有一个peint(a),a没有被定义在子进程的内存空间里面，所以会爆a未定义

那个1又是谁打印的那？肯定是父进程打印的，当父进程创建子进程并运行子进程之后，会继续向下执行，a = 1，所以会打印1

import time
from multiprocessing import Process,Manager
def func(dic):
    dic ['count'] -=1
if __name__ == '__main__':
    m = Manager()
    dic = m.dict({'count':100})
    p_list =[]
    for i in range(100):
        p = Process(target=func,args=(dic,))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print(dic)

from multiprocessing import Process,Manager,Lock
def func(dic,lock):
    with lock:
        dic ['count'] -=1
if __name__ == '__main__':
    m = Manager()
    lock = Lock()
    dic = m.dict({'count':100})
    # dic =
    p_list =[]
    for i in range(100):
        p = Process(target=func,args=(dic,lock))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print(dic)