爬虫-- 多线程

1.线程间的资源竞争

⼀个线程写⼊,⼀个线程读取,没问题,如果两个线程都写⼊呢？

import threading
import time
import dis
num=0
def demo1(nums):
    global num
    for i in range(nums):
        num+=1
        print('demo1---%d'%num)
def demo2(nums):
    global num
    for i in range(nums):
        num += 1
        print('demo2---%d' % num)
def main():
    t1=threading.Thread(target=demo1,args=(1000000,))
    t2= threading.Thread(target=demo1, args=(1000000,))
    t1.start()
    t2.start()
    print('main---%d'%num)
if __name__=='__main__':
    main()

2. 互斥锁和死锁

2.1 互斥锁

当多个线程⼏乎同时修改某⼀个共享数据的时候，需要进⾏同步控制。 某个线程要更改共享数据时，先将其锁定，此时资源的状态为"锁定",其他线程 不能改变，只到该线程释放资源，将资源的状态变成"⾮锁定"，其他的线程才能 再次锁定该资源。
互斥锁保证了每次只有⼀个线程进⾏写⼊操作，从⽽保证了 多线程情况下数据的正确性。

 
# 创建锁 
mutex = threading.Lock()
#锁定
mutex.acquire()
#解锁 
mutex.release() 

import threading
import time
#import dis
# mutex=threading.Lock()
mutex=threading.RLock() #可以上多把锁，但是加锁和解锁的数量要一一对应
num=0
def demo1(nums):
    global num
    mutex.acquire()
    mutex.acquire()
    for i in range(nums):
        num += 1
    # mutex.release()
    mutex.release()
    print('demo1---%d'%num)
def demo2(nums):
    global num
    mutex.acquire()
    for i in range(nums):
        num += 1
    mutex.release()
    print('demo2---%d'%num)
def main():
    t1=threading.Thread(target=demo1,args=(1000000,))
    t2=threading.Thread(target=demo2,args=(1000000,))
    t1.start()
    t2.start()
    time.sleep(3)
    print('main---%d'%num)
if __name__ == '__main__':
    main()

2.2 死锁

在线程间共享多个资源的时候，如果两个线程分别占有⼀部分资源并且同时等 待对⽅的资源，就会造成死锁。

import threading
import time 
class MyThread1(threading.Thread):
def run(self):
# 对mutexA上锁 
  mutexA.acquire()
 # mutexA上锁后，延时1秒，等待另外那个线程 把mutexB上锁 
  print(self.name+'----do1---up----') 
  time.sleep(1) 
 # 此时会堵塞，因为这个mutexB已经被另外的线程抢先上锁了 
  mutexB.acquire()
  print(self.name+'----do1---down----') 
  mutexB.release()
 # 对mutexA解锁 
  mutexA.release()
class MyThread2(threading.Thread): 
  def run(self):
  # 对mutexB上锁 
  mutexB.acquire() 
   #mutexB上锁后，延时1秒，等待另外那个线程 把mutexA上锁 
  print(self.name+'----do2---up----') 
  time.sleep(1) 2930
  # 此时会堵塞，因为这个mutexA已经被另外的线程抢先上锁了 
  mutexA.acquire() 
  print(self.name+'----do2---down----') 
  mutexA.release() 3
  # 对mutexB解锁 
  mutexB.release() 
  mutexA = threading.Lock() 
  mutexB = threading.Lock() 
if __name__ == '__main__': 
  t1 = MyThread1()
  t2 = MyThread2() 
  t1.start() 
  t2.start() 

2.3 避免死锁

程序设计时要尽量避免
添加超时时间等

3. Queue线程

在线程中，访问⼀些全局变量，加锁是⼀个经常的过程。如果你是想把⼀些数据存储到某个队列中，那么Python内置了⼀个线程安全的模块叫做queue模块。
Python中的queue模块中提供了同步、线程安全的队列类，包括 FIFO（先进先出）队列Queue，LIFO（后⼊先出）队列LifoQueue。这些队列 都实现了锁原语（可以理解为原⼦操作，即要么不做，要么都做完），能够在 多线程中直接使⽤。可以使⽤队列来实现线程间的同步。
Queue 就是对数据结构中的栈和队列这种数据结构的封装。
初始化Queue(maxsize)：创建一个先进先出的队列。
qsize()：返回队列的大小。
empty()：判断队列是否为空。
full()：判断队列是否满了。
get()：从队列中取最后一个数据。
put()：将一个数据放到队列中。

4.线程同步

import threading
# from threading import Condition
class XiaoAi(threading.Thread):
    def __init__(self,cond):
        # super() 可以用来获取当前类的父类
        super().__init__(name='小爱')
        self.cond = cond
    def run(self):
        # self.cond.acquire()
        # print(4)
        with self.cond:
            self.cond.wait()
            # print(5)
            print('{}: 在'.format(self.name))
            self.cond.notify()
            self.cond.wait()
            print('{}: 你猜猜几点了'.format(self.name))
            self.cond.notify()
        # self.cond.release()
class TianMao(threading.Thread):
    def __init__(self, cond):
        # super() 可以用来获取当前类的父类
        super().__init__(name='天猫')
        self.cond = cond
    def run(self):
        self.cond.acquire()
        print('{}: 小爱同学'.format(self.name))
        # print(1)
        self.cond.notify()
        # print(2)
        self.cond.wait()
        # print(3)
        print('{}: 现在几点了?'.format(self.name))
        self.cond.notify()
        self.cond.release()
if __name__ == '__main__':
    # 定义一把锁
    # mutex = threading.RLock()
    cond = threading.Condition()
    xiaoai = XiaoAi(cond)
    tianmao = TianMao(cond)
    xiaoai.start()
    tianmao.start()

结果

天猫: 小爱同学
小爱: 在
天猫: 现在几点了?
小爱: 你猜猜几点了