Spring 타이머 StopWatch 사용 예시

10542 단어 Spring타이머
StopWatch 는 org.springframework.util 패키지 에 있 는 도구 클래스 로 프로그램 부분 코드 를 편리 하 게 시간 계산(ms 단계)할 수 있 으 며 동기 화 단일 스 레 드 코드 블록 에 적 용 됩 니 다.
정상 적 인 상황 에서 우 리 는 특정한 코드 의 실행 시간 을 볼 필요 가 있다 면 다음 과 같은 방식 으로 볼 것 이다.

public static void main(String[] args) throws InterruptedException {
   StopWatchTest.test0();
//    StopWatchTest.test1();
}

public static void test0() throws InterruptedException {
   long start = System.currentTimeMillis();
   // do something
   Thread.sleep(100);
  long end = System.currentTimeMillis();
  long start2 = System.currentTimeMillis();
  // do something
  Thread.sleep(200);
  long end2 = System.currentTimeMillis();
  System.out.println("  1    :" + (end - start));
  System.out.println("  2    :" + (end2 - start2));
}
실행 결과:
모모 1 실행 소요 시간:105
모모 2 실행 시간:203
이 방법 은 실행 완료 시간 과 실행 시작 시간의 차 이 를 얻 는 것 을 통 해 프로그램의 실행 시간 을 얻 을 수 있 습 니 다.간단 하고 직접적 으로 효과 가 있 지만 많이 쓰 는 것 도 귀 찮 을 것 입 니 다.특히 설명 할 수 없 는 코드 를 만 났 을 때 bug 채 팅 을 몇 개 더 쓰 는 것 을 참 을 수 없 을 것 입 니 다.그리고 이 결 과 는 직관 적 이지 않 습 니 다.이때 도구 류 가 있 는 지 생각 합 니 다.이런 방법 을 제공 하거나 스스로 도구 류 를 쓰 면 이런 장면 을 만족 시 키 고 결 과 를 더욱 직관 적 으로 보 여줄 수 있다.
 우선 우리 의 요 구 는 다음 과 같다.
  • 시작 시점 기록
  • 종료 시점 기록
  • 출력 실행 시간 및 시간 대별 비례
  • 이 수요 에 따라 저 희 는 org.spring from work.util 패키지 의 도구 류 인 StopWatch 를 직접 사용 할 수 있 습 니 다.이 도구 류 를 통 해 저 희 는 상기 코드 를 다음 과 같이 개조 할 수 있 습 니 다.
    
    public static void main(String[] args) throws InterruptedException {
    //    StopWatchTest.test0();
       StopWatchTest.test1();
    }
    
    public static void test1() throws InterruptedException {
       StopWatch sw = new StopWatch("test");
       sw.start("task1");
       // do something
      Thread.sleep(100);
      sw.stop();
      sw.start("task2");
      // do something
      Thread.sleep(200);
      sw.stop();
      System.out.println("sw.prettyPrint()~~~~~~~~~~~~~~~~~");
      System.out.println(sw.prettyPrint());
    }
    실행 결과:
    sw.prettyPrint()~~~~~~~~~~~~~~~~~
    StopWatch 'test': running time (millis) = 308
    -----------------------------------------
    ms     %     Task name
    -----------------------------------------
    00104  034%  task1
    00204  066%  task2
    start 기록 을 시작 하고 stop 기록 을 정지 한 다음 에 StopWatch 의 pretty Print 방법 을 통 해 직관 적 인 출력 코드 실행 시간 과 실행 시간 백분율 을 통 해 순간 적 으로 이전 방식 보다 한 단계 높 은 것 을 느 낄 수 있 습 니 다.
    그 밖 에 다음 과 같은 두 가지 방법 이 있 습 니 다.shortSummary,getTotalTimeMillis,프로그램 실행 시간 을 봅 니 다.
    실행 코드 및 결과:
    
    System.out.println("sw.shortSummary()~~~~~~~~~~~~~~~~~");
    System.out.println(sw.shortSummary());
    System.out.println("sw.getTotalTimeMillis()~~~~~~~~~~~~~~~~~");
    System.out.println(sw.getTotalTimeMillis());
    실행 결과
    sw.shortSummary()~~~~~~~~~~~~~~~~~
    StopWatch 'test': running time (millis) = 308
    sw.getTotalTimeMillis()~~~~~~~~~~~~~~~~~
    308
    사실은 상기 내용 은 이 도구 류 에서 실현 되 는 것 도 매우 간단 하 다.start 와 stop 방법 을 통 해 시작 시간 과 끝 시간 을 각각 기록 할 수 있다.그 중에서 종료 시간 을 기록 할 때 하나의 링크 유형의 tasklist 속성 을 유지 하여 이 종 류 는 여러 가지 임 무 를 기록 할 수 있 고 마지막 출력 도 기 존 에 기 록 된 정보 에 대해 통 일 된 요약 출력 을 할 뿐이다.결 과 를 더욱 직관 적 으로 보 여 준다.
    StopWatch 의 장단 점:
    장점:
  • spring 자체 공구 류,직접 사용 가능
  • 코드 는 간단 하고 사용 이 더욱 간단 하 다
  • 통일 적 으로 요약 하여 모든 임무 의 시간 소모 와 전체 시간 을 차지 하 는 백분율 을 보 여 주 며 전시 결 과 는 직관 적
  • 이다.
  • 성능 소모 가 상대 적 으로 적 고 start 와 stop 간 의 시간 기록 의 정확성 을 최대한 확보 했다
  • start 시 작업 이름 을 직접 지정 하여 기록 결 과 를 더욱 직관 적 으로 표시 할 수 있 습 니 다
  • 단점:
  • 하나의 StopWatch 인 스 턴 스 는 한 번 에 하나의 task 만 열 수 있 고 여러 task 를 동시에 시작 할 수 없습니다.또한 이 task 가 멈 추 지 않 기 전에 새로운 task 를 시작 할 수 없습니다.이 task stop 후에 야 새로운 task 를 시작 할 수 있 습 니 다.한 번 에 여러 개 를 시작 하려 면 new 의 다른 StopWatch 인 스 턴 스
  • 가 필요 합 니 다.
  • 코드 침입 식 으로 사용 하려 면 여러 곳 의 코드
  • 를 바 꿔 야 합 니 다.
    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('
    '); if (!this.keepTaskList) { sb.append("No task info kept"); } else { sb.append("-----------------------------------------
    "); sb.append("ms % Task name
    "); sb.append("-----------------------------------------
    "); 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("
    "); } } 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; } } }
     스프링 타이머 스 톱 워 치 사용 예시 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.스프링 타이머 스 톱 워 치 에 관 한 더 많은 내용 은 저희 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 읽 어 주시 기 바 랍 니 다.앞으로 도 많은 응원 부 탁 드 리 겠 습 니 다!

    좋은 웹페이지 즐겨찾기