【2016-08-07】

=========================================================

一、学习Metrics

=========================================================

1、Metrics可以称之为“度量”，它是用来为某个系统做性能监控的工具类。它可以统计QPS、RT等等，结合业务逻辑，从很多维度来对系统进行实时监控。目前觉得它的一些好处如下：

1）它实现了和系统本身的解耦，根据具体的系统或系统所使用的框架，可以很方便的将Metrics嵌入到系统中；

2）它提供了一些方法（Meter、Timer、Counter、Gauge等），具体的指标统计计算方式都已封装，不需要开发者进行计算操作；

3）结合InfluxDB、Gragana等工具，可以开发出有很高可用性的监控系统；

2、在系统中使用Metrics需要添加Metrics包或添加Metrics的依赖，它的Maven依赖如下：

<dependencies>
    <dependency>
        <groupId>io.dropwizard.metrics</groupId>
        <artifactId>metrics-core</artifactId>
        <version>#具体版本号#</version>
    </dependency>
</dependencies>

3、使用Metrics的入口，也就是Metrics监控开始的地方是MetricsRegister类。通过MetricsRegister类创建Metrics，在Metrics中包含了许多方法（timer、counter、gauge等等）。

final MetricRegistry metrics = new MetricRegistry();

4、一些方法的作用...

Meter： meter测量在过去的时间里发生的事件的比率，如每秒的请求速率。

ConsoleReport：在控制台打印统计报告信息，打印时间间隔可以自己控制；

Gauge：它测量的不是一个时间段的值，测量的是某一个指标的瞬时值，可以使很多类型（具体还没深究）；

Counter：它实际上就是Gauge的一个Integer类型值得实例；

Histograms：是什么图标统计，还没跑通，不知道怎么用；

Timers：它是用来测量时间，如RT（响应时间）；

特别的，还有一些其他功能：

HealthChecks：做一些有效性检查，如检查数据库是否能连通；

还有一些Reporting Via JMX、Reporting Via Http等，还不懂是什么。。。。

5、对一些测量工具类进行了编码测试：

//对Meter的测试

package Meter;

import com.codahale.metrics.ConsoleReporter;
import com.codahale.metrics.Counter;
import com.codahale.metrics.MetricRegistry;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

/**
 * Created by carrot on 16/8/7.
 */
public class Meter extends HttpServlet {

    private static MetricRegistry registry = new MetricRegistry();

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        startReprot();
        com.codahale.metrics.Meter meter = registry.meter("request");
        meter.mark();



        try {
            Thread.sleep(3000);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }

    static void startReprot() {
        ConsoleReporter reporter = ConsoleReporter.forRegistry(registry)
                .convertRatesTo(TimeUnit.SECONDS).convertDurationsTo(TimeUnit.MILLISECONDS)
                .build();
        reporter.start(3, TimeUnit.SECONDS);
    }


}

//Gauge

import com.codahale.metrics.ConsoleReporter;
import com.codahale.metrics.Gauge;
import com.codahale.metrics.MetricRegistry;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.TimeUnit;
/**
 * Created by carrot on 16/8/7.
 */
public class ListManage {
    private List list;
    public ListManage(final List list, MetricRegistry metrics) {
        this.list = list;
        ConsoleReporter reporter = ConsoleReporter.forRegistry(metrics)
                .convertRatesTo(TimeUnit.SECONDS).convertDurationsTo(TimeUnit.MILLISECONDS)
                .build();
        reporter.start(3, TimeUnit.SECONDS);
        metrics.register(MetricRegistry.name(Queue.class), new Gauge<Integer>() {
            public Integer getValue() {
                return list.size();
            }
        });
    }
    public void GuageTest(List<Integer> list, int size) {
        while(true) {
            try {
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            list.add(++size);
        }
    }
}

import com.codahale.metrics.MetricRegistry;
import com.google.common.collect.Lists;
import java.util.List;
/**
 * Created by carrot on 16/8/7.
 */
public class Test {
    public static void main(String[] args) {
        MetricRegistry metrics = new MetricRegistry();
        final List<Integer> list = Lists.newArrayList();
        int size = 0;
        new ListManage(list, metrics).GuageTest(list,size);
    }
}

//Counter

import com.codahale.metrics.ConsoleReporter;
import com.codahale.metrics.Counter;
import com.codahale.metrics.MetricRegistry;
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.TimeUnit;
/**
 * Created by carrot on 16/8/7.
 */
public class Manage {
    private static MetricRegistry metrics = new MetricRegistry();
    private static Counter counter = metrics.counter(MetricRegistry.name(Queue.class));;
    private static Queue queue = new LinkedList();
    private static Queue<Integer> createList() {
        queue = new LinkedList();
        return queue;
    }
    public Manage() {
    }
    private static void addEle(Queue queue, int ele) {
        counter.inc();
        queue.offer(ele);
    }
    private static int takeEle(Queue queue) {
        counter.dec();
        return (Integer) queue.poll();
    }
    private static void Sleep(int secend) {
        try {
            Thread.sleep(secend);
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        int ele = 0;
        ConsoleReporter reporter = ConsoleReporter.forRegistry(metrics)
                .convertRatesTo(TimeUnit.SECONDS).convertDurationsTo(TimeUnit.MILLISECONDS)
                .build();
        reporter.start(3, TimeUnit.SECONDS);
        while (true) {
            addEle(queue, ++ele);
            Sleep(3000);
            addEle(queue, ++ele);
            Sleep(3000);
            addEle(queue, ++ele);
            Sleep(3000);
            System.out.println(takeEle(queue));
            Sleep(3000);
            System.out.println(takeEle(queue));
            Sleep(3000);
            System.out.println(takeEle(queue));
            Sleep(3000);
        }
    }
}

此后略去“一万行”代码...