线程同步:

一个场景:

　　一个列表里所有元素都是0,线程A从后向前把所有元素改成1,而线程B负责从前往后读取列表并打印.

那么,可能线程A开始改的时候,线程B便来打印列表了,输出就变成一半0一半1,这就是数据的不同步

　　线程同步就是为了防止这个,同时也引入了锁的概念.Lock和Rlock可以实现线程同步.这两个对象都有

acquire方法和release方法,对于那些需要每次只允许一个线程操作的数据,可以将其操作放到acquire和release方法之间.

你可以理解为这两个方法之间的东西会被锁定.

　　每当一个线程比如A要访问共享数据时,必须先获得锁定;如果已经有别的线程比如B获得锁定了,那么就让线程A暂停,

也就是同步阻塞;等到线程B访问完毕,释放锁之后,再让线程A继续

　　经过这样的处理,打印列表时要么全部输出0,要么全部输出1,不会再出现一半0一半1

 

常用方法:

threading.Lock()　　同一线程不能连续多次acquire,否则死锁
threading.RLock()　　同一线程允许连续acquire,但是acquire和release必须成对出现


import threading 
import time #用于停顿的


class myThread(threading.Thread):    #使用多线程,必须要继承父类threading.Thread
    def __init__(self,threadID,name,counter):
        threading.Thread.__init__(self)   #固定格式,相当于线程的初始化
        self.threadID = threadID
        self.name = name
        self.counter = counter
        print('初始化完成')
        
    def run(self):    #你不能确定run()在不同线程间的执行顺序,这个由CPU处理来决定的
        print("开始线程" + self.name)
        
        #获取锁,成功获得锁定后返回True,可选的timeout参数不填时将一直阻塞直到获得锁定
        threadLock.acquire()
        print_time(self.name,self.counter,3)
        #释放锁,开始下一个线程
        threadLock.release()

def print_time(threadName,counter,delay):
    while counter:
        time.sleep(delay)#停顿5s
        print("%s:%s"%(threadName,time.ctime(time.time())))#打印线程名和时间
        counter = counter - 1


threadLock = threading.Lock() #方法返回一个值,用变量threadLock接收
threads = [] #暂时忽略这句

#创建线程,生成两个对象
thread1 = myThread(1,"Thread-1",1)
thread2 = myThread(2,"Thread-2",2)

#开启线程
thread1.start()    #启动线程,每个线程对象必须至少调用一次该函数,他会自动调用run()方法
thread2.start()

#将两个线程追加到空列表
threads.append(thread1)
threads.append(thread2)

#join([time])   等待至线程中止.这阻塞调用线程直至线程的join()方法被调用中止,正常退出或者抛出
#未处理的异常,或者可选的超时反生
#检测线程是否全都运行完成,等待完成后,再执行join()之后的内容
for t in threads:
    t.join()
    
print("我等到花儿也谢了,海儿也哭了,嗯,活该...")

 

结果:

初始化完成
初始化完成
开始线程Thread-1
开始线程Thread-2
Thread-1:Sat Jun 17 01:22:44 2017
Thread-2:Sat Jun 17 01:22:47 2017
Thread-2:Sat Jun 17 01:22:50 2017
我等到花儿也谢了,海儿也哭了,嗯,活该...