精华内容
下载资源
问答
  • JAVA计算方法执行时间

    千次阅读 2019-10-02 12:01:28
    1 package tesWeb; 2 3 import java.math.BigDecimal; 4 5 public class Test02 { 6 ... 7 public static void main(String[] args) { ... 8 double upTime;//方法的执行时间(秒) 9 ...
     1 package tesWeb;
     2 
     3 import java.math.BigDecimal;
     4 
     5 public class Test02 {
     6 
     7     public static void main(String[] args) {
     8         double upTime;//方法的执行时间(秒)
     9         long startTime=System.currentTimeMillis(); //获取开始时间 
    10         for (int i = 0; i < 10; i++) {
    11             i++;
    12         }
    13         long endTime=System.currentTimeMillis(); //获取结束时间 
    14         upTime = new BigDecimal(endTime-startTime).divide(new BigDecimal(1000)).doubleValue();//耗时(秒) 
    15         System.out.println(upTime);
    16     }
    17 }

     

    转载于:https://www.cnblogs.com/tianxialuox/p/10879664.html

    展开全文
  • 我们在运行top 或者uptime时,会计算当前系统的负载平衡。 当前系统的负载平衡是看我们cpu对于当前执行任务的一个执行情况。同时也判断我们系统的任务 对于cpu的需求情况。 这句话是对于负载平衡的一个很好的总结: ...

    我们在运行top 或者uptime时,会计算当前系统的负载平衡。
    当前系统的负载平衡是看我们cpu对于当前执行任务的一个执行情况。同时也判断我们系统的任务
    对于cpu的需求情况。
    这句话是对于负载平衡的一个很好的总结:

    The CPU percentage shows us how much the cars are using the freeway, but the load averages show us the whole picture, including pent-up demand.

    以下是我收集的负载平和的计算方法
    负载的查看

    在Linux系统中,使用uptime、w和top命令都可以查看负载,或者直接通过cat /proc/loadavg查看。

    比如说uptime命令:

    20:56:33 up 22 min, 3 users, load average: 0.39, 0.25, 0.10
    

    可以看到有三个值,这三个值分别表示:

    前1分钟系统的平均负载
    前5分钟系统的平均负载
    前15分钟系统的平均负载
    

    下面就来看看负载的含义。
    负载的含义

    负载的含义是运行队列的平均长度。

    具体而言,对于Linux系统,其统计了最近1分钟、最近5分钟、最近15分钟处于running或者uninterruptible sleep状态的进程数。

    文末参考资料里给出了一个车道的例子进行类比,这儿就不赘述了。举几个例子:

    负载为0.5,表示CPU有平均一半的时间是空闲的
    负载为1,这时就表示CPU被充分利用了
    负载为2,则表示负载过大,有一半的任务在等待CPU执行
    

    一般认为负载为0.7是警戒线。
    负载与多处理器

    对于多处理器,相当于多车道。比如对于双处理器,那么负载为2才算满。 可以简单地将负载除以CPU核心数换算成单处理的情况。
    负载与CPU使用率

    文末参考资料中提到:

    The CPU percentage shows us how much the cars are using the freeway, but the load averages show us the whole picture, including pent-up demand.
    

    相比于CPU使用率,负载可能展示更多的信息,即CPU的需求量。
    负载和多线程

    Wikipedia提到在不同的Unix系统中多线程负载的计算方式有很多种,比如线程与核实体间不同的模型就有所不同。而在Linux系统中每个线程应该都是独立计算的。
    负载的计算

    我并不了解统计学等知识,以下只是个人一些粗浅的理解。

    负载计算原理是统计学的EWMA(Exponentially Damped/Weighted Moving Average),利用指数衰减函数递推出当前序列平均值。

    Wikipedia里提到:

    Hence, the 1-minute load average consists of 63% (more precisely: 1 - 1/e) of the load from the last minute and 37% (1/e) of the average load since start up, excluding the last minute. For the 5- and 15-minute load averages, the same 63%/37% ratio is computed over 5 minutes and 15 minutes respectively. Therefore, it's not technically accurate that the 1-minute load average only includes the last 60 seconds of activity (it actually includes 37% of the activity from the past), but it is correct to state that it includes mostly the last minute.
    

    即统计计算出一段时间的负载,其本质是计算均值。比如说:

        要计算——最近x分钟负载:$la_{-x}$
        假设已知——自系统启动到x分钟前的负载为:$la_{+x}$
        假设可以得到——近x分钟的运行的任务数为:$n_x$
    

    那么 lax=la+xtimes(e1)+nxtimes(1e1)la_{-x} = la_{+x} times (e^{-1}) + n_x times (1-e^{-1})lax=la+xtimes0.37+nxtimes0.63la_{-x} = la_{+x} times 0.37 + n_x times 0.63

    可以看出xx分钟前的负载权重是比较小的,随着时间的推移前面的信息影响会越来越小,直到趋近于0,最近时间的信息影响的比重比较大。

    而在Linux系统中,是每间隔5HZ5HZ或者55秒统计一次运行的任务数,然后计算均值。那么随着时间推移,可以得出这么一个序列:

    n1,n2,n3,...,nt1,ntn_1, n_2, n_3, ..., n_{t-1}, n_t

    当前时刻tt的Moving Average——mvtmv_t同样根据mvt1mv_{t-1}计算出:

    mvt=mvt1times(elambda)+nttimes(1elambda)mv_t = mv_{t-1} times (e^{-lambda}) + n_t times (1-e^{-lambda})

    对于要统计最近1分钟(60秒)的均值,由于时间间隔为5秒,那么lambdalambda的取值应为frac560frac 5{60};同理,最近5分钟(300秒)的均值,lambdalambda的取值应为frac5300frac 5{300};最近15分钟(900秒)的均值,lambdalambda的取值应为frac5900frac 5{900}

    下面来看看Linux中如何实现负载的计算。
    负载计算的实现

    Linux内核中维护了一个Jiffies变量,记录自开机一开经历的Tick数,每次更新Jiffies时系统会调用timer.c中的do_timer();

    unsigned long avenrun[3];
    static inline void (unsigned long ticks)
    {
    	unsigned long active_tasks; 
    	static int count = LOAD_FREQ;
    	count -= ticks;
    	if (count < 0) {
    		count += LOAD_FREQ;
    		active_tasks = count_active_tasks();
    		CALC_LOAD(avenrun[0], EXP_1, active_tasks);
    		CALC_LOAD(avenrun[1], EXP_5, active_tasks);
    		CALC_LOAD(avenrun[2], EXP_15, active_tasks);
    	}
    }
    

    在sched.h中可以看到上面calc_load()里一些变量、宏的定义:

    extern unsigned long avenrun[];	/* Load averages */
    #define FIXED_1  (1<<FSHIFT)	/* 1.0 as fixed-point */
    #define LOAD_FREQ (5*HZ)	/* 5 sec intervals */
    #define EXP_1  1884		/* 1/exp(5sec/1min) as fixed-point */
    #define EXP_5  2014		/* 1/exp(5sec/5min) */
    #define EXP_15 2037		/* 1/exp(5sec/15min) */
    #define CALC_LOAD(load,exp,n) 
    	load *= exp; 
    	load += n*(FIXED_1-exp); 
    	load >>= FSHIFT;
    

    可以看到,每次Jiffies+1时调用calc_load(),并不会马上统计计算负载信息,而是等到一个LOAD_FREQ的周期结束,随后又开始新的LOAD_FREQ周期;

    通过调用count_active_tasks()可以获得处于running或者uninterruptible sleep状态的进程数;

    最后执行三次的CALC_LOAD,分别更新统计的1分钟、5分钟和15分钟的负载信息。

    值得一提的就是CALC_LOAD的实现,其本质是将上面的Moving Average计算的式子乘以2112^{11},最后再除以2112^{11},采用位运算并且避免了浮点数运算,提高了计算效率。

    展开全文
  • unix平均负载average load计算方法

    千次阅读 2015-05-03 19:42:52
    average load?表示系统在一段时间内的平均进程个数,也就是表示系统的繁忙...查看方法在linux系统下使用uptime命令,或者查看/proc/loadavg都可以看到系统负载average load。使用uptime命令会显示系统分别在过去的1分钟
    average load?表示系统在一段时间内的平均进程个数,也就是表示系统的繁忙程度。average load和CPU利用率不一样,更加能够表示系统的繁忙程度,下面将就系统的average load的计算和相关进行简单介绍。
    

    查看方法

    在linux系统下使用uptime命令,或者查看/proc/loadavg都可以看到系统负载average load。使用uptime命令会显示系统分别在过去的1分钟,5分钟和10分钟里的平均负载。

    [root@localhost ~]# uptime
    19:32:09 up 5 days, 8:53, 5 users, load average: 0.05, 0.04, 0.05
    [root@localhost ~]# cat /proc/loadavg
    0.04 0.04 0.05 1/394 23203

    那么uptime命令计算load average的工作原理是什么呢?

    计算方法

    对于单cpu和多cpu情况,系统的average load情况稍有不同。单cpu是最简单的情形,比如过去的平均一分钟里面,判断系统处于运行或者等待状态的进程数则表示系统的平均负载,但是在linux系统下稍有不同,那些处于io等待状态的进程也会被纳入去计算。这样就导致CPU利用率可能和平均负载很不同,在大部分进程都在做IO的时候,即使平均负载很大,也会没有很大的CPU利用率。另外,有些系统对于进程和线程的处理也很不一样,有的对于每一个线程都会进行计算,有的只关注进程,对于超线程技术的线程来说,可能又是别的处理方式。对于多CPU的平均负载的计算,是在单CPU的情况下再除以CPU的个数。

    文件: kernel/timer.c:

    
    unsigned long avenrun[3];
    
    static inline void calc_load(unsigned long ticks)
    {
    unsigned long active_tasks; /* fixed-point */
    static int count = LOAD_FREQ;
    
    count -= ticks;
    if (count < 0) {
    count += LOAD_FREQ;
    active_tasks = count_active_tasks();
    CALC_LOAD(avenrun[0], EXP_1, active_tasks);
    CALC_LOAD(avenrun[1], EXP_5, active_tasks);
    CALC_LOAD(avenrun[2], EXP_15, active_tasks);
    }
    }

    内核中的函数sched.h

    /*
     * These are the constant used to fake the fixed-point load-average
     * counting. Some notes:
     *  - 11 bit fractions expand to 22 bits by the multiplies: this gives
     *    a load-average precision of 10 bits integer + 11 bits fractional
     *  - if you want to count load-averages more often, you need more
     *    precision, or rounding will get you. With 2-second counting freq,
     *    the EXP_n values would be 1981, 2034 and 2043 if still using only
     *    11 bit fractions.
     */
    extern unsigned long avenrun[];         /* Load averages */
    extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
    
    #define FSHIFT          11              /* nr of bits of precision */
    #define FIXED_1         (1<<FSHIFT)     /* 1.0 as fixed-point */
    #define LOAD_FREQ       (5*HZ+1)        /* 5 sec intervals */
    #define EXP_1           1884            /* 1/exp(5sec/1min) as fixed-point */
    #define EXP_5           2014            /* 1/exp(5sec/5min) */
    #define EXP_15          2037            /* 1/exp(5sec/15min) */
    
    #define CALC_LOAD(load,exp,n) \
            load *= exp; \
            load += n*(FIXED_1-exp); \
            load >>= FSHIFT;
    
    extern unsigned long total_forks;
    extern int nr_threads;
    DECLARE_PER_CPU(unsigned long, process_counts);
    extern int nr_processes(void);
    extern unsigned long nr_running(void);
    extern unsigned long nr_uninterruptible(void);
    extern unsigned long nr_iowait(void);
    extern unsigned long nr_iowait_cpu(int cpu);
    extern unsigned long this_cpu_load(void);

    ewma算法

    linux系统在很多方面都使用了这个算法,比如除了这个还有TC系统的CBQ算法,这是统计学的一个算法,具体请参考http://en.wikipedia.org/wiki/EWMA_charthttp://en.wikipedia.org/wiki/Moving_average

    参考文献

    http://man.he.net/man8/tc-cbq-details
    linux内核代码
    http://en.wikipedia.org/wiki/EWMA_chart
    http://en.wikipedia.org/wiki/Moving_average

    展开全文
  • 关于android APP PSS计算方法

    千次阅读 2018-06-06 21:13:53
    通过adb shell dumpsys meminfo + pid可以得到如下信息:Applications Memory Usage (in Kilobytes): Uptime: 30456752 Realtime: 106205372 ** MEMINFO in pid 2188 [com.android.systemui] ** Pss Priva...

    通过adb shell dumpsys meminfo + pid可以得到如下信息:

    Applications Memory Usage (in Kilobytes):
    Uptime: 30456752 Realtime: 106205372
    
    ** MEMINFO in pid 2188 [com.android.systemui] **
                       Pss  Private  Private  SwapPss     Heap     Heap     Heap
                     Total    Dirty    Clean    Dirty     Size    Alloc     Free
                    ------   ------   ------   ------   ------   ------   ------
      Native Heap    11875    11148      708    70091    96640    80732    15907
      Dalvik Heap     8681     8416      248      340    15441     6225     9216
     Dalvik Other     3860     3576      284       69
            Stack       36       36        0       20
           Ashmem        6        0        0        0
        Other dev       14        0        8        0
         .so mmap     1184      152      144      353
        .jar mmap        0        0        0        1
        .apk mmap     1027        0      772        0
        .ttf mmap      238        0      184        0
        .dex mmap     6397        0     4476        4
        .oat mmap     1499        0      228        0
        .art mmap     1036      624      164       28
       Other mmap     1304        0      608        4
       EGL mtrack     6701     6701        0        0
        GL mtrack    15773    15773        0        0
          Unknown      540      496       44      744
            TOTAL   131825    46922     7868    71654   112081    86957    25123
    
     App Summary
                           Pss(KB)
                            ------
               Java Heap:     9204
             Native Heap:    11148
                    Code:     5956
                   Stack:       36
                Graphics:    22474
           Private Other:     5972
                  System:    77035
    
                   TOTAL:   131825       TOTAL SWAP PSS:    71654
    
     Objects
                   Views:     1133         ViewRootImpl:        5
             AppContexts:       21           Activities:        1
                  Assets:        9        AssetManagers:        8
           Local Binders:      192        Proxy Binders:       69
           Parcel memory:       31         Parcel count:      132
        Death Recipients:        2      OpenSSL Sockets:        0
                WebViews:        0
    
     SQL
             MEMORY_USED:      145
      PAGECACHE_OVERFLOW:        9          MALLOC_SIZE:      117
    
     DATABASES
          pgsz     dbsz   Lookaside(b)          cache  Dbname
             4       20             19         0/18/1  /data/user_de/0/com.android.systemui/databases/timezones.db3
    
     Asset Allocations
        zip:/system/priv-app/MtkSystemUI/MtkSystemUI.apk:/assets/fonts/hiosClock_regular.ttf: 10K

    下面讲一下这里面关于memory信息的数据关系,以下计算公式主要通过代码研究得到:

    PSS total= Pss Total列总和 + SwapPss Dirty列总和

    即:total=11875+8681+3860+36+6+14+1184+1027+238+6397+1499+1036+1304+6701+15773+540+70097+340+69+20+353+1+4+28+4+744=131825KB

    Java heap=Dalvik private dirty+.art mmap private clean+.art mmap private dirty=8461+624+164 =9204

    native heap = native private dirty=11148

    code = .so private (clean+dirty) + .jar private (clean+dirty) + .apk private (clean+dirty) + .ttf private (clean+ dirty) + .dex private (clean + dirty) + .oat private (clean + dirty)=152+144+772+184+4476+228=5956

    stack = stack private dirty = 36

    graphics= GL mtrack private (clean + dirty) + EGL mtrack private(clean + dirty)=6701+15773=22474

    private other= private clean列+private dirty列-java heap-native heap-code-stack-graphic=46922+7868-9204-11148-5956-36-22474=5972

    system=total-private Clean 列总和+private dirty列总和=131825-46922-7868=77035


    展开全文
  • 在对数据库的性能监控上经常会提到QPS和TPS这两个名词,下面就分别简单的分享一下关于MySQL数据库中的QPS和TPS的意义和计算方法。1 TPS: 每秒事务量,通过以下方式来得到客户端应用程序所请求的 TPS 值,计算方法...
  • 在linux下可以使用uptime查看当前系统的...这里的负载是指平均负载,一共有三个值,分别对应过去1分钟、5分钟、15分钟的负载情况,平均负载的计算方法是:统计处于 可运行状态 或 不可中断状态 的进程的平均数量。 ...
  • 转载:添加链接描述 Information from web QPS (Query per second) ...计算方法 ___________________________________________________________ QPS Questions = SHOW GLOBAL STATUS LIKE 'Questions'; Uptime = SH
  • 下面的代码是把filterlists放到方法里面,就可以用了,但是放到计算里面就只执行一次。计算属性不是依赖有更新,自己就会更新吗。vue-todolist{{uptime}}mylist-todo{{item.text}}×{{item.addtime}}已完成未完成...
  • 1 QPS计算(每秒查询数) 针对MyISAM引擎为主的DB MySQL> show GLOBAL status like 'questions'; +---------------+------------+ | Variable_name | Value | +---------------+------------+ | Questions | ...
  • QPS、TPS计算

    2017-07-18 18:17:00
    QPS (Query per second) (每秒查询量) TPS(Transaction per second) (每秒事务量,如果是...计算方法 QPS Questions = SHOW GLOBAL STATUS LIKE 'Questions'; Uptime = SHOW GLOBAL STATUS LIKE 'Uptime'; QPS=Q...
  • QPS:每秒的查询数 TPS:每秒的事物量 QPS的计算方法 Questions = SHOW GLOBAL STATUS LIKE 'Questions'; Uptime = SHOW GLOBAL STATUS ...
  • 需要在应用程序获取系统的启动时间,通过sysinfo中的uptime可以计算出系统的启动时间,下面介绍一下获取方法,大家参考使用吧
  • MySQL的TPS和QPS 计算方式

    千次阅读 2016-10-26 20:12:28
    TPS - Transactions Per Second(每秒传输的事物处理个数),这是指服务器每秒处理的事务数,...计算方法: TPS = (COM_COMMIT + COM_ROLLBACK)/UPTIME [sql] view plain copy use i
  • Mac/Linux 查看计算机运行多长时间

    千次阅读 2016-04-12 15:52:26
    Mac/Linux 查看计算机运行多长时间 ...在terminal(终端)中,输入指令:uptime代码以及解释ishios-MacBook-Pro:~ shixiongwei$ uptime 15:39 up 12 days, 2:02, 2 users, load averages: 2.22 1.90 1.83upti
  • Linux下如何查看系统启动时间和运行时间1.uptime命令输出:16:11:40 ...查看/proc/uptime文件计算系统启动时间cat /proc/uptime输出: 5113396.94 575949.85第一数字即是系统已运行的时间5113396.94 秒,运用系统工具...
  • 在调优MySQL数据库和监控数据库时,很多朋友不知道如何下手,怎么来确定是不是参数设置的合理,下面给出一些如何计算指标,来确定数据库参数是否设置合理,希望给大家一些方法,去做MySQL数据库优化,最好对照一下...
  • 在调优MySQL数据库和监控数据库时,很多朋友不知道如何下手,怎么来确定是不是参数设置的合理,下面给出一些如何计算指标,来确定数据库参数是否设置合理,希望给大家一些方法,去做MySQL数据库优化,最好对照一下...
  • Linux下查看系统信息方法总结

    千次阅读 2018-01-11 17:59:27
    1.查看/proc/uptime文件计算系统启动时间: cat /proc/uptime 输出: 5113396.94 575949.85 第一数字即是系统已运行的时间5113396.94秒,运用系统工具date即可算出系统启动时间 date -d "$(awk -F. '{print $...
  • Nodejs中获取时间戳的方法有很多种,例如:new Date().getTime()Date.now()process.uptime()process.hrtime()平时想获取一个时间戳的话,用这些方法都可以,那么这些方法有什么区别呢?new Date().getTime()和Date....
  • Nodejs中获取时间戳的方法有很多种,例如:1.new Date().getTime()2.Date.now()3.process.uptime()4.process.hrtime()平时想获取一个时间戳的话,用这些方法都可以,那么这些方法有什么区别呢?new Date().getTime()...
  • 方法一: # who -b //系统最后一次开机的时间 方法二: # who -r //查看当前系统运行时间 方法三: # last reboot //可以...方法六:查看/proc/uptime文件计算系统启动时间 cat /proc/uptime 输出: 5113396.94 57
  • 在调优MySQL数据库和监控数据库时,很多朋友不知道如何下手,怎么来确定是不是参数设置的合理,下面给出一些如何计算指标,来确定数据库参数是否设置合理,希望给大家一些方法,去做MySQL数据库优化,最好对照一下...
  • [From]http://www.jb51.net/article/89767.htmNodejs中获取时间戳的方法有很多种,例如:1.new Date().getTime()2.Date.now()3.process.uptime()4.process.hrtime()平时想获取一个时间戳的话,用这些方法都可以,那么...

空空如也

空空如也

1 2 3
收藏数 44
精华内容 17
关键字:

uptime计算方法