初识多线程

import threading
import time
def coding():
    for i in range(3):
        print('输入代码%s' %i)
        time.sleep(1)
def drawing():
    for i in range(3):
        print('开始画画%s'%i)
        time.sleep(1)
def main():
    t1 = threading.Thread(target=coding)
    t2 = threading.Thread(target=drawing)

    t1.start()
    t2.start()
if __name__ == '__main__':
    main()

Output:

D:\PyCharm\Anaconda3\python.exe D:/PyCharm/Py_work/test2.py
输入代码0
开始画画0
输入代码1
开始画画1
输入代码2
开始画画2

Process finished with exit code 0

还可以通过继承Thread类来创建多线程：

import threading
import time
class codingThread(threading.Thread):
    def run(self):
        for i in range(3):
            print('输入代码%s' %threading.current_thread())
            time.sleep(1)
class drawingThread(threading.Thread):
    def run(self):
        for i in range(3):
            print('开始画画%s'%threading.current_thread())
            time.sleep(1)
def main():
    t1 = codingThread()
    t2 = drawingThread()

    t1.start()
    t2.start()
if __name__ == '__main__':
    main()

Output

D:\PyCharm\Anaconda3\python.exe D:/PyCharm/Py_work/test2.py
输入代码<codingThread(Thread-1, started 8836)>
开始画画<drawingThread(Thread-2, started 9080)>
开始画画<drawingThread(Thread-2, started 9080)>
输入代码<codingThread(Thread-1, started 8836)>
输入代码<codingThread(Thread-1, started 8836)>
开始画画<drawingThread(Thread-2, started 9080)>

Process finished with exit code 0

多线程共享全局变量的问题：

多线程都是在同一个进程中运行的。因此在进程中的全局变量所有线程都是共享的。这就造成了一个问题，因为线程执行的顺序是无序的，有可能会造成数据错误。

###当数据量小的时候，可能不会出错，如下：
import threading
value = 0
def add_value():
    global value
    for i in range(1000):
        value += 1
    print(value)
def main():
    for x in range(2):
        t = threading.Thread(target=add_value)
        t.start()

if __name__ == '__main__':
    main()

Output

1000
2000

第一个线程先加到1000，第二线程再加到2000，这里看起来没什么问题。但是当数据量大的时候，问题就出现了，如下：

import threading
value = 0
def add_value():
    global value
    for i in range(1000000):
        value += 1
    print(value)
def main():
    for x in range(2):
        t = threading.Thread(target=add_value)
        t.start()

if __name__ == '__main__':
    main()

Output

1222047
1246006

按理说应该先输出1000000，再输出2000000。但是结果却不是，这就是多线程执行顺序无序的后果。举个例子：当value=10的时候，线程1和线程2同时启动，本来value经过两个线程执行后应该是value=12。但是由于两个线程是同时执行，导致value +=1 被同时执行了两次，最后的结果就是value还是等于11.

这时候，就需要一个锁来消除这种不好的后果。就是如果线程1比线程2线对value先执行的时候，那么就先把value给锁起来，不让其他线程对value进行任何操作，等线程1操作完后再对value 进行解锁，这时候其他线程才可以对value进行操作。（这样看起来，好像和单线程没啥区别~~~~~）。

注意：这个锁一般只用于多个线程修改全局变量的代码段。比如下面代码的7行和8行。

import threading
value = 0
gLock = threading.Lock()
def add_value():
    global value
    gLock.acquire()  #上锁
    for i in range(1000000):
        value += 1
    gLock.release()  #解锁
    print(value)
def main():
    for x in range(2):
        t = threading.Thread(target=add_value)
        t.start()

if __name__ == '__main__':
    main()

Output

1000000
2000000

 

 

Lock版本生产者和消费者模式

生产者和消费者模式是多线程开发中经常见到的一种模式。生产者的线程专门用来生产一些数据，然后存放到一个中间变量中。消费者再从这个中间的变量中取出来数据进行消费。但是因为要使用中间变量，中间变量经常是一些全局变量，因此余姚使用锁来保证数据完整性。

import threading,random,time

gMoney = 1000 #此全局变量用来保存生产和消费的钱
gLock = threading.Lock()
gTotalTimes = 10  #此全局变量用来保存需要消费多少次
gtimes = 0   #此全局变量用来保存生产了多少次

class producer(threading.Thread):  #生产者
    def run(self):
        global gMoney,gtimes
        while True:
            money = random.randint(100,1000)
            gLock.acquire()     #上锁
            if gtimes >= gTotalTimes:  #如果生产了10次，就退出循环
                gLock.release()
                break
            gMoney += money
            print('%s生产了%d元钱，剩余%d元钱' %(threading.current_thread(),money,gMoney))
            gtimes += 1
            gLock.release()    #解锁
            time.sleep(0.5)

class consumer(threading.Thread):  #消费者
    def run(self):
        global gMoney
        while True:
            money = random.randint(100,1000)
            gLock.acquire()
            if gMoney >= money:
                gMoney -= money
                print('%s消费了%d元钱，剩余%d元钱' % (threading.current_thread(), money, gMoney))
            else:
                if gtimes >= gTotalTimes:
                    gLock.release()
                    break
                print('%s消费者准备消费%d元钱，剩余%d元钱，余额不足' % (threading.current_thread(), money, gMoney))

            gLock.release()  #此处的解锁如果放在if代码块里面，可能会造成死锁
            time.sleep(0.5)

def main():
    for i in range(5):
        t = consumer(name='消费者线程%d' %i)
        t.start()

    for i in range(5):
        t = producer(name='生产者线程%d' %i)
        t.start()

if __name__ == '__main__':
    main()

 

Condition版的生产者和消费者模式：

Lock版本的生产者和消费者模式可以正常的运行。但是存在一个不足，在消费者中，总是通过while Ture死循环并且上锁的方式去判断钱够不够。上锁是一个很费CPU资源的行为，因此这种方式不是最好的。

还有一种更好的方式便是使用threading.Condition来实现。threading.Condition可以在没有数据的时候处于阻塞等待状态。一旦有合适的数据了，还可以使用notify相关的函数来同时其他处于等待状态的线程。这样就可以不用做一些无用的上锁和解锁操作，可以提高程序的性能。threading.Condition和threading.Lock部分功能类似，其相关函数介绍如下：

1、acquire：上锁

2、release：解锁

3、wait：将当前线程处于等待状态，并且会释放锁，可以被其他线程使用notify或者notify_all函数唤醒。被唤醒后会继续等待上锁，上锁后继续执行下面的代码。

4、notify：通知某个正在等待的线程。默认是第1个等待的线程。

5、notify_all：通知所有正在等待的线程。notify和notify_all不会释放锁，因此需要在release之前调用

import threading,random,time

gMoney = 1000 #此全局变量用来保存生产和消费的钱
gCondition = threading.Condition()
gTotalTimes = 10  #此全局变量用来保存需要消费多少次
gtimes = 0   #此全局变量用来保存生产了多少次

class producer(threading.Thread):  #生产者
    def run(self):
        global gMoney,gtimes
        while True:
            money = random.randint(100,1000)
            gCondition.acquire()     #上锁
            if gtimes >= gTotalTimes:  #如果生产了10次，就退出循环
                gCondition.release()
                break
            gMoney += money
            print('%s生产了%d元钱，剩余%d元钱' %(threading.current_thread(),money,gMoney))
            gtimes += 1
            gCondition.notify_all()
            gCondition.release()    #解锁
            time.sleep(0.5)

class consumer(threading.Thread):  #消费者
    def run(self):
        global gMoney
        while True:
            money = random.randint(100,1000)
            gCondition.acquire()
            while gMoney < money:
                if gtimes >= gTotalTimes:
                    gCondition.release()
                    return
                else:
                    print('%s准备消费%d元钱，剩余%d元钱，余额不足' % (threading.current_thread(), money, gMoney))
                gCondition.wait()
            gMoney -= money
            print('%s消费了%d元钱，剩余%d元钱' %(threading.current_thread(),money,gMoney))
            gCondition.release()  #此处的解锁如果放在if代码块里面，可能会造成死锁
            time.sleep(0.5)

def main():
    for i in range(5):
        t = consumer(name='消费者线程%d' %i)
        t.start()

    for i in range(5):
        t = producer(name='生产者线程%d' %i)
        t.start()

if __name__ == '__main__':
    main()