• 线程


    线程:
    操作系统调度的最小单位, 一串指令集和,要操作cpu,至少要先创建一个线程,叫驻现场
    同一个进程里的线程共享同一块内存
    同一个进程里的两个线程内存共享
    创建新线程很简单
    一个线程可以操作同一个进程里线程
    主线程是程序本身,不是自己建立的线程
    调用操作系统,c语言的pthread
    threading.current_thread(),查看当前线程角色
    threading.active_count(),查看当前线程数量
    thread_name.join() #线程获取到执行结果之前不继续run


    import threading
    import time
    
    # 普通写法
    def run(n):
        print("task", n)
        time.sleep(2)
    
    t1 = threading.Thread(target=run, args=("t1",))
    t2 = threading.Thread(target=run, args=("t2",))
    t1.start()
    t2.start()
    
    
    # 继承写法
    class MyThread(threading.Thread):
        def __init__(self, n):
            super(MyThread, self).__init__()
            self.n = n
    
        def run(self):
            print("runing task ", self.n)
            time.sleep(2)
    
    t3 = MyThread("t3")
    t4 = MyThread("t4")
    t3.start()
    t4.start()
    
    
    



    GIL锁:
    全局解释器锁(CPython独有)
    保证同一时间只能有一个线程执行

    多线程没有线程锁执行步骤:
    0,源生数据n=0
    1,线程池生成py thread a
    2,申请gil锁,以便操作cpu
    3,调用系统源生线程
    4,在cpu上执行
    5,执行时间到了,被要求释放gil锁,解释器每一百条切换一次锁
    6,第二个线程拿到公共数据 py thread b
    7,申请gil
    8,调用源生线程
    9,在cpu上执行
    10,完成公共数据加减操作n=0+1
    11,反馈给公共数据
    12,线程a再次申请gil锁
    13,计算完毕n=0+1
    14,反馈给公共数据n=1

    线程锁(mutex):
    保证同一时间只有一个线程修改数据
    lock = threading.Lock()
    lock.acquire()
    lock.release()

    递归锁(Rlock):
    在一个大锁中还要在包含子锁,避免死循环
    threading.RLock()

    信号量(Semaphore)
    允许一定量的线程更改数据,跟锁的区别是有多把锁
    semaphore = threading.BoundedSemaphore(5) #同时允许多少个线程在活动
    semaphore.acquire()
    semaphore.release()


    event
    是简单的同步对象
    event = threading.Event()
    event.set() #标识位被设置,绿灯,直接同行
    event.clear() #标识位被清空,红灯,等待再次set
    event.wait() #等待标识位被设置
     
    #!/usr/bin/env python3
    # -*- coding:utf-8 -*-
    # -*- Author:Hinimix -*-
    
    import time
    import threading
    
    event = threading.Event()
    def lighter():
        count = 0
        event.set()
        while True:
            if count > 5 and count < 10:
                event.clear()
                print("33[41;1mred light 33[0m", count)
            elif count > 10:
                count = 0
                event.set()
            else:
                print("33[46;1mgreen light 33[0m", count)
            time.sleep(1)
            count += 1
    
    
    def car(name):
        while True:
            time.sleep(1)
            if event.is_set():
                print(name, "is running")
            else:
                print(name, "is waiting")
                event.wait()
    
    
    light = threading.Thread(target=lighter,)
    light.start()
    
    car1 = threading.Thread(target=car,args=("hondacity",))
    car1.start()
    car2 = threading.Thread(target=car,args=("benz",))
    car2.start()
    car3 = threading.Thread(target=car,args=("toyoto",))
    car3.start()
    queue(线程queue)
    class queue.Queue(maxsize=0) #先入先出
    class queue.LifoQueue(maxsize=0) #后入先出 last in first out
    class queue.PriorityQueue(maxsize=0) #按优先级
    queue.qsize() #查询队列后面还有多长
    #!/usr/bin/env python3
    # -*- coding:utf-8 -*-
    # -*- Author:Hinimix -*-
    
    import queue
    q = queue.Queue(maxsize=100)    #指定队列长度
    q.put("h1")
    q.put("h2")
    print(q.qsize())
    print(q.get())
    print(q.get())
    # print(q.get())      #队列没有数据时候会卡住
    # print(q.get(block=False))      #队列没有数据时候会不会卡住
    print(q.get_nowait())   #队列没有数据时候会不会卡住
    
    

     有优先级的队列

    import queue
    q = queue.PriorityQueue(maxsize=10)
    
    q.put((10, "h1"))
    q.put((-20, "h2"))
    # 优先级越低越先出
    print(q.get())
    print(q.get())
    多线程使用场景:
    不适合CPU密集操作型任务, 适合IO密集型任务
     
  • 相关阅读:
    LeetCode 204
    华为OJ2051-最小的K个数(Top K问题)
    华为OJ1964-求解立方根(牛顿迭代法)
    华为OJ2288-合唱队(最长递增子序列)
    华为OJ2011-最长公共子串
    【Unix编程】进程间通信(IPC)
    可利用空间表(Free List)
    13.10 Scrapy 通用爬虫
    13.9 Scrapy 对接 Splash
    第十四章 分布式爬虫
  • 原文地址:https://www.cnblogs.com/hinimix/p/9134286.html
Copyright © 2020-2023  润新知