精华内容
下载资源
问答
  • 多线程和单线程的联系与区别 答: 1.在单核CPU中,将CPU分为很小的时间片,在每一时刻只能有一个线程在执行,是一种微观上轮流占用CPU的机制。 2.多线程会存在线程上下文切换,会导致程序执行速度变慢,即采用一个...

    多线程和单线程的联系与区别

    答:

    1.在单核CPU中,将CPU分为很小的时间片,在每一时刻只能有一个线程在执行,是一种微观上轮流占用CPU的机制。

    2.多线程会存在线程上下文切换,会导致程序执行速度变慢,即采用一个拥有两个线程的进程执行所需要的时间比一个线程的进程执行两次所需要的时间要多一些。

    结论:即采用多线程不会提高程序的执行速度,反而会降低速度,但是对于用户来说,可以减少用户的响应时间

    展开全文
  • Python默认的解释器是CPython,而CPython中有一个全局锁GIL,任何线程获得锁之后才能执行,所以多线程只能交替进行,即使是多核...下面分别使用多线程和单线程进行端口(0-5000端口)扫描:单线程(无延时)#encoding:

    Python默认的解释器是CPython,而CPython中有一个全局锁GIL,任何线程获得锁之后才能执行,所以多线程只能交替进行,即使是多核CPU也只能用到1核。因此,Python中使用多线程并不一定能提高效率,一般来说CPU密集型的任务不适合用多线程,IO密集型的任务适当使用多线程是可以提高效率的。下面分别使用多线程和单线程进行端口(0-5000端口)扫描:

    单线程(无延时)

    #encoding: utf-8  
    #python3.4 
    import socket, time
    
    if __name__=='__main__':
        openPortNum = 0 
        t=time.time()
        for port in range(0,5000):
            #time.sleep(0.01)
            s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
            result = s.connect_ex(('ip',port)) 
            if(result == 0):  
                print (port,'is open')
                openPortNum+=1  
            s.close()
        print ('total open port is %s, scan used time is: %f ' % (openPortNum, time.time()-t))  

    多线程(无延时)

    #encoding: utf-8  
    #python3.4 
    import socket, sys, threading, time  
    
    openPortNum = 0  
    socket.setdefaulttimeout(3)  
    threads=[] 
    
    def socket_port(ip, PORT):  
        global openPortNum  
        #time.sleep(0.01)
        s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  
        result = s.connect_ex((ip, PORT))
        if(result == 0):  
            print (PORT,'is open')
            openPortNum += 1 
        s.close()  
    
    if __name__ == '__main__':  
    
        t=time.time()
        for port in range(0, 5000):
            th=threading.Thread(target=socket_port, args=('ip',port))
            threads.append(th)  
            th.start()
    
        print ('total open port is %s, scan used time is: %f ' % (openPortNum, time.time()-t))  

    没有延迟的情况下,单线程和多线程得到扫描耗时为:
    这里写图片描述

    单线程0.1s,多线程1.3s,多线程反而没有优势,这是因为线程需要频繁切换,而且IO等待时间较短,无法体现多线程的优势。那么可以在每一个线程执行的时候加一个延时,模拟较长的IO等待时间。

    单线程(有延时,延时设为0.01s)

    #encoding: utf-8  
    #python3.4 
    import socket, time
    
    if __name__=='__main__':
        openPortNum = 0 
        t=time.time()
        for port in range(0,5000):
            time.sleep(0.01)
            s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
            result = s.connect_ex(('ip',port)) 
            if(result == 0):  
                print (port,'is open')
                openPortNum+=1  
            s.close()
        print ('total open port is %s, single_thread scan used time is: %f ' % (openPortNum, time.time()-t))  

    多线程(有延时,延时为0.01s)

    #encoding: utf-8  
    #python3.4 
    import socket, sys, threading, time  
    
    openPortNum = 0  
    socket.setdefaulttimeout(3)  
    threads=[] 
    
    def socket_port(ip, PORT):  
        global openPortNum  
        time.sleep(0.01)
        s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  
        result = s.connect_ex((ip, PORT))
        if(result == 0):  
            print (PORT,'is open')
            openPortNum += 1 
        s.close()  
    
    if __name__ == '__main__':  
    
        t=time.time()
        for port in range(0, 5000):
            th=threading.Thread(target=socket_port, args=('ip',port))
            threads.append(th)  
            th.start()
    
        print ('total open port is %s, multi_thread scan used time is: %f ' % (openPortNum, time.time()-t))  

    有延时的情况下,单线程与多线程的扫描时间分别为:
    这里写图片描述
    单线程51.9s,多线程1.3s,多线程的优势就体现出来了。

    总结一下,Python多线程对于IO密集型任务有正面效果,对于CPU密集型任务反而效率更低,主要就是因为GIL的存在。

    如何减少GIL的影响呢?可以通过使用多进程代替多线程、CPU计算密集型任务使用C模块或其他语言、换成JPython等其他解释器等方法。

    展开全文
  • 多线程和单线程的执行效率问题

    千次阅读 2016-10-12 21:46:31
    多线程和单线程的执行效率问题 转:平凡之路的博客 一提到多线程一般大家的第一感觉就是可以提升程序性能,在实际的操作中往往遇到性能的问题,都尝试使用多线程来解决问题,但多线程程序并不是在任何情况...

    多线程和单线程的执行效率问题

    一提到多线程一般大家的第一感觉就是可以提升程序性能,在实际的操作中往往遇到性能的问题,都尝试使用多线程来解决问题,但多线程程序并不是在任何情况下都能提升效率,在一些情况下恰恰相反,反而会降低程序的性能。这里给出两个简单的例子来说明下:

    程序1:

    import threading
    from time import ctime
    
    class MyThread(threading.Thread):
        def __init__(self, func, args, name):
            threading.Thread.__init__(self)
            self.name = name
            self.func = func
            self.args = args
    
        def run(self):
            print 'starting', self.name, 'at:',ctime()
            apply(self.func, self.args)
            print self.name, 'finished at:', ctime()
    
    def fun1(x):
        y = 0
        for i in range(x):
            y+=1
    
    def fun2(x):
        y = 0
        for i in range(x):
            y+=1
            
    def main():
        print 'staring single thread at:',ctime()
        fun1(10000000)
        fun2(10000000)
        print 'finished single thread at:',ctime()
    
        t1 = MyThread(fun1,(10000000,),fun1.__name__)
        t2 = MyThread(fun2,(10000000,),fun2.__name__)
        t1.start()
        t2.start()
        t1.join()
        t2.join()
        
        print 'all done'
        
    if __name__ == '__main__':
        main()

    该程序执行结果为:

    staring single thread at: Sat Dec 08 10:27:11 2012
    finished single thread at: Sat Dec 08 10:27:14 2012
    starting  fun1  at:  Sat Dec 08 10:27:14 2012
    starting  fun2  at:  Sat Dec 08 10:27:14 2012
    fun1  finished at:Sat Dec 08 10:27:21 2012 
    fun2  finished at:Sat Dec 08 10:27:21 2012
    all done

    结果显示对于同样的问题多线程耗费了多一倍的时间,fun1,、fun2都是计算型程序,这就意味着两个代码都需要占用CPU资源,虽然采用了多线程但CPU资源是唯一的(不考虑多CPU多核的情况),同一时刻只能一个线程使用,导致多线程无法真正的并发,相反由于线程的切换的开销,效率反而有明显的下降。由此看以在单CPU的场景下对于计算密集型的程序,多线程并不能带来效率的提升。

    程序2:

    import threading
    from time import ctime
    
    class MyThread(threading.Thread):
        def __init__(self, func, args, name):
            threading.Thread.__init__(self)
            self.name = name
            self.func = func
            self.args = args
    
        def run(self):
            print 'starting', self.name, 'at:',ctime()
            apply(self.func, self.args)
            print self.name, 'finished at:', ctime()
    
    def fun1(x):
        for i in range(x):
            fd = open('1','w')
            fd.close()
    
    def fun2(x):
        y = 0
        for i in range(x):
            y+=1
            
    def main():
        print 'staring single thread at:',ctime()
        fun1(15000)
        fun2(50000000)
        print 'finished single thread at:',ctime()
    
        t1 = MyThread(fun1,(15000,),fun1.__name__)
        t2 = MyThread(fun2,(50000000,),fun2.__name__)
        t1.start()
        t2.start()
        t1.join()
        t2.join()
        
        print 'all done'
        
    if __name__ == '__main__':
        main()

    该程序执行结果为:

    staring single thread at: Sat Dec 08 11:03:30 2012
    finished single thread at: Sat Dec 08 11:03:46 2012
    starting  fun1  at:  Sat Dec 08 11:03:46 2012
    starting  fun2  at:  Sat Dec 08 11:03:46 2012
    fun2 finished at: Sat Dec 08 11:03:55 2012
    fun1 finished at: Sat Dec 08 11:03:58 2012
    all done

    结果显示这个程序采用多线程比单线程的效率有明显的提升。这是由于fun1主要是文件的操作,fun2是计算操作,单线程的情况下,虽然两个程序主要使用不同的资源但是在线程内部只能串行执行,在IO操作的时候,CPU实际是无事可做。多线程的情况下,如果一个线程在等待IO操作,线程会马上调度到另外一个线程上,并发的使用了不同的资源。

    结论:

    线程本身由于创建和切换的开销,采用多线程不会提高程序的执行速度,反而会降低速度,但是对于频繁IO操作的程序,多线程可以有效的并发。

    对于包含不同任务的程序,可以考虑每个任务使用一个线程。这样的程序在设计上相对于单线程做所有事的程序来说,更为清晰明了,比如生产、消费者问题。

    在实际的开发中对于性能优化的问题需要考虑到具体的场景来考虑是否使用多线程技术。




    展开全文
  • 多线程和单线程环境的类实例: 在多线程环境下,共享使用一个实例,如果实例是有状态的,并且线程要修改这个实例的状态,就要考虑线程安全问题,做好同步,如果需要 局部同步就局部同步,如果全局同步(比如,对...

    论多线程和单线程环境的类实例:
    在多线程环境下,共享使用一个实例,如果实例是有状态的,并且线程要修改这个实例的状态,就要考虑线程安全问题,做好同步,如果需要
    局部同步就局部同步,如果全局同步(比如,对这个内存无论是读还是写都同步)的情况,就需要控制进程之间的同步和唤醒(可以直接通过notify或者间接利用信号变量);

    在多线程环境下,共享调用静态方法,如果方法不是修改一个共享的内存,那么是幂等的,不用考虑线程安全问题;

    尽量使用接口来表示行为,这样有利于(基于行为作出)策略算法的调整,因为策略可以面向接口,而不是具体实现;
    尽量使用类泛型和方法泛型,这样有利于一个类处理一类数据,而不是处理一类(相同结构体和行为)需要多个“处理类”来实现;

    静态方法调用非静态类,和调用静态类:要理解好静态和非静态的区别;

    (不变)尽量将功能通过一个入口开放出去(比如用一个门面类),这样是为了封装,并且方便调用方插拔使用;
    (变),尽量将经常变化的东西可配置化;

    展开全文
  • 多线程和单线程执行效率比较

    千次阅读 2017-11-23 18:14:09
    单线程的也就是程序执行时,所跑的程序路径(处理的东西)是连续顺序下来的,必须前面的处理好,后面的彩绘执行到。  多线程嘛,举个例子也就是说程序可以同时执行2个以上相同类似的操作,比如一些搜索代理或者...
  • 1、多线程的产生并不是因为发明了多核CPU甚至现在有多个CPU+多核的硬件,也不是因为多线程CPU运行效率比单线程高。单从CPU的运行效率上考虑,单任务进程及单线程效率是最高的,因为CPU没有任何进程及线程的切换开销...
  • 单线程拷贝一个文件和多线程拷贝一个文件,那个效率更高,求大神写个例子证明一下。
  • 你怎么理解多线程和单线程的区别

    千次阅读 2018-04-07 15:20:08
    程序、进程、线程程序:由源代码生成的可执行应用。 (例如:QQ.app)进程:一个正在运行的程序可以看做一个进程,(例如:正在运行的QQ警示一个劲曾),... 单线程每个正在运行的程序(即进程),至少包括一个线...
  • 为什么需要多线程呢?因为我们的CPU的运算速度是非常的快的,在一个应用程序的运行过程中的大部分时间,都花在了,I/O操作,网络请求,数据库操作上。如果没有多线程,我们的CPU大部分时间都是处于等待的状态,对...
  •  多线程和多进程是什么自行google补脑  对于python 多线程的理解,我花了很长时间,搜索的大部份文章都不够通俗易懂。所以,这里力图用简单的例子,让你对多线程有个初步的认识。   单线程    ...
  • 为什么 i的值s1的值不一样 而且差距比较大? 下面是代码。 public class Main{ int s1 = 0; class A extends Thread{ @Override public void run() { while(!Thread.currentThread().isInterrupted()){ s1....
  • 很显然,以之相适应的是应用服务器内部的多线程处理机制。大集中应用系统的一大特点就是业务数据的集中管理,隐含地就有了另外一个具体的需求:应对并发性访问需求。应对并发性访问需求需要考虑的因素很多,比如...
  • Python 多线程和单进程

    2019-04-24 11:45:31
    Python 多线程和单进程 最近也补脑了一下了解一下多线程 和单线程 文章出处 虫师->写的非常好 单线程 在好些年前的MS-DOS时代,操作系统处理问题都是单任务的,我想做听音乐和看电影两件事儿,那么一定要先排一下...
  • 什么是进程? 当一个程序开始运行时,它就是一个进程,进程包括运行中的程序程序所使用到的内存系统资源。...多线程是指程序中包含多个执行流,即在一个程序中可以同时运行多个不同的线程来执行不同的任务, 也...
  • 线程的执行时无序的,是由操作系统决定的 单线程:默认情况下,程序启动只有一个线程,这个线程就是主线程 注意点:target后面的赋值不需要括号() 多线程:借助包 import threading ...
  • 单线程和多线程

    2020-11-04 22:13:24
    线程和多线程 单线程 普通的程序默认都是单线程,程序的执行方式是从上至下串行执行,示例 import time def func(a,b): time.sleep(1) print(a+b) s = time.time() func(5,10) func(2,5) func(6,84) func(9,46) ...
  • 多线程编程 - 单线程和多线程执行对比 递归求斐波那契、阶乘与累加函数的执行。该脚本按照单线程的方式运行这三个函数,之后使用多线程的方式执行同样的任务,用来说明多线程环境的优点。 以单线程模式运行时,...
  • 浏览器多线程和js单线程

    万次阅读 2017-08-02 15:13:11
    这些问题的根源就是因为浏览器的多线程和js的单线程引起的。看本篇博客之前,应该充分理解消息队列,事件循环,同步异步任务等概念。 这些概念以前都知道,也了解多线程的概念。但是当遇到问题的时候,这些东西都被...
  • Java单线程和多线程

    2019-08-22 21:41:50
    Java单线程和多线程 线程 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组...
  • 分别使用单线程和多线程把一个文件夹下的饿一百张图片复制到另一个文件夹下,比较它们的处理时间 使用单线程: package lesson19; import java.io.File; import java.io.FileInputStream; import java.io....
  • 四、多线程单线程的区别 五、主线程与子线程之间的关系 在软件层面,多线程就是能同时从多个路线同时执行处理。从软件的角度来说,线程可以看作是同时的。即便在单核处理器的电脑上也能实现多线程。但是多个线程...
  • 0.背景 在项目中加入了等待通讯的内容,所以原来单个请求处理时间...得到的结论是:多线程和单线程在执行的流程和使用方法几乎一样,所以多线程不会带来额外的负担。 1.单线程的处理步骤 1.1一个简单的单线程
  • 多线程单线程

    2016-04-03 00:44:44
    今天写了一个小程序来展示一下多线程单线程的效果. 首先来看一下单线程的代码与效果 这是只有一个主线程main函数的流程,就是所说的单线程,根据main方法的代码依次执行, 接下来看一看两条线程同时进行的...
  • 场景: Server: springboot 开发的一个 web 项目 client:使用 HttpClient 分别在单线程和多线程环境下测试某个模块的性能 问题: ...多线程和单线程效率基本没差别 2.CPU使用率很低
  • 第二种定时任务:单线程和多线程 1、创建定时任务: package com.accord.task;   import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.scheduling.annotation.Scheduled...
  • java单线程和多线程的实现方式java单线程实现方式1、创建单线程java多线程的实现方式创建线程池2、停止线程 java单线程实现方式 1、创建单线程 /** * 单个线程管理 */ ExecutorService singleThreadExecutor = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,131
精华内容 11,652
关键字:

多线程和单线程