<python的线程与threading模块>

一线程的两种调用方式

threading 模块建立在thread 模块之上。thread模块以低级、原始的方式来处理和控制线程，而threading 模块通过对thread进行二次封装，

提供了更方便的api来处理线程。

直接调用：

import threading

import time

def sayhi(num): #定义每个线程要运行的函数

    print("running on number:%s" %num)

    time.sleep(3)

if __name__ == '__main__':

    t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例

    t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例

    t1.start() #启动线程

    t2.start() #启动另一个线程

    print(t1.getName()) #获取线程名

    print(t2.getName())

继承式调用：

import threading

import time

class MyThread(threading.Thread):

    def __init__(self,num):

        threading.Thread.__init__(self)

        self.num = num

    def run(self):#定义每个线程要运行的函数

        print("running on number:%s" %self.num)

        time.sleep(3)

if __name__ == '__main__':

    t1 = MyThread(1)

    t2 = MyThread(2)

    t1.start()

    t2.start()

    print("ending......")

二 threading.thread的实例方法

join&Daemon方法

import threading

from time import ctime,sleep

import time

def ListenMusic(name):

        print ("Begin listening to %s. %s" %(name,ctime()))

        sleep(3)

        print("end listening %s"%ctime())

def RecordBlog(title):

        print ("Begin recording the %s! %s" %(title,ctime()))

        sleep(5)

        print('end recording %s'%ctime())

threads = []

t1 = threading.Thread(target=ListenMusic,args=('水手',))

t2 = threading.Thread(target=RecordBlog,args=('python线程',))

threads.append(t1)

threads.append(t2)

if __name__ == '__main__':

    for t in threads:

        #t.setDaemon(True) #注意:一定在start之前设置

        t.start()

        # t.join()

    # t1.join()

    t1.setDaemon(True)

    #t2.join()########考虑这三种join位置下的结果？

    print ("all over %s" %ctime())

join()：在子线程完成运行之前，这个子线程的父线程将一直被阻塞。

setDaemon(True)：

将线程声明为守护线程，必须在start() 方法调用之前设置，如果不设置为守护线程程序会被无限挂起。这个方法基本和join是相反的。

当我们在程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程就分兵两路，分别运行，那么当主线程完成

想退出时，会检验子线程是否完成。如果子线程未完成，则主线程会等待子线程完成后再退出。但是有时候我们需要的是只要主线程

完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以用setDaemon方法啦

其它方法

# run():  线程被cpu调度后自动执行线程对象的run方法

# start():启动线程活动。

# isAlive(): 返回线程是否活动的。

# getName(): 返回线程名。

# setName(): 设置线程名。

threading模块提供的一些方法：

# threading.currentThread(): 返回当前的线程变量。

# threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。

# threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

三同步锁(Lock)

import time

import threading

def addNum():

    global num #在每个线程中都获取这个全局变量

    #num-=1

    temp=num

    #print('--get num:',num )

    time.sleep(0.1)

    num =temp-1 #对此公共变量进行-1操作

num = 100  #设定一个共享变量

thread_list = []

for i in range(100):

    t = threading.Thread(target=addNum)

    t.start()

    thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕

    t.join()

print('final num:', num )

观察：time.sleep(0.1) /0.001/0.0000001 结果分别是多少？

多个线程都在同时操作同一个共享资源，所以造成了资源破坏，怎么办呢？(join会造成串行，失去所线程的意义)

我们可以通过同步锁来解决这种问题

R=threading.Lock()

####

def sub():

global num

R.acquire()

temp=num-1

time.sleep(0.1)

num=temp

R.release(