Java Stopwatch类代码示例

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
private void sendNow(UpdateTasks updateTasks) {
    if (updateTasks.numMetrics == 0) {
        return;
    }
    pushSizeCount.increment();
    pushSizeTotal.increment(updateTasks.numMetrics);

    final Stopwatch s = updateTimer.start();
    int totalSent = 0;
    try {
        totalSent = RxHttp.sendAll(updateTasks.tasks, updateTasks.numMetrics, sendTimeoutMs);
        LOGGER.debug("Sent {}/{} metrics to atlas", totalSent, updateTasks.numMetrics);
    } finally {
        s.stop();
        int dropped = updateTasks.numMetrics - totalSent;
        numMetricsDroppedSendTimeout.increment(dropped);
    }
}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
@Override
public <T> T execute(
		final HttpHost target,
		final HttpRequest request,
		final ResponseHandler<? extends T> responseHandler,
		final HttpContext context)
				throws IOException, ClientProtocolException {
    Stopwatch sw = tracer.start();
	try{
		// TODO: replaced method.getQueryString() with request.getRequestLine().getUri()
		LOGGER.debug("Executing HTTP method: {}, uri: {}", request.getRequestLine().getMethod(), request.getRequestLine().getUri());
		return super.execute(target, request, responseHandler, context);
	}finally{
		sw.stop();
	}
}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
private static Stopwatch start(StatsMonitor sm) {

		Stopwatch sw = new BasicStopwatch() {

			@Override
			public void stop() {
				super.stop();
				long duration = getDuration(TimeUnit.MILLISECONDS);
				sm.record(duration);
			}

		};
		sw.start();
		return sw;
	}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
private static Stopwatch start(Timer sm) {

		Stopwatch sw = new BasicStopwatch() {

			@Override
			public void stop() {
				super.stop();
				long duration = getDuration(TimeUnit.MILLISECONDS);
				sm.record(duration, TimeUnit.MILLISECONDS);
			}

		};
		sw.start();
		return sw;
	}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
@Override
protected BasicPoolEntry createEntry(RouteSpecificPool rospl,
        ClientConnectionOperator op) {
    createEntryCounter.increment();
    Stopwatch stopWatch = creationTimer.start();
    try {
        return super.createEntry(rospl, op);
    } finally {
        stopWatch.stop();
    }
}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
@Override
protected BasicPoolEntry getEntryBlocking(HttpRoute route, Object state,
        long timeout, TimeUnit tunit, WaitingThreadAborter aborter)
        throws ConnectionPoolTimeoutException, InterruptedException {
    Stopwatch stopWatch = requestTimer.start();
    try {
        return super.getEntryBlocking(route, state, timeout, tunit, aborter);
    } finally {
        stopWatch.stop();
    }
}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
/**
 * Prime connections, blocking until configured percentage (default is 100%) of target servers are primed 
 * or max time is reached.
 * 
 * @see CommonClientConfigKey#MinPrimeConnectionsRatio
 * @see CommonClientConfigKey#MaxTotalTimeToPrimeConnections
 * 
 */
public void primeConnections(List<Server> servers) {
    if (servers == null || servers.size() == 0) {
        logger.debug("No server to prime");
        return;
    }
    for (Server server: servers) {
        server.setReadyToServe(false);
    }
    int totalCount = (int) (servers.size() * primeRatio); 
    final CountDownLatch latch = new CountDownLatch(totalCount);
    final AtomicInteger successCount = new AtomicInteger(0);
    final AtomicInteger failureCount= new AtomicInteger(0);
    primeConnectionsAsync(servers, new PrimeConnectionListener()  {            
        @Override
        public void primeCompleted(Server s, Throwable lastException) {
            if (lastException == null) {
                successCount.incrementAndGet();
                s.setReadyToServe(true);
            } else {
                failureCount.incrementAndGet();
            }
            latch.countDown();
        }
    }); 
            
    Stopwatch stopWatch = initialPrimeTimer.start();
    try {
        latch.await(maxTotalTimeToPrimeConnections, TimeUnit.MILLISECONDS);
    } catch (InterruptedException e) {
        logger.error("Priming connection interrupted", e);
    } finally {
        stopWatch.stop();
    }

    stats = new PrimeConnectionEndStats(totalCount, successCount.get(), failureCount.get(), stopWatch.getDuration(TimeUnit.MILLISECONDS));

    printStats(stats);
}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
public <T> EVCacheOperationFuture<CASValue<T>> asyncGetAndTouch(final String key, final int exp, final Transcoder<T> tc) {
    final CountDownLatch latch = new CountDownLatch(1);
    final EVCacheOperationFuture<CASValue<T>> rv = new EVCacheOperationFuture<CASValue<T>>(key, latch, new AtomicReference<CASValue<T>>(null), connectionFactory.getOperationTimeout(), executorService, appName, serverGroup);
    final Stopwatch operationDuration = getTimer(GET_AND_TOUCH_OPERATION_STRING).start();
    Operation op = opFact.getAndTouch(key, exp, new GetAndTouchOperation.Callback() {
        private CASValue<T> val = null;

        public void receivedStatus(OperationStatus status) {
            operationDuration.stop();
            rv.set(val, status);
        }

        public void complete() {
            latch.countDown();
            rv.signalComplete();
        }

        public void gotData(String k, int flags, long cas, byte[] data) {
            if (!key.equals(k)) log.warn("Wrong key returned. Key - {}; Returned Key {}", key, k);
            if (data != null)  {
                if(getAndTouchDataSize == null) getAndTouchDataSize = EVCacheMetricsFactory.getDistributionSummary(appName + "-GATOperation-DataSize", appName, serverGroup.getName());
                if (getAndTouchDataSize != null) getAndTouchDataSize.record(data.length);
            }

            val = new CASValue<T>(cas, tc.decode(new CachedData(flags, data, tc.getMaxSize())));
        }
    });
    rv.setOperation(op);
    mconn.enqueueOperation(key, op);
    return rv;
}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
public OperationFuture<Boolean> delete(String key, EVCacheLatch evcacheLatch) {
    final CountDownLatch latch = new CountDownLatch(1);
    final OperationFuture<Boolean> rv = new OperationFuture<Boolean>(key, latch, connectionFactory.getOperationTimeout(), executorService);
    final Stopwatch operationDuration = getTimer(DELETE_STRING).start();
    final DeleteOperation.Callback callback = new DeleteOperation.Callback() {
        @Override
        public void receivedStatus(OperationStatus status) {
            operationDuration.stop();
            rv.set(Boolean.TRUE, status);
            if (status.getStatusCode().equals(StatusCode.SUCCESS)) {
                getCounter(DELETE_OPERATION_SUCCESS_STRING).increment();
            } else {
                getCounter("DeleteOperation-"+ status.getStatusCode().name()).increment();
            }
        }

        @Override
        public void gotData(long cas) {
            rv.setCas(cas);
        }

        @Override
        public void complete() {
            latch.countDown();
            rv.signalComplete();
        }
    };

    final DeleteOperation op = opFact.delete(key, callback);
    rv.setOperation(op);
    if (evcacheLatch != null && evcacheLatch instanceof EVCacheLatchImpl && !client.isInWriteOnly()) ((EVCacheLatchImpl) evcacheLatch).addFuture(rv);
    mconn.enqueueOperation(key, op);
    return rv;
}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
public <T> OperationFuture<Boolean> touch(final String key, final int exp, EVCacheLatch evcacheLatch) {
    final CountDownLatch latch = new CountDownLatch(1);
    final OperationFuture<Boolean> rv = new OperationFuture<Boolean>(key, latch, connectionFactory.getOperationTimeout(), executorService);
    final Stopwatch operationDuration = getTimer(TOUCH_OPERATION_STRING).start();
    Operation op = opFact.touch(key, exp, new OperationCallback() {
        @Override
        public void receivedStatus(OperationStatus status) {
            operationDuration.stop();
            rv.set(status.isSuccess(), status);

            if (status.getStatusCode().equals(StatusCode.SUCCESS)) {
                getCounter(TOUCH_OPERATION_SUCCESS_STRING).increment();
            } else {
                getCounter(TOUCH_OPERATION_STRING + "-" + status.getStatusCode().name()).increment();
            }
        }

        @Override
        public void complete() {
            latch.countDown();
            rv.signalComplete();
        }
    });
    rv.setOperation(op);
    if (evcacheLatch != null && evcacheLatch instanceof EVCacheLatchImpl && !client.isInWriteOnly()) ((EVCacheLatchImpl) evcacheLatch).addFuture(rv);
    mconn.enqueueOperation(key, op);
    return rv;
}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
public long incr(String key, long by, long def, int exp) {
    final Stopwatch operationDuration = getTimer(INCR_OPERATION_STRING).start();
    long val = 0;
    try {
        val = mutate(Mutator.incr, key, by, def, exp);
    } finally {
        operationDuration.stop();
        if (log.isDebugEnabled()) log.debug("Increment Key : " + key + "; by : " + by + "; default : " + def + "; exp : " + exp 
                + "; val : " + val + "; Elapsed Time - " + operationDuration.getDuration(TimeUnit.MILLISECONDS));
    }
    return val;
}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
public long decr(String key, long by, long def, int exp) {
    final Stopwatch operationDuration = getTimer(DECR_OPERATION_STRING).start();
    long val = 0;
    try {
        val = super.decr(key, by, def, exp);
    } finally {
        operationDuration.stop();
        if (log.isDebugEnabled()) log.debug("decrement Key : " + key + "; by : " + by + "; default : " + def + "; exp : " + exp 
                + "; val : " + val + "; Elapsed Time - " + (operationDuration.getDuration(TimeUnit.MILLISECONDS)));
    }
    return val;
}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
public static Stopwatch executionTimer(String taskType) {
	return start("task_execute_time", taskType);
}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
private void pollForTask(Worker worker) {
	
	if(ec != null && !ec.getInstanceRemoteStatus().equals(InstanceStatus.UP)) {
		logger.debug("Instance is NOT UP in discovery - will not poll");
		return;
	}
	
	if(worker.paused()) {
		WorkflowTaskMetrics.paused(worker.getTaskDefName());
		logger.debug("Worker {} has been paused. Not polling anymore!", worker.getClass());
		return;
	}
	String domain = PropertyFactory.getString(worker.getTaskDefName(), DOMAIN, null);		
	if(domain == null){
		domain = PropertyFactory.getString(ALL_WORKERS, DOMAIN, null);		
	}
	logger.debug("Polling {}, domain={}, count = {} timeout = {} ms", worker.getTaskDefName(), domain, worker.getPollCount(), worker.getLongPollTimeoutInMS());
	
	try{

           // get the remaining capacity of worker queue to prevent queue full exception
           int realPollCount = Math.min(workerQueue.remainingCapacity(), worker.getPollCount());
           if (realPollCount <= 0) {
			logger.warn("All workers are busy, not polling.  queue size {}, max {}", workerQueue.size(), workerQueueSize);
			return;
           }
		String taskType = worker.getTaskDefName();
		Stopwatch sw = WorkflowTaskMetrics.pollTimer(worker.getTaskDefName());
		List<Task> tasks = client.poll(taskType, domain, worker.getIdentity(), realPollCount, worker.getLongPollTimeoutInMS());
           sw.stop();
           logger.debug("Polled {}, for domain {} and received {} tasks", worker.getTaskDefName(), domain, tasks.size());
           for(Task task : tasks) {
			es.submit(() -> {
				try {
					execute(worker, task);
				} catch (Throwable t) {
					task.setStatus(Task.Status.FAILED);
					TaskResult result = new TaskResult(task);
					handleException(t, result, worker, true, task);
				}
			});
		}

	}catch(RejectedExecutionException qfe) {
		WorkflowTaskMetrics.queueFull(worker.getTaskDefName());
		logger.error("Execution queue is full", qfe);
	} catch (Exception e) {
		WorkflowTaskMetrics.pollingException(worker.getTaskDefName(), e);
		logger.error("Error when polling for task " + e.getMessage(), e);
	}
}
 

import com.netflix.servo.monitor.Stopwatch; //导入依赖的package包/类
public <T> EVCacheOperationFuture<T> asyncGet(final String key, final Transcoder<T> tc, EVCacheGetOperationListener<T> listener) {
    final CountDownLatch latch = new CountDownLatch(1);
    final EVCacheOperationFuture<T> rv = new EVCacheOperationFuture<T>(key, latch, new AtomicReference<T>(null), readTimeout.get().intValue(), executorService, appName, serverGroup);
    final Stopwatch operationDuration = getTimer(GET_OPERATION_STRING).start();
    Operation op = opFact.get(key, new GetOperation.Callback() {
        private Future<T> val = null;

        public void receivedStatus(OperationStatus status) {
            operationDuration .stop();
            try {
                if (val != null) {
                    rv.set(val.get(), status);
                } else {
                    rv.set(null, status);
                }
            } catch (Exception e) {
                log.error(e.getMessage(), e);
                rv.set(null, status);
            }
        }

        @SuppressWarnings("unchecked")
        public void gotData(String k, int flags, byte[] data) {

            if (data != null)  {
                if(getDataSize == null) getDataSize = EVCacheMetricsFactory.getDistributionSummary(appName + "-GetOperation-DataSize", appName, serverGroup.getName());
                if (getDataSize != null) getDataSize.record(data.length);
            }
            if (!key.equals(k)) log.warn("Wrong key returned. Key - {}; Returned Key {}", key, k);
            if (tc == null) {
                if (tcService == null) {
                    log.error("tcService is null, will not be able to decode");
                    throw new RuntimeException("TranscoderSevice is null. Not able to decode");
                } else {
                    final Transcoder<T> t = (Transcoder<T>) getTranscoder();
                    val = tcService.decode(t, new CachedData(flags, data, t.getMaxSize()));
                }
            } else {
                if (tcService == null) {
                    log.error("tcService is null, will not be able to decode");
                    throw new RuntimeException("TranscoderSevice is null. Not able to decode");
                } else {
                    val = tcService.decode(tc, new CachedData(flags, data, tc.getMaxSize()));
                }
            }
        }

        public void complete() {
            latch.countDown();
            rv.signalComplete();
        }
    });
    rv.setOperation(op);
    if (listener != null) rv.addListener(listener);
    mconn.enqueueOperation(key, op);
    return rv;
}