线程和进程

进程

  优点：同时利用多个CPU，能够同时进行多个操作

  缺点：耗费资源（新进程需要重新开辟内存控件）

  进程是越多越好吗？

  很显然，进程并不是越多越好，最好是和系统的CPU数量一致。

线程

  优点：共享内存，IO操作时候，创造并发操作

  缺点：抢占资源

  线程是越多越好吗？

  CPU处理多线程的时候，每次每个线程处理的上下文都需要记录，并且在下一次来处理该线程时，需要进行上下文切换，而这个上下文切换非常耗时。所以过多的线程反而会影响CPU的处理效率。

  线程的数量最好需要根据自己的业务来进行取决。

threading模块

  threading模块建立在_thread模块之上。thread模块以低级、原始的方式来处理和控制线程，而 threading 模块通过对 thread 进行二次封装，提供了更方便的 api 来处理线程。

#!/usr/local/bin/python3
# -*- coding:utf-8 -*-

import threading
import time

def worker(num):
    '''
    threading worker function
    :param num:
    :return:
    '''
    time.sleep(1)
    print("Thread %d" %num)
    return

for i in range(20):
    t = threading.Thread(target=worker,args=(i,),name="t.%d" %i)
    t.start()

  运行结果：

Thread 0
Thread 8
Thread 4
Thread 6
Thread 9
Thread 1
Thread 3
Thread 7
Thread 2
Thread 5

  thread方法说明:

t.start() : 激活线程
t.getName() : 获取线程的名称
t.setName() ： 设置线程的名称
t.name : 获取或设置线程的名称
t.is_alive() ： 判断线程是否为激活状态
t.isAlive() ：判断线程是否为激活状态
t.setDaemon() 设置为后台线程或前台线程（默认：False）;通过一个布尔值设置线程是否为守护线程，必须在执行start()方法之后才可以使用。如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止；如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
t.isDaemon() ： 判断是否为守护线程
t.ident ：获取线程的标识符。线程标识符是一个非零整数，只有在调用了start()方法之后该属性才有效，否则它只返回None。
t.join() ：逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
t.run() ：线程被cpu调度后自动执行线程对象的run方法

线程锁threading.RLock和threading.Lock

  我们使用线程对数据进行操作的时候，如果多个线程同时修改某个数据，可能会出现不可预料的结果，为了保证数据的准确性，引入了锁的概念。

#!/usr/local/bin/python3
# -*- coding:utf-8 -*-

import threading
import time

globals_num = 0

lock = threading.RLock()

def Func():
    lock.acquire() # 获得锁
    global globals_num
    globals_num += 1
    time.sleep(1)
    print(globals_num)
    lock.release() #释放锁

for i in range(10):
    t = threading.Thread(target=Func)
    t.start()

  threading.RLock和threading.Lock 的区别

  RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。 如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐。

   Lock：

#!/usr/local/bin/python3
# -*- coding:utf-8 -*-
import threading

lock = threading.Lock() #Lock对象
lock.acquire()
print("here...1")
lock.acquire() #产生了死锁，程序执行到这里会卡死
print("here...2")
lock.release()
print("here...3")
lock.release()
print("here...end")

  RLock:

#!/usr/local/bin/python3
# -*- coding:utf-8 -*-
import threading

lock = threading.RLock() #Lock对象
lock.acquire()
print("here...1")
lock.acquire() #在同一线程内，程序不会堵塞。
print("here...2")
lock.release()
print("here...3")
lock.release()
print("here...4")

threading.Event

  Event是线程之间的通信机制之一：一个线程发送一个event信号，其他的线程则等待这个信号。用于主线程控制其他线程的执行。 Events 管理一个flag，这个flag可以使用set()设置成True或者使用clear()重置为False，wait()则用于阻塞，在flag为True之前。flag默认为False。

• Event.wait([timeout]) ： 堵塞线程，直到Event对象内部标识位被设为True或超时（如果提供了参数timeout）。
• Event.set() ：将标识位设为Ture。
• Event.clear() ： 将标识设为False。
• Event.isSet() ：判断标识位是否为Ture。

#!/usr/local/bin/python3
# -*- coding:utf-8 -*-

import threading

def do(event):
    print("start")
    event.wait()
    print("execute")

event_obj = threading.Event()

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

event_obj.clear()
inp = input("inp: ")
if inp == "true":
    event_obj.set()

  当线程执行的时候，如果flag为False，则线程会阻塞，当flag为True的时候，线程不会阻塞。它提供了本地和远程的并发性。

threading.Condition

  一个condition变量总是与某些类型的锁相联系，这个可以使用默认的情况或创建一个，当几个condition变量必须共享和同一个锁的时候，是很有用的。锁是conditon对象的一部分：没有必要分别跟踪。

  condition变量服从上下文管理协议：with语句块封闭之前可以获取与锁的联系。 acquire() 和 release() 会调用与锁相关联的相应的方法。

  其他和锁关联的方法必须被调用，wait()方法会释放锁，当另外一个线程使用 notify() or notify_all()唤醒它之前会一直阻塞。一旦被唤醒，wait()会重新获得锁并返回。

Condition(lock=None)

  Condition类实现了一个conditon变量。 这个conditiaon变量允许一个或多个线程等待，直到他们被另一个线程通知。 如果lock参数，被给定一个非空的值，，那么他必须是一个lock或者Rlock对象，它用来做底层锁。否则，会创建一个新的Rlock对象，用来做底层锁。

• wait(timeout=None) ： 等待通知，或者等到设定的超时时间。当调用这wait()方法时，如果调用它的线程没有得到锁，那么会抛出一个RuntimeError 异常。 wati()释放锁以后，在被调用相同条件的另一个进程用notify() or notify_all() 叫醒之前 会一直阻塞。wait() 还可以指定一个超时时间。

  如果有等待的线程，notify()方法会唤醒一个在等待conditon变量的线程。notify_all() 则会唤醒所有在等待conditon变量的线程。

  注意：notify()和notify_all()不会释放锁，也就是说，线程被唤醒后不会立刻返回他们的wait() 调用。除非线程调用notify()和notify_all()之后放弃了锁的所有权。

  在典型的设计风格里，利用condition变量用锁去通许访问一些共享状态，线程在获取到它想得到的状态前，会反复调用wait()。修改状态的线程在他们状态改变时调用 notify() or notify_all()，用这种方式，线程会尽可能的获取到想要的一个等待者状态。 例子： 生产者-消费者模型。

#!/usr/local/bin/python3
# -*- coding:utf-8 -*-

import threading
import time


def consumer(cond):
    with cond:
        print("consumer before wait")
        cond.wait()
        print("consumer after wait")


def producer(cond):
    with cond:
        print("producer before notifyAll")
        cond.notifyAll()
        print("producer after notifyAll")


condition = threading.Condition()
c1 = threading.Thread(name="c1", target=consumer, args=(condition,))
c2 = threading.Thread(name="c2", target=consumer, args=(condition,))

p = threading.Thread(name="p", target=producer, args=(condition,))

c1.start()
time.sleep(2)
c2.start()
time.sleep(2)
p.start()

  consumer()线程要等待producer()设置了Condition之后才能继续。

进程与线程之间的关系

  线程是属于进程的，线程运行在进程空间内，同一进程所产生的线程共享同一内存空间，当进程退出时该进程所产生的线程都会被强制退出并清除。线程可与属于同一进程的其它线程共享进程所拥有的全部资源，但是其本身基本上不拥有系统资源，只拥有一点在运行中必不可少的信息(如程序计数器、一组寄存器和栈)。

queue模块

  Queue就是对队列，它的线程安全的。

  举例来说，我们去肯德基吃饭。厨房是给我们做饭的地方，前台负责把厨房做好的饭卖给顾客，顾客则去前台领取做好的饭。这里的前台就相当于我们的队列。这个模型也叫生产者-消费者模型。

  queue模块方法说明：

import queue

q = queue.Queue(maxsize=0) #构造一个先进显出队列，maxsize指定队列长度，为0 时，表示队列长度无限制。

q.join() # 等到队列为空的时候，再执行别的操作
q.qsize() #返回队列的大小（不可靠）
q.empty() #当队列为空的时候返回True，否则返回False（不可靠）
q.full() #当队列满的时候返回True，否则返回False（不可靠）
q.put(item="",block=True,timeout=None) #将item放入Queue尾部，item必须存在，可以参数block默认为True,表示当队列满时，会等待队列给出可用位置，为False时为非阻塞，此时如果队列已满，会引发queue.Full 异常。 可选参数timeout，表示 会阻塞设置的时间，过后如果队列无法给出放入item的位置，则引发 queue.Full 异常
q.get(block=True,timeout=None)  #移除并返回队列头部的一个值，可选参数block默认为True，表示获取值的时候，如果队列为空，则阻塞，为False时，不阻塞，若此时队列为空，则引发 queue.Empty异常。 可选参数timeout，表示会阻塞设置的时候，过后，如果队列为空，则引发Empty异常。
q.put_nowait(item="") #同q.put(item="",block=True,timeout=None)
q.get_nowait() #同q.get(block=True,timeout=None)

  生产者--消费者：

总结

  进程和线程的目的是为了提高程序的执行效率，所以不要一味的去增加进程和线程，这样并不会提高运行效率。需要具体业务具体分析。

  执行任务的最小单位是线程。

  IO操作不利用CPU，所以，对于IO密集型的程序，适合用多线程。对于计算密集型，适合用多进程。

  GIL，全局解释器锁。

python中的进程和线程