Progress.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:4k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.util;
  19. import java.util.ArrayList;
  20. /** Utility to assist with generation of progress reports.  Applications build
  21.  * a hierarchy of {@link Progress} instances, each modelling a phase of
  22.  * execution.  The root is constructed with {@link #Progress()}.  Nodes for
  23.  * sub-phases are created by calling {@link #addPhase()}.
  24.  */
  25. public class Progress {
  26.   private String status = "";
  27.   private float progress;
  28.   private int currentPhase;
  29.   private ArrayList<Progress> phases = new ArrayList<Progress>();
  30.   private Progress parent;
  31.   private float progressPerPhase;
  32.   /** Creates a new root node. */
  33.   public Progress() {}
  34.   /** Adds a named node to the tree. */
  35.   public Progress addPhase(String status) {
  36.     Progress phase = addPhase();
  37.     phase.setStatus(status);
  38.     return phase;
  39.   }
  40.   /** Adds a node to the tree. */
  41.   public synchronized Progress addPhase() {
  42.     Progress phase = new Progress();
  43.     phases.add(phase);
  44.     phase.parent = this;
  45.     progressPerPhase = 1.0f / (float)phases.size();
  46.     return phase;
  47.   }
  48.   /** Called during execution to move to the next phase at this level in the
  49.    * tree. */
  50.   public synchronized void startNextPhase() {
  51.     currentPhase++;
  52.   }
  53.   /** Returns the current sub-node executing. */
  54.   public synchronized Progress phase() {
  55.     return phases.get(currentPhase);
  56.   }
  57.   /** Completes this node, moving the parent node to its next child. */
  58.   public void complete() {
  59.     // we have to traverse up to our parent, so be careful about locking.
  60.     Progress myParent;
  61.     synchronized(this) {
  62.       progress = 1.0f;
  63.       myParent = parent;
  64.     }
  65.     if (myParent != null) {
  66.       // this will synchronize on the parent, so we make sure we release
  67.       // our lock before getting the parent's, since we're traversing 
  68.       // against the normal traversal direction used by get() or toString().
  69.       // We don't need transactional semantics, so we're OK doing this. 
  70.       myParent.startNextPhase();
  71.     }
  72.   }
  73.   /** Called during execution on a leaf node to set its progress. */
  74.   public synchronized void set(float progress) {
  75.     this.progress = progress;
  76.   }
  77.   /** Returns the overall progress of the root. */
  78.   // this method probably does not need to be synchronized as getINternal() is synchronized 
  79.   // and the node's parent never changes. Still, it doesn't hurt. 
  80.   public synchronized float get() {
  81.     Progress node = this;
  82.     while (node.parent != null) {                 // find the root
  83.       node = parent;
  84.     }
  85.     return node.getInternal();
  86.   }
  87.   /** Computes progress in this node. */
  88.   private synchronized float getInternal() {
  89.     int phaseCount = phases.size();
  90.     if (phaseCount != 0) {
  91.       float subProgress =
  92.         currentPhase < phaseCount ? phase().getInternal() : 0.0f;
  93.       return progressPerPhase*(currentPhase + subProgress);
  94.     } else {
  95.       return progress;
  96.     }
  97.   }
  98.   public synchronized void setStatus(String status) {
  99.     this.status = status;
  100.   }
  101.   public String toString() {
  102.     StringBuffer result = new StringBuffer();
  103.     toString(result);
  104.     return result.toString();
  105.   }
  106.   private synchronized void toString(StringBuffer buffer) {
  107.     buffer.append(status);
  108.     if (phases.size() != 0 && currentPhase < phases.size()) {
  109.       buffer.append(" > ");
  110.       phase().toString(buffer);
  111.     }
  112.   }
  113. }