精华内容
下载资源
问答
  • 执行时间 方法1复制代码 代码...方法 2复制代码 代码如下:start = time.time()run_fun()end = time.time()print end-start 方法3复制代码 代码如下:start = time.clock()run_fun()end = time.clock()print end-start
  • 多线程执行顺序以及run方法的调用

    千次阅读 2018-04-24 21:15:10
    1.多线程的执行顺序先来看一个例子:public class test { public static void main(String[] args) { ...}输出结果:main这个例子说明一个问题:一个Java程序至少会有1个线程在运行,就如上面的main()方法,它是...

    1.多线程的执行顺序

    先来看一个例子:

    public class test {
    
    	public static void main(String[] args) {
    	    System.out.println(Thread.currentThread().getName());
    	}
    }

    输出结果:

    main

    这个例子说明一个问题:一个Java程序至少会有1个线程在运行,就如上面的main()方法,它是由JVM创建的一个叫main的线程调用的。控制台输出的就是这个线程的名字。

    接着再看下面这段代码:

    public class MyThread extends Thread{
    
        public static void main(String[] args) {
            MyThread myThread = new MyThread();
            myThread.start();
            System.out.println(Thread.currentThread().getName());
            System.out.println("运行结束!");
        }
    
        @Override
        public void run() {
            //super.run();
            System.out.println(Thread.currentThread().getName());
    
        }
    }

    输出结果:

    main
    运行结束!
    Thread-0

    或者是:

    main
    Thread-0
    运行结束!
    

    上段代码说明了两个问题:

    1. 上述代码有两个线程同时在运行:一个是JVM创建的main线程,该线程调用main函数,另一个是自己创建的MyThread线程类,名称是Thread-0,该线程调用run函数
    2. main()函数和run()函数中的打印结果顺序不确定。这是因为在使用多线程时,代码的运行结果与代码执行顺序或调用顺序是无关的。线程是一个子任务,上面代码有两个线程,意味着两个子任务各干各的事,互不干扰,一个线程正在调用main函数,另一个线程在这个时候去调用run函数,先打印哪个函数里面的东西都不一定。虽然main()这个函数比run()函数先调用,意思是时间起点早,但是具体到函数里面的语句调用顺序就说不清楚了。
    再比如下面的例子:
    public class Test3 {
    
        public static void main(String[] args) {
            MyThread3 t1 = new MyThread3("thread1");
            MyThread3 t2 = new MyThread3("thread2");
            MyThread3 t3 = new MyThread3("thread3");
            MyThread3 t4 = new MyThread3("thread4");
            MyThread3 t5 = new MyThread3("thread5");
            System.out.println(Thread.currentThread().getName());
            t1.start();
            System.out.println("t1准备好:");
            t2.start();
            System.out.println("t2准备好");
            t3.start();
            System.out.println("t3准备好");
            t4.start();
            System.out.println("t4准备好");
            t5.start();
            System.out.println("t5准备好");
    
        }
    }
    public class MyThread3 extends Thread {
    
        private String name;
        public MyThread3(String name){
            super(name);
            this.name = name;
        }
    
        @Override
        public void run() {
    
            System.out.println("当前执行run方法的线程是:" + Thread.currentThread().getName());
            try {
                for(int j = 0; j < 5; j++){
                    //int time = (int)(Math.random() * 1000);
                    int time = 500;
                    Thread.sleep(time);
                    System.out.println("j=" + j +",run=" + Thread.currentThread().getName());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    

    输出结果:

    main
    t1准备好:
    t2准备好
    t3准备好
    t4准备好
    当前执行run方法的线程是:thread1
    当前执行run方法的线程是:thread2
    t5准备好
    当前执行run方法的线程是:thread3
    当前执行run方法的线程是:thread5
    当前执行run方法的线程是:thread4
    j=0, run=thread5
    j=0, run=thread3
    j=0, run=thread4
    j=0, run=thread2
    j=0, run=thread1
    j=1, run=thread1
    j=1, run=thread3
    j=1, run=thread5
    j=1, run=thread2
    j=1, run=thread4
    j=2, run=thread4
    j=2, run=thread2
    j=2, run=thread1
    j=2, run=thread3
    j=2, run=thread5
    j=3, run=thread4
    j=3, run=thread5
    j=3, run=thread1
    j=3, run=thread3
    j=3, run=thread2
    j=4, run=thread2
    j=4, run=thread1
    j=4, run=thread4
    j=4, run=thread3
    j=4, run=thread5
    

    上述代码开了5个线程,每个线程的run函数被调用5次,从结果中可以看出,5个线程run函数的执行顺序是随机的。线程执行的顺序和代码的顺序无关。

    2.关于run()方法的调用

    源码中是这样说明run()方法的调用的:

    If this thread was constructed using a separate Runnable run object, then that Runnable object's run method is called; otherwise, this method does nothing and returns. 

    Subclasses of Thread should override this method.

    意思就是:如果这个线程是使用Runnable对象构造的,那么实际上是调用的Runnable对象的run方法;否则的话,方法不做任何处理。Thread类的子类应该重写该方法。

    上面的内容可以进一步补充一下,因为Thread类自身继承了Runnable接口,因此也可以采用继承了Thread的一个类的对象作为参数传入,构造Thread实例,这种情况下,实际上调用的则是该传入的Thread对象的run方法。

    run方法源码如下(源码中的target就是一个Runnable对象):

    @Override
        public void run() {
            if (target != null) {
                target.run();
            }
        }

    我们先进行测试一下:

    public class MyThread extends Thread {
    
        public MyThread(String name) {
            super(name);
            System.out.println("构造方法的打印:" + Thread.currentThread().getName());
        }
    
        @Override
        public void run() {
            System.out.println("run方法的打印:" + Thread.currentThread().getName());
        }
    }
    public class Run2 {
        public static void main(String[] args) {
            
            MyThread myThread = new MyThread("myThread");
            myThread.start();
            //myThread.run();
        }
    }

    打印结果为:

    构造方法的打印:main

    run方法的打印:myThread

    把Run2修改为如下:

    public class Run2 {
        public static void main(String[] args) {
            
            MyThread myThread = new MyThread("myThread");
            //myThread.start();
            myThread.run();
        }
    }

    打印结果:

    构造方法的打印:main
    run方法的打印:main

    从上面的例子我们可以看出:MyThread.java类的构造函数是被main线程调用的,启动start()后的隐式调用的run方法是被创建的名叫myThread线程调用的,而显式调用的run方法则是main线程调用的。

    接着,我们用下面的例子进一步来说明run的调用问题:

    public class MyThread_t4 extends Thread {
    
        private int count = 5;
    
        @Override
        public void run() {
            super.run();
            count--;
            System.out.println("由" + this.currentThread().getName() + "计算.count=" + count);
        }
    }
    public class Run_t4 {
        public static void main(String[] args) {
    //        MyThread_t4 myThread_t4 = new MyThread_t4();
    //        Thread a = new Thread(myThread_t4,"A");
    //        Thread b = new Thread(myThread_t4,"B");
    //        Thread c = new Thread(myThread_t4,"C");
    //        Thread d = new Thread(myThread_t4,"D");
    //        Thread e = new Thread(myThread_t4,"E");
            MyThread_t4 a = new MyThread_t4();
            MyThread_t4 b = new MyThread_t4();
            MyThread_t4 c = new MyThread_t4();
            MyThread_t4 d = new MyThread_t4();
            MyThread_t4 e = new MyThread_t4();
    
            a.start();
            b.start();
            c.start();
            d.start();
            e.start();
        }
    }
    
    上面的代码会创建a,b,c,d,e四个线程,每个线程都有自己的run方法,每个线程都有各自的count变量,自己减少自己的count变量的值,所以输出结果为4.

    输出结果:

    由Thread-0计算.count=4
    由Thread-3计算.count=4
    由Thread-1计算.count=4
    由Thread-2计算.count=4
    由Thread-4计算.count=4

    我们把测试代码修改为如下:

    public class Run_t5 {
        public static void main(String[] args) {
            MyThread_t4 myThread_t4 = new MyThread_t4();
            Thread a = new Thread(myThread_t4,"A");
            Thread b = new Thread(myThread_t4,"B");
            Thread c = new Thread(myThread_t4,"C");
            Thread d = new Thread(myThread_t4,"D");
            Thread e = new Thread(myThread_t4,"E");
    //        MyThread_t4 a = new MyThread_t4();
    //        MyThread_t4 b = new MyThread_t4();
    //        MyThread_t4 c = new MyThread_t4();
    //        MyThread_t4 d = new MyThread_t4();
    //        MyThread_t4 e = new MyThread_t4();
    
            a.start();
            b.start();
            c.start();
            d.start();
            e.start();
        }
    }
    

    输出结果如下:

    由A计算.count=4
    由C计算.count=2
    由B计算.count=3
    由E计算.count=0
    由D计算.count=1

    从该结果可以看出,产生了非线程安全问题。造成非线程安全问题的主要原因是因为多个线程同时访问了一个变量。为什么上面都是各自线程访问各自的count变量,为什么这里就是访问同一个count变量呢。原因是因为这里创建了a,b,c,d,e四个线程,但是这四个线程都是使用Thread对象myThread_t4作为参数构造的,那么调用的run函数实际上是myThread_t4对象的run函数(如果是使用Runnable对象构造的,那么实际上是调用的Runnable对象的run方法),因此不再是各自的四个run函数,而是一个run函数了,都去调用这个函数,当调用一个run函数的时候,对这个函数而言,内部就是同步操作,但是由于这里run函数内部count--这么一句,在某些JVM中,i--操作分3步,在3个步骤中,如果有多个线程同时访问,就会出现线程安全问题。解决的办法就是将run方法进行同步(加synchronized),当然,这里主要想说明的不是线程安全问题,而是run函数的调用问题,修改代码MyThread_t4如下:

    public class MyThread_t4 extends Thread {
    
        private int count = 5;
    
        @Override
        synchronized public void run() {
            super.run();
            count--;
            System.out.println("由" + this.currentThread().getName() + "计算.count=" + count);
        }
    }

    当然如下把代码修改成下面这样(把count--替换成count=count-1),也不会出现线程安全问题(因为多个线程访问同一个run()函数,run函数内部是同步执行的):

    public class MyThread_t4 extends Thread {
    
        private int count = 5;
    
        @Override
        public void run() {
            super.run();
            count=count-1;
            //count--;
            System.out.println("由" + this.currentThread().getName() + "计算.count=" + count);
        }
    }

    再运行测试函数Run_t5,

    输出结果为:

    由C计算.count=4
    由D计算.count=3
    由A计算.count=2
    由B计算.count=1
    由E计算.count=0





    展开全文
  • python计算程序运行的时间方法

    千次阅读 2019-05-07 13:49:21
    1.运用场景 在很多的时候我们需要计算我们程序的...计算Python的某个程序,或者是代码块运行的时间一般有三种方法方法一 import datetime start = datetime.datetime.now() run_function(): # do something e...

    1.运用场景

    在很多的时候我们需要计算我们程序的性能,这个时候我们常常需要统计程序运行的时间。下面我们就来说说怎么统计程序的运行时间。

    2. 实现方法

    计算Python的某个程序,或者是代码块运行的时间一般有三种方法。

    方法一

    import datetime
    start = datetime.datetime.now()
    run_function():
        # do something
     
    end = datetime.datetime.now()
    print (end-start)
    

    方法二:

    import time
    start = time.time()
    run_function()
    end = time.time()
     
    print str(end)
    

    方法三:

    import time
    start = time.clock()
    run_function()
    end = time.clock()
     
    print str(end-start)
    

    方法比较

    通过对以上方法的比较我们发现,方法二的精度比较高。方法一基本上是性能最差的。这个其实是和系统有关系的。一般我们推荐使用方法二和方法三。我的系统是Ubuntu,也就是Linux系统,方法二返回的是UTC时间。 在很多系统中time.time()的精度都是非常低的,包括windows。

    python 的标准库手册推荐在任何情况下尽量使用time.clock().但是这个函数在windows下返回的是真实时间(wall time)

    方法一和方法二都包含了其他程序使用CPU的时间。方法三只计算了程序运行CPU的时间。

    方法二和方法三都返回的是浮点数

    那究竟 time.clock() 跟 time.time(),谁比较精确呢?带着疑问,查了 Python 的 time 模块文档,当中 clock() 方法有这样的解释:
    来自官方文档:
    在这里插入图片描述
    time.clock() 返回的是处理器时间,而因为 Unix 中 jiffy 的缘故,所以精度不会太高。clock转秒,除以1000000。

    究竟是使用 time.clock() 精度高,还是使用 time.time() 精度更高,要视乎所在的平台来决定。总概来讲,在 Unix 系统中,建议使用 time.time(),在 Windows 系统中,建议使用 time.clock()。

    我们要实现跨平台的精度性,我们可以使用timeit 来代替time.

    import timeit
     
    start = timeit.default_timer()
    do_func()
    end = timeit.default_timer()
    print str(end-start)
    
    展开全文
  • Java自定义注解计算方法执行时间

    千次阅读 2019-03-21 17:05:13
    System.out.println("方法执行时间:" + (System.currentTimeMillis() - startTime)); return proceed; } catch (Throwable throwable) { throwable.printStackTrace(); } return null; } } 3.在需要切面...

    1.自定义注解

    package com.example.demotest.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target({ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface HandlingTime {
    
    }
    

    2.配置切面类

    package com.example.demotest.annotation.aspect;
    
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    @Aspect
    @Component
    public class HandlingTimeAspect {
    
        @Pointcut("@annotation(com.example.demotest.annotation.HandlingTime)")
        public void handlingTimePointcut() {}
    
        @Around("handlingTimePointcut()")
        public Object handlingTimeAround(ProceedingJoinPoint joinPoint){
            try {
                long startTime = System.currentTimeMillis();
                Object proceed = joinPoint.proceed();
                System.out.println(proceed);
                System.out.println("方法执行时间:" + (System.currentTimeMillis() - startTime));
                return proceed;
            } catch (Throwable throwable) {
                throwable.printStackTrace();
            }
            return null;
        }
    }
    

    3.在需要切面的方法加上自定义注解

        @HandlingTime
        @RequestMapping("www")
        public String www(String q) {
            int i = 100;
            while (i > 0) {
                i--;
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return "www";
        }

    4.开启AOP,否则Spring将识别不了

     一.在 applicationContext.xml文件中加上AOP需要的配置 <aop:aspectj-autoproxy/>

    二.使用注解的话需加上@EnableAspectJAutoProxy

    @SpringBootApplication
    @EnableAspectJAutoProxy
    public class DemoTestApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DemoTestApplication.class, args);
        }
    
    }
    展开全文
  • Python计算程序运行时间的三种方法

    千次阅读 多人点赞 2020-02-10 11:26:45
    Python中常用的用来测试程序运行时间方法: 第一种: import time start = time.time() run_function() end = time.time() print str(end-start) 第二种: import time start = time.clock() run_function() ...

    Python中常用的用来测试程序运行时间的方法:

    第一种:

    import time
    start = time.time()
    
    run_function()
    
    end = time.time()
    print str(end-start)
    

    第二种:

    import time
    start = time.clock()
    
    run_function()
    
    end = time.clock()
    print str(end-start)
    

    第三种:

    import datetime
    start = datetime.datetime.now()
    
    run_function():
    
    end = datetime.datetime.now()
    print (end-start)
    
    展开全文
  • Python 计算程序运行时间的几种方法

    千次阅读 2018-09-03 19:06:45
    方法1 import datetime starttime = datetime.datetime.now() #long running endtime = datetime.datetime.now() ...print (endtime - starttime).seconds ...方法 2 ...run_fun() end = time.tim...
  • python-time模块计算程序运行的时间

    千次阅读 2020-12-01 08:07:08
    计算python程序的运行时间方法1import datetimestarttime = datetime.datetime.now()#long runningendtime = datetime.datetime.now()print (endtime - starttime).seconds方法 2start = time.time()run_fun()end = ...
  • 真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码:调用Thread类的 start()方法来启动一个线程,这时此线程处于就绪(可运行)状态,并没有运行,一旦得到cpu时间片,就开始执行...
  • 如何计算python程序运行的时间

    千次阅读 2020-11-06 12:28:46
    这是对代码进行基准测试的快速方法,并向其他人表明他们需要多长时间来重新运行结果。 import numpy as np from numpy.random import randint # A function to simulate one million dice throws. def one_...
  • JAVA计算多线程的执行总时间

    千次阅读 2018-03-08 16:42:21
    代码: ExecutorService exec = Executors.newCachedThreadPool(); long start = System.nanoTime(); ...System.out.println( ...直到所有线程执行结束或者到了一个小时(我的参数),才能计算时间。从而达到目的。
  • C/C++中计算函数运行时间的两种方法

    万次阅读 多人点赞 2017-11-04 23:30:11
    方法就是在该段代码或者函数前面,记录一个时间T1,在代码段或函数后面记录时间T2,那其运行时间就是T2-T1,下面看看具体运算方法方法一:  clock()是C/C++中的计时函数,而与其相关的数据类型是clock_t; ...
  • Auto.js Pro 计算脚本运行时间

    万次阅读 2020-09-20 22:46:08
    本文仅供学习交流使用,如侵立删! 企鹅 、WX: 1033383881 ... //stamp:new Date() 当前时间时间戳 //时间格式化输出 "2020-09-20 10:21:12" return stamp.getFullYear() + '-' + (stamp.getMonth() + 1) +
  • C++程序内计算时间开销的方法举例

    千次阅读 2018-03-07 11:25:41
    在Linux系统下,有几种在C/c++常用的计时方法,1.clock() 1 #include &lt;stdio.h&gt; 2 #include &lt;stdlib.h&gt; 3 #include &lt;time.h&gt; 4 int main(void) 5 { 6 long i =...
  • 使用python装饰器计算函数运行时间

    万次阅读 2017-05-04 17:05:55
    装饰器在python里面有很重要的作用...本文主要是利用python装饰器计算函数运行时间 一些需要精确的计算函数运行了多久的程序,都可以采用这种方法 #coding:utf-8 import urllib2,re,time,random,os,datetime imp
  • 1.运用场景 在很多的时候我们需要计算我们程序的性能,这个时候我们常常需要统计程序运行的时间。下面我们就来说说怎么统计...计算Python的某个程序,或者是代码块运行的时间一般有三种方法方法一 import
  • Python计算函数执行时间(五种案例)

    千次阅读 多人点赞 2020-12-25 15:02:44
    Python计算函数执行时间1. time.time()2. time.perf_counter() 推荐3. timeit.timeit ()4.装饰器统计运行耗时5. with 语句统计运行耗时 1. time.time() 在计算函数执行时间时,这种时最简洁的一种方式,用两个时间戳...
  • Docker run 命令的使用方法

    万次阅读 2015-08-01 11:57:30
    编者的话】在Docker中,run应该是用户使用最多的命令了,很多读者反馈不是很明白run命令的用法,而且相关的书籍、中文资料中对run命令的描述也不是非常完整,所以DockerOne组织翻译了Docker官方的文档,以飨读者。...
  • 如何加速计算

    千次阅读 2021-11-10 08:08:26
    当模型很大时,如何加速计算(一) python常见并行库 DASK dask是python的一个并行计算库,可以动态调度资源提供并行计算,并行化的数据集成提供接口...我们测试一下在numpy和dask中数据计算时间。 import time impo
  • Linux应用层查看系统时间方法

    千次阅读 2016-03-26 17:48:34
    系统时间,硬件时间,UTC时间,本地时间,查看、修改系统时间和硬件时间方法计算系统时间的应用程序。
  • 用 JavaScript 实现时间轴与动画 - 前端组件化

    千次阅读 多人点赞 2021-04-05 09:06:09
    有了这个时间,我们就可以根据这个时间计算当前动画的属性应该变化多少。要计算这个属性的变化,我们首先需要知道动画初始值到终止值的总变化区间。 公式:变化区间(range) = 终止值(endValue) - 初始值(startValue...
  • Python计算程序运行时间

    千次阅读 2018-10-10 10:47:22
    #方法1 import datetime starttime = datetime.datetime.now() #long running endtime = datetime.datetime.now() print (endtime - starttime).seconds ...#方法 2 ...run_fun() end = time.ti...
  • [174]python计算程序运行时间

    千次阅读 2018-06-28 09:00:32
    方法1 import datetime starttime = datetime.datetime.now() #long running endtime = datetime.datetime.now() ...print (endtime - starttime).seconds ...方法 2 ...run_fun() end = time.t...
  • C语言 计算程序运行时间(精确到毫秒/微秒)

    万次阅读 多人点赞 2017-12-09 10:03:01
    C语言要计算程序的运行时间,这里总结两种方法,一种是精确到毫秒时间,一种是精确到微秒时间 方法一:精确到微秒时间 #include #include int main() { int a[10002]; int i = 0; double run_time; _LARGE_...
  • 给定一个作业提交列表,使用轮询调度规则计算所有作业的平均等待时间
  • Android Studio新功能解析,你真的了解Instant Run吗?

    万次阅读 多人点赞 2016-06-02 09:04:15
    hot swap会在应用程序的内部开启一个服务器,然后由Android Studio自动计算方法内实现的变更,将变更代码发送到服务器,服务器再利用类加载器和委托机制将新的代码实现注入到现有应用程序中,从而完成替换工作。...
  • 1、修改某一程序的时候,使用了session去取数据,导致时间效率非常低。后来,对session.run()进行了测试,发现使用session读取数据的效率是非常低下的. # -*- coding: utf-8 -*- import tensorflow as tf import time ...
  • 错误现象运行 VC# 程序,提示如下:复制代码代码如下:Unable to find a version of the runtime to run this application.初探原因这表示缺少对应版本的 .NET 运行库,需下载相应的 .NET Framework。说白了,就是...
  • Python--计算运行时间

    万次阅读 2018-08-13 23:14:21
    1.实际需求  在很多的时候我们需要计算我们...Python中有很多计算程序运行时间方法。 2. 方法展示  计算Python的某个程序,或者是代码块运行的时间一般有三种方法方法一 import datetime start = d...
  • QtConcurrent多线程 - run()与QFuture

    千次阅读 2020-03-06 00:10:25
    run()函数2. QFuture3. QFutureWatcher Qt中的 Concurrent 模块,为我们提供高级的(high-level)API 编写多线程程序,而不用使用低级的(low-level)线程元语(如互斥锁、读写锁、信号量、条件变量等)。 使用的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 229,116
精华内容 91,646
关键字:

如何计算run方法时间