一、總結

1.1、使用System.currentTimeMillis();計算程式執行毫秒數

		// 開始時間1
		long startTime1 = System.currentTimeMillis();
		Thread.sleep(100);
		// 結束時間1
		long endTime1 = System.currentTimeMillis();

		// 開始時間2
		long startTime2 = System.currentTimeMillis();
		Thread.sleep(200);
		// 結束時間2
		long endTime2 = System.currentTimeMillis();
		System.out.println("邏輯1執行時間："+ (endTime1 - startTime1));
		System.out.println("邏輯2執行時間："+ (endTime2 -startTime2));

1.2、使用org.springframework.util包下的一個工具類StopWatch計算執行時間

		StopWatch testTask = new StopWatch("TestTask");
		// 記錄開始時間點
		testTask.start("task1");
		Thread.sleep(100);
		// 記錄結束時間點
		testTask.stop();
		// 記錄開始時間點
		testTask.start("task2");
		Thread.sleep(200);
		// 記錄結束時間點
		testTask.stop();
		// 輸出執行時間
		System.out.println("==任務執行時間==");
		System.out.println(testTask.prettyPrint());
		System.out.println("執行任務的毫秒數："+testTask.getTotalTimeMillis());

1.3兩個案例的完整代碼、執行結果

package time.stopwatch;

import org.springframework.util.StopWatch;

public class StopWatchTest {
		public static void main(String[] args) throws InterruptedException {
		// 計算執行時間
		calculateExecuteTime1();
		// 計算執行時間
		calculateExecuteTime2();
	}

	public static void calculateExecuteTime1() throws InterruptedException {
		// 開始時間1
		long startTime1 = System.currentTimeMillis();
		Thread.sleep(100);
		// 結束時間1
		long endTime1 = System.currentTimeMillis();

		// 開始時間2
		long startTime2 = System.currentTimeMillis();
		Thread.sleep(200);
		// 結束時間2
		long endTime2 = System.currentTimeMillis();
		System.out.println("邏輯1執行時間："+ (endTime1 - startTime1));
		System.out.println("邏輯2執行時間："+ (endTime2 -startTime2));
	}

	public static void calculateExecuteTime2() throws InterruptedException {
		StopWatch testTask = new StopWatch("TestTask");
		// 記錄開始時間點
		testTask.start("task1");
		Thread.sleep(100);
		// 記錄結束時間點
		testTask.stop();
		// 記錄開始時間點
		testTask.start("task2");
		Thread.sleep(200);
		// 記錄結束時間點
		testTask.stop();
		// 輸出執行時間
		System.out.println("==任務執行時間==");
		System.out.println(testTask.prettyPrint());
		System.out.println("執行任務的毫秒數："+testTask.getTotalTimeMillis());
	}
}

執行結果：

邏輯1執行時間：109
邏輯2執行時間：203
==任務執行時間==
StopWatch 'TestTask': running time = 319076700 ns
---------------------------------------------
ns         %     Task name
---------------------------------------------
114748000  036%  task1
204328700  064%  task2

執行任務的毫秒數：319

1.4 StopWatch優缺點：

優點：
1、spring自帶工具類，可直接使用
2、代碼實現簡單，使用更簡單
3、統一歸納，展示每項任務耗時與占用總時間的百分比，展示結果直觀
4、性能消耗相對較小，並且最大程度的保證了start與stop之間的時間記錄的準確性
5、可在start時直接指定任務名字，從而更加直觀的顯示記錄結果
缺點：
1、一個StopWatch實例一次只能開啟一個task，不能同時start多個task，並且在該task未stop之前不能start一個新的task，必須在該task stop之後才能開啟新的task，若要一次開啟多個，需要new不同的StopWatch實例
2、代碼侵入式使用，需要改動多處代碼

1.5、spring中StopWatch源碼實現如下：

import java.text.NumberFormat;
import java.util.LinkedList;
import java.util.List;

public class StopWatch {
	private final String id;
	private boolean keepTaskList = true;
	private final List<TaskInfo> taskList = new LinkedList();
	private long startTimeMillis;
	private boolean running;
	private String currentTaskName;
	private StopWatch.TaskInfo lastTaskInfo;
	private int taskCount;
	private long totalTimeMillis;

	public StopWatch() {
		this.id = "";
	}

	public StopWatch(String id) {
		this.id = id;
	}

	public void setKeepTaskList(boolean keepTaskList) {
		this.keepTaskList = keepTaskList;
	}

	public void start() throws IllegalStateException {
		this.start("");
	}

	public void start(String taskName) throws IllegalStateException {
		if (this.running) {
			throw new IllegalStateException("Can't start StopWatch: it's already running");
		} else {
			this.startTimeMillis = System.currentTimeMillis();
			this.running = true;
			this.currentTaskName = taskName;
		}
	}

	public void stop() throws IllegalStateException {
		if (!this.running) {
			throw new IllegalStateException("Can't stop StopWatch: it's not running");
		} else {
			long lastTime = System.currentTimeMillis() - this.startTimeMillis;
			this.totalTimeMillis += lastTime;
			this.lastTaskInfo = new StopWatch.TaskInfo(this.currentTaskName, lastTime);
			if (this.keepTaskList) {
				this.taskList.add(this.lastTaskInfo);
			}

			++this.taskCount;
			this.running = false;
			this.currentTaskName = null;
		}
	}

	public boolean isRunning() {
		return this.running;
	}

	public long getLastTaskTimeMillis() throws IllegalStateException {
		if (this.lastTaskInfo == null) {
			throw new IllegalStateException("No tasks run: can't get last task interval");
		} else {
			return this.lastTaskInfo.getTimeMillis();
		}
	}

	public String getLastTaskName() throws IllegalStateException {
		if (this.lastTaskInfo == null) {
			throw new IllegalStateException("No tasks run: can't get last task name");
		} else {
			return this.lastTaskInfo.getTaskName();
		}
	}

	public StopWatch.TaskInfo getLastTaskInfo() throws IllegalStateException {
		if (this.lastTaskInfo == null) {
			throw new IllegalStateException("No tasks run: can't get last task info");
		} else {
			return this.lastTaskInfo;
		}
	}

	public long getTotalTimeMillis() {
		return this.totalTimeMillis;
	}

	public double getTotalTimeSeconds() {
		return (double) this.totalTimeMillis / 1000.0D;
	}

	public int getTaskCount() {
		return this.taskCount;
	}

	public StopWatch.TaskInfo[] getTaskInfo() {
		if (!this.keepTaskList) {
			throw new UnsupportedOperationException("Task info is not being kept!");
		} else {
			return (StopWatch.TaskInfo[]) this.taskList.toArray(new StopWatch.TaskInfo[this.taskList.size()]);
		}
	}

	public String shortSummary() {
		return "StopWatch '" + this.id + "': running time (millis) = " + this.getTotalTimeMillis();
	}

	public String prettyPrint() {
		StringBuilder sb = new StringBuilder(this.shortSummary());
		sb.append('\n');
		if (!this.keepTaskList) {
			sb.append("No task info kept");
		} else {
			sb.append("-----------------------------------------\n");
			sb.append("ms     %     Task name\n");
			sb.append("-----------------------------------------\n");
			NumberFormat nf = NumberFormat.getNumberInstance();
			nf.setMinimumIntegerDigits(5);
			nf.setGroupingUsed(false);
			NumberFormat pf = NumberFormat.getPercentInstance();
			pf.setMinimumIntegerDigits(3);
			pf.setGroupingUsed(false);
			StopWatch.TaskInfo[] var7;
			int var6 = (var7 = this.getTaskInfo()).length;

			for (int var5 = 0; var5 < var6; ++var5) {
				StopWatch.TaskInfo task = var7[var5];
				sb.append(nf.format(task.getTimeMillis())).append("  ");
				sb.append(pf.format(task.getTimeSeconds() / this.getTotalTimeSeconds())).append("  ");
				sb.append(task.getTaskName()).append("\n");
			}
		}

		return sb.toString();
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder(this.shortSummary());
		if (this.keepTaskList) {
			StopWatch.TaskInfo[] var5;
			int var4 = (var5 = this.getTaskInfo()).length;

			for (int var3 = 0; var3 < var4; ++var3) {
				StopWatch.TaskInfo task = var5[var3];
				sb.append("; [").append(task.getTaskName()).append("] took ").append(task.getTimeMillis());
				long percent = Math.round(100.0D * task.getTimeSeconds() / this.getTotalTimeSeconds());
				sb.append(" = ").append(percent).append("%");
			}
		} else {
			sb.append("; no task info kept");
		}

		return sb.toString();
	}

	public static final class TaskInfo {
		private final String taskName;
		private final long timeMillis;

		TaskInfo(String taskName, long timeMillis) {
			this.taskName = taskName;
			this.timeMillis = timeMillis;
		}

		public String getTaskName() {
			return this.taskName;
		}

		public long getTimeMillis() {
			return this.timeMillis;
		}

		public double getTimeSeconds() {
			return (double) this.timeMillis / 1000.0D;
		}
	}

}

原文摘錄至：https://blog.csdn.net/gxs1688/article/details/87185030
致敬原作者：一個不二，侵刪。