Python 多线程

1、 thread.start_new_thread(function, args)

　　功能 ： 开始一个新的线程

　　参数 ： function 为想要执行的函数名字， args 为给执行的函数传递的参数

　　返回类型 ： /

　　备注 ： / 

# -*- coding:UTF-8 -*-
import thread
import time

def testThread(threadName):
for count in range(10):
print threadName, '运行次数：', count

thread.start_new_thread(testThread, ('线程1',))
thread.start_new_thread(testThread, ('线程2',))
thread.start_new_thread(testThread, ('线程3',))
time.sleep(20)

　　运行结果

线程1线程2线程3   运行次数：运行次数：运行次数：   000

线程1线程2线程3   运行次数：运行次数：运行次数：   111

线程1线程2线程3   运行次数：运行次数：运行次数：   222

线程2线程3线程1   运行次数：运行次数：运行次数：   333

线程2线程1线程3   运行次数：运行次数：运行次数：   444

线程2线程3线程1   运行次数：运行次数：运行次数：   555

线程2线程1线程3   运行次数：运行次数：运行次数：   666

线程2线程1线程3   运行次数：运行次数：运行次数：   777

线程2线程1线程3   运行次数：运行次数：运行次数：   888

线程2线程1线程3   运行次数：运行次数：运行次数：   999

　　PS ： 我们看到这个结果（也许你的结果和我的不一样，没关系，这不重要），咦，这是什么东西，首先它不是根据我们写的代码顺序输出，其次，就连输出语句的顺序也不是对应代码中所写的语句顺序。那以我的理解，这就是线程，它执行的顺序是乱七八糟的，我们可以理解为他们在抢 CPU 的资源，谁抢到了，就执行谁，其中，执行时候输出的语句也在争抢。也就是说，我们看到我们输出语句写了三块，输出顺序为：谁 运行次数 几，但是在有线程输出谁时， CPU资源被别人抢走了，所以程序就执行了抢走资源的输出语句，所以运行结果看起来乱七八糟的。（也不知道你看懂了没有，我的表达能力也就这样了）

2、 写一个类继承 threading.Thread 然后调用 start() 方法

# -*- coding:UTF-8 -*-
import threading

class myThread(threading.Thread):
def __init__(self, name):
threading.Thread.__init__(self)
self.name = name

def run(self):
myWay(self.name)

def myWay(who):
for i in range(10):
print who, '走路中...走了', i+1, '步'

thread1 = myThread('AAA')
thread2 = myThread('BBB')

thread1.start()
thread2.start()

　　运行结果

AAA 走路中...走了 1 步BBB
AAA走路中...走了  走路中...走了1  2步
步BBB
AAA走路中...走了  走路中...走了2  3步
步BBB
AAA走路中...走了  走路中...走了3  4步
步BBB
AAA走路中...走了  走路中...走了4  5步
步BBB
AAA走路中...走了  走路中...走了5 6  步步

BBBAAA  走路中...走了走路中...走了  67  步步

BBBAAA  走路中...走了走路中...走了  78  步步

BBBAAA  走路中...走了走路中...走了  89  步步

BBBAAA  走路中...走了走路中...走了  910  步步

BBB 走路中...走了 10 步

　　PS ： 该执行解释同上

　　PPS ： 为了能够完整输出一句我们能看懂的话，这里就得用一个知识点 ： 线程同步

3、 线程同步

　　解释 ： 以我的理解，线程同步就是用锁锁住线程，使锁中（zhong 第四声）的线程执行的数据一起执行，也就是说刚才的输出语句三部份，我们用一个锁来锁住，它就会一起执行，也就是不论谁抢到了 CPU 资源，都是输出这三部分，然后别的线程才能抢到 CPU 的资源，直接看代码好理解一些，毕竟我的说话水平这么马虎。

# -*- coding:UTF-8 -*-
import thread
import threading
import time

def testThread(threadName):
for count in range(10):
threadLock.acquire()
print threadName, '运行次数：', count
threadLock.release()

threadLock = threading.Lock()

thread.start_new_thread(testThread, ('线程1',))
thread.start_new_thread(testThread, ('线程2',))
thread.start_new_thread(testThread, ('线程3',))
time.sleep(20)

　　运行结果

线程1 运行次数： 0
线程2 运行次数： 0
线程3 运行次数： 0
线程1 运行次数： 1
线程2 运行次数： 1
线程3 运行次数： 1
线程1 运行次数： 2
线程2 运行次数： 2
线程3 运行次数： 2
线程1 运行次数： 3
线程2 运行次数： 3
线程3 运行次数： 3
线程1 运行次数： 4
线程2 运行次数： 4
线程3 运行次数： 4
线程1 运行次数： 5
线程2 运行次数： 5
线程3 运行次数： 5
线程1 运行次数： 6
线程2 运行次数： 6
线程3 运行次数： 6
线程1 运行次数： 7
线程2 运行次数： 7
线程3 运行次数： 7
线程1 运行次数： 8
线程2 运行次数： 8
线程3 运行次数： 8
线程1 运行次数： 9
线程2 运行次数： 9
线程3 运行次数： 9

　　PS ： 我们可以看出，就加了几行代码，输出语句就很直观，同时发现线程123的顺序是乱的，这也就很好理解线程在抢 CPU 的资源，谁抢到就执行谁。

　　PPS ： 讲一个我记得的小故事帮助你理解线程锁

大家应该都有银行卡哈，我们的银行卡自己可以用，媳妇可以用（当然我没有，你们应该...），儿女也可以用（我也没得，你们就...）。
如果不加入线程锁，那么情况是这样子的 ：
你和你媳妇同时取钱，你看到卡上余额 100 块，你媳妇也看到了，然后你取了 10 块钱， 你媳妇取了 50 块 ，然后你们就溜了。第二天钱用完了，你又得取钱了， 你媳妇也得取钱了， 然后你们插上卡，看到余额 40 块，我的天哪，疯了，钱对不上了。这可咋整， 找银行处理吧， 看看什么情况， 不看不知道， 一看吓一跳， 真是心有灵犀， 你和你媳妇同时取钱。 真好。可以万一有一天看到的是你和别的男生同时取钱呢（......）
加入线程锁，那么情况是这样子的 ：
你去取钱， 你媳妇也取钱 ， 你还是取 10 块，然后你媳妇还是取 50 块，但是这次你取得同时你媳妇不可以取了， 等你取完了， 然后你媳妇看到的是你取了剩下的钱， 而不是原来的 100 块，下次看到余额，就没有问题了，被别的男生取了也不知道了（......）

转载于:https://www.cnblogs.com/rainbow-tan/p/11364433.html