多线程编程

1、多线程对于具有如下特点的编程任务是非常理想的：1、本质上是异步的 2、需要多个并发活动 3、每个活动的处理顺序是不确定的。

2、使用多线程编程，以及类似Queue的共享数据结构，这个编程任务可以规划成几个执行特定函数的线程。

• UserRequestThread：负责读取客户端输入，该输入可能来自I/O通道。程序将创建多个线程，每个客户端一个，客户端的请求会被放入队列中。
• RequestProcessor：该线程负责从队列中获取请求并进行处理，为第三个线程提供输出。
• ReplyThread：负责向用户输出，将结果传回给用户（如果是网络应用），或者把数据写到本地文件系统或数据库中。

　　使用多线程来规划这种编程任务可以降低程序的复杂性，使其实现更加清晰、高效和简洁。

3、进程

　　计算机程序只是存储在磁盘上的可执行二进制（或其他类型）文件。只有把它们加载到内存中并被操作系统调用，才能拥有其生命周期。进程则是一个执行中的程序。每个进程都拥有自己的地址空间、内存、数据栈以及其他用于追踪执行的辅助数据。操作系统管理其上所有进程的执行，并为这些进程合理的分配时间。进程有可以通过派生（fork或spawn）新的进程来执行其他任务，不过因为每个新进程也拥有自己的内存和数据栈等，所以只能采用进程间通信（IPC）的方式共享信息。

4、线程

　　与进程类似，不过它们是在同一个进程下执行的，并共享相同的上下文。可以将它们认为是在一个主进程或“主线程”中并行运行的一些“迷你进程”。

　　线程包括开始、执行顺序和结束三个部分。它有一个指令指针，用于记录当前运动的上下文。当其他线程运行时，它可以被抢占（中断）和临时挂起（也称为睡眠）——这种叫法叫做让步。

5、线程和Python

1、全局解释器

　　Python代码的执行是由Python虚拟机（又名解释器主循环）进行控制的。尽管Python解释器中可以运行多个线程，但是在任意时刻只有一个线程会被解释器执行。

　　对Python虚拟机的访问是由全局解释器锁（GIL）控制的。这个锁就是用来保证同时只能有一个线程运行。在多线程环境中，Python虚拟机将按照下面所述的方式执行。

1. 设置GIL
2. 切换进一个线程去进行
3. 执行操作之一（a。指定数量的字节码指令  b。线程主动让出控制权（可以调用time.sleep()来完成））
4. 把线程设置回睡眠状态（切换出线程）
5. 解锁GIL
6. 重复上述步骤

I/O密集型的Python程序要比计算密集型的代码能够更好的利用多线程环境。

2、不使用线程的情况

#!/usr/bin/env python

from time import sleep , ctime

def loop0():
    print('start loop 0 at:',ctime())
    sleep(4)
    print('loop 0 done at:',ctime())\

def loop1():
    print('start loop 1 at:',ctime())
    sleep(2)
    print('loop 1 done at:',ctime())

def main():
    print('starting at:',ctime())
    loop0()
    loop1()
    print('all done at:',ctime())

if __name__ == '__main__':
    main()


结果：
starting at: Fri Oct 20 12:09:34 2017
start loop 0 at: Fri Oct 20 12:09:34 2017
loop 0 done at: Fri Oct 20 12:09:38 2017
start loop 1 at: Fri Oct 20 12:09:38 2017
loop 1 done at: Fri Oct 20 12:09:40 2017
all done at: Fri Oct 20 12:09:40 2017

Process finished with exit code 0

3、Python的threading模块

threading模块提供了相比于thread更高级、功能更全面的线程管理

6、thread模块

　　除了派生线程外，thread模块还提供了基本的同步数据结构，称为锁对象（lock object，也叫原语锁、简单锁、互斥锁、互斥和二进制信号量）

7、Threading模块

　　　　表 threading模块的对象

避免使用thread模块的另一个原因是该模块不支持守护进程这个概念。当主线程退出时，所有子线程都将结束，不管它们是否仍在工作。

Threading模块支持守护进程，其工作模式是：守护进程一般是一个等待客户端请求的服务器。如果没有客户端请求，守护进程就是空闲的。如果把一个线程设置为守护进程，就表示这个线程是不重要的，线程退出时不需要等待这个线程执行完成。

要将一个线程设置为守护进程，需要启动线程之前执行如下的赋值语句：thread.daemon = True

1、Thread类

表：Thread对象的属性和方法

#!/usr/bin/env python

import threading
from time import sleep,ctime
loops = [4,2]

def loop(nloop,nsec):
    print('start loop',nloop,'at:',ctime())
    sleep(nsec)
    print('loop',nloop,'done at:',ctime())

def main():
    print('start at:',ctime())
    threads = []
    nloops = range(len(loops))

    for i in nloops:
        t = threading.Thread(target=loop,args=(i,loops[i]))
        threads.append(t)

    for i in nloops:
        threads[i].start()

    for i in nloops:        #wait for all
        threads[i].join()   #threads to finish
    print('all done at:',ctime())

if __name__ == '__main__':
    main()


=================================
start at: Wed Oct 25 15:07:45 2017
start loop 0 at: Wed Oct 25 15:07:45 2017
start loop 1 at: Wed Oct 25 15:07:45 2017
loop 1 done at: Wed Oct 25 15:07:47 2017
loop 0 done at: Wed Oct 25 15:07:49 2017
all done at: Wed Oct 25 15:07:49 2017

8、锁Lock

多线程和多进程最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响，而多线程中，所有变量都由所有线程共享，所以，任何一个变量都可以被任何一个线程修改，因此，线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了。

balance = 0
lock = threading.Lock()

def run_thread(n):
    for i in range(100000):
        # 先要获取锁:
        lock.acquire()
        try:
            # 放心地改吧:
            change_it(n)
        finally:
            # 改完了一定要释放锁:
            lock.release()

当多个线程同时执行lock.acquire()时，只有一个线程能成功地获取锁，然后继续执行代码，其他线程就继续等待直到获得锁为止。

获得锁的线程用完后一定要释放锁，否则那些苦苦等待锁的线程将永远等待下去，成为死线程。所以我们用try...finally来确保锁一定会被释放。

锁的好处就是确保了某段关键代码只能由一个线程从头到尾完整地执行，坏处当然也很多，首先是阻止了多线程并发执行，包含锁的某段代码实际上只能以单线程模式执行，效率就大大地下降了。其次，由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对方持有的锁时，可能会造成死锁，导致多个线程全部挂起，既不能执行，也无法结束，只能靠操作系统强制终止。