其实在 Python 中，多线程是不推荐使用的，除非明确不支持使用多进程的场景，否则的话，能用多进程就用多进程吧。写这篇文章的目的，可以对比多进程的文章来看，有很多相通的地方，看完也许会对并发编程有更好的理解。
GIL
Python（特指 CPython）的多线程的代码并不能利用多核的优势，而是通过著名的全局解释锁（GIL）来进行处理的。如果是一个计算型的任务，使用多线程 GIL 就会让多线程变慢。我们举个计算斐波那契数列的例子：
运行的结果你猜猜会怎么样？还不如不用多线程！
GIL 是必须的，这是 Python 设计的问题：Python 解释器是非线程安全的。这意味着当从线程内尝试安全的访问Python 对象的时候将有一个全局的强制锁。在任何时候，仅仅一个单一的线程能够获取 Python 对象或者 C API。每 100 个字节的 Python 指令解释器将重新获取锁，这（潜在的）阻塞了 I/O 操作。因为锁，CPU 密集型的代码使用线程库时，不会获得性能的提高（但是当它使用之后介绍的多进程库时，性能可以获得提高）。
那是不是由于 GIL 的存在，多线程库就是个「鸡肋」呢？当然不是。事实上我们平时会接触非常多的和网络通信或者数据输入/输出相关的程序，比如网络爬虫、文本处理等等。这时候由于网络情况和 I/O 的性能的限制，Python 解释器会等待读写数据的函数调用返回，这个时候就可以利用多线程库提高并发效率了。
线程对象
先说一个非常简单的方法，直接使用 Thread 来实例化目标函数，然后调用  来执行。
生成线程时可以传递参数给线程，什么类型的参数都可以。下面这个例子只传了一个数字：
还有一种创建线程的方法，通过继承 Thread 类，然后重写  方法，代码如下：
因为传递给 Thread 构造函数的参数  和  被保存成了带  前缀的私有变量，所以在子线程中访问不到，所以在自定义线程类中，要重新构造函数。
确定当前线程
每个 Thread 都有一个名称，可以使用默认值，也可以在创建线程时指定。
守护线程
默认情况下，在所有子线程退出之前，主程序不会退出。有些时候，启动后台线程运行而不阻止主程序退出是有用的，例如为监视工具生成“心跳”的任务。
要将线程标记为守护程序，在创建时传递  或调用，默认情况下，线程不是守护进程。
输出不包含守护线程的 ，因为在守护线程从  唤醒之前，其他线程，包括主程序都已经退出了。
如果想等守护线程完成工作，可以使用  方法。
输出信息已经包括守护线程的 。
默认情况下，无限期地阻止。也可以传一个浮点值，表示等待线程变为非活动状态的秒数。如果线程未在超时期限内完成，则无论如何都会返回。
由于传递的超时小于守护程序线程休眠的时间，因此 返回后线程仍处于“活动”状态。
枚举所有线程
方法可以返回活动 Thread 实例列表。由于该列表包括当前线程，并且由于加入当前线程会引入死锁情况，因此必须跳过它。
计时器线程
在延迟时间后开始工作，并且可以在该延迟时间段内的任何时间点取消。
此示例中的第二个计时器不会运行，并且第一个计时器似乎在主程序完成后运行的。由于它不是守护线程，因此在完成主线程时会隐式调用它。
同步机制
Semaphore
在多线程编程中，为了防止不同的线程同时对一个公用的资源（比如全部变量）进行修改，需要进行同时访问的数量（通常是 1）。信号量同步基于内部计数器，每调用一次 ，计数器减 1；每调用一次 ，计数器加 1。当计数器为 0 时， 调用被阻塞。
在这个例子中， 类只是为了展示在同一时刻，最多只有两个线程在运行。
Lock
Lock 也可以叫做互斥锁，其实相当于信号量为 1。我们先看一个不加锁的例子：
不加锁的情况下，结果会远远的小于 100。那我们加上互斥锁看看：
RLock
能够不被阻塞的被同一个线程调用多次。但是要注意的是  需要调用与  相同的次数才能释放锁。
先看一下使用  的情况：
在这种情况下，第二次调用将  被赋予零超时以防止它被阻塞，因为第一次调用已获得锁定。
再看看用替代的情况。
Condition
一个线程等待特定条件，而另一个线程发出特定条件满足的信号。最好说明的例子就是「生产者/消费者」模型：
可以看到生产者发送通知之后，消费者都收到了。
Event
一个线程发送/传递事件，另外的线程等待事件的触发。我们同样的用「生产者/消费者」模型的例子：
可以看到事件被 2 个消费者比较平均的接收并处理了。如果使用了  方法，线程就会等待我们设置事件，这也有助于保证任务的完成。
Queue
队列在并发开发中最常用的。我们借助「生产者/消费者」模式来理解：生产者把生产的「消息」放入队列，消费者从这个队列中对去对应的消息执行。
大家主要关心如下 4 个方法就好了：
put: 向队列中添加一个项。
get: 从队列中删除并返回一个项。
task_done: 当某一项任务完成时调用。
join: 阻塞直到所有的项目都被处理完。
这就是最简化的队列架构。
Queue 模块还自带了 PriorityQueue（带有优先级）和 LifoQueue（后进先出）2 种特殊队列。我们这里展示下线程安全的优先级队列的用法，PriorityQueue 要求我们 put 的数据的格式是，我们看看下面的例子：
其中消费者是故意让它执行的比生产者慢很多，为了节省篇幅，只随机产生 5 次随机结果。可以看到 put 时的数字是随机的，但是 get 的时候先从优先级更高（数字小表示优先级高）开始获取的。
线程池
面向对象开发中，大家知道创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。无节制的创建和销毁线程是一种极大的浪费。那我们可不可以把执行完任务的线程不销毁而重复利用呢？仿佛就是把这些线程放进一个池子，一方面我们可以控制同时工作的线程数量，一方面也避免了创建和销毁产生的开销。
线程池在标准库中其实是有体现的，只是在官方文章中基本没有被提及：
当然我们也可以自己实现一个：
线程池会保证同时提供 5 个线程工作，但是我们有 8 个待完成的任务，可以看到线程按顺序被循环利用了。
参考文章：
https://pymotw.com/3/threading/index.html
http://www.dongwm.com/archives/%E4%BD%BF%E7%94%A8Python%E8%BF%9B%E8%A1%8C%E5%B9%B6%E5%8F%91%E7%BC%96%E7%A8%8B-%E7%BA%BF%E7%A8%8B%E7%AF%87/

众所周知，Python代码中有一个threading模块，可以创建多线程，但是在这种模式下创建的多线程并不能将多核利用起来，所有由这种模式下创建的线程最多只能共享一个CPU核，所以在有些场景下，我们需要将一个作业分配给一个独立的线程，并且每个独立的线程可以使用不同的CPU核资源，做到真正的并发执行。
如何实现呢？这里有一个办法是通过调用一个C库函数来实现，在C库中再调用标准的pthread_create函数来实现，参考代码如下：
C库函数
#include 
#include 
#include 
#include 
void* myThread(void *arg)
{
while (1);
}
void createThread(void)
{
int err;
pthread_t tid;
err = pthread_create(&tid, NULL, myThread, NULL);
if (err != 0) {
printf("create thread failed!\n");
return;
}
return;
}
编译成动态库：
$ gcc -fPIC -shared -o libfoo.so foo.c
在Python中调用，实现真正的多线程
代码如下：
#-*- coding=utf-8 -*-
from ctypes import *
import time
lib = CDLL("./libfoo.so", RTLD_GLOBAL)
create_thread = lib.createThread
#create_thread.argtypes = [c_void]
#create_thread.restype = c_void
if __name__ == '__main__':
create_thread()
create_thread()
while True:
print 'I am in main thread!'
time.sleep(2)
运行起来后，查看CPU占用率：
hank@hank-desktop:~/Study/Python/CallC2$ top
top - 10:33:27 up  2:06,  3 users,  load average: 0.31, 0.08, 0.07
Tasks: 159 total,   1 running, 158 sleeping,   0 stopped,   0 zombie
%Cpu0  :100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu1  :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu2  :  0.3 us,  0.0 sy,  0.0 ni, 99.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
%Cpu3  :100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem:   8166744 total,  1696620 used,  6470124 free,   280708 buffers
KiB Swap:        0 total,        0 used,        0 free.   731816 cached Mem
PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
2625 hank      20   0   51404   7616   4824 S 199.8  0.1   0:17.52 python
1035 daemon    20   0  517408   8136   7144 S   0.3  0.1   0:25.53 CodeMeterLin
2628 hank      20   0   29152   3324   2804 R   0.3  0.0   0:00.01 top
可以看到在C库中创建的两个线程(while无限循环)分别消耗掉了两个独立的CPU核，这也就验证了可以做到真正并发的目的。

python 8-1 如何使用多线程

使用标准库中的threading.Thread创建线程, 在每一个线程中下载并转换一只股票数据

首先python受限于GIL的缘故，多线程只适合IO包括网络IO,磁盘IO,密集型的任务，不适合计算密集型的任务

实现多线程一般有两种方式

第一种:直接将需要执行逻辑部分的函数赋值给target 

t = Thread(target=handle,args=(1,)) 

t.start()

第二种:定义一个自己的类继承Thread,然后将逻辑函数放在run方法中执行

class MyThread(Thread): 

    def init(self,sid): 

        self(MyThread,self).init() 

        self.sid = sid 

    def run(self): 

        handle(self.sid)

t=MyThread(1) 

t.start()

from threading import Thread 

def handle(sid): 

    print “Download…%d”% sid 

    url=”http://table.finance.yahoo.com/table.csv?s=%s.sz” 

    url %=str(sid).rjust(6,’0’) 

    rf = download(url) 

    if rf is not None: continue 

    print ‘Convert to XML …(%d)’ % sid 

    fname = str(sid).rjust(6,’0’) + ‘.xml’ 

    with open (fname,’wb’) as wf: 

        createXmlFromCsv(rf,wf)    

t = Thread(target=handle,args=(1,)) 

t.start()

class MyThread(Thread): 

    def init(self,sid): 

        self(MyThread,self).init() 

        self.sid = sid 

    def run(self): 

        handle(self.sid)

t=MyThread(1) 

t.start()



import csv
from xml.etree.ElementTree import Element,ElementTree
import requests 
from StringIO import StringIO
from xml.dom.minidom import parse
from xml.dom import minidom
from test.test_heapq import SideEffectLT
from pip._vendor.requests.utils import get_environ_proxies

def download(url):
    proxies = {"http": "http://xx.yy.zz.ww:8000"}
    response = requests.get(url,proxies=proxies)
    if response.ok:
        return StringIO(response.content)

def createXmlFromCsv(scsv,fxml):
    root=minidom.Document()
    dataElement=root.createElement("Data")

    reader=csv.reader(scsv)
    headers=reader.next()
    headers = map(lambda h: h.replace(' ',''),headers)
    for row in reader:
        rowElement=root.createElement("Row")
        for tag,text in zip(headers,row):
            item=root.createElement(tag)
            item.appendChild(root.createTextNode(text))
            rowElement.appendChild(item)
        dataElement.appendChild(rowElement)
    fxml.write(root.appendChild(dataElement).toprettyxml())                            
    #return root.appendChild(dataElement)


if __name__ == '__main__':
    url = "http://table.finance.yahoo.com/table.csv?s=000001.sz"
    rf = download(url)
    if rf:
        with open("000001.xml",'wb') as wf:
            createXmlFromCsv(rf,wf)



from threading import Thread
def handle(sid):
    print "Download...%d"% sid
    url="http://table.finance.yahoo.com/table.csv?s=%s.sz"
    url %=str(sid).rjust(6,'0')
    rf = download(url)
    if rf is None: return
    print 'Convert to XML ...(%d)' % sid
    fname = str(sid).rjust(6,'0') + '.xml'
    with open (fname,'wb') as wf:
        createXmlFromCsv(rf,wf)    


import time
def handle2(sid):
    print "Counting... %d"%sid
    for i in [x for x in range(sid)]:
        time.sleep(0.01)

    print "Counting done %d"%sid


t = Thread(target=handle2,args=(1,))
t.start()

class MyThread(Thread):
    def __init__(self,sid):
        super(MyThread,self).__init__()
        self.sid = sid
    def run(self):
        handle2(self.sid)

t=MyThread(2)
t.start()


threads = []
for i in xrange(1,11):
    t = MyThread(i)
    threads.append(t)
    t.start()
for t in threads:
    t.join()

print "main thread..."

原始C++标准仅支持单线程编程。新的C++标准(称为C++11或C++0x)于2011年发布。在C++11中，引入了新的线程库。因此运行本文程序需要C++至少符合C++11标准。

文章目录
5 使用互斥锁解决资源竞争
5.1 std::mutex
5.2 std::lock_guard
5.3 参考

5 使用互斥锁解决资源竞争
在本文中，我们将讨论如何使用互斥锁来保护多线程环境中的共享数据并避免资源竞争。为了解决多线程环境中的资源竞争，我们需要互斥锁，即每个线程都需要在修改或读取共享数据之前锁定互斥锁，并且在修改数据之后，每个线程都应解锁互斥锁。
5.1 std::mutex
在C++11线程库中，互斥锁位于mutex头文件中。表示互斥锁的类是std::mutex类

互斥锁有两种重要的方法：

lock()
unlock()

我们已经在上一篇文章中使用多线程钱包解释了资源竞争。在本文中，我们将看到如何使用std::mutex修复该多线程钱包中的资源竞争。由于电子钱包提供了在电子钱包中添加资金的服务，并且在不同线程之间使用了相同的电子钱包对象，因此我们需要在电子钱包的addMoney()方法中添加锁定，即在增加电子钱包的货币之前获取锁并在离开该钱包之前释放锁功能。让我们看一下代码：

内部维护货币并提供服务/功能的钱包类，即addMoney()。

该成员函数首先获取一个锁，然后将钱包对象的内部货币增加指定的数量，然后释放该锁。
#include<iostream>
#include<thread>
#include<vector>
#include<mutex>

class Wallet
{
	int mMoney;
	std::mutex mutex;
public:
	Wallet() :mMoney(0) {}
	int getMoney() { return mMoney; }
	void addMoney(int money)
	{
		mutex.lock();
		for (int i = 0; i < money; ++i)
		{
			mMoney++;
		}
		mutex.unlock();
	}
};

现在，让我们创建5个线程，所有这些线程将共享Wallet类的同一对象，并使用其addMoney()成员函数并行向内部货币添加100000。因此，如果最初在钱包中的钱为0。那么在完成所有线程的执行后，在Wallet中的钱应该为500000。并且此互斥锁可确保电子钱包中的资金最终为500000。让我们测试一下:
#include<iostream>
#include<thread>
#include<vector>
#include<mutex>

class Wallet
{
	int mMoney;
	std::mutex mutex;
public:
	Wallet() :mMoney(0) {}
	int getMoney() { return mMoney; }
	void addMoney(int money)
	{
		mutex.lock();
		for (int i = 0; i < money; ++i)
		{
			mMoney++;
		}
		mutex.unlock();
	}
};

int testMultithreadedWallet()
{
	Wallet walletObject;
	std::vector<std::thread> threads;
	for (int i = 0; i < 5; ++i) {
		threads.push_back(std::thread(&Wallet::addMoney, &walletObject, 100000));
	}
	for (int i = 0; i < threads.size(); i++)
	{
		threads.at(i).join();
	}
	return walletObject.getMoney();
}
int main()
{
	int val = 0;
	for (int k = 0; k < 10; k++)
	{
		if ((val = testMultithreadedWallet()) != 500000)
		{
			std::cout << "Error at count = " << k << "  Money in Wallet = " << val << std::endl;
			//break;
		}
		else
		{
			std::cout << "Now count = " << k << "  Money in Wallet = " << val << std::endl;
			//break;
		}
	}
	return 0;
}

输出为：
Now count = 0  Money in Wallet = 500000
Now count = 1  Money in Wallet = 500000
Now count = 2  Money in Wallet = 500000
Now count = 3  Money in Wallet = 500000
Now count = 4  Money in Wallet = 500000
Now count = 5  Money in Wallet = 500000
Now count = 6  Money in Wallet = 500000
Now count = 7  Money in Wallet = 500000
Now count = 8  Money in Wallet = 500000
Now count = 9  Money in Wallet = 500000

可以保证不会发现钱包中的钱少于500000的单个情况。因为addMoney中的互斥锁可确保一旦一个线程完成了钱的修改，则只有其他任何线程才能修改Wallet中的钱。

但是，如果我们忘记在功能结束时解锁互斥锁，该怎么办？在这种情况下，一个线程将退出而不释放锁，而其他线程将保持等待状态。如果锁定互斥锁后发生某些异常，则可能发生这种情况。为了避免这种情况，我们应该使用std::lock_guard。
5.2 std::lock_guard
Lock_Guard是一个类模板，它实现了互斥锁的RAII。它将互斥体包装在其对象中，并将附加的互斥体锁定在其构造函数中。当调用它的析构函数时，它会释放互斥锁。让我们看看代码：
#include<iostream>
#include<thread>
#include<vector>
#include<mutex>

class Wallet
{
	int mMoney;
	std::mutex mutex;
public:
	Wallet() :mMoney(0) {}
	int getMoney() { return mMoney; }
	void addMoney(int money)
	{
		// 在构造函数中，它锁定互斥锁 In constructor it locks the mutex
		std::lock_guard<std::mutex> lockGuard(mutex);
		for (int i = 0; i < money; ++i)
		{
			// If some exception occurs at this poin then destructor of lockGuard will be called due to stack unwinding.
			// 如果在此位置发生异常，则由于堆栈展开，将调用lockGuard的析构函数。
			mMoney++;
		}
		// Once function exits, then destructor of lockGuard Object will be called. In destructor it unlocks the mutex.
		//一旦函数退出，则析构函数，将调用析构函数中的lockGuard对象，它解锁互斥锁。
	}
};

int testMultithreadedWallet()
{
	Wallet walletObject;
	std::vector<std::thread> threads;
	for (int i = 0; i < 5; ++i) {
		threads.push_back(std::thread(&Wallet::addMoney, &walletObject, 100000));
	}
	for (int i = 0; i < threads.size(); i++)
	{
		threads.at(i).join();
	}
	return walletObject.getMoney();
}
int main()
{
	int val = 0;
	for (int k = 0; k < 10; k++)
	{
		if ((val = testMultithreadedWallet()) != 500000)
		{
			std::cout << "Error at count = " << k << "  Money in Wallet = " << val << std::endl;
			//break;
		}
		else
		{
			std::cout << "Now count = " << k << "  Money in Wallet = " << val << std::endl;
			//break;
		}
	}
	return 0;
}

输出为：
Now count = 0  Money in Wallet = 500000
Now count = 1  Money in Wallet = 500000
Now count = 2  Money in Wallet = 500000
Now count = 3  Money in Wallet = 500000
Now count = 4  Money in Wallet = 500000
Now count = 5  Money in Wallet = 500000
Now count = 6  Money in Wallet = 500000
Now count = 7  Money in Wallet = 500000
Now count = 8  Money in Wallet = 500000
Now count = 9  Money in Wallet = 500000

5.3 参考

https://thispointer.com//c11-multithreading-part-5-using-mutex-to-fix-race-conditions/