众所周知，php的函数中，有获取当前秒数的time()，也有获取当前微秒数的microtime()，但是并没有获取毫秒数的函数。一般来说都是要我们自己转换的。这边记录一下。
一、获取php毫秒数的代码
/*
 * php输入毫秒部分的代码
 * */
  function msectime() {
    list($msec, $sec) = explode(' ', microtime());
    $msectime =  (float)sprintf('%.0f', (floatval($msec) + floatval($sec)) * 1000);
    return $msectime;
  }

以上代码会直接输出时间戳加毫秒数，格式类似于下面的
1511507346  758
10位的时间戳+3位的毫秒

二、以上代码用到的部分
（1）php的microtime（）函数
这个是php获取微妙数的函数，会输出两部分，一部分是微妙数，一部分是当下的时间戳。

具体参考手册：http://www.w3school.com.cn/php/func_date_microtime.asp
（2）php的list（）函数
把数组中的值赋给一些变量。

比如：
<?php
$my_array = array("Dog","Cat","Horse");

list($a, $b, $c) = $my_array;
echo "I have several animals, a $a, a $b and a $c.";

//输出结果
I have several animals, a Dog, a Cat and a Horse.
?>

      获取毫秒数的代码里面，相当于用list把通过microtime()获取的毫秒数和时间戳赋给了新的变量，$msec是微秒部分。$sec是时间戳部分
（3）php的sprintf()自动填充函数
这部分请看我转载的另一篇博客，总结的很好，地址：

http://blog.csdn.net/LJFPHP/article/details/78624821
 $msectime =  (float)sprintf('%.0f', (floatval($msec) + floatval($sec)) * 1000);
//在这句中，'%.0f'中，'%'代表替换符。'f'代表浮点型。'.0'代表小数点位数为0，也就是没有小数点

三、利用获取毫秒的函数测试代码速度：
 public function test_iot(Request $request){
 //生成10万条数据
    $num = 100000;
    $device_name = 'ABCD_';
    $m = 0;
    $strs = '';
    //调用获取毫秒时间的函数，t1
    $t1 = $this->msectime();
    for($i = 0; $i<$num; $i++){
      $m = $m+1;
      $str=$device_name.str_pad($m,7,'0',STR_PAD_LEFT );
      $strs .= '&'.$str;
    }
    //生成产品编号后，在此获取当前毫秒时间
    $t2 = $this->msectime();
    $strs = substr($strs,1);
    echo'<p>测试str_pad()函数生成100000条的数据</p>';
    //两次时间减一下
    $t = $t2 - $t1;
    echo '<br/>';
    print_r($t);
   // print_r($strs);

  }

结果：

这里的92就代表了执行这段代码，耗费了92毫秒!
end

System.currentTimeMillis()
使用System.currentTimeMillis()，获取系统当前时间（按ms计量），类型为long。
在测试代码段开始前打上第一个时间戳，使用System.currentTimeMillis()获取当前时间；在结束部分再打一个时间戳，再次使用System.currentTimeMillis()获取当前时间。
end-start 即为所求的运行用时。
ms已经很精确了 （Java还有支持ns的API但其实系统未必支持） ，但即使使用ns进行百千万次的运算，也很可能测出耗时0ms，所以想测试就不要去测那种没什么时耗的例子，找点典型的耗时应用算法去做测试。
Test1
我们将简单算术加法进行100W次，结果竟然耗时0ms。
public class GetTimeTest {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        long counter = 0;
        for (int i = 0; i < 1000000; i++) {
            counter += i;
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }
}

测试结果
0

Test2
我们将一个字符串连接100W次（1M次），测一下时间。

哪怕我们只用了空串，然而字符串连接这种行为本身就很消耗时间了，所以必然有个结果。
public class GetTimeTest {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String str = "";
        for (int i = 0; i < 1000000; i++) {
            str += "";
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }
}

测试结果
47

Test3
我们把Test2的连接次数再翻10倍，达到1000W次：
public class GetTimeTest {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String str = "";
        for (int i = 0; i < 10000000; i++) {
            str += "";
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }
}

测试结果：
159

总结
打时间戳来测试区间代码段运行时间，可以便于自己开展粗略的性能测试，是很重要的知识，一定要掌握啊！

前言
实际业务经常遇到求平均响应时间等操作，理论上应该可以直接求日期格式毫秒值，便可以计算时间差，But，Oracle没有对应函数，同时网上的方法求得是日期格式化的double类型数据，相加减时，遵循的是十进制，日期格式为60进制，所以毫秒值并不和我们理解的一样，目前提出几个解决思路，但是SQL稍微有点长，以后想办法优化，应该有其他思路，欢迎指正。目前解决思路就是自定义函数Thinking 4
1.Thinking 1 精确到秒 TO_DATE()
赶时间直接看4.Thinking 4 自定义函数解析时间,有时间的慢慢看，4为解决办法 

分三段写；

2019-05-28 23:59:59
--1559059199000
SELECT TO_NUMBER(TO_DATE('2019-05-28 23:59:59', 'YYYY-MM-DD HH24:MI:SS') -
                 TO_DATE('1970-01-01 8:0:0', 'YYYY-MM-DD HH24:MI:SS')) * 24 * 60 * 60 * 1000
FROM DUAL;

2019-05-29 00:01:00
--1559059260000
SELECT TO_NUMBER(TO_DATE('2019-05-29 00:01:00', 'YYYY-MM-DD HH24:MI:SS') -
                 TO_DATE('1970-01-01 8:0:0', 'YYYY-MM-DD HH24:MI:SS')) * 24 * 60 * 60 * 1000
FROM DUAL;

两数相减
--61000
select  1559059260000-1559059199000 from dual;

缺点
通过获取当前时间，直接日期相减，获得当天到1970年的毫秒值，but，to_date 函数只能精确到 秒，误差会出现，无法精确到毫秒，但是可以精确到秒求得我们所需毫秒值
2.Thinking 2 精确到毫秒 TO_TIMESTAMP()
实时计算日期函数TO_TIMESTAMP使用链接
既然to_date函数只能精确到秒，那么，我们使用Oracle的另一个可以精确到 毫秒 的函数 to_timestamp

2019-06-06 14:13:00
--2019-06-06 14:13:00.000000000
select to_timestamp('2019-06-06 14:13:00', 'YYYY-MM-DD HH24:MI:SS.ff')  from dual;

out

2019-06-06 14:13:00.000000000
模拟日期相减

2019-06-06 14:13:0.100

2019-06-06 14:10:0.200
select to_timestamp('2019-06-06 14:13:0.100', 'YYYY-MM-DD HH24:MI:SS.ff') 
      -to_timestamp('2019-06-06 14:10:0.200', 'YYYY-MM-DD HH24:MI:SS.ff')  from dual;

out

0 0:2:59.9
缺点
算出来为时间类型，几分几秒，很精准的算法。

如果你需要时间展示为毫秒形式long类型，使用Thinking 4
3.Thinking 3 精确到毫秒 EXTRACT()
换一个函数继续做毫秒问题

oracle中 extract() 函数----用于截取年、月、日、时、分、秒 详解链接
--4200
select EXTRACT(SECOND FROM(to_timestamp('2019-06-06 14:12:4.200', 'YYYY-MM-DD HH24:MI:SS.ff')   )) * 1000 from  dual;

缺点
这个只能计算到秒，两个时间差如果大于59秒，涉及到分钟，还是没办法，就算计算分钟，它也只会显示分钟，之后精度丢失

out

4200
4 Thinking 4 自定义函数解析时间
因为实在没有办法，所以决定自定义时间解析，Thinking 2出的时间类型 解析成毫秒

注：自定义函数可以随数据库一直存在，使用时调用即可 ?

TestSQL

我们解析Thinking 2返回的这个 0 0:2:59.9时间，然后把它截取字符串，我选择一个比较全的时间进行测试，然后把这个SQL转化为函数 传参式
select day* 24 * 60 * 60 * 1000+ hour * 60 * 60 * 1000 + min * 60 * 1000 + ss * 1000 + mi from (
select INSTR( '31 11:33:40.89', ' ' ) konggeIndex,SUBSTR('31 11:33:40.89',1,2) testIndex,
        instr('31 11:33:40.89', '.', 1) - instr('31 11:33:40.89', ':', 1,2) - 1 secondIndex,
        instr('31 11:33:40.89', ':', 1,2)  - instr('31 11:33:40.89', ':', 1)-1 minuteIndex,
        instr('31 11:33:40.89', ':', 1)   - instr('31 11:33:40.89', ' ', 1)-1 hourIndex,
        instr('31 11:33:40.89', ' ', 1)    -1 dayIndex,
  to_number(SUBSTR( '31 11:33:40.89', INSTR( '31 11:33:40.89', '.') + 1, 3)) mi,
  to_number(SUBSTR( '31 11:33:40.89', INSTR( '31 11:33:40.89', ':',1,2) + 1, instr('31 11:33:40.89', '.', 1) - instr('31 11:33:40.89', ':', 1,2) - 1)) ss,
  to_number(SUBSTR( '31 11:33:40.89', INSTR( '31 11:33:40.89', ':',1,1) + 1, instr('31 11:33:40.89', ':', 1,2)  - instr('31 11:33:40.89', ':', 1)-1 )) min,
  to_number(SUBSTR( '31 11:33:40.89', INSTR( '31 11:33:40.89', ' ') + 1 , instr('31 11:33:40.89', ':', 1) - instr('31 11:33:40.89', ' ', 1)-1) )hour,
 to_number(SUBSTR( '31 11:33:40.89' , 1,  (instr('31 11:33:40.89', ' ') ) )) day
 from dual) time;


自定义函数编写
创建函数
CREATE OR REPLACE FUNCTION get_timestamp_cha(endtime   in TIMESTAMP,
                                            starttime in TIMESTAMP)

    RETURN INTEGER


AS


    str      VARCHAR2(50);
    misecond INTEGER;
    seconds  INTEGER;
    minutes  INTEGER;
    hours    INTEGER;
    days     INTEGER;


BEGIN

    str := to_char(endtime - starttime);

    misecond := to_number(SUBSTR(str, INSTR(str, '.') + 1, 3));

    seconds := to_number(SUBSTR(str,  INSTR(str, ':',1,2) + 1, instr(str, '.', 1) - instr(str, ':', 1,2) - 1));

    minutes := to_number(SUBSTR(str, INSTR(str, ':',1,1) + 1,    (instr(str, ':', 1,2)  )- instr(str, ':', 1)-1 ));

    hours := to_number(SUBSTR(str, INSTR(str, ' ') + 1 ,  (instr(str, ':', 1)  )- instr(str, ' ', 1)-1));

    days := to_number(SUBSTR(str, 1, INSTR(str, ' ')));

    RETURN days * 24 * 60 * 60 * 1000 + hours * 60 * 60 * 1000 + minutes * 60 * 1000 + seconds * 1000 + misecond;

END;

调用函数
 select get_timestamp_cha( 
 to_timestamp('2019-06-06 14:13:0.100', 'YYYY-MM-DD HH24:MI:SS.ff'),  
 to_timestamp('2019-06-06 14:10:0.200', 'YYYY-MM-DD HH24:MI:SS.ff') ) 
 millisecond
 from dual;

out



顺便测试一下自己的时间



注：也可以单独计算当前时间毫秒值，开始时间传值为1970年毫秒日期就行

至此，终于解决了日期时间差毫秒值问题 ???
祝你幸福

送你一首歌：《The Nights》 Avicii / RAS

附图：小蓬草

计算两个时间段之间相差的天数，简单说一下思路：

首先获取两个时间段的时间值，分别将他们转换为毫秒数，在进行除以每天(24*60*60*1000)的毫秒数，那就得到了相差的天数了；

插件：

<script src="~/Content/JS/jquery-2.1.4.js"></script>

页面代码：

<div>
        <span>开始时间</span>
        <input type="date" id="Startdate" />
        <span>起止时间</span>
        <input type="date" id="Enddate" />
        <button onclick="Dateclick()">计算时间差</button>
        <input id="Date"/>
</div>


Js中的计算代码：

function Dateclick() {
            var Startdate = $("#Startdate").val().trim();
            var Enddate = $("#Enddate").val().trim();
            if (Startdate != "" && Enddate != "") {
                var start, end, days;
                //start = new Date(Startdate);//先转换为时间类型的
                //end = new Date(Enddate);
                //start = start.getTime();//geTime() 返回 1970/1/1 午夜距离该日期时间的毫秒数
                //end = end.getTime();
                start = Date.parse(Startdate);
//parse() 方法可解析一个日期时间字符串，并返回 1970/1/1 午夜距离该日期时间的毫秒数。
                end = Date.parse(Enddate);
                days = Math.floor(Math.abs(start - end) / (24 * 3600 * 1000));
//Math.abs() 返回数的绝对值 精确到毫秒。
                //Math.floor() 对数进行下舍入 -0.1转为1, 0.1转为0。
                $("#Date").val(days);
            }
            else {
                window.alert("请选择时间");
                 }
        }


控制器计算代码：

function Dateclick() {
            var Startdate = $("#Startdate").val().trim();
            var Enddate = $("#Enddate").val().trim();
            //var Startdate = "2019-01-12 13:12:55";
            //var Enddate = "2019-01-23 15:17:54"
            if (Startdate != "" && Enddate != "") {
                $.post("/LianXi/Date", { Startdate: Startdate, Enddate: Enddate }, function (data) {
                    $("#Date").val(data);
                });
            }
            else {
                window.alert("请选择时间");
                }
    }


控制器代码：

public string Date(DateTime Startdate, DateTime Enddate)
        {
            string Days = null;
            try
            {
                TimeSpan Start = new TimeSpan(Startdate.Ticks);
                TimeSpan End = new TimeSpan(Enddate.Ticks);
                //int Day = Start.Days - End.Days;
                //if (Day < 0)//判断时间天数是否为负
                //{
                //    //Days = Day.ToString().Substring(1); //将"-"截取舍去;
                //    Days = Day.ToString().Replace("-", "");//将"-"替换为空;
                //}
                //else
                //{
                //    Days = Day.ToString();
                //}
                TimeSpan Date = Start.Subtract(End).Duration();
                //Subtract()函数是TimeSpan时间相减，前值减去函数中的值，Duration()函数是获取TimeSpan的绝对值;
                 Days = Date.Days.ToString();//.Days获取时间间隔天数部分;
                Days = Date.TotalDays.ToString();
                //string[] Day = Days.Split('.');//适合参数值精确到时分秒的值;
                //Days = Day[0];
            }
            catch
            {
                throw;
            }
            return Days;
        }


运行结果图：