美文网首页
2018-09-13-day19多线程基础

2018-09-13-day19多线程基础

作者: oxd001 | 来源:发表于2018-09-15 14:56 被阅读0次

    1.什么是进程?

    进程是指在系统中正在运行的一个应用程序
    每个进程之间是独立的,每个进程均运行在其专用且受保护的内存空间内

    2.什么是线程?

    1个进程想要执行任务,必须要有线程(每一个进程至少要有1条线程)
    一个进程(程序)的所有任务都在线程中执行
    1个线程中的任务是串行的,如果一个线程中执行多个任务,那么只能一个一个按顺序执行这些任务

    3.多线程

    1个进程中开启多条线程,每条线程可以并行(同时)执行不同的任务
    注意:同一时间,cpu只能处理1条线程,只有1条线程在工作(执行)
    多线程并发(同时)执行,其实是cpu快速地在多条线程之间调度(切换),如果cpu调度线程的时间足够快,
    就造成了多线程并发执行的假象
    多线程能提高效率,主要是因为线程有阻塞或者耗时操作,这个时候就会执行其他线程
    思考:如果线程非常非常多,会发生什么情况?
    cpu会在N多线程之间调度,cpu会累死,消耗大量的cpu资源
    每条线程被调度执行的频次会降低(线程的执行效率降低)
    4.多线程执行过程

    多线程执行过程.PNG

    5.多线程提高效率


    多线程提高效率.PNG

    6.多线程实现方式
    方式一:

    """
    1.主线程
    每个进程默认都会有一个线程,这个线程我们一般叫它主线程。
    默认情况下,所有的代码都是在主线程中执行。
    
    2.子线程
    一个进程中可以有多个线程。除了主线程以外,其他的线程需要手动的添加
    
    3.threading是python中的一个内置模块,用来支持多线程
    a.Thread类
    Thread类的对象就是线程对象,需要线程的时候,就创建这个类或者这个类的子类对象
    
    b.threading.currentThread() --> 用来获取当前线程对象
    
    """
    import threading
    # from threading import Thread
    import datetime
    
    import time
    
    
    # 下载两个电影
    def download(file):
        print(threading.currentThread())
        print('开始下载:'+file, datetime.datetime.now())
        # 让线程阻塞10秒
        time.sleep(10)
        print(file+'下载结束:', datetime.datetime.now())
    
    
    if __name__ == '__main__':
        print('主线程中的代码')
        print(threading.currentThread())
    
        # 1.在主线程中下载两个电影:总共耗时20秒
        # download('终结者2')
        # download('沉默的羔羊')
    
        # 2.在两个子线程中去下载两个电影: 总共耗时10秒
        """
        Thread(target,args)
        target: 需要在子线程中调用的函数的函数名
        args: 函数的实参
        返回值: 创建好的线程对象
        """
        t1 = threading.Thread(target=download, args=('终结者',))
        # # 开始执行t1对应的线程中的任务
        t1.start()
    
        t2 = threading.Thread(target=download, args=('沉默的羔羊',))
        # 想要在子线程中执行任务,必须通过线程对象调用start方法才行
        t2.start()
    
        print('==========')
    
    

    方式二:

    from threading import Thread
    import datetime
    import time
    from random import randint
    
    """
    面向对象实现多线程技术
    1.声明一个类继承自Thread类
    2.重写run方法,将需要在子线程中执行的任务放到run方法中
    3.在需要子线程的位置去创建这个类的对象,然后用对象调用start方法去执行run中的任务
    """
    
    
    #  注意:继承的时候,可以继承自己写的类,也可以继承系统的类或者别人写好的类
    class DownloadThread(Thread):
        """下载线程类"""
        def __init__(self, file):
            super().__init__()
            self.file = file
    
        def run(self):
            print(self.file + '开始下载:', datetime.datetime.now())
            time.sleep(randint(5, 10))
            print(self.file + '下载结束:', datetime.datetime.now())
    
    
    if __name__ == '__main__':
    
        print('========')
    
        # 创建线程对象
        t1 = DownloadThread('沉默的羔羊')
        t1.start()
    
        t2 = DownloadThread('恐怖游轮')
        t2.start()
    
        print('++++++++')
    
    

    join在多线程中的作用

    from threading import Thread
    import time
    from datetime import datetime
    from random import randint
    
    
    # 在两个子线程中下载两个电影,在主线程中去统计两个电影下载的总的时间
    """
    如果希望某个线程结束后才执行某个操作,就用那个线程调用join方法
    """
    class DownloadThread(Thread):
        def __init__(self, file):
            super().__init__()
            self.file = file
    
        def run(self):
            print(self.file+'开始下载', datetime.now())
            time.sleep(randint(5, 15))
            print(self.file+'下载结束', datetime.now())
            return 10
    
    
    if __name__ == '__main__':
    
        t1 = DownloadThread('美丽人生')
        t2 = DownloadThread('怦然心动')
    
        start = time.time()
    
        tim1 = t1.start()
        tim2 = t2.start()
    
        # 系统t1和t2中的代码都结束后才执行下面的代码
        t1.join()   # 这句代码后面的代码在t1对应的线程结束后才执行
        t2.join()
        end = time.time()
        print(end-start)
    
    

    如何实现线程间的数据共享

    """
    模拟多个人对同一个账号进行操作
    
    同步锁(RLock)和互斥锁(Lock)
    """
    import time
    from threading import Thread, Lock, RLock
    
    
    class Account:
        """账号类"""
        def __init__(self, balance):
            # 余额
            self.balance = balance
            # 创建锁对象
            self.lock = Lock()
            self.lock2 = RLock()
    
    
        # 存钱的过程:读出原来的余额,确定钱的一系列操作,将原来的余额加上存的数额产生最新的余额再保存
        def save_money(self, amount):
            """存钱"""
            print('开始存钱')
            # 加锁
            self.lock.acquire()
            # 获取原来的余额
            old_amount = self.balance
            # 模拟时间消耗
            time.sleep(5)
            # 修改余额
            self.balance = old_amount + amount
            print('存钱成功!,最新余额是:', self.balance)
            # 解锁
            self.lock.release()
    
        def get_money(self, amount):
            """取钱"""
            print('开始取钱')
            old_amount = self.balance
            if old_amount < amount:
                print('余额不足!')
                return
            time.sleep(5)
            self.balance = old_amount - amount
            print('取钱成功,最新余额是:',self.balance)
    
        def show_balance(self):
            print('当前余额为:', self.balance)
    
    
    if __name__ == '__main__':
        # 创建账号
        account = Account(1000)
    
        # account.save_money(200)
        # account.save_money(1300)
        # account.get_money(800)
        # account.show_balance()
        """
        当多个线程同时对一个数据进行操作的时候,可能会出现数据混乱的问题
        """
        t1 = Thread(target=account.save_money, args=(200,))
        t2 = Thread(target=account.save_money, args=(1300,))
    
        t1.start()
        t2.start()
    
    

    相关文章

      网友评论

          本文标题:2018-09-13-day19多线程基础

          本文链接:https://www.haomeiwen.com/subject/pizzgftx.html