• 博客整理day29


    python day29

    进程互斥锁

    ​ 枷锁可以保证多个进程修改同一块数据时,同一时间只能有一个任务可以进行修改,即串行的修改,虽然牺牲了执行效率,保证了数据安全

    ​ 在程序并发执行时,需要修改数据时使用

    '''
    模拟抢票软件需求:
        并发查票与抢票
        1.查看余票
        2.开始抢票
    进程互斥锁:
        让并发变成串行, 牺牲了执行效率, 保证了数据安全.
        在程序并发执行时,需要修改数据时使用.
    '''
    import json
    from multiprocessing import Process
    from multiprocessing import Lock
    
    def search(user):
        with open('data.txt','r',encoding='utf8') as f:
            dic = json.load(f)
        print(f'{user}查询余票,还剩余{dic["ticket_num"]}')
    
    def buy(user):
        with open('data.txt','r',encoding='utf8') as f:
            dic = json.load(f)
    
        if dic['ticket_num'] > 0:
            dic['ticket_num'] -= 1
            with open('data.txt','w',encoding='utf8') as f:
                json.dump(dic,f)
                f.flush()
            print(f'{user}抢票成功!')
    
        else:
            print('没有票了!')
    
    def run(user,mutex):
        search(user)
        mutex.acquire()
        buy(user)
        mutex.release()
    
    if __name__ == '__main__':
        mutex = Lock()
        for i in range(10):
            p = Process(target=run,args=(f'用户{i}', mutex))
            p.start()
    

    进程间通信

    ​ 因为进程之间的数据是相互隔离的,要实现进程间的通信(IPC机制),就必须借助于其他的技术,比如multiprocessing模块中的:

    队列

    ​ 创建共享的进程队列,Queue是多进程安全的队列,可以使用Queue实现多进程之间的数据传递

    队列可以存放多个数据,但是数据要遵循先进先出的顺序

    '''
    队列:先进先出
    	相当于内存中产生一个队列空间
    堆栈: 先进后出
    '''
    from muliprocess import Queue
    
    #调用队列类,实例化队列对象q
    q = Queue(3)
    #put添加数据,若队列的数据满了,则卡住
    q.put(1)
    print('数据1')
    q.put(2)
    print('数据2')
    q.put(3)
    print('数据3')
    
    #查看队列是否满了
    print(q.full())  #True
    #q.get():获取的数据遵循'先进先出',若队列中无数据可取,也会卡住
    print(q.get())
    print(q.get())
    print(q.get())
    #print(q.get())
    
    #get_nowait():也是用来获取数据,队列中若没有,则会报错
    #print(q.get_nowait())
    
    #判断队列是否为空
    print(q.empty())
    q.put(4)
    q.pu_nowait(5)
    
    '''
    IPC(进程间通信):
        进程间数据是相互隔离的,若想实现进程间通信,可以利用队列.
    '''
    from muliprocessing import Process
    from muliprocessing import Queue
    
    def test1(q):
        data = '数据hello'
        q.put(data)
        print('进程1开始添加数据到队列中..')
        
    def test2(q):
        data = q.get()
        print(f'进程2从队列中获取数据{data}')
        
    if __name__ == '__main__':
        q = Queue()
        p1 = Process(target = test1,args = (q,))
        p2 = Process(target = test2,args = (q,))
        
        p1.start()
        p2.start()
    

    生产者消费者模型

    生产者 ----> 产生数据

    消费者 ----> 使用数据

    from multiprocessing import Queue, Process
    import time
    
    # 生产者
    def producer(name, food, q):
        for i in range(9):
            data = food, i
            msg = f'用户{name}开始制作{data}'
            print(msg)
            q.put(data)
            time.sleep(0.1)
    
    # 消费者
    def consumer(name, q):
        while True:
            data = q.get()
            if not data:
                break
            print(f'用户{name}开始吃{data}')
    
    if __name__ == '__main__':
        q = Queue()
        p1 = Process(target=producer, args=('user_1', '鸡腿', q))
        p2 = Process(target=producer, args=('user_2', '薯条', q))
    
        c1 = Process(target=consumer, args=('jack', q))
        c2 = Process(target=consumer, args=('rose', q))
    
        p1.start()
        p2.start()
        c1.start()
        c2.start()
    
        p2.join()
        print('主程序结束!')
    

    线程

    什么是线程

    ​ 在操作系统中,每个进程都有一个地址空间,而且默认就有一个控制线程

    ​ 线程与进程都是虚拟单位,目的是为了更好的描述某种事物,所以,进程只是用来把资源集中到一起,二线程才是cpu上的执行单位

    进程:资源单位

    线程:执行单位

    开启一个进程,一定会有一个线程,线程才是真正的执行者

    为什么要是用线程

    节省内存资源

    开启进程

    1. 开辟一个名称空间,每开启一个进程都会占用一份内存资源
    2. 会自带一个线程
    

    开启线程

    1. 一个进程可以开启多个线程
    2. 线程的开销远小于进程
    

    attention : 线程不能实现并行,线程只能实现并发,进程可以实现并行

    开启线程的方式

    方式一

    from threading import Thread
    import time
    def task():
        print('线程开启')
        time.sleep(1)
        print('线程结束')
        
    if __name__ == '__main__':
        #调用Thread线程类实例化得到线程对象
        t = Thread(target = task)
        t.start()
    

    方式二

    class MyThread(Thread):
        def run(self):
            print('线程开启')
            time.sleep(1)
            print('线程结束')
            
    if __name__ == '__main__':
        t = MyThread()
        t.start()
    

    线程对象的属性

    t.isAlive  判断线程是否还存活
    t.daemon  守护线程
    线程之间的数据是共享的
    

    线程互斥锁

    from threading import Thread,Lock
    import time
    
    mutex = Lock()
    
    n = 100
    
    def task(i):
        print(f'线程{i}启动..')
        global n
        mutex.acquire()
        temp = n
        time.sleep(0.1)
        n = temp - 1
        print(n)
        mutex.release()
        
    if __name__ == '__main__':
        t_list = []
        for i in range(10):
            t = Tread(target = task,args(i,))
            t_list.append(t)
            t.start()
        for i in t_list:
            t.join()
        
        print(n)
    
  • 相关阅读:
    docker on spark
    Install Docker Mac OS X
    HBase 1.1.1 发布(分布式数据库)
    spark streaming原理
    spark RDD的原理
    spark implementation hadoop setup,cleanup
    最近hadoop遇到的issuses
    Spark的日志配置
    大数据系列修炼-Scala课程11
    大数据系列修炼-Scala课程10
  • 原文地址:https://www.cnblogs.com/samoo/p/11722227.html
Copyright © 2020-2023  润新知