python基础-第九篇-9.2线程与多线程

单线程

import time

beginTime = time.time()

for a in range(10):

    print(a)

    time.sleep(1)

shijian = time.time() - beginTime

print(shijian)  #10.000571966171265

　　我们可以看到，上面这段代码就是纯正的单线程，一条道走到黑，讲究先后，所以花了10秒多

多线程

　　毕竟等待是让人心烦的，有什么方法能不这么耗时间啊，有啊，主角登场，欢迎多线程，那多线程做了一件什么事呢？它可以同时做多件事，就拿上面例子，在这个线程睡觉时，它会去执行其他的线程。

import threading

import time

def printNum(a):

    time.sleep(1)

    print(a)

beginTime = time.time()

for i in range(10):

    t = threading.Thread(target=printNum,args=(i,))

    t.start()

# for i in range(10):

#     t.join()

shijian = time.time() - beginTime

print(shijian)

结果为：

    0.0010001659393310547

    2

    1

    0

    4

    6

    9

    3

    5

    7

    8

　　看到这，你可能会想，输出的结果怎么是无序的，就是因为多线程是每个线程各自去执行自己的，所以就有可能存在抢占输出资源的情况。

　　你可能又会想，怎么只要0.001秒就完成了，太不符合逻辑了，那我告诉你，这个时间为主线程的执行时间，如果要知道所有的线程执行时间，只要解注释t.join()这两句代码就可以了，结果一般为1秒多点点。

过程详解

#引入线程模块threading

import threading

import time

#定义线程中的执行方法

def printNum(a):

    print('num:',a)

    time.sleep(1)

def printStr(str1,str2):

    print(str1,':',str2)

    time.sleep(1)

#初始化一个线程对象

t_0 = threading.Thread(target=printNum,args=(888,))

#启动线程

t_0.start()

#target指定需要执行的函数名，args指定元组形式的参数

t_1 = threading.Thread(target=printStr,args=('this is the arg','string'))

t_1.start()

#一次创建10个线程对象并启动

for i in range(10):

    t = threading.Thread(target=printNum,args=(i,))

    t.start()

threading模块详解

　　Python的线程中没有优先级、线程组，也不能被停止、暂停、恢复、中断，线程只能随着线程中的代码执行完毕而被销毁、

　　threading模块提供的类

　　--Thread, Lock, Rlock, Condition, [Bounded]Semaphore, Event, Timer, local

　　threading模块里的常用方法

threading.currentThread() 返回当前的线程变量
threading.enumerate（）返回一个包含正在运行的线程的list，正在运行指线程启动后、结束后，不包括启动前和终止后的线程
threading.activeCount（）返回正在运行的线程数量，与len（threading.enumerate（））相同结果

join的高级用法

import time

import threading

def printNum(a):

    print('num:',a)

    time.sleep(1)

def ThreadTest():

    return threading.Thread(target=printNum,args=(999,))

thread_li = []

for i in range(10):

    t = ThreadTest()

    thread_li.append(t)

for t in thread_li:

    t.start()

for t in thread_li:

    t.join()

print('finished')

　　我们从上面的代码可以看出，join方法不再像以前一样让线程一个一个排队执行了，所有的线程并发执行完后，才会执行主线程最后的代码！

Lock类和Rloc类

　　锁住资源，让线程一个一个来操作

acquire 给线程上锁
release 给线程解锁

import threading

lock = threading.Lock()  #创建锁对象

lock.acquire()

lock.acquire() #生成死锁，阻塞

lock.release()

lock.release()

　　Lock上锁与解锁两个方法只能一前一后出现，否则很容易出现死锁

import threading

Rlock = threading.RLock()  #创建锁对象

Rlock.acquire()

Rlock.acquire() #没有阻塞

Rlock.release()

Rlock.release()

　　而Rlock就比较随意，只要上锁和解锁两个方法成双出现就可以了

更多详细内容请见：http://www.cnblogs.com/xinsiwei18/p/5697802.html

欢迎大家对我的博客内容提出质疑和提问！谢谢

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 笔者：拍省先生