天雷henry_个人页

git commit --amend -m '最新注释'

建议先学spring，spring boot 是对spring的进一步封装，基于spring的原理做出的一系列简化配置的优化

创建方式存在两种：allocate方式wrap方式核心状态变量：a) position position变量跟踪了向缓冲区中写入了多少数据或者从缓冲区中读取了多少数据。 更确切的说，当您从通道中读取数据到缓冲区中时，它指示了下一个数据将放到数组的哪一个元素中。比如，如果您从通道中读三个字节到缓冲区中，那么缓冲区的position将会设置为3，指向数组中第4个元素。反之，当您从缓冲区中获取数据进行写通道时，它指示了下一个数据来自数组的哪一个元素。比如，当您从缓冲区写了5个字节到通道中，那么缓冲区的 position 将被设置为5，指向数组的第六个元素。b) limit limit变量表明还有多少数据需要取出(在从缓冲区写入通道时)，或者还有多少空间可以放入数据(在从通道读入缓冲区时)。 position总是小于或者等于limit。c) capacity capacity变量表明可以储存在缓冲区中的最大数据容量。实际上，它指定了底层数组的大小—或者至少是指定了准许我们使用的底层数组的容量。 limit总是小于或者等于capacity。

对需要查询和排序的字段要加索引。在一定环境下，left join还是比普通连接查询效率要高，但是要尽量少地连接表，并且在做连接查询时注意观察索引是否起了作用。排序尽量对第一个表的索引字段进行，可以避免mysql创建临时表，这是非常耗资源的。

netty啊，非阻塞网络通信框架，java并发编程啊

传统的程序开发中，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁（比如Connection等），对象始终会和其他的接口或类藕合起来。在spring的世界，所有的类都会在spring容器中登记，告诉spring你是个什 么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。AOP用途十分广泛，其中Spring内部的声明式事务和拦截器都是利用了AOP的强大威力，才得以优雅的实现。AOP是什么呢，简单来说，它可以让编程人员在不修改对象代码的情况下，为这个对象添加额外的功能或者限制。

1）ServletConfig：在容器初始化Servlet的时候，并为其提供上下文初始化参数的名/值对的引用。2）ServletContext：容器启动的时候，并为其提供Servlet初始化参数的名/值对的引用。

从实现难度上来说，Zookeeper实现非常简单，实现分布式锁的基本逻辑：客户端调用create()方法创建名为“locknode/guid-lock-”的节点，需要注意的是，这里节点的创建类型需要设置为EPHEMERAL_SEQUENTIAL。客户端调用getChildren(“locknode”)方法来获取所有已经创建的子节点。客户端获取到所有子节点path之后，如果发现自己在步骤1中创建的节点是所有节点中序号最小的，那么就认为这个客户端获得了锁。如果创建的节点不是所有节点中需要最小的，那么则监视比自己创建节点的序列号小的最大的节点，进入等待。直到下次监视的子节点变更的时候，再进行子节点的获取，判断是否获取锁。Redis实现比较复杂，流程如下：根据lockKey区进行setnx（set not exist，顾名思义，如果key值为空，则正常设置，返回1，否则不会进行设置并返回0）操作，如果设置成功，表示已经获得锁，否则并没有获取锁。如果没有获得锁，去Redis上拿到该key对应的值，在该key上我们存储一个时间戳（用毫秒表示，t1），为了避免死锁以及其他客户端占用该锁超过一定时间（5秒），使用该客户端当前时间戳，与存储的时间戳作比较。如果没有超过该key的使用时限，返回false，表示其他人正在占用该key，不能强制使用；如果已经超过时限，那我们就可以进行解锁，使用我们的时间戳来代替该字段的值。但是如果在setnx失败后，get该值却无法拿到该字段时，说明操作之前该锁已经被释放，这个时候，最好的办法就是重新执行一遍setnx方法来获取其值以获得该锁。

限流、降级、缓存，代码优化

我们首先来观察一下Method.invoke()方法。相关源代码在java.lang.reflect包下的Method类中。public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException { // 权限检查，忽略 ... if (!override) { if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) { Class caller = Reflection.getCallerClass(); checkAccess(caller, clazz, obj, modifiers); } } // 看这里 ... MethodAccessor ma = methodAccessor; // read volatile if (ma == null) { ma = acquireMethodAccessor(); } return ma.invoke(obj, args); } 可以看到，这里讲方法的调用，委派给了MethodAccessor类型的ma对象来处理。它是一个接口，有两个实现类。一个委派实现(DelegatingMethodAccessorImpl)，一个本地实现(NativeMethodAccessorImpl)。每一个Method实例的第一次调用，都会使用委派实现！，但是委派实现最终委派的实现确实本地实现。下面通过里一个例子观察一下： public class HowReflect { public static void targetMethod(int i) { // 打印调用栈 new Exception('version ' + i) .printStackTrace(); } public static void main(String[] args) throws Exception { Class howReflect = Class.forName('com.ynwa.jvm.HowReflect'); Method method = howReflect.getMethod('targetMethod', int.class); // 执行方法 method.invoke(null, 0); } } 上面的代码运行结果为：java.lang.Exception: 版本 0 at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:13) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) // 4 委派实现又委派给了本地实现 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) // 3 生成委派实现 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) // 2 反射调用方法 at java.lang.reflect.Method.invoke(Method.java:498) // 1 执行main方法 at com.ynwa.jvm.HowReflect.main(HowReflect.java:21) 上面在结果打印的调用栈中，注释的第3步个第4步，可以看到先用的委派实现，委派实现又委派了本地实现！那么问题来了！既然最终要用本地实现，那么为什么中间要加一层委派实现？，那么继续向下看。其实这是因为除了以上两种以外，还有一种动态实现，而所谓的委派实现，只不过是为了能够在本地实现和动态实现之间做切换。动态实现是一种字节码技术。但是如果只调用一次的话，本地实现要比动态实现块一点儿，这是因为动态实现操作字节码要慢一些。JVM会认为你每次只会很少的进行方法调用(或者说只调用一次)，所以它设定了一个阀值：16，如果调用15此以上，也就是说第17次开始，使用动态实现。使用本地实现的时候，因为要经过Java -> c++ -> Java的过程。第17次开始，JVM会利用已经生成的字节码来进行方法调用，所以这无疑就会增速很多！

按值传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的一个副本。因此，如果函数修改了该参数，仅改变副本，而原始值保持不变。按引用传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的内存地址，而不是值的副本。因此，如果函数修改了该参数，调用代码中的原始值也随之改变。1、对象是按引用传递的2、Java 应用程序有且仅有的一种参数传递机制，即按值传递3、按值传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的一个副本4、按引用传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的内存地址，而不是值的副本

最主要的是Java平台本身。Java平台扮演Java程序和所在的硬件与操作系统之间的缓冲角色。这样Java程序只需要与Java平台打交道，而不用管具体的操作系统。Java语言保证了基本数据类型的值域和行为都是由语言自己定义的。而C/C++中，基本数据类是由它的占位宽度决定的，占位宽度由所在平台决定的。不同平台编译同一个C++程序会出现不同的行为。通过保证基本数据类型在所有平台的一致性，Java语言为平台无关性提供强有力的支持。Java class文件。Java程序最终会被编译成二进制class文件。class文件可以在任何平台创建，也可以被任何平台的Java虚拟机装载运行。它的格式有着严格的定义，是平台无关的。可伸缩性。Sun通过改变API的方式得到三个基础API集合，表现为Java平台不同的伸缩性：J2EE,J2SE,J2ME。

mybatis

1-- ApplicationContext context = new FileSystemXmlApplicationContext('web/WEB-INF/classes/spring_*.xml');2--ApplicationContext context=new ClassPathXmlApplicationContext('pring_*.xml');3--WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext();  部分类里Spring无法注入bean时可以用这种

分布式系统间的协作产生了一些样板性质的模式，开发者使用 Spring Cloud 就可以快速地构建基于这些模式的服务和应用。boiler plate patterns 参考了 boilerplate code，就是一些代码量很少，可以拿过来放到系统中直接使用的样板代码。我认为 boiler plate patterns 可以白话地理解为套路模式。分布式系统间的协作都是有套路的，开发者使用 Spring Cloud 就可以快速地构建包括这些套路的服务和应用。

Session可以使用Spring boot的Redis集成，所有微服务间共享Session

（1）高并发、任务执行时间短的业务，线程池线程数可以设置为CPU核数+1，减少线程上下文的切换 （2）并发不高、任务执行时间长的业务要区分开看： 　　a）假如是业务时间长集中在IO操作上，也就是IO密集型的任务，因为IO操作并不占用CPU，所以不要让所有的CPU闲下来，可以适当加大线程池中的线程数目，让CPU处理更多的业务 　　b）假如是业务时间长集中在计算操作上，也就是计算密集型任务，这个就没办法了，和（1）一样吧，线程池中的线程数设置得少一些，减少线程上下文的切换 （3）并发高、业务执行时间长，解决这种类型任务的关键不在于线程池而在于整体架构的设计，看看这些业务里面某些数据是否能做缓存是第一步，增加服务器是第二步，至于线程池的设置，设置参考（2）。最后，业务执行时间长的问题，也可能需要分析一下，看看能不能使用中间件对任务进行拆分和解耦。

SELECT * FROM table limit #{offset}, #{pageSize}

netty啊，非阻塞网络通信框架，java并发编程啊

当我们用一个类型的构造器构造出一个对象时，这个对象的类型就已经确定的，也就说它的本质是不会再发生变化了。示例代码其实是使用Creator类型的引用，指向的是Dog对象。在Java中我们可以通过继承、向上转型的关系使用父类类型来引用它，这个时候我们是使用功能较弱的类型引用功能较强的对象，这是可行的。