目标

开始学习Python，练手 

建立一个任务队列，添加一堆任务，然后开启多个线程去处理队列里的任务



代码

#创建工作队列
for i in range(100000)：
    MyWorkThread.workQueue.put(work)

#启动多线程，处理工作队列里的内容
threads = []
for i in range(THREAD_NUM):
    thread = MyWorkThread.MyWorkThread()
    thread.start()
    threads.append(thread)
#等待队列清空
while not MyWorkThread.workQueue.empty():
    time.sleep(2)
    pass
#MyWorkThread.workQueue.join()

#通知线程是时候退出
MyWorkThread.exitAllThread()
print('触发退出所有工作线程')

#等待所有线程完成退出
for t in threads:
    t.join()

#!/usr/bin/python
#coding=utf-8

import threading
import time
import traceback
import os

import Queue

class MyWorkThread(threading.Thread):
    def __init__(self,):
        threading.Thread.__init__(self)

    def run(self):
        global workQueue
        global exitFlag
        globalLock.acquire()
        loop = exitFlag
        globalLock.release()
        while not loop:
            try:
                #任务并运行
                work = workQueue.get(False)
                work.run()
                del work
            except Queue.Empty:
                time.sleep(0.5)
            except Exception as e:
                print('ERROR:',e)
                print('traceback.format_exc():\n%s' % traceback.format_exc())
                time.sleep(0.5)
                os._exit(0)
            globalLock.acquire()
            loop = exitFlag
            globalLock.release()
        print('线程{}结束'.format(self.tid))

def exitAllThread():
    global exitFlag
    globalLock.acquire()
    exitFlag=1
    globalLock.release()

workQueue = Queue.Queue() #工作队列
globalLock = threading.Lock() #全局变量锁
exitFlag = 0 #线程结束

大家对多线程处理耗时工作的重要性应该早已认识到。本章的关键点是：把耗时的、与UI渲染无关的操作进行分割分配到多个线程中并发执行。
 
       在本章，googler 全篇介绍了通过 java 线程池来构造多线程执行环境的详细流程，关键要点如下：
 
1.   定义一个能在 Thread 中执行的 Runnable 子类 SubRunnable，把耗时的工作交给 SubRunnable 的 run() 方法；
 
2.   在 run() 中通过 Thread.currentThread() 获取并保存SubRunnable 所在的线程以备中断所需；
 
3.   初始化一个 BlockingQueue<Runnable> 队列的实例runQueue，用于排队缓冲等待执行的 SubRunnables；
 
4.   初始化并配置一个 java 线程池 ThreadPoolExecutor的实例 threadpool，配置初始化可用线程数、最大可用线程数、线程关闭前的闲置时间、闲置时间单位、工作队列（即上述初始化的 runQueue）；
 
5.   threadpool 是 runQueue 的实际操纵者，负责将 SubRunnable 排队、按照FIFO策略给 SubRunnable 分配 Thread 并调度执行；
 
6.   构造一个 Handler 的实例 mainHandler 用于接收 SubRunnable 执行的状态和结果，并更新UI，所以必须用主线程Looper 来初始化它：mainHandler= new Handler(Looper.getMainLooper()); 这样 mainHandler 将与 mian Looper 同处于主线程中，可以接收主线程的派发事件；
 
7.   当需要提交新的任务执行时，调用 threadpool.execute(newRunnable); newRunnable 将被排队调度执行；
 
8.   当 SubRunnable 需要报告执行状态和结果时，通过 mainHandler 传送给 UI 线程处理；
 
9.   当 SubRunnable 执行完毕，确定不再需要它时，中断其所在线程，并将其从队列中移除：”the runnable’s thread”.interrupt(); threadpool.remove(“the runnable”);这点很重要，否则队列中的资源无法释放，严重时将抛出 RejectedExecutionHandler 异常。
 
实际上这是一个android.os.AsyncTask 的手动实现流程，android.os.AsyncTask 正是对此流程的一种封装，只是不过手动实现的方案有更大的弹性，你可以灵活地配置 ThreadPoolExecutor 的参数和队列。
 
如果大家有兴趣可以查看一下android.os.AsyncTask 的源代码：
 
http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/4.2.2_r1/android/os/AsyncTask.java#AsyncTask
 
下面通过图示简要总结一下以上流程：
 


 

	

网上的各种关于 Java 学习路线的文章中都会提到多线程，往往作为 Java 进阶的部分存在。就是说当你想要在 Java 这条路上有所成，必须要掌握多线程。另外，在几乎所有的 Java 岗位的招聘要求中，都会提到多线程，如果你不能针对多线程说出个一二三，恐怕都找不到满意的工作。
但是，很多同学在工作过程中，好像并不会接触到多线程的东西啊。我们知道，像 tomcat 这种服务器软件本身就是多线程的，但是人家都已经封装好了，我们只需要拿来用即可，并不需要我们对多线程进行什么特殊的操作。
其实大多数的同学并不会直接在工作中使用多线程开发。那怎么办呢，我们总不能为了使用多线程而使用多线程吧。
那么什么场景下会使用到多线程技术呢。
多线程的使用场景
1、应用服务器软件
各种服务器软件都支持多线程的，比如我们常用的 Tomcat、Nginx、Jetty 等。因为线上服务肯定都不是一个人使用的，只要有多人访问，就有可能出现并发的情况，所以服务端软件必须是支持多线程的。
对于这些服务器软件，我们平时就是当做黑盒使用，最多也就是定制一下参数。很少有人有机会参与修改和开发。
2、游戏后端服务
如果你是从事游戏服务端开发的，游戏服务器一般都是定制开发的，我们的应用程序大多数都是 HTTP、HTTPS 协议，而游戏是一个长交互的过程，所以游戏中采用的通信协议一般都是 TCP、UDP 协议，如果是页游的话则可能是 websockets。而且游戏一般都是多人同时在线，必须要支持多线程、高并发。而且大多数的游戏后端服务都是采用 C++ 开发，很少有用 Java 开发的。
3、中间件、框架
中间件类似于连接器的效果，比如数据库中间件，用来连接我们的应用服务和数据库集群。
框架指的是那些封装好的拿来即用的框架，比如 RPC 框架，例如 Dubbo。或者是高性能的服务器框架 Netty。
由于面向的使用者未知，有可能是只有几十个人的内部应用，也有可能是成百上千万的超级应用，所以必须要考虑高并发、多线程的情况。
只有极少数的人需要开发中间件或者好用的框架，大多数人没有这个机会。
4、后台离线任务
后台离线任务一般是定期执行的 job，比如对于实时性要求不高的报表进行统计。
比如一个文件系统，每天要统计文件的增量信息，比如新增文件个数、文件空间占用等，我们如果用单一线程统计的话，当天新增文件较多的情况下统计就会很慢，这种情况就可以使用多线程统计，如果文件本身按照一定的规则分放的不同的文件夹里，可以针对每个文件夹创建一个线程进行扫描。
或者对于 mysql 数据表进行统计，比如对多个表进行汇总，每个表作为一个汇总指标存在，这样就可以针对每个表创建一个线程处理。或者有分库分表的情况，可以针对每个分表开启一个线程处理。
以上这些离线任务都可以通过多线程的方式加快处理速度。而这个场景在我们的项目中碰到的几率也比较大。
5、异步处理任务
异步处理任务类似于离线任务，同样是对实时性要求不是很高的情况下。比如电商系统中经常用到的短信、邮件通知的情况，用户在某电商网站下单付款后，通常会收到短信或者邮件的通知，而通知信息对于整个购买环节并不是最重要的，商家最关心的就是减掉库存和收到付款，所以对于通知的发送一般都采用异步方式，允许一定的延时甚至发送失败的情况。
当用户购买商品成功后，系统会向消息队列中写入订单相关的信息，发送通知的异步任务去消息队列拉取消息，拉到一个订单就向对应的手机或者邮箱发送通知消息。而这里的发送通知任务一般都采用多线程的方式，用来提高并发度，减小用户下单成功到收到通知之间的延时。
类似的场景都可以采用多线程的异步任务去处理，而我们在项目中碰到这种场景的几率也不小。
6、天然需要多线程的
另外还有一些功能就是一想到自然就想到多线程的情况，比较明显的就是爬虫程序。
通过爬虫学习多线程
如果你想学习多线程开发，但是又找不到合适的学习场景(对于照着书本或者博客敲一些 demo 代码并不能很好的掌握多线程开发)，那么你可以试着写个爬虫玩玩，既有趣儿又可以学习，何乐而不为呢。
当然一提到写爬虫，大家可能最先想到的是 Python，没错，比如我在刚学习 Python 的前两年就热衷于写爬虫，比如 2014 年写的这篇 https://www.cnblogs.com/fengzheng/p/3913639.html ，抓取百度音乐，竟然还用 PYQT 做了个界面出来，也真是有耐心。
今天建议大家写爬虫来学习 Java 多线程，那就自然是用 Java 开发了。
这里只说单机多线程的爬虫，不包括分布式爬虫。
一般用爬虫就是需要大批量数据的场景，比如说抓取某个或某些微博大 V 的微博内容，比如抓取知乎回答，豆瓣电影排行信息，甚至到 PornHub 上抓一下 Python 教程来学一学也是可以的。
拿微博来说吧，比如我准备采集某领域的 100 个大 V 的微博内容，如果用单线程来爬，可能耗时几十分钟，甚至几个小时。如果是更大量的数据采集，那耗时可想而知了。
为了加快速度、提高效率，一般都会采用多线程的方式来爬取数据。
不仅如此，爬虫程序还是生产消费者模式的经典应用场景。
整体的逻辑如下：
1、多个线程(这里的线程也就是生产消费者模式中的生成者线程)到目标网站上抓数据；
2、然后将数据放到一个中间队列，有条件的可以弄个真正的消息队列，比如 RabbitMQ、RocketMQ、kafka 或者 redis 也可以，没有条件的用 Java 本身的队列 Queue 也可以，或者自己实现一个队列结构；
3、最后，多个消费者线程订阅中间队列，将数据加工处理后存入数据库或者写入文件，实现持久化。
涉及到多线程的知识点
线程的创建
爬虫生产者线程和消费线程的创建，可以采用线程创建的两种方式：
1、实现 Runnable 接口，并重写 run() 方法
public static void main( String[] args ){
    ProducerWorker producerWorker = new ProducerWorker();
    producerWorker.run();
}
public static class ProducerWorker implements Runnable {
    @Override
    public void run(){
        try {
            /* 抓取数据 */
        }
        catch ( Exception e ) {
            e.printStackTrace();
        }
    }
}

	

Python多线程与多处理
Python中有一个称为线程的库 ，它使用线程(而不只是进程)来实现并行性。如果您了解Python的Global Interpreter Lock或GIL，这可能是令人惊讶的消息 ，但是它实际上在某些情况下可以很好地工作而不会违反GIL。这一切都没有任何开销-只需定义发出I / O请求的功能，系统即可处理其余的功能。
全局翻译锁
全局解释器锁通过一次只允许一个本机线程执行，从而降低了Python(更确切地说是CPython)中线程的有用性 。这使得在(通常是线程不安全的)C库中实现Python更加容易实现，并且可以提高单线程程序的执行速度。但是，它仍然存在争议，因为它阻止了真正的轻量级并行性。您可以实现并行性，但是它需要使用多重处理，这由同名的库 multiprocessing实现。该库不使用线程，而是使用绕过GIL的进程。
看起来，GIL会杀死Python多线程，但效果不佳。通常，多线程有两个主要用例：
在单台计算机上利用多个内核
利用I / O延迟来处理其他线程
通常，我们不能从(1)的线程中受益，但可以从(2)的中受益。
多处理
通用 threading 库是相当低级的，但事实证明它是将其 multiprocessing 包装起来的 multiprocessing.pool.ThreadPool，它方便地采用与相同的接口 multiprocessing.pool.Pool。
使用的好处之一 threading 是可以避免酸洗。多处理依赖于内存中的酸洗对象将其发送到其他进程。例如，如果 timed 装饰没有 wraps 了 wrapper 它返回的函数，那么CPython中就能够咸菜我们的功能 request_func ，并 selenium_func 因此这些不能多处理。相比之下，该 threading 库即使通过 multiprocessing.pool.ThreadPool 工作也很好。多处理还需要更多的内存和启动开销。
分析
我们分析了高度依赖I / O的任务，即对随机的维基百科页面发出100个URL请求。我们比较一下：
Python 请求 模块和
带有 PhantomJS的Python 硒。
我们以三种方式运行这些请求，并测量每次获取所需的时间：
串联
在threading 具有10个线程的池中并行
在multiprocessing 具有10个线程的池中并行
每个请求都是定时的，我们比较结果。
结果
首先，for的每线程运行时间 requests 明显少于for  selenium，因为后者需要启动一个新进程来运行 PhantomJS 无头浏览器。还有趣的是，各个线程(尤其是硒线程)的串行运行速度比并行运行速度快，这是典型的带宽与延迟之间的权衡。
尤其是，硒线程的速度要慢两倍以上，这很可能是由于10个硒工艺一次旋转导致的资源争夺。
同样， 与串行相比，多线程时所有线程的selenium 请求运行速度大约快4倍，请求运行速度 大约快8倍 requests。
结论
使用threading 和 之间没有明显的性能差异 multiprocessing。多线程和多处理之间的性能极为相似，确切的性能细节可能取决于您的特定应用程序。穿线 multiprocessing.pool.ThreadPool 真的很容易，或者至少和使用multiprocessing.pool.Pool 界面一样容易 -只需将I / O工作负载定义为一个函数，然后使用 ThreadPool 即可并行运行它们。
1