线程

python的线程和进程

考虑一个场景：浏览器，网易云音乐以及notepad++ 三个软件只能顺序执行是怎样一种场景呢？另外，假如有两个程序A和B，程序A在执行到一半的过程中，需要读取大量的数据输入（I/O操作），而此时CPU只能静静地等待任务A读取完数据才能继续执行，这样就白白浪费了CPU资源。你是不是已经想到在程序A读取数据的过程中，让程序B去执行，当程序A读取完数据之后，让程序B暂停。聪明，这当然没问题，但这里有一个关键词：切换。

既然是切换，那么这就涉及到了状态的保存，状态的恢复，加上程序A与程序B所需要的系统资源（内存，硬盘，键盘等等）是不一样的。自然而然的就需要有一个东西去记录程序A和程序B分别需要什么资源，怎样去识别程序A和程序B等等(比如读书)。

进程定义：

进程就是一个程序在一个数据集上的一次动态执行过程。进程一般由程序、数据集、进程控制块三部分组成。我们编写的程序用来描述进程要完成哪些功能以及如何完成；数据集则是程序在执行过程中所需要使用的资源；进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。

举一例说明进程：
想象一位有一手好厨艺的计算机科学家正在为他的女儿烘制生日蛋糕。他有做生日蛋糕的食谱，厨房里有所需的原料:面粉、鸡蛋、糖、香草汁等。在这个比喻中，做蛋糕的食谱就是程序(即用适当形式描述的算法)计算机科学家就是处理器(cpu)，而做蛋糕的各种原料就是输入数据。进程就是厨师阅读食谱、取来各种原料以及烘制蛋糕等一系列动作的总和。现在假设计算机科学家的儿子哭着跑了进来，说他的头被一只蜜蜂蛰了。计算机科学家就记录下他照着食谱做到哪儿了(保存进程的当前状态)，然后拿出一本急救手册，按照其中的指示处理蛰伤。这里，我们看到处理机从一个进程(做蛋糕)切换到另一个高优先级的进程(实施医疗救治)，每个进程拥有各自的程序(食谱和急救手册)。当蜜蜂蛰伤处理完之后，这位计算机科学家又回来做蛋糕，从他离开时的那一步继续做下去。

线程

的出现是为了降低上下文切换的消耗，提高系统的并发性，并突破一个进程只能干一样事的缺陷，使到进程内并发成为可能。

假设，一个文本程序，需要接受键盘输入，将内容显示在屏幕上，还需要保存信息到硬盘中。若只有一个进程，势必造成同一时间只能干一样事的尴尬（当保存时，就不能通过键盘输入内容）。若有多个进程，每个进程负责一个任务，进程A负责接收键盘输入的任务，进程B负责将内容显示在屏幕上的任务，进程C负责保存内容到硬盘中的任务。这里进程A，B，C间的协作涉及到了进程通信问题，而且有共同都需要拥有的东西——-文本内容，不停的切换造成性能上的损失。若有一种机制，可以使任务A，B，C共享资源，这样上下文切换所需要保存和恢复的内容就少了，同时又可以减少通信所带来的性能损耗，那就好了。是的，这种机制就是线程。
线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合和堆栈共同组成。线程的引入减小了程序并发执行时的开销，提高了操作系统的并发性能。线程没有自己的系统资源。

两者的关系

进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。或者说进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。
线程则是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。

进程和线程的关系：

(1)一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。
(2)资源分配给进程，同一进程的所有线程共享该进程的所有资源。
(3)CPU分给线程，即真正在CPU上运行的是线程。

并行处理（Parallel Processing）是计算机系统中能同时执行两个或更多个处理的一种计算方法。并行处理可同时工作于同一程序的不同方面。并行处理的主要目的是节省大型和复杂问题的解决时间。并发处理(concurrency Processing)：指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机(CPU)上运行，但任一个时刻点上只有一个程序在处理机(CPU)上运行

并发的关键是你有处理多个任务的能力，不一定要同时。并行的关键是你有同时处理多个任务的能力。所以说，并行是并发的子集

 

 在计算机领域，同步就是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到返回信息才继续执行下去；异步是指进程不需要一直等下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进程进行处理，这样可以提高执行的效率。举个例子，打电话时就是同步通信，发短息时就是异步通信。

开辟子线程需要的模块

Thread模块

import threading,time

def foo(n):

    time.sleep(0.5)

    print ('>>>>>>>>n')

    time.sleep(3)

 

t1=threading.Thread(target=foo,args=(2,))#创建子线程这个对象

t1.start()#启动

 

time.sleep(1)

print('ending K')

等待工具

当子线程结束了后，在完成主线程

用

t1.join()做阶段暂停，子线程不完成，父线程不结束

setDaemon守护线程

为了满足 主线程退出后 立刻关闭子线程

def foo(n):

    time.sleep(0.5)

    print ('>>>>>>>>n')

    time.sleep(3)

t1=threading.Thread(target=foo,args=(2,))#创建子线程这个对象

t1.setDaemon(True)#修改子线程为守护线程

t1.start()#启动

由主线程创建的子线程，默认继承了主线程的非守护线程的机制，所以我们会在主线程完成之后也需要等待非守护线程执行完成

io密集型任务 ：程序使用过程中含有大量的io操作

计算密集行任务：程序存在大量计算密集型操作，

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# __author__ = "wyd"
# Date: 2017/7/17

import threading
import time
def add(n):
    a=0
    for i in range(n):
        a+=i
    print(a)
def cheng(n):
    a=1
    for i in range(1,n):
        a*=i
    print(a)
s=time.time()#1.581054925918579
t1=threading.Thread(target=add,args=(10000000,))
t1.start()
t2=threading.Thread(target=cheng,args=(10000,))
t2.start()
t1.join()
t2.join()

print('线程耗时',time.time()-s)

s=time.time()
add(10000000)
cheng(10000)
print('非线程耗时',time.time()-s)#1.3426268100738525

对于python

多先处理上io操作有优势，但是计算密集型没有任何优势

这是因为 python在同一个进程下不可以利用多核优势gil锁，如果需要利用多核优势多进程比较好

event对象

如果两个独立运行的线程中，线程a需要线程b的一个结果，线程a需要控制b抛出一个结果，得到结果后a才能继续下去，我么要求满足这样的需求就需要event

这个叫做threading.event()他就好比 如果说thread.join()是让主线程等待子线程完成，那么event.wait()是让某一个线程阻塞。

 

 

event.isSet()：返回event的状态值；

 

event.wait()：如果 event.isSet()==False将阻塞线程；

这里的wait（）里面可以加时间值，就不会再等待set标志位了

 

event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；

 

event.clear()：恢复event的状态值为False。

import threading,time
event=threading.Event()
def foo()
        while not event.is_set():
            print('sleep to wait.....')
            event.wait(2)#在这里休息两秒阻塞主
        print(' connent to redis server' , n)

for i in range(10):
    t=threading.Thread(target=foo,args=(i,))
    t.start

print('redis sever started')
time.sleep(10000)
print('tedis start access.......')
event.set()#在这里修改成True

 列队（queue）

定义:他在非多线程里面是无用的。它是一种数据结构

他是为了保证线程的数据结构安全性

 

创建一个“队列”对象

import Queue
q = Queue.Queue(maxsize = 10)
Queue.Queue类即是一个队列的同步实现。队列长度可为无限或者有限。可通过Queue的构造函数的可选参数
maxsize来设定队列长度。如果maxsize小于0就表示队列长度无限。

将一个值放入队列中（如队）
q.put(10)
调用队列对象的put()方法在队尾插入一个项目。put()有两个参数，第一个item为必需的，为插入项目的值；
第二个block为可选参数，默认为
1。如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。如果block为0，
put方法将引发Full异常。

将一个值从队列中取出（出队）
q.get()
调用队列对象的get()方法从队头删除并返回一个项目。可选参数为block，默认为True。如果队列为空且
block为True，get()就使调用线程暂停，直至有项目可用。如果队列为空且block为False，队列将引发Empty异常。

补充

此包中的常用方法(q = Queue.Queue()):

q.qsize() 返回队列的大小
q.empty() 如果队列为空，返回True,反之False
q.full() 如果队列满了，返回True,反之False
q.full 与 maxsize 大小对应
q.get([block[, timeout]]) 获取队列，timeout等待时间
q.get_nowait() 相当q.get(False)非阻塞 
q.put(item) 写入队列，timeout等待时间
q.put_nowait(item) 相当q.put(item, False)
q.task_done() 在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号
q.join() 实际上意味着等到队列为空，再执行别的操作

 

共有三种类型

 

第一种：queue.Queue()#FIFO先进先出

这种就好比在一个整齐的队伍，从左面进入，从右面出去，第一个进去的人，第一个出去，好比扶梯

import queue
q=queue.Queue()#FIFO先进先出

##进队
q.put(11)
q.put('hellow')

##出队
print(q.get())
print(q.get())

join与task_done方法

他们的好处是，如果我想在列队中添加完这部分后，想等这部分全部清除出去，

也可以理解成，清空这个方法内添加的列队内容

join() 阻塞进程，直到所有任务完成，需要配合另一个方法task_done。

    def join(self):
     with self.all_tasks_done:
      while self.unfinished_tasks:
       self.all_tasks_done.wait()

task_done() 表示某个任务完成。每一条get语句后需要一条task_done。也就是说上面出现了几次put下面需要跟随几个task_done()

import queue,threading,time
q=queue.Queue()
def foo():
    q.put(123)
    q.put(234)
    q.put(345)
    q.join()
    print('end foo')
    q.put_nowait(555)#假如说不添加join的话就会产生报错

def bar():
    print(q.get())
    q.task_done()
    print(q.get())
    q.task_done()
    print(q.get())
    time.sleep()
    q.task_done()
   
t1=threading.Thread(target=foo,args=())
t1.start()
t2=threading.Thraed(target=bar,args=())
t2.start()

结果就是不报错，
打印出
123
234
345

FILO#栈出方式

这里有点像是坐电梯，如果第一个上了电梯（直梯）的人 ，最先进去的那个人，等到出来的时候肯定最后一个出来，这也是第一个put进去的人，get的时候肯定最后一个出来

import queue,threading

q=queue.LifoQueue()#FILO的方式

q.put(11)
q.put(12)
q.put(13)

while not q.empty():#如果列表不为空empty就是false
    print(q.get())



打印结果：：

13
12
11

优先级的方式

import queue
q=queue.PriorityQueue()
q.put([1,'hello1'])#设置[优先级,内容]
q.put([5,'hello5'])
q.put([2,'hello2'])
q.put([1,'111111'])
while not q.empty():
        print(q.get())

打印的结果
[1, '11111']
[1, 'hello1']
[2, 'hello2']
[5, 'hello5']

生产者消费者模型

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

import queue,threading,random,time
q=queue.Queue(5)
def foo():
    while True:
        s=random.randint(1,99)
        q.put(s)
　　　　　print('make baozi%s' %(s,))
        time.sleep(3)
def eat():
    while True:
        print('eat baozi%s' %(q.get()))
        time.sleep(2)
for i in range(10):
    t=threading.Thread(target=foo,args=())
    t.start()
for i in range(50):
    t=threading.Thread(target=eat,args=())
    t.start()

这里重点是限定在q=queue.Queue(5)这里规定了队列中只能有5个人