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模块里的常用方法

  1. threading.currentThread()  返回当前的线程变量
  2. threading.enumerate()    返回一个包含正在运行的线程的list,正在运行指线程启动后、结束后,不包括启动前和终止后的线程
  3. 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

 

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

 

                                                                             笔者:拍省先生

 

posted @ 2016-07-24 21:04  财经知识狂魔  阅读(201)  评论(0编辑  收藏  举报