在1.5以前是重量级锁，当遇到synchronzed时，其他线程需要等待并进入blocked状态。

在1.6以后，经过大量的测试发现加锁的地方经常被一个线程访问。所以对synchronized进行了锁的粒度优化，主要在对象头增加标记位因此有了偏向锁、轻量级锁、重量级锁。

• spring mvc

  采用SPI技术，注入Spring的Servlet类，具体是实现了javax.servlet.ServletContainerInitializer接口的SpringServletContainerInitializer类,在这个类上注解@HandlesTypes传递的参数给Servlet中进行扩展使用

  ]]>https://clibing.com/posts/java/rate_limit/Thu, 20 Aug 2020 13:52:27 +0800https://clibing.com/posts/java/rate_limit/限流器

  我们项目是新闻类的站点，每天需要限制各种爬虫，保证服务在可承受范围内，需要保护后台服务正常。需要使用限流器。

  ]]>https://clibing.com/posts/linux/docker/java_docker_jvm/Thu, 20 Aug 2020 13:48:32 +0800https://clibing.com/posts/linux/docker/java_docker_jvm/当前jvm配置
  • -XX:+PrintFlagsInitial 查看初始

  docker JAVA_OPTS

   1-XX:+AlwaysPreTouch 
   2    JAVA进程启动的时候,虽然我们可以为JVM指定合适的内存大小,但是这些内存操作系统并没有真正的分配给JVM,而是等JVM访问这些内存的时候,才真正分配,这样会造成以下问题。
   3    1、GC的时候,新生代的对象要晋升到老年代的时候,需要内存,这个时候操作系统才真正分配内存,这样就会加大young gc的停顿时间;
   4    2、可能存在内存碎片的问题。
   5
   6    jvm启用会慢，JDK8版本以前都不是并行处理的，到了JDK9才是并行
   7
   8    在没有配置-XX:+AlwaysPreTouch参数即默认情况下，JVM参数-Xms申明的堆只是在虚拟内存中分配，而不是在物理内存中分配：它被以一种内部数据结构的形式记录，从而避免被其他进程使用这些内存。这些内存页直到被访问时，才会在物理内存中分配。当JVM需要内存的时候，操作系统将根据需要分配内存页。
   9
  10    配置-XX:+AlwaysPreTouch参数后，JVM将-Xms指定的堆内存中每个字节都写入'0'，这样的话，除了在虚拟内存中以内部数据结构保留之外，还会在物理内存中分配。并且由于touch这个行为是单线程的，因此它将会让JVM进程启动变慢。所以，要么选择减少接下来对每个缓存页的第一次访问时间，要么选择减少JVM进程启动时间，这是一种trade-off。
  11
  12-XX:AutoBoxCacheMax=20000 
  13   jvm启动加载rt.jar包的时候，其中IntegerCache会加载int的~128-128为Integer到cahce，其他范围的使用时会进行new Integer操作。所以建议设置到大一点。 一般设置20000。 
  14-XX:InitialHeapSize=523969984 
  15-XX:MaxHeapSize=8383519744 
  16-XX:+PrintCommandLineFlags 打印当前使用的参数
  17-XX:+PrintFlagsFinal 打印当前使用参数最终的值
  18-XX:+PrintGC  打印GC
  19-XX:+PrintGCApplicationStoppedTime :打印垃圾回收期间程序暂停的时间.
  20-XX:+PrintGCDateStamps :默认是+PrintGCTimeStamps打印jvm启动的相对时间，这个时间不利于查看，所以调整为系统时间
  21-XX:+PrintGCDetails : 打印gc详细的信息
  22-XX:+PrintGCTimeStamps :jvm启动的相对时间
  23-XX:+UnlockExperimentalVMOptions : 可保证你的Java进程不会因为内存问题被容器Kill
  24-XX:+UseCGroupMemoryLimitForHeap :感知CGroup的内存限制，防止容器被kill
  25-XX:+UseCompressedOops 
  26-XX:+UseCompressedClassPointers : 开启需要UseCompressedOops的支持，
  27    如果不开启普通对象指针压缩，-UseCompressedOops，会在内存中消耗24个字节，o 指针占8个字节，Object对象占16个字节。
  28    如果开启普通对象指针压缩，+UseCompressedOops，会在内存中消耗20个字节，o指针占4个字节，Object对象占16个字节。
  29-XX:+UseParallelGC: 指定垃圾收集器为并行收集器
  

  压缩

  • -XX:+UseCompressedOops: 针对32位、64位系统占用空间不同，进行压缩，主要节省内存和缩短GC时间

    ]]>https://clibing.com/posts/java/spring/controller-annotation/Thu, 16 Apr 2020 17:31:56 +0800https://clibing.com/posts/java/spring/controller-annotation/定义自定义注解

    1@Retention(RetentionPolicy.RUNTIME)
    2@Target(ElementType.PARAMETER)
    3public @interface Logined {
    4}
    

    注解处理器

     1@Component
     2@Slf4j
     3public class LoginedArgumentResolver implements HandlerMethodArgumentResolver {
     4    @Override
     5    public boolean supportsParameter(MethodParameter parameter) {
     6        return CurrentRequest.class.isAssignableFrom(parameter.getParameterType());
     7    }
     8
     9    @Override
    10    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
    11        HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
    12        CurrentRequest currentRequest = (CurrentRequest) request.getAttribute(CurrentRequest.requestAttributeName());
    13        return currentRequest;
    14    }
    15}
    

    使用

    1    @RequestMapping(value = {"..."})
    2    public Object create(HttpServletRequest request,
    3                         @Logined CurrentRequest user) {
    4                             ......
    5    }
    

    ]]>https://clibing.com/posts/java/jdk/java_base/Thu, 16 Apr 2020 17:31:56 +0800https://clibing.com/posts/java/jdk/java_base/Java 基础技能

    包括以下大致内容

    • Object类的常用方法
    • 常用反射方法
    • 常用字段处理
    • 枚举处理
    • 泛型的获取
    • 基本类型的判断

    1. isAssignableFrom()与instanceof

    • isAssignableFrom()
      • 描述：判断目标类是否为父类的子类
      • 使用：父类.class.isAssignableFrom(子类.class)
    • instanceof
      • 描述：判断实例是否为父类的子类
      • 描述：(new)实例 instanceof 父类

    具体的demo如下

    ]]>https://clibing.com/posts/java/jdk/basic_types/Fri, 10 Apr 2020 15:46:22 +0800https://clibing.com/posts/java/jdk/basic_types/一、Java基础类型

    名字	默认值	占用空间	最大值	最小值
    byte	0	8位	127(2^7-1)	-128(-2^7)
    chat	‘u0000’	16 位 Unicode 字符	\uffff (65535)	\u0000 (0)
    boolean	false	1位	-	-
    short	0	16位	32767（2^15 - 1）	-32768（-2^15）
    int	0	32 位	2,147,483,647(2^31 - 1)	-2,147,483,648（-2^31）
    float	0.0f	32位	-	-
    long	0L	64 位	9,223,372,036,854,775,807(2^63 -1)	-9,223,372,036,854,775,808(-2^63)
    double	0.0d	64位	-	-
    String	null	-	-	-

    占用空间: 位/8=字节

    ]]>https://clibing.com/posts/java/jdk/clinit-and-init-diffent/Mon, 06 Apr 2020 14:38:56 +0800https://clibing.com/posts/java/jdk/clinit-and-init-diffent/调用时机

    clinit在jvm第一次加载class时调用，init在实例创建出来的时候调用

    • clinit在jvm第一次加载class文件时调用，包括静态变量初始化语句和静态块的执行
    • init在实例创建出来的时候调用，包括调用new操作符；调用Class或java.lang.reflect.Constructor对象的newInstance()方法；调用任何现有对象的clone()方法；通过java.io.ObjectInputStream类的getObject()方法反序列化。

    详情

    1. clinit方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块只能访问到定义在静态语句块之前的变量，点贵在他之后的变量，在前面的静态语句块中可以赋值但不能访问。

       1public class Test{
       2  static{
       3    i = 0;//给变量赋值可以正常通过
       4    System.out.println(i);//这句编译器会提示“非法向前引用”
       5  }
       6  static int i = 1;
       7}
       

    2. clinit方法与类的构造函数（或者说实例构造器中的()方法）不同， 它不需要显示的调用父类构造器，虚拟机会保证在子类的<init>()方法执行之前，父类的<clinit>()方法已经执行完毕。因为在虚拟机中第一个被执行的()方法的类肯定是java.lang.Object
    3. 由于父类的clinit方法先执行，也就意味着父类中定义的静态语句块要优先于子类类的变量赋值操作。
    4. clinit方法对于类或者接口来说并不是必须的，如果一个类没有静态语句块，也就没有变量的赋值操作，那么编译器可以不为这个类生成()方法。
    5. 接口中不能使用静态语句块，但仍然可以有变量初始化的赋值操作，因此接口与类一样都会生成()方法。但接口与类不同，执行接口的()方法不需要先执行父接口的()方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的()方法。
    6. 虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只有一个线程去执行这个类的()方法中有耗时很长的操作，就可能造成多个线程阻塞。

    举例

     1    class Single {
     2        private static Single single = new Single();
     3        public static int count1;
     4        public static int count2 = 0;
     5
     6        private Single() {
     7            count1++;
     8            count2++;
     9        }
    10        public static Single getInstance() {
    11            return single;
    12        }
    13    }
    14
    15    public class Test {
    16        public static void main(String[] args) {
    17            Single single = Single.getInstance();
    18            System.out.println("count1=" + single.count1);
    19            System.out.println("count2=" + single.count2);
    20        }
    21    }
    

    输出结果：

    ]]>https://clibing.com/posts/java/jdk/reference/Tue, 27 Feb 2018 14:38:56 +0800https://clibing.com/posts/java/jdk/reference/Java的内存优化之Reference，SoftReference、WeakReference、StrongReference

    引用对象类型定义

    首先，引用对象在Java定义中有三种类型，从弱到强依次为：软引用、弱引用与虚引用，三种级别也各有所不同(软引用>弱引用)。本文浅析下软引用与弱引用。大概的解释，软引用适合应用在需要cache的场景，一般面向实现内存敏感的缓存；弱引用则是适用在某些场景为了无法防止被回收的规范性映射，它优先级最低，一般与引用队列联合使用。

    ]]>https://clibing.com/posts/java/apache-httpclient/Thu, 08 Feb 2018 14:38:56 +0800https://clibing.com/posts/java/apache-httpclient/HttpClient 工具类

      1package cn.linuxcrypt.utils;
      2
      3import org.apache.http.*;
      4import org.apache.http.client.ClientProtocolException;
      5import org.apache.http.client.ResponseHandler;
      6import org.apache.http.client.config.CookieSpecs;
      7import org.apache.http.client.config.RequestConfig;
      8import org.apache.http.client.entity.UrlEncodedFormEntity;
      9import org.apache.http.client.methods.CloseableHttpResponse;
     10import org.apache.http.client.methods.HttpGet;
     11import org.apache.http.client.methods.HttpPost;
     12import org.apache.http.client.methods.HttpRequestBase;
     13import org.apache.http.client.protocol.HttpClientContext;
     14import org.apache.http.config.ConnectionConfig;
     15import org.apache.http.config.Registry;
     16import org.apache.http.config.RegistryBuilder;
     17import org.apache.http.conn.ConnectionKeepAliveStrategy;
     18import org.apache.http.conn.socket.ConnectionSocketFactory;
     19import org.apache.http.conn.socket.PlainConnectionSocketFactory;
     20import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
     21import org.apache.http.entity.ContentType;
     22import org.apache.http.impl.client.CloseableHttpClient;
     23import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
     24import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
     25import org.apache.http.message.BasicHeader;
     26import org.apache.http.message.BasicHeaderElementIterator;
     27import org.apache.http.message.BasicNameValuePair;
     28import org.apache.http.protocol.HTTP;
     29import org.apache.http.protocol.HttpContext;
     30import org.apache.http.ssl.SSLContextBuilder;
     31import org.apache.http.util.Args;
     32import org.apache.http.util.EntityUtils;
     33
     34import javax.net.ssl.SSLContext;
     35import javax.net.ssl.TrustManager;
     36import javax.net.ssl.X509TrustManager;
     37import java.io.IOException;
     38import java.nio.charset.Charset;
     39import java.nio.charset.CodingErrorAction;
     40import java.security.cert.X509Certificate;
     41import java.util.*;
     42
     43public final class HttpClients {
     44    // 设置整个连接池最大连接数
     45    private static int POOL_MAX_TOTAL = 2;
     46    /**
     47     * 设置整个连接池最大连接数
     48     *
     49     * @param maxTotal
     50     */
     51    public static void setPoolMaxTotal(int maxTotal) {
     52        synchronized (HttpClients.class) {
     53            POOL_MAX_TOTAL = maxTotal;
     54            HttpClientPool.setMaxTotal(maxTotal);
     55        }
     56    }
     57
     58    /**
     59     * http 连接池
     60     */
     61    static class HttpClientPool {
     62        private static PoolingHttpClientConnectionManager poolingHttpClientConnectionManager = null;
     63        // 设置每个路由上的默认连接个数，setMaxPerRoute则单独为某个站点设置最大连接个数。
     64        private static final int POOL_MAX_PER_ROUTER = 1;
     65        private static final String DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:60.0) Gecko/20100101 Firefox/60.0";
     66        // keepalive
     67        private static int DEFAULT_KEEP_ALIVE = 30 * 1000;
     68        /**
     69         * 从连接池中获取请求连接的超时时间 单位毫秒
     70         * -1: 系统默认的超时时间，内核级配置
     71         * 0: 无限制。
     72         * 具体参考{@link org.apache.http.client.config.RequestConfig#getConnectionRequestTimeout()}
     73         */
     74        public static final int DEFAULT_CONNECTION_REQUEST_TIMEOUT = -1;
     75
     76        // 默认连接超时时间
     77        public static final int DEFAULT_CONNECT_TIMEOUT = 10000;
     78
     79        // 默认socket读取数据超时时间,具体的长耗时请求中(如文件传送等)必须覆盖此设置
     80        public static final int DEFAULT_SO_TIMEOUT = 15000;
     81
     82        static {
     83            Registry<ConnectionSocketFactory> socketFactoryRegistry = null;
     84            try {
     85                final SSLContext sslContext = SSLContextBuilder.create().build();
     86                sslContext.init(null, new TrustManager[]{
     87                        new X509TrustManager() {
     88                            public X509Certificate[] getAcceptedIssuers() {
     89                                return null;
     90                            }
     91
     92                            public void checkClientTrusted(X509Certificate[] certs, String authType) {
     93                            }
     94
     95                            public void checkServerTrusted(X509Certificate[] certs, String authType) {
     96                            }
     97                        }
     98                }, null);
     99                socketFactoryRegistry = RegistryBuilder
    100                        .<ConnectionSocketFactory>create()
    101                        .register("http", PlainConnectionSocketFactory.INSTANCE)
    102                        .register("https", new SSLConnectionSocketFactory(sslContext)).build();
    103            } catch (Exception e) {
    104
    105            }
    106
    107            poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
    108
    109            //连接池的最大连接数
    110            poolingHttpClientConnectionManager.setMaxTotal(POOL_MAX_TOTAL);
    111
    112            /**
    113             * 设置每个路由上的默认连接个数，setMaxPerRoute则单独为某个站点设置最大连接个数。
    114             *
    115             * DefaultMaxPerRoute是根据连接到的主机对MaxTotal的一个细分；比如：
    116             * MaxtTotal=400 DefaultMaxPerRoute=200
    117             * 而我只连接到http://a.com时，到这个主机的并发最多只有200；而不是400；
    118             * 而我连接到http://a.com 和 http://b.com时，到每个主机的并发最多只有200；即加起来是400（但不能超过400；所以起作用的设置是DefaultMaxPerRoute。
    119             */
    120            poolingHttpClientConnectionManager.setDefaultMaxPerRoute(POOL_MAX_PER_ROUTER);
    121
    122            // 默认连接配置
    123            ConnectionConfig connectionConfig = ConnectionConfig.custom()
    124                    .setMalformedInputAction(CodingErrorAction.IGNORE)
    125                    .setUnmappableInputAction(CodingErrorAction.IGNORE)
    126                    .setCharset(Consts.UTF_8)
    127                    .build();
    128            poolingHttpClientConnectionManager.setDefaultConnectionConfig(connectionConfig);
    129        }
    130
    131        public static void setMaxTotal(int maxTotal) {
    132            poolingHttpClientConnectionManager.setMaxTotal(maxTotal);
    133        }
    134
    135        /**
    136         * 增加默认的http 头
    137         *
    138         * @return
    139         * @{link https://www.cnblogs.com/lwhkdash/archive/2012/10/14/2723252.html}
    140         */
    141        private static Set<Header> defaultHeaders() {
    142            Set<Header> header = new HashSet<>();
    143
    144            Header accept = new BasicHeader(HttpHeaders.ACCEPT,
    145                    "text/html,application/xhtml+xml,application/json,application/xml;q=0.9,*/*;q=0.8");
    146            header.add(accept);
    147            Header acceptEncoding = new BasicHeader(HttpHeaders.ACCEPT_ENCODING, "gzip, deflate");
    148            header.add(acceptEncoding);
    149            Header acceptLanguage = new BasicHeader(HttpHeaders.ACCEPT_LANGUAGE, "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3");
    150            header.add(acceptLanguage);
    151            Header connect = new BasicHeader(HttpHeaders.CONNECTION, "keep-alive");
    152            header.add(connect);
    153            Header acceptCharset = new BasicHeader(HttpHeaders.ACCEPT_CHARSET, Consts.UTF_8.name());
    154            header.add(acceptCharset);
    155
    156            // DO NOT TRACK的缩写，要求服务器程序不要跟踪记录用户信息。DNT: 1 (开启DNT) DNT: 0 (关闭DNT)火狐，safari,IE9都支持这个头域，并且于2011年3月7日被提交至IETF组织实现标准化
    157            Header dnt = new BasicHeader("DNT", "1");
    158            header.add(dnt);
    159
    160            return header;
    161        }
    162
    163        /**
    164         * 获取 HttpClient
    165         * @return
    166         */
    167        public static CloseableHttpClient getHttpClient() {
    168            return getHttpClient(DEFAULT_SO_TIMEOUT, DEFAULT_CONNECT_TIMEOUT, 0);
    169        }
    170
    171        /**
    172         * 默认keepAlive策略：如果响应中存在服务器端的keepAlive超时时间则返回该时间否则返回默认的
    173         */
    174        public static class DefaultConnectionKeepAliveStrategy implements ConnectionKeepAliveStrategy {
    175            public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
    176                HeaderElementIterator it = new BasicHeaderElementIterator(response.headerIterator(HTTP.CONN_KEEP_ALIVE));
    177                while (it.hasNext()) {
    178                    HeaderElement he = it.nextElement();
    179                    String param = he.getName();
    180                    String value = he.getValue();
    181                    if (value != null && param.equalsIgnoreCase("timeout")) {
    182                        try {
    183                            return Long.parseLong(value) * 1000;
    184                        } catch (NumberFormatException ignore) {
    185                        }
    186                    }
    187                }
    188                return DEFAULT_KEEP_ALIVE; //默认30秒
    189            }
    190        }
    191
    192        public static CloseableHttpClient getHttpClient(int socketTimeout, int connectTimeout, int retryCount) {
    193            RequestConfig globalConfig = RequestConfig.custom()
    194                    .setCookieSpec(CookieSpecs.IGNORE_COOKIES)
    195                    .setSocketTimeout(socketTimeout)
    196                    .setConnectionRequestTimeout(DEFAULT_CONNECTION_REQUEST_TIMEOUT)
    197                    .setConnectTimeout(connectTimeout)
    198                    .build();
    199
    200            CloseableHttpClient closeableHttpClient = org.apache.http.impl.client.HttpClients
    201                    .custom()
    202                    .setConnectionManager(poolingHttpClientConnectionManager)
    203                    .setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy())
    204                    // 另外设置http client的重试次数，默认是3次；当前是禁用掉（如果项目量不到，这个默认即可）
    205                    .setRetryHandler(new DefaultHttpRequestRetryHandler(retryCount, false))
    206                    .setUserAgent(DEFAULT_USER_AGENT)
    207                    .setDefaultHeaders(defaultHeaders())
    208                    .setDefaultRequestConfig(globalConfig)
    209                    .setConnectionManagerShared(true)
    210                    .evictExpiredConnections()// 开启超时清理线程
    211                    .build();
    212
    213            return closeableHttpClient;
    214        }
    215    }
    216
    217    /**
    218     * 对于特殊请求(比如请求涉及到cookie的处理,鉴权认证等),默认的一些配置已经满足不了了,
    219     * 这时就可以使用一个独立于全局的配置来执行请求,这个独立于全局,又不会干扰其他线程的请求执行的机制就是使用HttpClientContext,
    220     * 该设置类用于对已经提供的一个基于全局配置的副本,来设置一些配置(见HttpClientContext.setXxx)
    221     */
    222    public static interface HttpClientContextSetter {
    223        public void setHttpClientContext(HttpClientContext context);
    224    }
    225
    226    /**
    227     * <p>执行http请求</p>
    228     *
    229     * @param httpMethod              - HTTP请求(HttpGet、HttpPost等等)
    230     * @param httpClientContextSetter - 可选参数,请求前的一些参数设置(如：cookie、鉴权认证等)
    231     * @param responseHandler         - 必选参数,响应处理类(如针对httpstatu的各种值做一些策略处理等等)
    232     * @return 推荐使用 org.apache.http.impl.client.CloseableHttpClient#execute( org.apache.http.HttpHost,
    233     * org.apache.http.HttpRequest,
    234     * org.apache.http.client.ResponseHandler,
    235     * org.apache.http.protocol.HttpContext)
    236     */
    237    public static <T> T doHttpRequest(HttpRequestBase httpMethod, HttpClientContextSetter httpClientContextSetter, ResponseHandler<T> responseHandler) {
    238        Args.notNull(httpMethod, "Parameter 'httpMethod' can not be null!");
    239        Args.notNull(responseHandler, "Parameter 'responseHandler' can not be null!");
    240        CloseableHttpResponse response = null;
    241        try {
    242            if (httpClientContextSetter != null) {
    243                HttpClientContext context = HttpClientContext.create();
    244                httpClientContextSetter.setHttpClientContext(context);
    245                response = HttpClientPool.getHttpClient().execute(httpMethod, context);
    246            } else {
    247                response = HttpClientPool.getHttpClient().execute(httpMethod);
    248            }
    249            return response == null ? null : responseHandler.handleResponse(response);
    250        } catch (Exception e) {
    251            throw new RuntimeException(e.getMessage(), e);
    252        } finally {
    253            if (response != null) {
    254                try {
    255                    response.close();
    256                } catch (IOException e) {
    257                }
    258            }
    259        }
    260    }
    261
    262    /**
    263     * 默认的处理返回值为String的ResponseHandler
    264     */
    265    public static class DefaultStringResponseHandler implements ResponseHandler<String> {
    266        /**
    267         * 默认响应html字符集编码
    268         */
    269        private Charset defaultCharset = Consts.UTF_8;
    270
    271        public DefaultStringResponseHandler() {
    272            super();
    273        }
    274
    275        public DefaultStringResponseHandler(String defaultCharset) {
    276            super();
    277            this.defaultCharset = Charset.forName(defaultCharset);
    278        }
    279
    280        public Charset getDefaultCharset() {
    281            return defaultCharset;
    282        }
    283
    284        public void setDefaultCharset(Charset defaultCharset) {
    285            this.defaultCharset = defaultCharset;
    286        }
    287
    288        public String handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
    289            HttpEntity httpEntity = response.getEntity();
    290            if (httpEntity != null) {
    291                return EntityUtils.toString(httpEntity, defaultCharset == null ? ContentType.getOrDefault(httpEntity).getCharset() : defaultCharset);
    292            }
    293            return null;
    294        }
    295    }
    296
    297    /**
    298     * <p>根据URL和参数创建HttpPost对象</p>
    299     *
    300     * @param url
    301     * @param paramMap
    302     * @return
    303     */
    304    public static HttpPost createHttpPost(String url, Map<String, String> paramMap) {
    305        try {
    306            HttpPost httpPost = new HttpPost(url);
    307            if (paramMap != null && !paramMap.isEmpty()) {
    308                List<NameValuePair> params = new ArrayList<NameValuePair>();
    309                for (Map.Entry<String, String> entry : paramMap.entrySet()) {
    310                    params.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
    311                }
    312                UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(params, Consts.UTF_8.name());
    313                httpPost.setEntity(formEntity);
    314            }
    315            return httpPost;
    316        } catch (Exception e) {
    317            throw new RuntimeException(e.getMessage(), e);
    318        }
    319    }
    320
    321    public static String get(String url) {
    322        HttpGet httpGet = new HttpGet(url);
    323        String value = doHttpRequest(httpGet, null, new DefaultStringResponseHandler());
    324        return value;
    325    }
    326
    327    public static String post(String url, Map<String, String> param){
    328        HttpPost post = createHttpPost(url, param);
    329        return doHttpRequest(post, null, new DefaultStringResponseHandler());
    330    }
    331}
    

    总结

    1. DefaultMaxPerRoute和MaxTotal配置 DefaultMaxPerRoute是根据连接到的主机对MaxTotal的一个细分；比如： MaxtTotal=400 DefaultMaxPerRoute=200 而我只连接到http://a.com时，到这个主机的并发最多只有200；而不是400； 而我连接到http://a.com 和 http://b.com时，到每个主机的并发最多只有200；即加起来是400（但不能超过400；所以起作用的设置是DefaultMaxPerRoute。
    2. 超时设置
    • connectionRequestTimeout: 从连接池中获取请求连接的超时时间 单位毫秒, -1:系统默认的超时时间，内核级配置; 0:无限制
    • connectTimeout: 默认连接超时时间
    • soTimeout: 默认socket读取数据超时时间,具体的长耗时请求中(如文件传送等)必须覆盖此设置
    3. 策略
    • pool.evictExpiredConnections(true): 后台启动一个线程，进行超时连接处理
    • 当获取可用连接时，采用LRU进行处理连接。
    4. 池中池
    • httpclient在初始化时，设置的MaxTotal的参数为总的连接池
    • 在最大的池中，根据主机的名字(route)进行小池的划分
    • 在动态获取可用连接的时候采用LRU算法，清理或者释放连接
    5. available集合和leased集合
    • 见 org.apache.http.pool.AbstractConnPool
    • leased集合当前租用的连接
    • available集合当前可用的连接
    • LRU会根据MaxTotal、leased集合总数、available集合总数进行LRU淘汰。
    6. Future 进行一步接收数据
    7. 持久连接
    • HTTP/1.1采取持久连接的方式替代了Keep-Alive
    • HTTP/1.1的连接默认情况下都是持久连接。如果要显式关闭，需要在报文中加上Connection:Close首部。即在HTTP/1.1中，所有的连接都进行了复用
    • 两种方式，空闲的持久连接也可以随时被客户端与服务端关闭。不发送Connection:Close不意味着服务器承诺连接永远保持打开。
    8. EntityUtils.toString(HttpEntity, …)和EntityUtils.consume(HttpEntity);
    • 注意此方法会关闭InputStream，因为是多路复用，每次读取完必须关闭，否则不能被复用
    • CloseableHttpResponse在每次请求完进行reponse.close()
    9. HttpClient不能关闭，否则连接都会重新建立，会发起tcp的3次握手连接和4次握手断开

    测试

    抓包测试池化后网络连接3次握手建立连接和4次握手断开连接(抓包只看到3次)

    ]]>https://clibing.com/posts/java/jdk/array-deque/Tue, 06 Feb 2018 14:38:56 +0800https://clibing.com/posts/java/jdk/array-deque/概述

    

    Deque是Queue的子接口,我们知道Queue是一种队列形式,而Deque则是双向队列,它支持从两个端点方向检索和插入元素,因此Deque既可以支持LIFO形式也可以支持LIFO形式.Deque接口是一种比Stack和Vector更为丰富的抽象数据形式,因为它同时实现了以上两者 ArrayDeque实现了Deque的接口以及上图其他的接口，因此ArrayDeque支持序列化、克隆、迭代器操作、队列特性并且扩展了AbstractCollection抽象类

    ]]>https://clibing.com/posts/java/jdk/java8-functional-interface/Mon, 29 Jan 2018 14:38:56 +0800https://clibing.com/posts/java/jdk/java8-functional-interface/Java 8中的常用函数式接口

    函数式接口	函数描述符	原始类型特化
    Predicate	T->boolean	IntPredicate, LongPredicate, DoublePredicate
    Consumer	T->void	IntConsumer,LongConsumer, DoubleConsumer
    Function<T,R>	T->R	IntFunction, IntToDoubleFunction, IntToLongFunction, LongFunction, LongToDoubleFunction, LongToIntFunction, DoubleFunction, ToIntFunction, ToDoubleFunction, ToLongFunction
    Supplier	()->T	BooleanSupplier,IntSupplier, LongSupplier, DoubleSupplier
    UnaryOperator	T->T	IntUnaryOperator, LongUnaryOperator, DoubleUnaryOperator
    BinaryOperator	(T,T)->T	IntBinaryOperator, LongBinaryOperator, DoubleBinaryOperator
    BiPredicate<L,R>	(L,R)->boolean
    BiConsumer<T,U>	(T,U)->void	ObjIntConsumer, ObjLongConsumer, ObjDoubleConsumer
    BiFunction<T,U,R>	(T,U)->R	ToIntBiFunction<T,U>, ToLongBiFunction<T,U>, ToDoubleBiFunction<T,U>

    测试

    对于下列函数描述符(即Lambda表达式的签名),你会使用哪些函数式接口?在上表中 可以找到大部分答案。作为进一步练习,请构造一个可以利用这些函数式接口的有效Lambda

    ]]>https://clibing.com/posts/java/jdk/java-classloader/Mon, 22 Jan 2018 14:38:56 +0800https://clibing.com/posts/java/jdk/java-classloader/Java 类的加载机制

    

    大致流程: 读取.class文件二进制文件–>验证与解析(格式 关键字 关键词 语法 引用 类型转化等等) –> 初始化 –> 使用 –> 卸载

    ]]>https://clibing.com/posts/java/mybatis/distributed-transaction/Mon, 22 Jan 2018 14:38:56 +0800https://clibing.com/posts/java/mybatis/distributed-transaction/

    我们都知道普通的事务中有原子性，一致性，隔离性，持久性。而分布式事务中也有这些属性。

    分布式事务

    随着分布式计算的发展，事务在分布式中也得到了广泛的应用。 在单机数据库中，我们很容易能够实现满足ACID特性的事务处理系统，但在分布式数据库中，数据分散在各个不同的机器上，如何对这些数据进行分布式的事务处理具有非常大的挑战。 分布式中会有机器宕机和各种网络异常。尽管存在这种种分布式问题，但是在分布式计算领域，为了保证分布式应用程序的可靠性，分布式事务是无法回避的。

    ]]>https://clibing.com/posts/java/jdk/java-cas/Mon, 06 Feb 2017 14:38:56 +0800https://clibing.com/posts/java/jdk/java-cas/<blockquote> <p>CAS(Compare and Swap) 是利用底层硬件平台特性，实现原子性操作的算法，Java 1.5 以后 JUC(java.util.concurrent) 实现主要以此为基础；找了不少资料以下记录一下个人对于 CAS 的理解(部分资料 copy 的)</p>https://clibing.com/posts/java/java-btrace-greys-jvmsanbox/Mon, 06 Feb 2017 14:38:56 +0800https://clibing.com/posts/java/java-btrace-greys-jvmsanbox/Java 动态跟踪工具介绍
    • BTrace
    • Greys-anatomy
    • Greys介绍
    • jvm-sandbox
    ]]>https://clibing.com/posts/java/jdk/direct_buffer/Mon, 06 Feb 2017 14:38:56 +0800https://clibing.com/posts/java/jdk/direct_buffer/一、概念和特征
    • 直接内存并非 JVMS 定义的标准 Java 运行时内存。
    • JDK1.4 加入了新的 NIO 机制，目的是防止 Java 堆 和 Native 堆之间往复的数据复制带来的性能损耗，此后 NIO 可以使用 Native 的方式直接在 Native 堆分配内存。
    • 直接内存区域是全局共享的内存区域。
    • 直接内存区域可以进行自动内存管理(GC)，但机制并不完善。
    • 本机的 Native 堆(直接内存) 不受 JVM 堆内存大小限制。
    • 可能出现 OutOfMemoryError 异常。

    二、异常演示

    测试代码：

    ]]>