精华内容
下载资源
问答
  • 主要介绍了python多线程实现同时执行两个while循环的操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 1.模拟银行服务完成程序代码 目前,在以银行营业大厅为代表的窗口行业中大量使用排队(叫号)系统,该系统完全模拟了人群排队全过程,通过取票进队、排队等待、叫号服务等功能,代替了人们站队的辛苦。...
  • 能根据url的个数快速开启对个线程,单个线程可以实现对同一个url的次访问,返回访问成功或者失败的结果
  • 本文给大家分享的是Python使用多线程通过ping命令检测服务器的在线状况,给大家了内网和外网的2个例子,有需要的小伙伴可以参考下。
  • 本文实例为大家分享了python多线程实现TCP服务端的具体代码,供大家参考,具体内容如下 需求 1.创建一个TCP服务器接收服务端发送的信息并给予答复 2.以多线程方式实现接收客户端信息 3.间客户端发送的信息解码...
  • 临界资源即那些一次只能被一个线程访问的资源,典型例子就是打印机,它一次只能被一个程序用来执行打印功能,因为不能线程同时操作,而访问这部分资源的代码通常称之为临界区。 锁机制 threading的Lock类,用该...
  • python多线程实现selenium定时循环发送huya弹幕
  • Python多线程实现程序加速

    千次阅读 2020-02-15 21:29:57
    多线程即同时执行多个应用程序,这样可以减少时间消耗,提高程序性能,所以下面就和大家分享Python多线程实现。主要包括以下几个方面: 什么是Python中的多任务处理? 什么是线程? 何时在Python中使用多线程? ...

    多线程即同时执行多个应用程序,这样可以减少时间消耗,提高程序性能,所以下面就和大家分享Python中多线程的实现。主要包括以下几个方面:

    什么是Python中的多任务处理?

    什么是线程?

    何时在Python中使用多线程?

    如何在Python中实现多线程?

    多线程的优点

    什么是Python中的多任务处理?

    通常,多任务处理是同时执行多个任务的能力。在技术方面,多任务处理是指操作系统同时执行不同任务的能力。例如,您正在PC上下载内容以及收听歌曲和同时玩游戏等。所有这些任务都由同一个OS同步执行。这不过是多任务处理,它不仅可以帮助您节省时间,还可以提高工作效率。操作系统中有两种类型的多任务处理:

    基于进程

    基于线程

    什么是线程?
    在这里插入图片描述
    线程基本上是一个独立的执行流程。单个进程可以包含多个线程。程序中的每个线程都执行特定任务。例如,当你在PC上玩游戏时说FIFA,整个游戏只是一个进程,但它由几个负责播放音乐,接受用户输入,同步运行游戏等的线程组成。所有这些都是独立的线程,负责在同一程序中执行这些不同的任务。每个进程都有一个始终在运行的线程。这是主线程。这个主线程实际上创建了子线程对象。子线程也由主线程启动。

    何时在Python中使用多线程?

    多线程对于节省时间和提高性能非常有用,但它也有一些应用限制。在之前的FIFA示例中,音乐线程独立于获取输入的线程,而获取输入的线程独立于运行游戏的线程。这些线程独立运行,因为它们不是相互依赖的。因此只有各个线程之间不存在依赖关系时才能使用多线程。

    如何在Python中实现多线程?

    Python中的多线程可以通过导入threading模块来实现。在导入此模块之前,可以使用pip3安装。要在anaconda环境中可以使用conda命令安装。

    成功安装后,您可以使用以下一个命令导入threading模块:

    如何在Python中创建线程?

    Python中的线程可以通过三种方式创建:

    没有创建一个类

    通过扩展Thread类

    没有扩展Thread类

    没有创建一个类

    Python中的多线程也可以在不创建类的情况下完成。以下是一个示例:

    程序表示第一个线程是主线程。然后,该主线程创建一个正在执行该函数的子线程,然后由主线程再次执行最终的print语句。输出结果为:

    扩展Thread类:

    通过扩展Thread类创建子类时,子类表示新线程正在执行某个任务。扩展Thread类时,子类只能覆盖两个方法,即__init __()方法和run()方法。除了这两种方法之外,没有其他方法可以被覆盖。以下是如何扩展Thread类以创建线程的示例:

    输出结果为:

    上面的例子表明myclass类继承了Thread类和子类,即myclass重写了run方法。默认情况下,任何类函数的第一个参数都需要是self,它是指向当前对象的指针。输出显示子线程执行run()方法,主线程等待子进程执行完成。这是因为join()函数使主线程等待子进程完成。这种创建线程的方法是最标准的方法,但是如果您想在不继承或扩展Thread类的情况下创建线程,可以参见下一个示例。

    没有扩展Thread类

    要在不扩展Thread类的情况下创建线程,可以[添加链接描述通过以下示例代码:

    程序通过子线程执行myfunc,之后主线程执行最后一个print语句。输出结果为:

    使用线程的优点

    总结多线程的优点如下:

    更好地利用资源

    简化代码

    允许并发和并行发生各种任务

    减少时间消耗或响应时间,从而提高性能。

    下面通过一个示例来比较在python中使用和不使用多线程执行代码所需的时间:

    首先我们计算不使用线程所需要的时间,程序如下:

    需要时间为:9.040220737457275。通过以上一个简单的示例比较可以看出与不使用线程执行相同程序所花费的时间相比,我们使用线程所花费的时间要少得多。因此在执行多个相互间不冲突的任务时,可以通过多线程进行程序加速。
    推荐我们的python学习基地,看老程序是如何学习的!从基础的python脚本、爬虫、django、数据挖掘等编程技术,工作经验,还有前辈精心为学习python的小伙伴整理零基础到项目实战的资料,!每天都有程序员定时讲解Python技术,分享一些学习的方法和需要留意的小细节,

    展开全文
  • 编写一个有2个线程的程序 线程1用来接收数据然后显示 线程2用来检测键盘数据然后通过udp发送数据 import socket import threading def send_msg(udp_socket): """获取键盘数据,并将其发送给对方""" while ...

    需求:

    • 编写一个有2个线程的程序
    • 线程1用来接收数据然后显示
    • 线程2用来检测键盘数据然后通过udp发送数据
    import socket
    import threading
    
    
    def send_msg(udp_socket):
        """获取键盘数据,并将其发送给对方"""
        while True:
            # 1. 从键盘输入数据
            msg = input("\n请输入要发送的数据:")
            # 2. 输入对方的ip地址
            dest_ip = input("\n请输入对方的ip地址:")
            # 3. 输入对方的port
            dest_port = int(input("\n请输入对方的port:"))
            # 4. 发送数据
            udp_socket.sendto(msg.encode("gbk"), (dest_ip, dest_port))
    
    
    def recv_msg(udp_socket):
        """接收数据并显示"""
        while True:
            # 1. 接收数据
            recv_msg = udp_socket.recvfrom(1024)
            # 2. 解码
            recv_ip = recv_msg[1]
            recv_msg = recv_msg[0].decode("gbk")  #注意这里的编码如果是windows选择gbk,linux选择utf-8
            # 3. 显示接收到的数据
            print(">>>%s:%s" % (str(recv_ip), recv_msg))
    
    
    def main():
        # 1. 创建套接字
        udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        # 2. 绑定本地信息
        udp_socket.bind(("", 7890))
    
        # 3. 创建一个子线程用来接收数据
        t = threading.Thread(target=recv_msg, args=(udp_socket,))
        t.start()
        # 4. 让主线程用来检测键盘数据并且发送
        send_msg(udp_socket)
    
    if __name__ == "__main__":
        main()
    

    启动程序,启动网路调试助手,多个客户端同时与之通信

    请输入要发送的数据:fasdfads建安家居
    
    请输入对方的ip地址:192.168.1.1
    
    请输入对方的port:6666
    
    请输入要发送的数据:>>>('192.168.1.1', 6666):来自网络调试助手7777
    
    
    请输入对方的ip地址:192.168.1.1
    
    请输入对方的port:4444
    
    请输入要发送的数据:fasdfasdf嘎嘎嘎嘎嘎过
    
    请输入对方的ip地址:192.168.1.1
    
    请输入对方的port:4444
    
    请输入要发送的数据:>>>('192.168.1.1', 4444):来自4444的fasdfasdf
    >>>('192.168.1.1', 6666):来自网络调试助手7777fdsfds
    >>>('192.168.1.1', 4444):来自4444的fasdfasdfsfsfd少时诵诗书所所所所所所所所所

    统一声明:关于原创博客内容,可能会有部分内容参考自互联网,如有原创链接会声明引用;如找不到原创链接,在此声明如有侵权请联系删除哈。关于转载博客,如有原创链接会声明;如找不到原创链接,在此声明如有侵权请联系删除哈。

    展开全文
  • 主要为大家详细介绍了python多线程同步之文件读写控制,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Python多线程实现生产者消费者模式

    千次阅读 2020-07-15 17:25:59
    某些模块负责生产数据,这些数据由其他模块来负责处理(此处的模块可能是:函数、线程、进程等)。产生数据的模块称为生产者,而处理数据的模块称为消费者。在生产者与消费者之间的缓冲区称之为仓库。生产者负责往...

    什么是生产者消费者模式

    在软件开发的过程中,经常碰到这样的场景:
    某些模块负责生产数据,这些数据由其他模块来负责处理(此处的模块可能是:函数、线程、进程等)。产生数据的模块称为生产者,而处理数据的模块称为消费者。在生产者与消费者之间的缓冲区称之为仓库。生产者负责往仓库运输商品,而消费者负责从仓库里取出商品,这就构成了生产者消费者模式。
    结构图如下:
    在这里插入图片描述

    为了大家容易理解,我们举一个寄信的例子。假设你要寄一封信,大致过程如下:
    1、你把信写好——相当于生产者生产数据
    2、你把信放入邮箱——相当于生产者把数据放入缓冲区
    3、邮递员把信从邮箱取出,做相应处理——相当于消费者把数据取出缓冲区,处理数据

    生产者消费者模式的优点

    • 解耦

    假设生产者和消费者分别是两个线程。如果让生产者直接调用消费者的某个方法,那么生产者对于消费者就会产生依赖(也就是耦合)。如果未来消费者的代码发生变化,可能会影响到生产者的代码。而如果两者都依赖于某个缓冲区,两者之间不直接依赖,耦合也就相应降低了。
    举个例子,我们去邮局投递信件,如果不使用邮箱(也就是缓冲区),你必须得把信直接交给邮递员。有同学会说,直接给邮递员不是挺简单的嘛?其实不简单,你必须 得认识谁是邮递员,才能把信给他。这就产生了你和邮递员之间的依赖(相当于生产者和消费者的强耦合)。万一哪天邮递员 换人了,你还要重新认识一下(相当于消费者变化导致修改生产者代码)。而邮箱相对来说比较固定,你依赖它的成本就比较低(相当于和缓冲区之间的弱耦合)。

    • 并发

    由于生产者与消费者是两个独立的并发体,他们之间是用缓冲区通信的,生产者只需要往缓冲区里丢数据,就可以继续生产下一个数据,而消费者只需要从缓冲区拿数据即可,这样就不会因为彼此的处理速度而发生阻塞。
    继续上面的例子,如果我们不使用邮箱,就得在邮局等邮递员,直到他回来,把信件交给他,这期间我们啥事儿都不能干(也就是生产者阻塞)。或者邮递员得挨家挨户问,谁要寄信(相当于消费者轮询)。

    • 支持忙闲不均

    当生产者制造数据快的时候,消费者来不及处理,未处理的数据可以暂时存在缓冲区中,慢慢处理掉。而不至于因为消费者的性能造成数据丢失或影响生产者生产。
    我们再拿寄信的例子,假设邮递员一次只能带走1000封信,万一碰上情人节(或是圣诞节)送贺卡,需要寄出去的信超过了1000封,这时候邮箱这个缓冲区就派上用场了。邮递员把来不及带走的信暂存在邮箱中,等下次过来时再拿走。
    通过上面的介绍大家应该已经明白了生产者消费者模式。

    Python中的多线程编程

    在实现生产者消费者模式之前,我们先学习下Python中的多线程编程。
    线程是操作系统直接支持的执行单元,高级语言通常都内置多线程的支持,Python也不例外,并且Python的线程是真正的Posix Thread,而不是模拟出来的线程。
    Python的标准库提供了两个模块:_thread和threading,_thread是低级模块,threading是高级模块,对_thread进行了封装。绝大多数情况下,我们只需要使用threading这个高级模块。

    下面我们先看一段在Python中实现多线程的代码。

    import time,threading
    
    class TaskThread(threading.Thread):
        def __init__(self,name):
            threading.Thread.__init__(self,name=name)
        def run(self):
            print('thread %s is running...' % self.getName())
    
            for i in range(6):
                print('thread %s >>> %s' % (self.getName(), i))
                time.sleep(1)
    
            print('thread %s finished.' % self.getName())
    
    taskthread = TaskThread('TaskThread')
    taskthread.start()
    taskthread.join()
    

    下面是程序的执行结果:

    thread TaskThread is running...
    thread TaskThread >>> 0
    thread TaskThread >>> 1
    thread TaskThread >>> 2
    thread TaskThread >>> 3
    thread TaskThread >>> 4
    thread TaskThread >>> 5
    thread TaskThread finished.
    

    TaskThread类继承自threading模块中的Thread线程类。构造函数的name参数指定线程的名字,通过重载基类run函数实现具体任务。

    在简单熟悉了Python的线程后,下面我们实现一个生产者消费者模式。

    from Queue import Queue
    import random,threading,time
    
    
    class Producer(threading.Thread):
        def __init__(self, name,queue):
            threading.Thread.__init__(self, name=name)
            self.data=queue
    
        def run(self):
            for i in range(5):
                print("%s is producing %d to the queue!" % (self.getName(), i))
                self.data.put(i)
                time.sleep(random.randrange(10)/5)
            print("%s finished!" % self.getName())
    
    
    class Consumer(threading.Thread):
        def __init__(self,name,queue):
            threading.Thread.__init__(self,name=name)
            self.data=queue
        def run(self):
            for i in range(5):
                val = self.data.get()
                print("%s is consuming. %d in the queue is consumed!" % (self.getName(),val))
                time.sleep(random.randrange(10))
            print("%s finished!" % self.getName())
    
    def main():
        queue = Queue()
        producer = Producer('Producer',queue)
        consumer = Consumer('Consumer',queue)
    
        producer.start()
        consumer.start()
    
        producer.join()
        consumer.join()
        print 'All threads finished!'
    
    if __name__ == '__main__':
        main()
    

    执行结果可能如下:

    Producer is producing 0 to the queue!
    Consumer is consuming. 0 in the queue is consumed!
    Producer is producing 1 to the queue!
    Producer is producing 2 to the queue!
    Consumer is consuming. 1 in the queue is consumed!
    Consumer is consuming. 2 in the queue is consumed!
    Producer is producing 3 to the queue!
    Producer is producing 4 to the queue!
    Producer finished!
    Consumer is consuming. 3 in the queue is consumed!
    Consumer is consuming. 4 in the queue is consumed!
    Consumer finished!
    All threads finished!
    

    因为多线程是抢占式执行的,所以打印出的运行结果不一定和上面的完全一致。

    小结

    本例通过Python实现了一个简单的生产者消费者模型。Python中的Queue模块已经提供了对线程同步的支持,所以本文并没有涉及锁、同步、死锁等多线程问题。

    本文代码使用 在线Python编辑器 编写。

    展开全文
  • 压缩包内包含四个文件,实现的效果都是通过多线程或多进程执行加法运算; multiprocess_queue,通过任务队列方式实现多进程任务;(multiprocessing模块) multithread_queue,通过任务队列方式实现多线程任务;...
  • 主要介绍了python多线程实现支付模拟请求过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 需要模块:threading,socket-client-server 服务器类的代码,请单独将它作为一个文件,命名为_server.py #服务器类 from socket import *; #套接字模块 from time import ctime;... #线程模块 class _Se...

    需要模块:threading,socket-client-server

    先看运行效果

    在这里插入图片描述
    这里是你每次的输入都会被客户端读到,然后发送给服务器,服务器接收到后,回送接收到的信息并附加上时间戳,客户端接收到回送消息后打印消息到屏幕上。

    上面的图片明显可以看到每个消息下面都有一个附加上时间的相同的消息,这个消息就是服务器发送回来的消息,没有带时间的消息就是我们输入的消息,也是客户端发送给服务器的消息


    下面上代码

    服务器类的代码,请单独将它作为一个文件,命名为_server.py

    #服务器类
    
    from socket import *;        #套接字模块
    from time import ctime;      #时间模块,用来打印时间
    import threading;            #线程模块
    
    class _Server(threading.Thread):
        def __init__(self, Addr, BufSize):                        #Addr:服务器ip地址
            threading.Thread.__init__(self);                      #初始化线程
            self.tcpSerSock=socket(AF_INET,SOCK_STREAM);          #AF_INET代表生成面向网络的套接字,SOCK_STREAM代表TCP类型
            self.tcpSerSock.bind(Addr);                           #将服务器ip地址与套接字绑定
            self.tcpSerSock.listen(5);                            #设置该服务器最多建立5个TCP连接
            self.BufSize=BufSize;                                 #设置缓冲区大小
        def run(self):                                            #多线程的启动函数,只能命名为run()
            while True:
                print("waiting for connection...");
                tcpCliSock,addr=self.tcpSerSock.accept();         #accept()函数接收到客户端连接申请后,将切换消息,从而让出总线,tcpCliSock就是接线员,addr是客户端的IP地址
                print('...connected from:',addr);
    
                while True:
                    data=tcpCliSock.recv(self.BufSize);           #客户端发来的消息存入data中
                    if not data:
                        break;
                    tcpCliSock.send(str('['+ctime()+']  ').encode('utf-8')+data);#将客户端发送的消息回送给客户端,并附加上时间戳,表示服务器已经收到
    
                tcpCliSock.close();                               #关闭接线员通道
            tcpSerSock.close();                                   #关闭TCP连接
    
    
    

    客户端代码,与服务器的代码差不多,就不注释了,命名为_client.py

    from socket import *;
    from time import ctime;
    import threading;
    
    class _Client(threading.Thread):
        def __init__(self,Addr,BufSize):
            threading.Thread.__init__(self);
            self.tcpCliSock=socket(AF_INET,SOCK_STREAM);
            self.tcpCliSock.connect(Addr);
            self.BufSize=BufSize;
    
        def run(self):
            while True:
                data=input('>');
                if not data:
                    break;
                self.tcpCliSock.send(data.encode('utf-8'));
                data=self.tcpCliSock.recv(self.BufSize);
                if not data:
                    break;
                print(data.decode('utf-8'));
            self.tcpCliSock.close();
    
    

    main代码,请保证这个是主函数文件

    from _server import _Server;
    from _client import _Client;
    import threading;
    
    from socket import *;
    from time import ctime;
    
    
    server_Host='';                       #服务器地址,由于我们是在同一台电脑模拟客户端和服务器通信,所以不必填服务器的地址
    server_Port=21567;                    #服务器端口号,最好选择非周知端口号
    server_BufSize=1024;                  #缓冲区大小,单位是字节
    server_Addr=(server_Host,server_Port);#生成服务器地址,主机地址加上端口号
    
    client_Host='localhost';              #客户端类似,不再注释,localhost代指127.0.0.1,你也可以直接写127.0.0.1,这个是代指本机IP地址,
    client_Port=21567;
    client_Bufsize=1024;
    client_Addr=(client_Host,client_Port);
    
    Ser=_Server(server_Addr, server_BufSize);  #生成一个服务器对象
    Cli=_Client(client_Addr,client_Bufsize);   #生成一个客户端对象
    
    #多线程并发运行
    Cli.start();
    Ser.start();
    
    

    编译环境:Visual Studio Python 3.6
    参考书籍:《Python核心编程》

    展开全文
  • python多线程实现窗口卖票系统

    千次阅读 2019-03-15 09:41:09
    例一、创建十个线程,卖100张火车票 import threading list_ticket = [] lock = threading.Lock() # 获取线程锁 num = 100 j = 0 for i in range(1,num+1): ticket_num = '0'*(len(str(num))-len(str(i))) + str...
  • 此处实现一个tcp的应答程序,一个读线程一个写线程python负责服务端,java负责客户端。任一端输入小写over,传输结束(另一端需要按下回车即可退出)。 服务端 服务端套接字的创建和监听 python服务端套接字的...
  • python多线程实现多任务 附demo

    千次阅读 2018-09-27 22:24:34
    使用线程完成任务需要导入threading包:import threading 1.线程类Thread参数说明: Thread([group [, target [, name [, args [, kwargs]]]]]) group: 线程组,目前只能使用None target: 执行的目标任务名 ...
  • python 多线程实现全局变量

    千次阅读 2018-09-04 18:57:46
    多线程-共享全局变量 import threading num=0 def work1(number): global num for i in range(number): num+=1 print('此时num等于',num) def work2(number): global num for i in range(number...
  • 主要介绍了Python基于多线程实现抓取数据存入数据库的方法,结合实例形式分析了Python使用数据库类与多线程类进行数据抓取与写入数据库操作的具体使用技巧,需要的朋友可以参考下
  • 主要介绍了python使用多线程查询数据库的实现示例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • python 多线程实现多客户端连接的 TCP Server最近看《python核心编程》,书中实现了一个简单的1对1的TCPserver,但是在实际使用中1对1的形势明显是不行的,所以研究了一下如何在server端通过启动不同的线程(进程)...
  • 主要为大家详细介绍了python实现多线程的两种方式,感兴趣的朋友可以参考一下
  • 任务队列(request_queue):存放任务的队列,使用了queue实现的。工作线程从任务队列中get任务进行处理; 任务处理函数(callable):工作线程get到任务后,通过调用任务的任务处理函数即(request.cal
  • python多线程实现绘制动态图

    千次阅读 2020-12-11 20:37:20
    我们面对实时更新的数据,希望能够在一个窗口中可视化出来,并且能够实时更新,方便我们观察数据的变化,从而进行数据分析,例如:绘制音频的波形,绘制动态曲线等,下面介绍使用matplotlib结合多线程绘制动态图,...
  • 如果想同时执行两个while True循环,可以使用多线程threading来实现。完整代码#coding=gbkfrom time import sleep, ctime import threadingdef muisc(func): while True: print 'Start playing: %s! %s' %(func,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 161,890
精华内容 64,756
关键字:

python多线程实现

python 订阅