301 Moved Permanently

一、Java内存分配     Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域。这些区域存储不同类型的数据，这些区域的内存分配和销毁的时间也不同，有的区域随着虚拟机进程的启动而存在，有些区域则是依赖用户线程的启动和结束而建立和销毁。根据《Java虚拟机规范（第2版）》的规定，Java虚拟机管理的内存包括五个运行时数据区域，如下图所示：      1、方法区     方法区（Method Area）是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息（包括类的名称、方法信息、成员变量信息）、常量、静态变量、以及编译器编译后的代码等数据。当方法区无法满足内存分配需求时，将抛出OutOfMemeryError异常。     运行时常量池（Runtime Constant Pool）是方法区的一部分,此区域会在两种情况下存储数据。     （1）class文件的常量池中的数据     class文件中的常量池用于存放编译期生成的各种字面值和常量，这部分内容在类被加载后存放到方法区的运行时常量池中。     字面值：private String name="zhangSan"；private int age = 23+3；     常量：private final String TAG = "MainActivity"；private final int age = 26;     （2）运行期间生成的常量     运行时常量池相对于class文件常量池的另外一个重要特征是具备动态性，Java语言并不要求常量一定只能在编译期产生，也就是并非预置入class文件中常量池的内容才能进入方法区运行时常量池，运行期间也可能将新的常量放入池中，这种特性被开发人员利用得比较多的便是String类的intern()方法。String str = "abc".intern();当运行时常量池中存在字符串"abc时，将该字符串的引用返回，赋值给str，否则创建字符串"abc"，加入运行时常量池中，并返回引用赋值给str。既然运行时常量池是方法区的一部分，自然会受到方法区内存的限制，当常量池无法再申请到内存时会抛出OutOfMemoryError异常。 2、虚拟机栈     虚拟机栈是线程私有的内存空间，每个线程都有一个线程栈，每个方法被执行时都会创建一个栈帧，方法执行完成，栈帧弹出，线程运行结束，线程栈被回收。虚拟机栈就是Java中的方法执行的内存模型，每个方法在执行的同时都会创建一个栈帧，这个栈帧用于存储局部变量表、操作数栈、指向当前方法所属的类的运行时常量池的引用、方法返回地址等信息，每个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。局部变量表用来存储方法中的局部变量，包括方法中声明的变量以及函数形参。对于基本数据类型的变量，则直接存储它的值，对于引用类型的变量，则存的是指向对象的引用。局部变量表的大小在编译器就可以确定其大小，并且在程序执行期间局部变量表的大小是不会改变的。程序中的所有计算过程都是在借助于操作数栈来完成的。指向运行时常量池的引用，因为在方法执行的过程中有可能需要用到类中的常量，所以必须要有一个引用指向当前方法所属的类的运行时常量池。方法返回地址，当一个方法执行完毕之后，要返回之前调用它的地方，因此在栈帧中必须保存一个方法返回地址。     在Java虚拟机规范中，对这个区域规定了两种异常状况：如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常；如果虚拟机栈可以动态扩展（当前大部分的Java虚拟机都可动态扩展，只不过Java虚拟机规范中也允许固定长度的虚拟机栈），当扩展时无法申请到足够的内存时会抛出OutOfMemoryError异常。 3、本地方法栈     本地方法栈也是线程私有的内存空间，本地方法栈与Java栈所发挥的作用是非常相似的，它们之间的区别不过是Java栈执行Java方法，本地方法栈执行的是本地方法，有的虚拟机直接把本地方法栈和虚拟机栈合二为一。 4、堆     Java堆是Java虚拟机所管理的内存中最大的一块，在虚拟机启动时创建，此内存区域的目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。从内存分配的角度来看，线程共享的Java堆中可能划分出多个线程私有的分配缓冲区(TLAB)。Java堆可以处于物理上不连续的内存空间，只要逻辑上连续即可，在实现上，既可以实现固定大小的，也可以是扩展的。如果堆中没有足够的内存分配给实例，并且堆也无法再拓展时，将会抛出OutOfMemeryError异常。     堆是运行时动态分配内存，对象在没有引用变量指向它的时候，才变成垃圾，但是仍然占着内存，在程序空闲的时候（没有工作线程运行，GC线程优先级最低）或者堆内存不足的时候（GC线程被触发），被垃圾回收器释放掉，由于要在运行时动态分配内存，存取速度较慢。 5、程序计数器     程序计数器的作用可以看做是当前线程所执行的字节码的行号指示。字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。由于Java虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的，在任何一个确定的时刻，一个处理器（对于多核处理器来说是一个内核）只会执行一条线程中的指令。因此，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各条线程之间的计数器互不影响，独立存储，我们称这类内存区域为线程私有的内存。如果线程正在执行的是一个Java方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址；如果正在执行的是Natvie方法，这个计数器值则为空。 二、Java内存回收     对于虚拟机栈空间，当方法调用结束后，基本类型变量、引用类型变量、形参占据的空间会被自动释放，但引用类型指向的对象在堆中，堆中的无用内存由垃圾回收线程回收，GC线程优先级最低，只有当没有工作线程存在时GC线程才会执行，或者堆空间不足时会自动触发GC线程工作。除了回收内存，GC线程还负责整理堆中的碎片。 1、四种引用类型     Java中的对象引用分为四种，强引用类型、软引用类型、弱引用类型、虚引用类型。Java中提供这四种引用类型主要有两个目的：第一是可以让程序员通过代码的方式决定某些对象的生命周期；第二是有利于JVM进行垃圾回收。使用软引用和弱引用可以有效的避免oom。软引用关联的对象，只有软引用关联时，才可回收，如果有强引用同时关联，不会回收对象占用的内存，弱引用也如此。 （1）强引用     强引用是使用最普遍的引用，类似Object obj = new Object()、String str = "hello"。如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。 （2）软引用（SoftReference）     软引用是用来描述一些有用但并不是必需的对象，在Java中用java.lang.ref.SoftReference类来表示，如果内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用通常用于网页缓存、图片缓存，防止内存溢出，在内存充足的时候，缓存对象会一直存在，在内存不足的时候，缓存对象占用的内存会被垃圾收集器回收。使用示例： public void testSoftReference() { Map<String,SoftReference<Bitmap>> imagesCache = new HashMap<String,SoftReference<Bitmap>>(); Bitmap bitmap = getBitmap(); SoftReference<Bitmap> image1 = new SoftReference<Bitmap>(bitmap); imagesCache.put("image1",image1); SoftReference<Bitmap> result_SoftReference = imagesCache.get("image1"); Bitmap result_Bitmap = result_SoftReference .get(); } import java.lang.ref.SoftReference; public class Main { public static void main(String[] args) { SoftReference<String> sr = new SoftReference<String>(new String("hello")); System.out.println(sr.get()); } } （3）弱引用（WeakReference）     弱引用也是用来描述非必需对象的，但是它的强度比软引用更弱一些，在java中用java.lang.ref.WeakReference类来表示。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象，不过由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用可以用于：单例类持有一个activity引用时，会造成内存泄露，把activity声明为弱引用，在activity销毁后，垃圾收集器扫描到activity对象时，会回收activity对象的内存。使用示例： public class SingleTon1 { private static final SingleTon1 mInstance = null; private WeakReference<Context> mContext; private SingleTon1(WeakReference<Context> context) { mContext = context; } public static SingleTon1 getInstance(WeakReference<Context> context) { if (mInstance == null) { synchronized (SingleTon1.class) { if (mInstance == null) { mInstance = new SingleTon1(context); } } } return mInstance; } } public class MyActivity extents Activity { public void onCreate (Bundle savedInstanceState){ super.onCreate(savedInstanceState); setContentView(R.layout.main); SingleTon1 singleTon1 = SingleTon1.getInstance(new WeakReference<Context>(this)); } }import java.lang.ref.WeakReference; public class Main { public static void main(String[] args) { WeakReference<String> sr = new WeakReference<String>(new String("hello")); System.out.println(sr.get()); System.gc(); //通知JVM的gc进行垃圾回收 System.out.println(sr.get()); } } 输出结果： hellonull     第二个输出结果是null，这说明只要JVM进行垃圾回收，被弱引用关联的对象必定会被回收掉。不过要注意的是，这里所说的被弱引用关联的对象是指只有弱引用与之关联，如果存在强引用同时与之关联，则进行垃圾回收时也不会回收该对象（软引用也是如此）。 （4）虚引用     虚引用和软引用、弱引用不同，它并不影响对象的生命周期，也无法通过虚引用来取得一个对象实例，在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。虚引用必须和引用队列（ReferenceQueue）联合使用，如下： import java.lang.ref.PhantomReference;import java.lang.ref.ReferenceQueue; public class Main { public static void main(String[] args) { ReferenceQueue<String> queue = new ReferenceQueue<String>(); PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue); System.out.println(pr.get()); } } 2、垃圾回收算法 （1）标记-清除（Mark-Sweep）    标记-清除（Mark-Sweep）算法，分为标记和清除两个阶段：首先标记出所有需要回收的对象，在标记完成后统一回收掉所有被标记的对象。 标记-清除算法主要问题是：1、效率问题，标记和清除过程的效率很低2、空间问题，标记清除之后会产生大量不连续的内存碎片，空间碎片太多可能会导致，当程序在以后的运行过程中需要分配较大对象时无法找到足够的连续内存而不得不提前触发另一次垃圾收集 （2）复制（Copying）算法     复制算法，它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用过的内存空间一次清理掉。这样使得每次都是对其中的一块进行内存回收，内存分配时也就不用考虑内存碎片等复杂情况，只要移动堆顶指针，按顺序分配内存即可，实现简单，运行高效。 复制算法的主要问题是：1、复制算法将内存缩小为原来的一半，过于浪费2、对象存活率较高时就要执行较多的复制操作，造成频繁GC,效率将会变低 （3）标记-整理（Mark-Compact）     标记-整理算法的标记过程仍然与标记-清除算法一样，但后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存，这样连续的内存空间就比较多了。     如上图所示，所有存活的对象依次向左上角移动，（0,4）移动到（0,2），（1,0）移动到（0,3），依次类推，当所有的存活对象移动完成后，把剩余的所有空间清空，也就是清空（1,1）后的所有空间。 （4）分代回收（generational collection） 程序创建的大部分对象的生命周期都很短，只有一小部分对象的生命周期比较长，根据这样的规律，一般把Java堆分为Young Generation（新生代），Old Generation（老年代）和Permanent Generation（持久代），上面几种算法是通过分代回收混合在一起的，这样就可以根据各个年代的特点采用最适当的回收算法。 （1）新生代     在新生代中，有一个叫Eden Space的空间，主要是用来存放新生的对象，还有两个Survivor Spaces（from、to）， 这两个区域大小相等，相当于copying算法中的两个区域，它们用来存放每次垃圾回收后存活下来的对象。在新生代中，垃圾回收一般用Copying的算法，速度快。     当新建对象无法放入eden区时，将触发minor collection（minorGC 是清理新生代的GC线程，eden的清理，from、to的清理都由MinorGC完成），将eden区与from区的存活对象复制到to区，经过一次垃圾回收，eden区和from区清空，to区中则紧密的存放着存活对象；当eden区再次满时，minor collection将eden区和to区的存活对象复制到from区，eden区和to区被清空，from区存放eden区和to区的存活对象，就这样from区和to区来回切换。如果进行minor collection的时候，发现to区放不下，则将eden区和from区的部分对象放入成熟代。另一方面，即使to区没有满，JVM依然会移动世代足够久远的对象到成熟代。 （2）成熟代     在成熟代中主要存放应用程序中生命周期长的内存对象，垃圾回收一般用mark-compact的算法，速度慢些，但减少内存要求。如果成熟代放满对象，无法从新生代移入新的对象，那么将触发major collection（major GC清理整合OldGen的内存空间）。 （3）永久代    在永久代中，主要用来放JVM自己的反射对象，比如类对象、方法对象、成员变量对象、构造方法对象等。     此外，垃圾回收一般是在程序空闲的时候（没有工作线程，GC线程优先级较低）或者堆内存不足的时候自动触发，也可以调用System.gc()主动的通知Java虚拟机进行垃圾回收，但这只是个建议，Java虚拟机不一定马上执行，启动时机的选择由JVM决定，并且取决于堆内存中Eden区是否可用 作者：喜六六 来源：CSDN 原文：https://blog.csdn.net/qq_29078329/article/details/78929457 版权声明：本文为博主原创文章，转载请附上博文链接！

1.阻塞与同步2.BIO与NIO对比3.NIO简介4.缓冲区Buffer5.通道Channel6.反应堆7.选择器8.NIO源码分析9.AIO1.阻塞与同步1）阻塞(Block)和非租塞(NonBlock):阻塞和非阻塞是进程在访问数据的时候，数据是否准备就绪的一种处理方式，当数据没有准备的时候阻塞：往往需要等待缞冲区中的数据准备好过后才处理其他的事情，否則一直等待在那里。非阻塞：当我们的进程访问我们的数据缓冲区的时候，如果数据没有准备好则直接返回，不会等待。如果数据已经准备好，也直接返回2）同步(Synchronization)和异步(Async)的方式：同步和异步都是基于应用程序私操作系统处理IO事件所采用的方式，比如同步：是应用程序要直接参与IO读写的操作。异步：所有的IO读写交给搡作系统去处理，应用程序只需要等待通知。同步方式在处理IO事件的时候，必须阻塞在某个方法上靣等待我们的IO事件完成(阻塞IO事件或者通过轮询IO事件的方式）.对于异步来说，所有的IO读写都交给了搡作系统。这个时候，我们可以去做其他的事情，并不拓要去完成真正的IO搡作，当搡作完成IO后.会给我们的应用程序一个通知同步：阻塞到IO事件，阻塞到read成则write。这个时候我们就完全不能做自己的事情，让读写方法加入到线程里面，然后阻塞线程来实现，对线程的性能开销比较大，参考：https://blog.csdn.net/CharJay_Lin/article/details/812598802.BIO与NIO对比block IO与Non-block IO1）区别IO模型 IO NIO方式 从硬盘到内存 从内存到硬盘通信 面向流（乡村公路） 面向缓存（高速公路，多路复用技术）处理 阻塞IO（多线程） 非阻塞IO（反应堆Reactor）触发 无 选择器（轮询机制）2）面向流与面向缓冲Java NIO和IO之间第一个最大的区别是，IO是面向流的.NIO是面向缓冲区的。Java IO面向流意味着毎次从流中读一个成多个字节，直至读取所有字节，它们没有被缓存在任何地方，此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的教据，需要先将它缓存到一个缓冲区。Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，霱要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数裾。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。3）阻塞与非阻塞Java IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。 Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。4）选择器（Selector)Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择"通道：这些通里已经有可以处理的褕入，或者选择已准备写入的通道。这选怿机制，使得一个单独的线程很容易来管理多个通道。5）NIO和BIO读取文件BIO读取文件：链接BIO从一个阻塞的流中一行一行的读取数据image | left | 469x426NIO读取文件：链接通道是数据的载体，buffer是存储数据的地方，线程每次从buffer检查数据通知给通道image | left | 559x3946）处理数据的线程数NIO：一个线程管理多个连接BIO：一个线程管理一个连接3.NIO简介在Java1.4之前的I/O系统中，提供的都是面向流的I/O系统，系统一次一个字节地处理数据，一个输入流产生一个字节的数据，一个输出流消费一个字节的数据，面向流的I/O速度非常慢，而在Java 1.4中推出了NIO，这是一个面向块的I/O系统，系统以块的方式处理处理，每一个操作在一步中产生或者消费一个数据库，按块处理要比按字节处理数据快的多。在NIO中有几个核心对象需要掌握：缓冲区（Buffer）、通道（Channel）、选择器（Selector）。参考：链接image2.png | center | 851x3834.缓冲区Buffer缓冲区实际上是一个容器对象，更直接的说，其实就是一个数组，在NIO库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的； 在写入数据时，它也是写入到缓冲区中的；任何时候访问 NIO 中的数据，都是将它放到缓冲区中。而在面向流I/O系统中，所有数据都是直接写入或者直接将数据读取到Stream对象中。在NIO中，所有的缓冲区类型都继承于抽象类Buffer，最常用的就是ByteBuffer，对于Java中的基本类型，基本都有一个具体Buffer类型与之相对应，它们之间的继承关系如下图所示：image3.png | center | 650x3681）其中的四个属性的含义分别如下：容量（Capacity）：缓冲区能够容纳的数据元素的最大数量。这一个容量在缓冲区创建时被设定，并且永远不能改变。上界(Limit)：缓冲区的第一个不能被读或写的元素。或者说,缓冲区中现存元素的计数。位置(Position)：下一个要被读或写的元素的索引。位置会自动由相应的 get( )和 put( )函数更新。标记(Mark)：下一个要被读或写的元素的索引。位置会自动由相应的 get( )和 put( )函数更新。2）Buffer的常见方法如下所示:flip(): 写模式转换成读模式rewind()：将 position 重置为 0 ，一般用于重复读。clear() ：compact(): 将未读取的数据拷贝到 buffer 的头部位。mark(): reset():mark 可以标记一个位置， reset 可以重置到该位置。Buffer 常见类型： ByteBuffer 、 MappedByteBuffer 、 CharBuffer 、 DoubleBuffer 、 FloatBuffer 、 IntBuffer 、 LongBuffer 、 ShortBuffer 。3）基本操作Buffer基础操作： 链接缓冲区分片，缓冲区分配，直接缓存区，缓存区映射，缓存区只读：链接4）缓冲区存取数据流程存数据时position会++，当停止数据读取的时候调用flip()，此时limit=position，position=0读取数据时position++，一直读取到limitclear() 清空 buffer ，准备再次被写入 (position 变成 0 ， limit 变成 capacity) 。5.通道Channel通道是一个对象，通过它可以读取和写入数据，当然了所有数据都通过Buffer对象来处理。我们永远不会将字节直接写入通道中，相反是将数据写入包含一个或者多个字节的缓冲区。同样不会直接从通道中读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。image4.png | center | 368x191在NIO中，提供了多种通道对象，而所有的通道对象都实现了Channel接口。它们之间的继承关系如下图所示：image5.png | center | 650x5171）使用NIO读取数据在前面我们说过，任何时候读取数据，都不是直接从通道读取，而是从通道读取到缓冲区。所以使用NIO读取数据可以分为下面三个步骤：从FileInputStream获取Channel 创建Buffer 将数据从Channel读取到Buffer中 例子：链接 2）使用NIO写入数据使用NIO写入数据与读取数据的过程类似，同样数据不是直接写入通道，而是写入缓冲区，可以分为下面三个步骤：从FileInputStream获取Channel 创建Buffer 将数据从Channel写入到Buffer中 例子：链接 6.反应堆1）阻塞IO模型在老的IO包中，serverSocket和socket都是阻塞式的，因此一旦有大规模的并发行为，而每一个访问都会开启一个新线程。这时会有大规模的线程上下文切换操作（因为都在等待，所以资源全都被已有的线程吃掉了），这时无论是等待的线程还是正在处理的线程，响应率都会下降，并且会影响新的线程。image6.png | center | 739x3362）NIOJava NIO是在jdk1.4开始使用的，它既可以说成“新IO”，也可以说成非阻塞式I/O。下面是java NIO的工作原理：1.由一个专门的线程来处理所有的IO事件，并负责分发。2.事件驱动机制：事件到的时候触发，而不是同步的去监视事件。3.线程通讯：线程之间通过wait,notify等方式通讯。保证每次上下文切换都是有意义的。减少无谓的线程切换。image7.png | center | 689x251注：每个线程的处理流程大概都是读取数据，解码，计算处理，编码，发送响应。7.选择器传统的 server / client 模式会基于 TPR ( Thread per Request ) ．服务器会为每个客户端请求建立一个线程．由该线程单独负贵处理一个客户请求。这种模式带未的一个问题就是线程数是的剧增．大量的线程会增大服务器的开销，大多数的实现为了避免这个问题，都采用了线程池模型，并设置线程池线程的最大数量，这又带来了新的问题，如果线程池中有 200 个线程，而有 200 个用户都在进行大文件下载，会导致第 201 个用户的请求无法及时处理，即便第 201 个用户只想请求一个几 KB 大小的页面。传统的 Sorvor / Client 模式如下围所示：image8.png | center | 597x286NIO 中非阻塞IO采用了基于Reactor模式的工作方式，IO调用不会被阻塞，相反是注册感兴趣的特点IO事件，如可读数据到达，新的套接字等等，在发生持定率件时，系统再通知我们。 NlO中实现非阻塞IO的核心设计Selector，Selector就是注册各种IO事件的地方，而且当那些事件发生时，就是这个对象告诉我们所发生的事件。image9.png | center | 462x408当有读或者写等任何注册的事件发生时，可以从Selector中获得相应的SelectionKey，同时从SelectionKey中可以找到发生的事件和该事件所发生的具体的SelectableChannel，以获得客户端发送过来的数据。使用NIO中非阻塞IO编写服务器处理程序，有三个步骤1.向Selector对象注册感兴趣的事件2.从Selector中获取感兴趣的事件3.根据不同事件进行相应的处理8.NIO源码分析Selector是NIO的核心epool模型1）SelectorSelector的open()方法：链接2）ServerSocketChannelServerSocketChannel.open() 链接9.AIOAsynchronous IO异步非阻塞IOBIO ServerSocketNIO ServerSocketChannelAIO AsynchronousServerSocketChannel

怎么 没人来呀 @中山野鬼###### 1、如果想去掉while（true），可以考虑通知实现； 2、关于自动重连的问题，可以考虑重发送逻辑中抽离出来，采用心跳检测完成； 3、另外发送速率统计部分也应该抽离出来。 4、上多通道要考虑资源使用可控。 5、实在不行按照业务拆分成多模块，用redis 或mq类的扩展一下架构设计； ######回复 @OS小小小 : map =(Map)JSONObject.parse(SendMsgCMPP2ThredPoolByDB.ZhangYi.take()); 换成take，阻塞线程，试试。######回复 @OS小小小 : 1、通知只是告知队列里有新的数据需要处理了； 5、内存队列换成redis队列 实现成本增加，但是可扩展性增加；######1、通知实现的话 ，岂不是 无法保证 最少发送么，又会陷入另一个问题中 是吗？ 或者是我的想法不对么？ 2、嗯，这一块可以这样做。谢谢你 3、速率统计这里 我目前想不到怎么抽离、既可以控制到位，又可以保证不影响。。。 5、redis 是有的 但是 redis的队列的话 跟我这个 没啥区别吧，可能速度更快一点。######while(true) 里面 没数据最起码要休眠啊，不停死循环操作，又没有休眠cpu不高才怪######回复 @OS小小小 : 休眠是必须的，只是前面有数据进来，可以用wait notify 的思路通知，思路就是这样，CountDownLatch 之类多线程通讯也可以实现有数据来就能立即处理的功能######嗯，目前在测试 排除没有数据的情况，所以这一块没有去让他休眠，后面会加进去。 就针对于目前这种情况，有啥好办法吗###### 我的思路是：一个主线程，多个任务子线程。 主线程有一层while(true)，这个循环是不断的扫描LinkedBlockingQueue是否有数据，有则交个任务子线程（也就是你这里定义的线程池）处理，而不是像你这样每个子任务线程都有一个while(true) ######这才是对的做法######嗯，这思路可以。谢谢哈###### 引用来自“K袁”的评论 我的思路是：一个主线程，多个任务子线程。 主线程有一层while(true)，这个循环是不断的扫描LinkedBlockingQueue是否有数据，有则交个任务子线程（也就是你这里定义的线程池）处理，而不是像你这样每个子任务线程都有一个while(true) 正确做法. 还有就是 LinkedBlockingQueue 本身阻塞的，while(true)没问题，主要在于不需要每个发送线程都去block######while（true）不加休眠就会这样###### java 的线程数量大致要和cpu数量一致，并不是越多越快，线程调度是很消耗时间的。要用好多线程，就需要设计出好的多线程业务模型，不恰当的sleep和block是性能的噩梦。利用好LinkedBlockingQueue，队列空闲时读队列的线程会释放cpu。利用消息触发后续线程工作，就没必要使用while(true)来不停的扫描。 ######@蓝水晶飞机 看到你要比牛逼，我就没有兴趣跟你说话了######回复 @不日小鸡 : 我就是装逼怎么啦，特么的装逼装出样子来的，起码也比你牛逼啊。######回复 @蓝水晶飞机 : 你说这话不能掩盖你没有回复我的问题又来回复我导致装逼失败的事实。 那你不是楼主你回复我干什么，还不是回答我的问题。 不要装逼了好么，装多就成傻逼了######回复 @不日小鸡 : 此贴楼主不是你，装什么逼。######回复 @王斌_ : 这些我都知道，我的意思是你这样回复可能会误导其他看帖子的人或者新手，让他们以为线程数就等于CPU数###### 引用来自“OS小小小”的评论 怎么 没人来呀 @中山野鬼 抬举我了。c++ 我还敢对不知深浅的人说，“权当我不懂”，java真心只是学过，没有实际工程上的经验。哈。而且我是c的思维，面对c适合的应用开发，是反对使用线程的。基本思维是，执行模块的生命周期不以任务为决定，同类的执行模块，可根据物理硬核数量，形成对应独立多个进程，但绝对不会同类的任务独立对应多个线程。哈。所以java这类面向线程的设计，没办法参与讨论。设计应用目标不同，系统组织策略自然有异。 唯一的建议是：永远不要依赖工具，特别是所谓的垃圾资源处理回收机制，无论它做的再好，一旦你依赖，必然你的代码，在不久的将来会因为系统设计规模的变大，而变的垃圾。哈。 听不懂的随便喷，希望听懂的，能记得这个观点，这不是我一个人的观点。 ######给100万像素做插值运算进行染色特效，请问单线程怎么做比多线程快？###### @乌龟壳 : 几种方法都可以，第一是按照计算步骤，每个进程处理一个步骤，然后切换共享空间（这没有数据传递逻辑上的额外开销），就是流水思维。第二个是block的思维，同样的几个进程负责相同计算，但负责不同片区。同时存在另一类的进程是对前期并发处理完的工作进行边界处理。 你这个例子体现不出进程和线程的差异的。 如果非要考虑进程和线程在片内cache的差异，如果没记错（错了大家纠正哈），进程之间的共享是在二级缓存之间吧。即便线程能做到一级缓存之间的共享，但对于这种大批量像素的计算，用进程仍然是使用 dma，将数据成块载入一级缓存区域进行处理，而这个载入工作和计算工作是同步的。不会有额外太多的延迟。 你举的这个例子，还真好是我以前的老本行。再说了。像素计算，如今都用专用计算处理器了吧。还用x86或arm来处理，不累死啊。哈。 而且这种东西java不适合，同样的处理器，用c写，基本可以比java快1到2倍。因为c可以直接根据硬件特性和计算逻辑特点有效调度底层硬件驱动方式。而java即便你用了底层优化的官方库，仍然不能保证硬件与计算目标特性的高度整合。 ######回复 @中山野鬼 : 简单来说，你的多个进程处理结果进行汇总的时候，是不是要做内存复制操作？如果是多线程天然就不用，多进程用系统的共享内存机制也不用，问题是既然用了共享内存，和多线程就没区别了。######回复 @乌龟壳 : 两回事哦。共享空间是独立的，而线程如果我没记错，全局变量，包括文件内的（静态变量）是共享的。不同线程共享同一个进程内的变量嘛。这些和业务逻辑相关的东西，每个线程又是独立一套业务逻辑，针对c语言，这样去设计，不是没事找事嘛。面向对象语言，这块都帮你处理好了，自然没有关系。######既然有共享空间了，那你所说的进程和线程实际就是一回事了。###### @乌龟壳   ，数据分两种，一种和算法或处理相关的。一种是待处理的数据。 前者，不应该共享，后者属于数据加工流程，必然存在数据传递或流动，最低成本的传递／流动方式就是共享内存，交替使用权限的思路。 但这仅仅针对待加工的数据和辅助信息，而不针对程序本身。 进程不会搞混乱这些东西特别是（待加工数据的辅助信息），而线程，就各种乱吧。哈。 进程之间，虽然用共享空间，但它本质是数据传递／流动，当你采用多机（物理机器）并发处理时，进程移动到另外一个物理主机，则共享空间就是不能选择的传递／流动方式了。但线程就没有这些概念。 ######回复 @中山野鬼 : 是啊，java天然就不是像C一样对汇编的包装。######@乌龟壳 面向企业级的各种业务，java这些没问题的。而且更有优势，面向计算设备特性的设计开发，就不行了。哈。######回复 @中山野鬼 : 也算各有场景吧，java同样可以多进程可以分布式来降低多线程的风险。java也可以静态编译成目标机器码。总之事在人为。######回复 @乌龟壳 : 高手，啥都可以，低手，依赖这些，就是各种想当然。哈哈。######回复 @中山野鬼 : 那针对java的垃圾回收，这个东西是可以调节它算法的，不算依赖工具吧，哈。不然依赖C语言语法也算依赖工具咯。哈。;-p

【Java问答学堂】13期 redis 和 memcached 有什么区别？redis 的线程模型是什么？为什么 redis 单线程却能支撑高并发？ 面试官心理分析 这个是问 redis 的时候，最基本的问题吧，redis 最基本的一个内部原理和特点，就是 redis 实际上是个单线程工作模型，你要是这个都不知道，那后面玩儿 redis 的时候，出了问题岂不是什么都不知道？ 还有可能面试官会问问你 redis 和 memcached 的区别，但是 memcached 是早些年各大互联网公司常用的缓存方案，但是现在近几年基本都是 redis，没什么公司用 memcached 了。 面试题剖析 redis 和 memcached 有啥区别？ redis 支持复杂的数据结构 redis 相比 memcached 来说，拥有更多的数据结构，能支持更丰富的数据操作。如果需要缓存能够支持更复杂的结构和操作， redis 会是不错的选择。 redis 原生支持集群模式 在 redis3.x 版本中，便能支持 cluster 模式，而 memcached 没有原生的集群模式，需要依靠客户端来实现往集群中分片写入数据。 性能对比 由于 redis 只使用单核，而 memcached 可以使用多核，所以平均每一个核上 redis 在存储小数据时比 memcached 性能更高。而在 100k 以上的数据中，memcached 性能要高于 redis。虽然 redis 最近也在存储大数据的性能上进行优化，但是比起 memcached，还是稍有逊色。 redis 的线程模型 redis 内部使用文件事件处理器 file event handler，这个文件事件处理器是单线程的，所以 redis 才叫做单线程的模型。它采用 IO 多路复用机制同时监听多个 socket，将产生事件的 socket 压入内存队列中，事件分派器根据 socket 上的事件类型来选择对应的事件处理器进行处理。 文件事件处理器的结构包含 4 个部分： 多个 socketIO 多路复用程序文件事件分派器事件处理器（连接应答处理器、命令请求处理器、命令回复处理器） 多个 socket 可能会并发产生不同的操作，每个操作对应不同的文件事件，但是 IO 多路复用程序会监听多个 socket，会将产生事件的 socket 放入队列中排队，事件分派器每次从队列中取出一个 socket，根据 socket 的事件类型交给对应的事件处理器进行处理。 来看客户端与 redis 的一次通信过程： 要明白，通信是通过 socket 来完成的，不懂的同学可以先去看一看 socket 网络编程。 首先，redis 服务端进程初始化的时候，会将 server socket 的 AE_READABLE 事件与连接应答处理器关联。 客户端 socket01 向 redis 进程的 server socket 请求建立连接，此时 server socket 会产生一个 AE_READABLE 事件，IO 多路复用程序监听到 server socket 产生的事件后，将该 socket 压入队列中。文件事件分派器从队列中获取 socket，交给连接应答处理器。连接应答处理器会创建一个能与客户端通信的 socket01，并将该 socket01 的 AE_READABLE 事件与命令请求处理器关联。 假设此时客户端发送了一个 set key value 请求，此时 redis 中的 socket01 会产生 AE_READABLE 事件，IO 多路复用程序将 socket01 压入队列，此时事件分派器从队列中获取到 socket01 产生的 AE_READABLE 事件，由于前面 socket01 的 AE_READABLE 事件已经与命令请求处理器关联，因此事件分派器将事件交给命令请求处理器来处理。命令请求处理器读取 socket01 的 key value 并在自己内存中完成 key value 的设置。操作完成后，它会将 socket01 的 AE_WRITABLE 事件与命令回复处理器关联。 如果此时客户端准备好接收返回结果了，那么 redis 中的 socket01 会产生一个 AE_WRITABLE 事件，同样压入队列中，事件分派器找到相关联的命令回复处理器，由命令回复处理器对 socket01 输入本次操作的一个结果，比如 ok，之后解除 socket01 的 AE_WRITABLE 事件与命令回复处理器的关联。 这样便完成了一次通信。关于 Redis 的一次通信过程，推荐读者阅读《Redis 设计与实现——黄健宏》进行系统学习。 为啥 redis 单线程模型也能效率这么高？ 纯内存操作。核心是基于非阻塞的 IO 多路复用机制。C 语言实现，一般来说，C 语言实现的程序“距离”操作系统更近，执行速度相对会更快。单线程反而避免了多线程的频繁上下文切换问题，预防了多线程可能产生的竞争问题。 往期回顾： 【Java问答学堂】1期 为什么使用消息队列？消息队列有什么优点和缺点？Kafka、ActiveMQ、RabbitMQ、RocketMQ 都有什么区别，以及适合哪些场景？ 【Java问答学堂】2期 如何保证消息队列的高可用？ 【Java问答学堂】3期 如何保证消息不被重复消费？或者说，如何保证消息消费的幂等性？ 【Java问答学堂】4期 如何保证消息的可靠性传输？（如何处理消息丢失的问题？） 【Java问答学堂】5期 如何保证消息的顺序性？ 【Java问答学堂】6期 如何解决消息队列的延时以及过期失效问题？ 【Java问答学堂】7期 如果让你写一个消息队列，该如何进行架构设计？ 【Java问答学堂】8期 es 的分布式架构原理能说一下么（es 是如何实现分布式的啊）？ 【Java问答学堂】9期 es 写入数据的工作原理是什么啊？es 查询数据的工作原理是什么啊？ 【Java问答学堂】10期 es 在数据量很大的情况下（数十亿级别）如何提高查询效率啊？ 【Java问答学堂】11期 es 生产集群的部署架构是什么？每个索引的数据量大概有多少？ 【Java问答学堂】12期 项目中缓存是如何使用的？为什么要用缓存？缓存使用不当会造成什么后果？

92题 一般来说，建立INDEX有以下益处：提高查询效率；建立唯一索引以保证数据的唯一性；设计INDEX避免排序。 缺点，INDEX的维护有以下开销：叶节点的‘分裂’消耗；INSERT、DELETE和UPDATE操作在INDEX上的维护开销；有存储要求；其他日常维护的消耗：对恢复的影响，重组的影响。 需要建立索引的情况：为了建立分区数据库的PATITION INDEX必须建立； 为了保证数据约束性需要而建立的INDEX必须建立； 为了提高查询效率，则考虑建立（是否建立要考虑相关性能及维护开销）； 考虑在使用UNION,DISTINCT,GROUP BY,ORDER BY等字句的列上加索引。 91题 作用：加快查询速度。原则：(1) 如果某属性或属性组经常出现在查询条件中，考虑为该属性或属性组建立索引；(2) 如果某个属性常作为最大值和最小值等聚集函数的参数，考虑为该属性建立索引；(3) 如果某属性经常出现在连接操作的连接条件中，考虑为该属性或属性组建立索引。 90题 快照Snapshot是一个文件系统在特定时间里的镜像，对于在线实时数据备份非常有用。快照对于拥有不能停止的应用或具有常打开文件的文件系统的备份非常重要。对于只能提供一个非常短的备份时间而言，快照能保证系统的完整性。 89题 游标用于定位结果集的行，通过判断全局变量@@FETCH_STATUS可以判断是否到了最后，通常此变量不等于0表示出错或到了最后。 88题 事前触发器运行于触发事件发生之前，而事后触发器运行于触发事件发生之后。通常事前触发器可以获取事件之前和新的字段值。语句级触发器可以在语句执行前或后执行，而行级触发在触发器所影响的每一行触发一次。 87题 MySQL可以使用多个字段同时建立一个索引，叫做联合索引。在联合索引中，如果想要命中索引，需要按照建立索引时的字段顺序挨个使用，否则无法命中索引。具体原因为：MySQL使用索引时需要索引有序，假设现在建立了"name，age，school"的联合索引，那么索引的排序为: 先按照name排序，如果name相同，则按照age排序，如果age的值也相等，则按照school进行排序。因此在建立联合索引的时候应该注意索引列的顺序，一般情况下，将查询需求频繁或者字段选择性高的列放在前面。此外可以根据特例的查询或者表结构进行单独的调整。 86题 建立索引的时候一般要考虑到字段的使用频率，经常作为条件进行查询的字段比较适合。如果需要建立联合索引的话，还需要考虑联合索引中的顺序。此外也要考虑其他方面，比如防止过多的所有对表造成太大的压力。这些都和实际的表结构以及查询方式有关。 85题 存储过程是一组Transact-SQL语句，在一次编译后可以执行多次。因为不必重新编译Transact-SQL语句，所以执行存储过程可以提高性能。触发器是一种特殊类型的存储过程，不由用户直接调用。创建触发器时会对其进行定义，以便在对特定表或列作特定类型的数据修改时执行。 84题 存储过程是用户定义的一系列SQL语句的集合，涉及特定表或其它对象的任务，用户可以调用存储过程，而函数通常是数据库已定义的方法，它接收参数并返回某种类型的值并且不涉及特定用户表。 83题 减少表连接，减少复杂 SQL，拆分成简单SQL。减少排序：非必要不排序，利用索引排序，减少参与排序的记录数。尽量避免 select *。尽量用 join 代替子查询。尽量少使用 or，使用 in 或者 union(union all) 代替。尽量用 union all 代替 union。尽量早的将无用数据过滤：选择更优的索引，先分页再Join…。避免类型转换：索引失效。优先优化高并发的 SQL，而不是执行频率低某些“大”SQL。从全局出发优化，而不是片面调整。尽可能对每一条SQL进行 explain。 82题 如果条件中有or，即使其中有条件带索引也不会使用(要想使用or，又想让索引生效，只能将or条件中的每个列都加上索引)。对于多列索引，不是使用的第一部分，则不会使用索引。like查询是以%开头。如果列类型是字符串，那一定要在条件中将数据使用引号引用起来，否则不使用索引。如果mysql估计使用全表扫描要比使用索引快，则不使用索引。例如，使用<>、not in 、not exist，对于这三种情况大多数情况下认为结果集很大，MySQL就有可能不使用索引。 81题 主键不能重复，不能为空，唯一键不能重复，可以为空。建立主键的目的是让外键来引用。一个表最多只有一个主键，但可以有很多唯一键。 80题 空值('')是不占用空间的，判断空字符用=''或者<>''来进行处理。NULL值是未知的，且占用空间，不走索引；判断 NULL 用 IS NULL 或者 is not null ，SQL 语句函数中可以使用 ifnull ()函数来进行处理。无法比较 NULL 和 0；它们是不等价的。无法使用比较运算符来测试 NULL 值，比如 =, <, 或者 <>。NULL 值可以使用 <=> 符号进行比较，该符号与等号作用相似，但对NULL有意义。进行 count ()统计某列的记录数的时候，如果采用的 NULL 值，会被系统自动忽略掉，但是空值是统计到其中。 79题 HEAP表是访问数据速度最快的MySQL表，他使用保存在内存中的散列索引。一旦服务器重启，所有heap表数据丢失。BLOB或TEXT字段是不允许的。只能使用比较运算符=，<，>，=>，= <。HEAP表不支持AUTO_INCREMENT。索引不可为NULL。 78题 如果想输入字符为十六进制数字，可以输入带有单引号的十六进制数字和前缀（X），或者只用（Ox）前缀输入十六进制数字。如果表达式上下文是字符串，则十六进制数字串将自动转换为字符串。 77题 Mysql服务器通过权限表来控制用户对数据库的访问，权限表存放在mysql数据库里，由mysql_install_db脚本初始化。这些权限表分别user，db，table_priv，columns_priv和host。 76题 在缺省模式下，MYSQL是autocommit模式的，所有的数据库更新操作都会即时提交，所以在缺省情况下，mysql是不支持事务的。但是如果你的MYSQL表类型是使用InnoDB Tables 或 BDB tables的话，你的MYSQL就可以使用事务处理,使用SET AUTOCOMMIT=0就可以使MYSQL允许在非autocommit模式，在非autocommit模式下，你必须使用COMMIT来提交你的更改，或者用ROLLBACK来回滚你的更改。 75题 它会停止递增，任何进一步的插入都将产生错误，因为密钥已被使用。 74题 创建索引的时候尽量使用唯一性大的列来创建索引，由于使用b+tree做为索引，以innodb为例，一个树节点的大小由“innodb_page_size”，为了减少树的高度，同时让一个节点能存放更多的值，索引列尽量在整数类型上创建，如果必须使用字符类型，也应该使用长度较少的字符类型。 73题 当MySQL单表记录数过大时，数据库的CRUD性能会明显下降，一些常见的优化措施如下： 限定数据的范围： 务必禁止不带任何限制数据范围条件的查询语句。比如：我们当用户在查询订单历史的时候，我们可以控制在一个月的范围内。读/写分离： 经典的数据库拆分方案，主库负责写，从库负责读。垂直分区： 根据数据库里面数据表的相关性进行拆分。简单来说垂直拆分是指数据表列的拆分，把一张列比较多的表拆分为多张表。水平分区： 保持数据表结构不变，通过某种策略存储数据分片。这样每一片数据分散到不同的表或者库中，达到了分布式的目的。水平拆分可以支撑非常大的数据量。 72题 乐观锁失败后会抛出ObjectOptimisticLockingFailureException，那么我们就针对这块考虑一下重试，自定义一个注解，用于做切面。针对注解进行切面，设置最大重试次数n，然后超过n次后就不再重试。 71题 一致性非锁定读讲的是一条记录被加了X锁其他事务仍然可以读而不被阻塞，是通过innodb的行多版本实现的，行多版本并不是实际存储多个版本记录而是通过undo实现（undo日志用来记录数据修改前的版本，回滚时会用到，用来保证事务的原子性）。一致性锁定读讲的是我可以通过SELECT语句显式地给一条记录加X锁从而保证特定应用场景下的数据一致性。 70题 数据库引擎：尤其是mysql数据库只有是InnoDB引擎的时候事物才能生效。 show engines 查看数据库默认引擎;SHOW TABLE STATUS from 数据库名字 where Name='表名' 如下;SHOW TABLE STATUS from rrz where Name='rrz_cust';修改表的引擎alter table table_name engine=innodb。 69题 如果是等值查询，那么哈希索引明显有绝对优势，因为只需要经过一次算法即可找到相应的键值；当然了，这个前提是，键值都是唯一的。如果键值不是唯一的，就需要先找到该键所在位置，然后再根据链表往后扫描，直到找到相应的数据；如果是范围查询检索，这时候哈希索引就毫无用武之地了，因为原先是有序的键值，经过哈希算法后，有可能变成不连续的了，就没办法再利用索引完成范围查询检索；同理，哈希索引也没办法利用索引完成排序，以及like ‘xxx%’ 这样的部分模糊查询（这种部分模糊查询，其实本质上也是范围查询）；哈希索引也不支持多列联合索引的最左匹配规则；B+树索引的关键字检索效率比较平均，不像B树那样波动幅度大，在有大量重复键值情况下，哈希索引的效率也是极低的，因为存在所谓的哈希碰撞问题。 68题 decimal精度比float高,数据处理比float简单，一般优先考虑，但float存储的数据范围大，所以范围大的数据就只能用它了，但要注意一些处理细节，因为不精确可能会与自己想的不一致，也常有关于float 出错的问题。 67题 datetime、timestamp精确度都是秒，datetime与时区无关，存储的范围广(1001-9999)，timestamp与时区有关，存储的范围小(1970-2038)。 66题 Char使用固定长度的空间进行存储，char(4)存储4个字符，根据编码方式的不同占用不同的字节，gbk编码方式，不论是中文还是英文，每个字符占用2个字节的空间，utf8编码方式，每个字符占用3个字节的空间。Varchar保存可变长度的字符串，使用额外的一个或两个字节存储字符串长度，varchar(10),除了需要存储10个字符，还需要1个字节存储长度信息(10),超过255的长度需要2个字节来存储。char和varchar后面如果有空格，char会自动去掉空格后存储，varchar虽然不会去掉空格，但在进行字符串比较时，会去掉空格进行比较。Varbinary保存变长的字符串，后面不会补\0。 65题 首先分析语句，看看是否load了额外的数据，可能是查询了多余的行并且抛弃掉了，可能是加载了许多结果中并不需要的列，对语句进行分析以及重写。分析语句的执行计划，然后获得其使用索引的情况，之后修改语句或者修改索引，使得语句可以尽可能的命中索引。如果对语句的优化已经无法进行，可以考虑表中的数据量是否太大，如果是的话可以进行横向或者纵向的分表。 64题 建立索引的时候一般要考虑到字段的使用频率，经常作为条件进行查询的字段比较适合。如果需要建立联合索引的话，还需要考虑联合索引中的顺序。此外也要考虑其他方面，比如防止过多的所有对表造成太大的压力。这些都和实际的表结构以及查询方式有关。 63题 存储过程是一些预编译的SQL语句。1、更加直白的理解：存储过程可以说是一个记录集，它是由一些T-SQL语句组成的代码块，这些T-SQL语句代码像一个方法一样实现一些功能（对单表或多表的增删改查），然后再给这个代码块取一个名字，在用到这个功能的时候调用他就行了。2、存储过程是一个预编译的代码块，执行效率比较高，一个存储过程替代大量T_SQL语句 ，可以降低网络通信量，提高通信速率，可以一定程度上确保数据安全。 62题 密码散列、盐、用户身份证号等固定长度的字符串应该使用char而不是varchar来存储,这样可以节省空间且提高检索效率。 61题 推荐使用自增ID，不要使用UUID。因为在InnoDB存储引擎中，主键索引是作为聚簇索引存在的，也就是说，主键索引的B+树叶子节点上存储了主键索引以及全部的数据(按照顺序)，如果主键索引是自增ID，那么只需要不断向后排列即可，如果是UUID，由于到来的ID与原来的大小不确定，会造成非常多的数据插入,数据移动,然后导致产生很多的内存碎片，进而造成插入性能的下降。总之,在数据量大一些的情况下,用自增主键性能会好一些。 60题 char是一个定长字段，假如申请了char(10)的空间，那么无论实际存储多少内容。该字段都占用10个字符，而varchar是变长的，也就是说申请的只是最大长度，占用的空间为实际字符长度+1，最后一个字符存储使用了多长的空间。在检索效率上来讲，char > varchar，因此在使用中，如果确定某个字段的值的长度，可以使用char，否则应该尽量使用varchar。例如存储用户MD5加密后的密码,则应该使用char。 59题 一. read uncommitted（读取未提交数据） 即便是事务没有commit，但是我们仍然能读到未提交的数据，这是所有隔离级别中最低的一种。 二. read committed（可以读取其他事务提交的数据）---大多数数据库默认的隔离级别 当前会话只能读取到其他事务提交的数据，未提交的数据读不到。 三. repeatable read（可重读）---MySQL默认的隔离级别 当前会话可以重复读，就是每次读取的结果集都相同，而不管其他事务有没有提交。 四. serializable（串行化） 其他会话对该表的写操作将被挂起。可以看到，这是隔离级别中最严格的，但是这样做势必对性能造成影响。所以在实际的选用上，我们要根据当前具体的情况选用合适的。 58题 B+树的高度一般为2-4层，所以查找记录时最多只需要2-4次IO，相对二叉平衡树已经大大降低了。范围查找时，能通过叶子节点的指针获取数据。例如查找大于等于3的数据，当在叶子节点中查到3时，通过3的尾指针便能获取所有数据，而不需要再像二叉树一样再获取到3的父节点。 57题 因为事务在修改页时，要先记 undo，在记 undo 之前要记 undo 的 redo， 然后修改数据页，再记数据页修改的 redo。 Redo（里面包括 undo 的修改） 一定要比数据页先持久化到磁盘。 当事务需要回滚时，因为有 undo，可以把数据页回滚到前镜像的状态，崩溃恢复时，如果 redo log 中事务没有对应的 commit 记录，那么需要用 undo把该事务的修改回滚到事务开始之前。 如果有 commit 记录，就用 redo 前滚到该事务完成时并提交掉。 56题 redo log是物理日志,记录的是"在某个数据页上做了什么修改"。 binlog是逻辑日志,记录的是这个语句的原始逻辑,比如"给ID=2这一行的c字段加1"。 redo log是InnoDB引擎特有的;binlog是MySQL的Server层实现的,所有引擎都可以使用。 redo log是循环写的,空间固定会用完:binlog 是可以追加写入的。"追加写"是指binlog文件写到一定大小后会切换到下一个,并不会覆盖以前的日志。 最开始 MySQL 里并没有 InnoDB 引擎，MySQL 自带的引擎是 MyISAM，但是 MyISAM 没有 crash-safe 的能力,binlog日志只能用于归档。而InnoDB 是另一个公司以插件形式引入 MySQL 的，既然只依靠 binlog 是没有 crash-safe 能力的，所以 InnoDB 使用另外一套日志系统，也就是 redo log 来实现 crash-safe 能力。 55题 重做日志（redo log)      作用：确保事务的持久性，防止在发生故障，脏页未写入磁盘。重启数据库会进行redo log执行重做，达到事务一致性。 回滚日志（undo log)  作用：保证数据的原子性，保存了事务发生之前的数据的一个版本，可以用于回滚，同时可以提供多版本并发控制下的读(MVCC)，也即非锁定读。 二进 制日志（binlog)    作用：用于主从复制，实现主从同步；用于数据库的基于时间点的还原。 错误日志（errorlog) 作用：Mysql本身启动，停止，运行期间发生的错误信息。 慢查询日志（slow query log)  作用：记录执行时间过长的sql，时间阈值可以配置，只记录执行成功。 一般查询日志（general log)    作用：记录数据库的操作明细，默认关闭，开启后会降低数据库性能 。 中继日志（relay log) 作用：用于数据库主从同步，将主库发来的bin log保存在本地，然后从库进行回放。 54题 MySQL有三种锁的级别：页级、表级、行级。 表级锁：开销小，加锁快；不会出现死锁；锁定粒度大，发生锁冲突的概率最高,并发度最低。 行级锁：开销大，加锁慢；会出现死锁；锁定粒度最小，发生锁冲突的概率最低,并发度也最高。 页面锁：开销和加锁时间界于表锁和行锁之间；会出现死锁；锁定粒度界于表锁和行锁之间，并发度一般。 死锁: 是指两个或两个以上的进程在执行过程中。因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。 死锁的关键在于：两个(或以上)的Session加锁的顺序不一致。 那么对应的解决死锁问题的关键就是：让不同的session加锁有次序。死锁的解决办法：1.查出的线程杀死。2.设置锁的超时时间。3.指定获取锁的顺序。 53题 当多个用户并发地存取数据时，在数据库中就会产生多个事务同时存取同一数据的情况。若对并发操作不加控制就可能会读取和存储不正确的数据，破坏数据库的一致性(脏读，不可重复读，幻读等)，可能产生死锁。 乐观锁：乐观锁不是数据库自带的，需要我们自己去实现。 悲观锁：在进行每次操作时都要通过获取锁才能进行对相同数据的操作。 共享锁：加了共享锁的数据对象可以被其他事务读取，但不能修改。 排他锁：当数据对象被加上排它锁时，一个事务必须得到锁才能对该数据对象进行访问，一直到事务结束锁才被释放。 行锁：就是给某一条记录加上锁。 52题 Mysql是关系型数据库，MongoDB是非关系型数据库，数据存储结构的不同。 51题 关系型数据库优点：1.保持数据的一致性（事务处理）。 2.由于以标准化为前提，数据更新的开销很小。 3. 可以进行Join等复杂查询。 缺点：1、为了维护一致性所付出的巨大代价就是其读写性能比较差。 2、固定的表结构。 3、高并发读写需求。 4、海量数据的高效率读写。 非关系型数据库优点：1、无需经过sql层的解析，读写性能很高。 2、基于键值对，数据没有耦合性，容易扩展。 3、存储数据的格式：nosql的存储格式是key,value形式、文档形式、图片形式等等，文档形式、图片形式等等，而关系型数据库则只支持基础类型。 缺点：1、不提供sql支持，学习和使用成本较高。 2、无事务处理，附加功能bi和报表等支持也不好。 redis与mongoDB的区别： 性能：TPS方面redis要大于mongodb。 可操作性：mongodb支持丰富的数据表达，索引，redis较少的网络IO次数。 可用性:MongoDB优于Redis。 一致性:redis事务支持比较弱,mongoDB不支持事务。 数据分析:mongoDB内置了数据分析的功能(mapreduce)。 应用场景:redis数据量较小的更性能操作和运算上,MongoDB主要解决海量数据的访问效率问题。 50题 如果Redis被当做缓存使用，使用一致性哈希实现动态扩容缩容。如果Redis被当做一个持久化存储使用，必须使用固定的keys-to-nodes映射关系，节点的数量一旦确定不能变化。否则的话(即Redis节点需要动态变化的情况），必须使用可以在运行时进行数据再平衡的一套系统，而当前只有Redis集群可以做到这样。 49题 分区可以让Redis管理更大的内存，Redis将可以使用所有机器的内存。如果没有分区，你最多只能使用一台机器的内存。分区使Redis的计算能力通过简单地增加计算机得到成倍提升,Redis的网络带宽也会随着计算机和网卡的增加而成倍增长。 48题 除了缓存服务器自带的缓存失效策略之外（Redis默认的有6种策略可供选择），我们还可以根据具体的业务需求进行自定义的缓存淘汰，常见的策略有两种： 1.定时去清理过期的缓存； 2.当有用户请求过来时，再判断这个请求所用到的缓存是否过期，过期的话就去底层系统得到新数据并更新缓存。 两者各有优劣，第一种的缺点是维护大量缓存的key是比较麻烦的，第二种的缺点就是每次用户请求过来都要判断缓存失效，逻辑相对比较复杂！具体用哪种方案，可以根据应用场景来权衡。 47题 Redis提供了两种方式来作消息队列: 一个是使用生产者消费模式模式:会让一个或者多个客户端监听消息队列，一旦消息到达，消费者马上消费，谁先抢到算谁的，如果队列里没有消息，则消费者继续监听 。另一个就是发布订阅者模式:也是一个或多个客户端订阅消息频道，只要发布者发布消息，所有订阅者都能收到消息，订阅者都是平等的。 46题 Redis的数据结构列表(list)可以实现延时队列，可以通过队列和栈来实现。blpop/brpop来替换lpop/rpop，blpop/brpop阻塞读在队列没有数据的时候，会立即进入休眠状态，一旦数据到来，则立刻醒过来。Redis的有序集合(zset)可以用于实现延时队列，消息作为value，时间作为score。Zrem 命令用于移除有序集中的一个或多个成员，不存在的成员将被忽略。当 key 存在但不是有序集类型时，返回一个错误。 45题 1.热点数据缓存：因为Redis 访问速度块、支持的数据类型比较丰富。 2.限时业务：expire 命令设置 key 的生存时间，到时间后自动删除 key。 3.计数器：incrby 命令可以实现原子性的递增。 4.排行榜：借助 SortedSet 进行热点数据的排序。 5.分布式锁：利用 Redis 的 setnx 命令进行。 6.队列机制：有 list push 和 list pop 这样的命令。 44题 一致哈希 是一种特殊的哈希算法。在使用一致哈希算法后，哈希表槽位数（大小）的改变平均只需要对 K/n 个关键字重新映射，其中K是关键字的数量， n是槽位数量。然而在传统的哈希表中，添加或删除一个槽位的几乎需要对所有关键字进行重新映射。 43题 RDB的优点：适合做冷备份；读写服务影响小，reids可以保持高性能；重启和恢复redis进程，更加快速。RDB的缺点：宕机会丢失最近5分钟的数据；文件特别大时可能会暂停数毫秒，或者甚至数秒。 AOF的优点：每个一秒执行fsync操作，最多丢失1秒钟的数据；以append-only模式写入，没有任何磁盘寻址的开销；文件过大时，不会影响客户端读写；适合做灾难性的误删除的紧急恢复。AOF的缺点：AOF日志文件比RDB数据快照文件更大，支持写QPS比RDB支持的写QPS低；比RDB脆弱，容易有bug。 42题 对于Redis而言，命令的原子性指的是：一个操作的不可以再分，操作要么执行，要么不执行。Redis的操作之所以是原子性的，是因为Redis是单线程的。而在程序中执行多个Redis命令并非是原子性的，这也和普通数据库的表现是一样的，可以用incr或者使用Redis的事务，或者使用Redis+Lua的方式实现。对Redis来说，执行get、set以及eval等API，都是一个一个的任务，这些任务都会由Redis的线程去负责执行，任务要么执行成功，要么执行失败，这就是Redis的命令是原子性的原因。 41题 (1)twemproxy,使用方式简单（相对redis只需修改连接端口），对旧项目扩展的首选。(2)codis,目前用的最多的集群方案，基本和twemproxy一致的效果，但它支持在节点数改变情况下，旧节点数据可恢复到新hash节点。(3)redis cluster3.0自带的集群，特点在于他的分布式算法不是一致性hash,而是hash槽的概念，以及自身支持节点设置从节点。(4)在业务代码层实现，起几个毫无关联的redis实例，在代码层，对key进行hash计算，然后去对应的redis实例操作数据。这种方式对hash层代码要求比较高，考虑部分包括，节点失效后的代替算法方案，数据震荡后的自动脚本恢复，实例的监控，等等。 40题 (1) Master最好不要做任何持久化工作，如RDB内存快照和AOF日志文件 (2) 如果数据比较重要，某个Slave开启AOF备份数据，策略设置为每秒同步一次 (3) 为了主从复制的速度和连接的稳定性，Master和Slave最好在同一个局域网内 (4) 尽量避免在压力很大的主库上增加从库 (5) 主从复制不要用图状结构，用单向链表结构更为稳定，即：Master <- Slave1 <- Slave2 <- Slave3...这样的结构方便解决单点故障问题，实现Slave对Master的替换。如果Master挂了，可以立刻启用Slave1做Master，其他不变。 39题 比如订单管理，热数据：3个月内的订单数据，查询实时性较高;温数据：3个月 ~ 12个月前的订单数据，查询频率不高;冷数据：1年前的订单数据，几乎不会查询，只有偶尔的查询需求。热数据使用mysql进行存储，需要分库分表;温数据可以存储在ES中，利用搜索引擎的特性基本上也可以做到比较快的查询;冷数据可以存放到Hive中。从存储形式来说，一般情况冷数据存储在磁带、光盘，热数据一般存放在SSD中，存取速度快，而温数据可以存放在7200转的硬盘。 38题 当访问量剧增、服务出现问题（如响应时间慢或不响应）或非核心服务影响到核心流程的性能时，仍然需要保证服务还是可用的，即使是有损服务。系统可以根据一些关键数据进行自动降级，也可以配置开关实现人工降级。降级的最终目的是保证核心服务可用，即使是有损的。而且有些服务是无法降级的（如加入购物车、结算）。 37题 分层架构设计，有一条准则：站点层、服务层要做到无数据无状态，这样才能任意的加节点水平扩展，数据和状态尽量存储到后端的数据存储服务，例如数据库服务或者缓存服务。显然进程内缓存违背了这一原则。 36题 更新数据的时候，根据数据的唯一标识，将操作路由之后，发送到一个 jvm 内部队列中。读取数据的时候，如果发现数据不在缓存中，那么将重新读取数据+更新缓存的操作，根据唯一标识路由之后，也发送同一个 jvm 内部队列中。一个队列对应一个工作线程，每个工作线程串行拿到对应的操作，然后一条一条的执行。 35题 redis分布式锁加锁过程：通过setnx向特定的key写入一个随机值，并同时设置失效时间，写值成功既加锁成功；redis分布式锁解锁过程：匹配随机值，删除redis上的特点key数据，要保证获取数据、判断一致以及删除数据三个操作是原子的，为保证原子性一般使用lua脚本实现；在此基础上进一步优化的话，考虑使用心跳检测对锁的有效期进行续期，同时基于redis的发布订阅优雅的实现阻塞式加锁。 34题 volatile-lru：当内存不足以容纳写入数据时，从已设置过期时间的数据集中挑选最近最少使用的数据淘汰。 volatile-ttl：当内存不足以容纳写入数据时，从已设置过期时间的数据集中挑选将要过期的数据淘汰。 volatile-random：当内存不足以容纳写入数据时，从已设置过期时间的数据集中任意选择数据淘汰。 allkeys-lru：当内存不足以容纳写入数据时，从数据集中挑选最近最少使用的数据淘汰。 allkeys-random：当内存不足以容纳写入数据时，从数据集中任意选择数据淘汰。 noeviction：禁止驱逐数据，当内存使用达到阈值的时候，所有引起申请内存的命令会报错。 33题 定时过期：每个设置过期时间的key都需要创建一个定时器，到过期时间就会立即清除。该策略可以立即清除过期的数据，对内存很友好；但是会占用大量的CPU资源去处理过期的数据，从而影响缓存的响应时间和吞吐量。 惰性过期：只有当访问一个key时，才会判断该key是否已过期，过期则清除。该策略可以最大化地节省CPU资源，却对内存非常不友好。极端情况可能出现大量的过期key没有再次被访问，从而不会被清除，占用大量内存。 定期过期：每隔一定的时间，会扫描一定数量的数据库的expires字典中一定数量的key，并清除其中已过期的key。该策略是前两者的一个折中方案。通过调整定时扫描的时间间隔和每次扫描的限定耗时，可以在不同情况下使得CPU和内存资源达到最优的平衡效果。 32题 缓存击穿，一个存在的key，在缓存过期的一刻，同时有大量的请求，这些请求都会击穿到DB，造成瞬时DB请求量大、压力骤增。如何避免：在访问key之前，采用SETNX（set if not exists）来设置另一个短期key来锁住当前key的访问，访问结束再删除该短期key。 31题 缓存雪崩，是指在某一个时间段，缓存集中过期失效。大量的key设置了相同的过期时间，导致在缓存在同一时刻全部失效，造成瞬时DB请求量大、压力骤增，引起雪崩。而缓存服务器某个节点宕机或断网，对数据库服务器造成的压力是不可预知的，很有可能瞬间就把数据库压垮。如何避免：1.redis高可用，搭建redis集群。2.限流降级，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。3.数据预热，在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间。 30题 缓存穿透，是指查询一个数据库一定不存在的数据。正常的使用缓存流程大致是，数据查询先进行缓存查询，如果key不存在或者key已经过期，再对数据库进行查询，并把查询到的对象，放进缓存。如果数据库查询对象为空，则不放进缓存。一些恶意的请求会故意查询不存在的 key，请求量很大，对数据库造成压力，甚至压垮数据库。 如何避免：1：对查询结果为空的情况也进行缓存，缓存时间设置短一点，或者该 key 对应的数据 insert 了之后清理缓存。2：对一定不存在的 key 进行过滤。可以把所有的可能存在的 key 放到一个大的 Bitmap 中，查询时通过该 bitmap 过滤。 29题 1.memcached 所有的值均是简单的字符串，redis 作为其替代者，支持更为丰富的数据类型。 2.redis 的速度比 memcached 快很多。 3.redis 可以持久化其数据。 4.Redis支持数据的备份，即master-slave模式的数据备份。 5.Redis采用VM机制。 6.value大小：redis最大可以达到1GB，而memcache只有1MB。 28题 Spring Boot 推荐使用 Java 配置而非 XML 配置，但是 Spring Boot 中也可以使用 XML 配置，通过spring提供的@ImportResource来加载xml配置。例如：@ImportResource({"classpath:some-context.xml","classpath:another-context.xml"}) 27题 Spring像一个大家族，有众多衍生产品例如Spring Boot，Spring Security等等，但他们的基础都是Spring的IOC和AOP，IOC提供了依赖注入的容器，而AOP解决了面向切面的编程，然后在此两者的基础上实现了其他衍生产品的高级功能。Spring MVC是基于Servlet的一个MVC框架，主要解决WEB开发的问题，因为 Spring的配置非常复杂，各种xml，properties处理起来比较繁琐。Spring Boot遵循约定优于配置，极大降低了Spring使用门槛，又有着Spring原本灵活强大的功能。总结：Spring MVC和Spring Boot都属于Spring，Spring MVC是基于Spring的一个MVC框架，而Spring Boot是基于Spring的一套快速开发整合包。 26题 YAML 是 "YAML Ain't a Markup Language"（YAML 不是一种标记语言）的递归缩写。YAML 的配置文件后缀为 .yml，是一种人类可读的数据序列化语言，可以简单表达清单、散列表，标量等数据形态。它通常用于配置文件，与属性文件相比，YAML文件就更加结构化，而且更少混淆。可以看出YAML具有分层配置数据。 25题 Spring Boot有3种热部署方式： 1.使用springloaded配置pom.xml文件，使用mvn spring-boot:run启动。 2.使用springloaded本地加载启动，配置jvm参数-javaagent:<jar包地址> -noverify。 3.使用devtools工具包，操作简单，但是每次需要重新部署。 用