浅谈进程及线程

**进程：**一个运行的程序（代码）就是一个进程，没有运行的代码叫程序，进程是系统资源分配的最小单位，进程拥有自己独立的内存空间，所有进程间数据不共享，开销大。

**僵尸进程：**进程使用fork创建子进程，如果子进程退出，而父进程没有调用wait获取waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中的这些进程是僵尸进程。

**孤儿进程：**父进程退出，子进程还在运行的这些子进程都是孤儿进程，孤儿进程将被init进程（进程号为1）所收养，并由init进程对他们完成状态收集工作。

避免僵尸进程的方法：
fork两次用孙子进程去完成子进程的任务
用wait()函数使父进程阻塞
使用信号量，在signal handler中调用waitpid，这样父进程不用阻塞。
创建进程：

import os
from mulitprocessing import Process
import time
def pro_great(*args):
    for i in range(5):
        print("子进程正在运行中,pid=%d"%(,os.getpid())
        time.sleep(1)
if __name__ =="__main__":
    #创建Process对象
    p = Process(target=pro_great,kwargs={'m':20})
    #启动进程
    p.start()
    p.join()

创建进程池：

import time
import os
from multiprocessing import Pool
def jcc(num):
    print(num)
    print('进程已经创建id为%d'%os.getpid())
    time.sleep(1)
if __name__ == '__main__':
    p = Pool(3)
    for i in range(20):
        p.apply_async(jcc,(i,))
    p.close()
    p.join()

进程间的交互：
进程间的交互需要用到队列Queue

import time,os
from multiprocessing import *
def writ(q):
    listq=['a','c','v','n']
    for i in listq:
        q.put(i)
    time.sleep(3)
def reado(q):
    while True:
        if not q.empty():
            print(q.get())
        else:
            break
if __name__ == '__main__':
    q = Queue()
    qw = Process(target=writ,args=(q,))
    qw.start()
    qw.join()

    qe = Process(target=reado,args=(q,))
    qe.start()
    qe.join()

**线程：**cpu调度执行的最小单位，也叫执行路径，不能独立存在，以来进程存在，一个进程至少有一个线程，叫做主线程，而多个线程共享内存（数据共享，共享全局变量），从而极大地提高了程序的运行效率。

线程同步：

setDaemon(False)当一个进程启动之后，会默认产生一个主线程，因为线程是程序执行的最小单位，当设置多线程时，主线程会创建多个子线程，在python中，默认情况下就是setDaemon(False)主线程执行完自己的任务以后，就退出了，此时子线程会继续执行自己的任务，知道自己的任务结束。

例子：

import threading 
import time
 
def thread():
    time.sleep(1)
    print('---子线程结束---')
 
def main():
    t1 = threading.Thread(target=thread)
    t1.start()
    print('---主线程--结束')
 
if __name__ =='__main__':
    main()

#执行结果
setDaemon(True)当我们使用setDaemon(True)时，这是子线程为守护线程，主线程一旦执行结束，则全部子线程被强制终止。
例子：

import threading
import time
def thread():
    time.sleep(2)
    print('---子线程结束---')
def main():
    t1 = threading.Thread(target=thread)
    t1.setDaemon(True)#设置子线程守护主线程
    t1.start()
    print('---主线程结束---')
 
if __name__ =='__main__':
    main()

#执行结果
#只有主线程结束，子线程来不及执行就被强制结束
join(线程同步)join所完成的工作就是线程同步，即主线程任务结束以后，进入阻塞状态，一直等待所有的子线程结束以后，主线程再终止。

当设置守护线程时，含义是主线程对于子线程等待timeout的时间将会杀死该子线程，最后退出程序，所以说，如果有10个子线程，全部的等待时间就是每个timeout的累加和，简单的来说，就是给每个子线程一个timeout的时间，让他去执行，时间一到，不管任务有没有完成，直接杀死。

没有设置守护线程时，主线程将会等待timeout的累加和这样一段时间，时间一到，主线程结束，但是并没有杀死子线程，子线程依然可以继续执行，直到子线程全部结束，程序退出。

例子：

import threading
import time
 
def thread():
    time.sleep(2)
    print('---子线程结束---')
 
def main():
    t1 = threading.Thread(target=thread)
    t1.setDaemon(True)
    t1.start()
    t1.join(timeout=1)
          #1 线程同步，主线程堵塞1s 然后主线程结束，子线程继续执行
          #2 如果不设置timeout参数就等子线程结束主线程再结束
          #3 如果设置了setDaemon=True和timeout=1主线程等待1s后会强制杀死子线程，然后主线程结束
    print('---主线程结束---')
 
if __name__=='__main___':
    main()

多线程竞争及解决方法
线程是非独立的，同一个进程里线程的数据是共享的，当各个线程访问数据资源时会出现竞争状态，即：数据几乎同步会被多个线程占用，造成数据混乱，即所谓的线程不安全。
**解决多线程问题的方法：**锁。
锁的好处：确保了某段关键代码（共享数据资源）只能有一个线程从头到尾完整地执行能解决多线程资源竞争下的原子操作问题。
锁的坏处：阻止了多线程并发执行，包含锁的某段代码实际上只能单线程执行，效率就打打地下降了。
**锁的致命问题：**死锁。
锁（Lock）是python提供的对线程控制的对象。有互斥锁、可重入锁、死锁。
死锁：若干子线程在系统资源竞争时，都在等待对方对某部分资源解除占用状态，结果师谁也不愿意先解锁，互相等待，程序无法执行下去，这就是死锁。
GIL锁 全局解释器锁（只在cython里才有）
**作用：**限制多线程同时执行，保证同一时间只有一个线程执行，所以cython里的多线程其实是伪多线程。
所以在python里常常使用协程技术来代替多线程，协程是一种更轻量级的线程。
进程和线程的切换时由系统决定，而协程有我们程序员自己决定，而模块gevent下切换是遇到了耗时操作才会切换。
**互斥锁：**每个对象都对应于一个可称为’互斥锁‘的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
同一进程中的多线程之间是共享系统资源的，多个线程同时对一个对象进行操作，一个线程操作尚未结束，另一个线程已经对其进行操作，导致最终结果出现错误，此时需要对被操作对象添加互斥锁，保证每个线程对该对象的操作都得到正确的结果。