精华内容
下载资源
问答
我要提问

  • 八大内存排序算法

     千次阅读 2020-06-02 20:24:40
    类型一、选择排序 （1）冒泡排序： a.每趟排序，最大沉底; b.排列元素个数逐渐（从尾）减一，因为每趟排序，最后一位已确定； c.每次冒泡序列：0 ~ i-1 TimeCost：O(N^2) SpaceCost：O(N) 代码： void BubbleSort... 
    类型一、选择排序
     

     
 
    （1）冒泡排序：
     a.每趟排序，最大沉底;
     b.排列元素个数逐渐（从尾）减一，因为每趟排序，最后一位已确定；
     c.每次冒泡序列：0 ~ i-1
     TimeCost：O(N^2)
     SpaceCost：O(N)
     

     

    代码：
     

    void BubbleSort(int[] nums){
	int i,j;

	for(i=nums.length; i>0; i--){
		for(j=0; j<i; j++){
			if(nums[j] > nums[j+1])
				swap(nums[j], nums[j+1]);
		}
	}
}

     

    （2）快速排序（划分排序、基准位排序）
     

     
 
    a. 思想：基准位排序，每趟划分找出基准位，基准位左边小于它，基准位右边大于它；
     

     

     
 
    b. 递归操作
     递归原子操作：分别划分基准位左边序列(left，k-1) 和基准位右边序列（k+1，right）；
     递归判定条件：最小划分为单个元素，基准位为单个元素，此时left == right，所以判定条件为left < right；
     

     

     
 
    c. 复杂度分析
     Time Complexity：共(logN)趟划分，每趟划分耗时(O(N)),共耗时O(NlogN)，所以O(NlogN)；
     Space Complexity：递归栈深度为N, 所以O(N)；
     

     

    代码：
     

    /*启动函数*/
void StartQuickSort(int[] nums){
	QuickSort(nums, 0, nums.length);
}

/*快排函数*/
void QuickSort(int[] nums, int left, int right){
	int k = 0;
	if(left < right){
		k = Partition(nums, left, right);
		QuickSort(nums, left, k-1);
		QuickSort(nums, k+1, right);
	}
}

/*划分函数, 返回基准元素*/
int Partition(int[] nums, int left, int right){
	int pivot = left;
	while(left < right){
		while(nums[left] < nums[k]) left++;

		while(nums[right] > nums[k]) right++;

		if(left < right)
			swap(nums[left], nums[right]);
	}
	swap(nums[pivot], nums[right]);

	return right;
}

     

    类型二、选择排序
     

     
 
    （3） 简单选择排序：
     a.每趟从已知序列中找出最小值，与首元素交换；
     b.排列元素个数逐渐（从头）减一，因为每趟排序，首位已确定；
     c.每次选择序列：i ~ len；
     TimeCost：O(N^2)
     SpaceCost：O(N)
     

     

    代码：
     

    void SelectSort(int[] nums){
	int i,j,min;

	for(i = 0; i<nums.length; i++){
		for(j = i, j<nums.length;j++){
			min = nums[j];
			if(nums[j] < min)
				min = nums[j]
		}
		swap(num[i], min);
	}
}

     

     
 
    （4）堆排序：
     利用小顶堆，每次输出堆顶值（最小值）；
     TimeCost：O(NlogN)
     SpaceCost：O(N)
     

     

    类型三、插入排序
     

     
 
    （5）直接插入排序：
     a. 以首元素为有序序列，后面元素依次插入有序序列；
     b. 每次插入序列：0 ~ i；
     TimeCost：O(N^2)
     SpaceCost：O(N)
     

     

    代码：
     

    void InsertSort(int[] nums){
	int i,j;

	for(i = 1; i<nums.length; i++){
		for(j = 0; j<i; j++){
			if(nums[j] > nums[j+1])
				swap(nums[j], nums[j+1]);
		}
	}
}

     

     
 
    （6）希尔排序
     

     

    类型四、合并排序
     

    （7）合并排序
     在这里插入图片描述
     

     
 
    a. 思想：
     先分裂，再合并；
     合并两个有序序列，最小的有序序列为单个；
     

     

     
 
    b. 递归操作
     递归原子操作：合并(left, mid)和(mid+1, right)两个有序序列
     递归判定条件：取决于原子操作，单个有序序列只有一个元素，left和right相等，即可返回，所以判定条件为 left < right；
     

     

     
 
    c. 复杂度分析
     Time Complexity：O(NlogN)
     Space Complexity：O(N)
     

     

    代码：
     

        int[] sort(int[] nums, int low, int high) {
        int mid = (low + high) / 2;
        if (low < high) {
            // 左边分裂
            sort(nums, low, mid);
            // 右边分裂
            sort(nums, mid + 1, high);
            // 左右归并
            merge(nums, low, mid, high);
        }
        return nums;
    }

    void merge(int[] nums, int low, int mid, int high) {
        int[] temp = new int[high - low + 1];
        int i = low;		// 左指针
        int j = mid + 1;	// 右指针
        int k = 0;

        // 把较小的数先移到新数组中
        while (i <= mid && j <= high) {
            if (nums[i] < nums[j]) {
                temp[k++] = nums[i++];
            } else {
                temp[k++] = nums[j++];
            }
        }

        // 把左边剩余的数移入数组
        while (i <= mid) {
            temp[k++] = nums[i++];
        }

        // 把右边边剩余的数移入数组
        while (j <= high) {
            temp[k++] = nums[j++];
        }

        // 把新数组中的数，覆盖部分nums数组
        for (int k2 = 0; k2 < temp.length; k2++) {
            nums[k2 + low] = temp[k2];
        }
    }

     

    类型五、基数排序（桶排序）
     

     
 
    （8）基数排序
    收起
    展开全文
    数据结构 算法

  • 排序算法，对内存小数据量大的数据排序(一)

     千次阅读 2018-08-22 16:59:04
    问题描述 百度面试题： 搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。 假设目前有一千万个记录（这些查询串的重复度比较高，...外部排序指的是大文件的排序... 
    问题描述 
     百度面试题： 
     搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。 
     假设目前有一千万个记录（这些查询串的重复度比较高，虽然总数是1千万，但如果除去重复后，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门。），请你统计最热门的10个查询串，要求使用的内存不能超过1G。
     

    外部排序指的是大文件的排序，即待排序的记录存储在外存储器上，待排序的文件无法一次装入内存，需要在内存和外部存储器之间进行多次数据交换，以达到排序整个文件的目的。 
     排序是计算机程序设计中的一种重要操作，它的功能是将任意序列的数据元素或记录重新按关键字顺序排列成有序的序列。 有序序列为记录的查找、插入和删除提供了方便，可以有效提高搜索效率。因此，研究各类排序方法是计算机研究中的重要课题之一。根据待排序记录数量及其在排序过程中涉及的存储器，可将排序方法分为两大类: 一类是内部排序, 指的是待排序记录存放在计算机存储器中进行的排序过程；另一类是外部排序, 指的是待排序记录的数量很大，以至于内存一次不能容纳全部记录，在排序过程中尚需对外存进行访问的排序过程。 [1] 
     外部排序指的是大文件的排序，当待排序的文件很大时，无法将整个文件的所有记录同时调入内存进行排序，只能将文件存放在外存，这种排称为外部排序。外部排序的过程主要是依据数据的内外存交换和“内部归并”两者结合起来实现的。
     

    一般提到排序都是指内排序，比如快速排序，堆排序，归并排序等，所谓内排序就是可以在内存中完成的排序。RAM的访问速度大约是磁盘的25万倍，我们当然希望如果可以的话都是内排来完成。但对于大数据集来说，内存是远远不够的，这时候就涉及到外排序的知识了。 [2] 
     外部排序最常用的算法是多路归并排序，即将原文件分解成多个能够一次性装入内存的部分分别把每一部分调入内存完成排序。然后，对已经排序的子文件进行归并排序。
     

    第一步：Query统计 
     Query统计有以下俩个方法，可供选择： 
     1、直接排序法 
     首先我们最先想到的的算法就是排序了，首先对这个日志里面的所有Query都进行排序，然后再遍历排好序的Query，统计每个Query出现的次数了。
     

    但是题目中有明确要求，那就是内存不能超过1G，一千万条记录，每条记录是255Byte，很显然要占据2.375G内存，这个条件就不满足要求了。

让我们回忆一下数据结构课程上的内容，当数据量比较大而且内存无法装下的时候，我们可以采用外排序的方法来进行排序，这里我们可以采用归并排序，因为归并排序有一个比较好的时间复杂度O(NlgN)。

排完序之后我们再对已经有序的Query文件进行遍历，统计每个Query出现的次数，再次写入文件中。

综合分析一下，排序的时间复杂度是O(NlgN)，而遍历的时间复杂度是O(N)，因此该算法的总体时间复杂度就是O(N+NlgN)=O（NlgN）。

     

    2、Hash Table法 
     在第1个方法中，我们采用了排序的办法来统计每个Query出现的次数，时间复杂度是NlgN，那么能不能有更好的方法来存储，而时间复杂度更低呢？
     

    题目中说明了，虽然有一千万个Query，但是由于重复度比较高，因此事实上只有300万的Query，每个Query255Byte，因此我们可以考虑把他们都放进内存中去，而现在只是需要一个合适的数据结构，在这里，Hash Table绝对是我们优先的选择，因为Hash Table的查询速度非常的快，几乎是O(1)的时间复杂度。

那么，我们的算法就有了：维护一个Key为Query字串，Value为该Query出现次数的HashTable，每次读取一个Query，如果该字串不在Table中，那么加入该字串，并且将Value值设为1；如果该字串在Table中，那么将该字串的计数加一即可。最终我们在O(N)的时间复杂度内完成了对该海量数据的处理。

本方法相比算法1：在时间复杂度上提高了一个数量级，为O（N），但不仅仅是时间复杂度上的优化，该方法只需要IO数据文件一次，而算法1的IO次数较多的，因此该算法2比算法1在工程上有更好的可操作性。

     

    数组的特点是：寻址容易，插入和删除困难；而链表的特点是：寻址困难，插入和删除容易。那么我们能不能综合两者的特性，做出一种寻址容易，插入删除也容易的数据结构？答案是肯定的，这就是我们要提起的哈希表，哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法——拉链法，我们可以理解为“链表的数组”
    收起
    展开全文
    算法 hash

  • Java知识体系最强总结(2021版)

     万次阅读 多人点赞 2019-12-18 10:09:56
    基础知识 并发理论 并发关键字 Lock体系 并发容器 线程池 原子操作类 并发工具 并发实践 数据结构与算法 数据结构 算法 排序算法 LeetCode 数据库 Oracle MySQL 数据库基础知识 数据类型 引擎 索引 三大范式 常用SQL... 
     
 
    更新于2021-08-13 22:55:12
     

     

    欢迎关注微信公众号【技术人成长之路】
     

    【技术人成长之路】，助力技术人成长！更多精彩文章第一时间在公众号发布哦！
     
     

    本人从事Java开发已多年，平时有记录问题解决方案和总结知识点的习惯，整理了一些有关Java的知识体系，这不是最终版，会不定期的更新。也算是记录自己在从事编程工作的成长足迹，通过博客可以促进博主与阅读者的共同进步，结交更多志同道合的朋友。特此分享给大家，本人见识有限，写的博客难免有错误或者疏忽的地方，还望各位大佬指点，在此表示感激不尽。
     

    整理的Java知识体系主要包括基础知识，工具，并发编程，数据结构与算法，数据库，JVM，架构设计，应用框架，中间件，微服务架构，分布式架构，程序员的一些思考，团队与项目管理，运维，权限，推荐书籍，云计算，区块链等，包含了作为一个Java工程师在开发工作学习中需要用到或者可能用到的绝大部分知识。千里之行始于足下，希望大家根据自己的薄弱点，查缺补漏，根据自己感兴趣的方面多学习，学的精通一点，从现在开始行动起来。路漫漫其修远兮，吾将上下而求索，不管编程开发的路有多么难走，多么艰辛，我们都将百折不挠，不遗余力地去追求和探索。
     

     

    

    
 
    文章目录
    
 

    

     

    Java面试总结
     

    Java面试总结汇总，整理了包括Java基础知识，集合容器，并发编程，JVM，常用开源框架Spring，MyBatis，数据库，中间件等，包含了作为一个Java工程师在面试中需要用到或者可能用到的绝大部分知识。欢迎大家阅读，本人见识有限，写的博客难免有错误或者疏忽的地方，还望各位大佬指点，在此表示感激不尽。文章持续更新中…
     

    序号内容链接地址
    1Java基础知识面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104390612
    2Java集合容器面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104588551
    3Java异常面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104390689
    4并发编程面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104863992
    5JVM面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104390752
    6Spring面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104397516
    7Spring MVC面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104397427
    8Spring Boot面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104397299
    9Spring Cloud面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104397367
    10MyBatis面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/101292950
    11Redis面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/103522351
    12MySQL数据库面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104778621
    13消息中间件MQ与RabbitMQ面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104588612
    14Dubbo面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104390006
    15Linux面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104588679
    16Tomcat面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104397665
    17ZooKeeper面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104397719
    18Netty面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/104391081
    19架构设计&分布式&数据结构与算法面试题（2020最新版）https://thinkwon.blog.csdn.net/article/details/105870730
    

    基础知识
     

    Java概述
     

    序号内容链接地址
    1Java简介https://thinkwon.blog.csdn.net/article/details/94353575
    2Java发展历程https://thinkwon.blog.csdn.net/article/details/94353653
    3Java语言特点https://thinkwon.blog.csdn.net/article/details/94354013
    4JDK安装与环境变量配置https://thinkwon.blog.csdn.net/article/details/94353907
    5JVM、JRE和JDK的关系https://thinkwon.blog.csdn.net/article/details/101369973
    6Java是编译型还是解释型语言https://thinkwon.blog.csdn.net/article/details/108678327
    

    基础语法
     

    大部分已完成
     

    待整理：
     

    Java开发必会的反编译知识（附支持对Lambda进行反编译的工具）
     

    一文读懂什么是Java中的自动拆装箱
     

    Java的枚举类型用法介绍
     

    类、枚举、接口、数组、可变参数
     

    泛型、序列化
     

    序号内容链接地址
    1Java标识符https://thinkwon.blog.csdn.net/article/details/101637454
    2Java关键字(Java 8版本)https://thinkwon.blog.csdn.net/article/details/101642385
    3Java注释https://thinkwon.blog.csdn.net/article/details/101643185
    4Java访问修饰符https://thinkwon.blog.csdn.net/article/details/101643412
    5Java分隔符https://thinkwon.blog.csdn.net/article/details/101643617
    6Java转义字符https://thinkwon.blog.csdn.net/article/details/101643769
    7Java进制https://thinkwon.blog.csdn.net/article/details/101643936
    8Java流程控制语句https://thinkwon.blog.csdn.net/article/details/101645978
    9Java流程控制语句-顺序结构https://thinkwon.blog.csdn.net/article/details/101644820
    10Java流程控制语句-分支结构https://thinkwon.blog.csdn.net/article/details/101645224
    11Java流程控制语句-循环结构https://thinkwon.blog.csdn.net/article/details/101645757
    12Java表达式https://thinkwon.blog.csdn.net/article/details/101648114
    13Java运算符https://thinkwon.blog.csdn.net/article/details/101649002
    14Java变量https://thinkwon.blog.csdn.net/article/details/101649292
    15Java常量https://thinkwon.blog.csdn.net/article/details/101649446
    16Java数据类型https://thinkwon.blog.csdn.net/article/details/101649568
    17Java反射https://thinkwon.blog.csdn.net/article/details/100128361
    18Java语法糖https://thinkwon.blog.csdn.net/article/details/100103689
    19Java注解https://thinkwon.blog.csdn.net/article/details/100178709
    20JSON简介https://thinkwon.blog.csdn.net/article/details/100642585
    21Properties类简介https://thinkwon.blog.csdn.net/article/details/100667783
    22XML简介https://thinkwon.blog.csdn.net/article/details/100642425
    23YML简介https://thinkwon.blog.csdn.net/article/details/100642870
    24Java8新特性-Lambda表达式https://thinkwon.blog.csdn.net/article/details/100642932
    25Java基础语法https://thinkwon.blog.csdn.net/article/details/94354151
    

    面向对象
     

    待整理：
     

    抽象
     

    继承、封装、多态
     

    接口、抽象类、内部类
     

    序号内容链接地址
    1什么是面向对象https://thinkwon.blog.csdn.net/article/details/100667386
    

    集合框架
     

    迭代器、增强for、泛型
     

    序号内容链接地址
    1Java集合框架总结https://thinkwon.blog.csdn.net/article/details/98844796
    2ArrayList(JDK1.8)源码解析https://thinkwon.blog.csdn.net/article/details/98845119
    3HashMap(JDK1.8)源码解析https://thinkwon.blog.csdn.net/article/details/98845487
    4LinkedHashMap(JDK1.8)源码解析https://thinkwon.blog.csdn.net/article/details/102574293
    5LinkedList(JDK1.8)源码解析https://thinkwon.blog.csdn.net/article/details/102573923
    6TreeMap(JDK1.8)源码解析https://thinkwon.blog.csdn.net/article/details/102571883
    

    IO流
     

    待整理：
     

    File、递归
     

    字节流、字节缓冲流
     

    编码表、编码方式、转换流、序列化、序列化流、打印流、commons-io
     

    网络编程
     

    网络概述、网络模型
     

    Socket原理机制
     

    UDP
     

    TCP/IP
     

    协议、OSI 七层协议、HTTP、HTTP2.0、HTTPS
     

    网络安全
     

    ​ XSS、CSRF、SQL注入、Hash Dos、脚本注入、漏洞扫描工具、验证码
     

    ​ DDoS防范、用户隐私信息保护、序列化漏洞
     

    ​ 加密解密、对称加密、哈希算法、非对称加密
     

    ​ 服务安全、数据安全、数据备份
     

    ​ 网络隔离、登录跳板机、非外网分离
     

    ​ 认证、授权
     

    常用API
     

    String、StringBuffer、StringBuilder、正则表达式
     

    Number、Radom、Math、System、包装类
     

    Arrays、Collections
     

    日期时间API
     

    序号内容链接地址
    1Java7日期时间APIhttps://thinkwon.blog.csdn.net/article/details/110777654
    2史上最全Java7日期时间工具类https://thinkwon.blog.csdn.net/article/details/110779441
    3Java8日期时间APIhttps://thinkwon.blog.csdn.net/article/details/111087199
    4史上最全Java8日期时间工具类https://thinkwon.blog.csdn.net/article/details/111116600
    

    常用工具类库
     

    待整理：OkHttp、commons-lang3
     

    序号内容链接地址
    1HttpClient工具类https://thinkwon.blog.csdn.net/article/details/101391489
    2WGS84地球坐标系，GCJ02火星坐标系，BD09百度坐标系简介与转换https://thinkwon.blog.csdn.net/article/details/101392187
    3Lombok简介、使用、工作原理、优缺点https://thinkwon.blog.csdn.net/article/details/101392808
    4Java几种常用JSON库性能比较https://thinkwon.blog.csdn.net/article/details/94354358
    

    单元测试
     

    JUnit
     

    异常
     

    序号内容链接地址
    1Java异常总结https://thinkwon.blog.csdn.net/article/details/94346911
    2Java异常架构与异常关键字https://thinkwon.blog.csdn.net/article/details/101676779
    3Java异常处理流程https://thinkwon.blog.csdn.net/article/details/101677638
    4如何选择异常类型https://thinkwon.blog.csdn.net/article/details/94346911
    5Java异常常见面试题https://thinkwon.blog.csdn.net/article/details/101681073
    6Java异常处理最佳实践https://thinkwon.blog.csdn.net/article/details/94347002
    

    日志
     

    序号内容链接地址
    1常用日志框架Log4j，Logback，Log4j2性能比较与日志门面SLF4J简介https://thinkwon.blog.csdn.net/article/details/101621135
    2日志作用https://thinkwon.blog.csdn.net/article/details/101619725
    3Apache Log4j2详解https://thinkwon.blog.csdn.net/article/details/95043111
    4Log4j2同步日志，混合日志和异步日志配置详解https://thinkwon.blog.csdn.net/article/details/101625124
    5Log4j2配置文件详解https://thinkwon.blog.csdn.net/article/details/101629302
    6Log4j2的Appenders配置详解https://thinkwon.blog.csdn.net/article/details/101625820
    7Log4j2的Filters配置详解https://thinkwon.blog.csdn.net/article/details/101627162
    8Log4j2的Policy触发策略与Strategy滚动策略配置详解https://thinkwon.blog.csdn.net/article/details/101628222
    9Log4j2的Loggers配置详解https://thinkwon.blog.csdn.net/article/details/101628736
    

    Java8新特性
     

    序号内容链接地址
    1Java8新特性-Lambda表达式https://thinkwon.blog.csdn.net/article/details/113764085
    2Java8新特性-Optionalhttps://thinkwon.blog.csdn.net/article/details/113791796
    3Java8新特性-Streamhttps://thinkwon.blog.csdn.net/article/details/113798096
    4Java8新特性-Base64https://thinkwon.blog.csdn.net/article/details/113798575
    5Java8新特性-日期时间APIhttps://thinkwon.blog.csdn.net/article/details/111087199
    

    工具
     

    IDEA
     

    序号内容链接地址
    1IDEA常用配置和常用插件https://thinkwon.blog.csdn.net/article/details/101020481
    2IDEA中Maven依赖下载失败解决方案https://thinkwon.blog.csdn.net/article/details/101312918
    3在IDEA中使用Linux命令https://thinkwon.blog.csdn.net/article/details/106320360
    

    Eclipse & STS
     

    序号内容链接地址
    1Eclipse & Spring Tool Suite常用配置https://thinkwon.blog.csdn.net/article/details/101025543
    

    Maven
     

    序号内容链接地址
    1Maven简介https://thinkwon.blog.csdn.net/article/details/94346090
    2Maven安装与配置https://thinkwon.blog.csdn.net/article/details/94346569
    3Maven依赖冲突https://thinkwon.blog.csdn.net/article/details/101483020
    4手动安装Maven依赖https://thinkwon.blog.csdn.net/article/details/101483478
    5Maven部署jar包到远程仓库https://thinkwon.blog.csdn.net/article/details/101483769
    6Maven私服Nexus安装与使用https://thinkwon.blog.csdn.net/article/details/94346681
    

    Docker
     

    序号内容链接地址
    1使用Docker安装GitLabhttps://thinkwon.blog.csdn.net/article/details/95042797
    2虚拟机和容器有什么不同https://thinkwon.blog.csdn.net/article/details/107476886
    3Docker 从入门到实践系列一 - 什么是Dockerhttps://thinkwon.blog.csdn.net/article/details/107477065
    4Docker 从入门到实践系列二 - Docker 安装https://thinkwon.blog.csdn.net/article/details/117638107
    5Docker 从入门到实践系列三 - Docker 常用命令https://thinkwon.blog.csdn.net/article/details/117638128
    6Docker 从入门到实践系列四 - Docker 容器编排利器 Docker Composehttps://thinkwon.blog.csdn.net/article/details/119511551
    

    Git
     

    序号内容链接地址
    1Git简介https://thinkwon.blog.csdn.net/article/details/94346816
    2版本控制https://thinkwon.blog.csdn.net/article/details/101449228
    3Git忽略文件.gitignore详解https://thinkwon.blog.csdn.net/article/details/101447866
    4Git与SVN的区别https://thinkwon.blog.csdn.net/article/details/101449611
    5常用Git命令https://thinkwon.blog.csdn.net/article/details/101450420
    6Git，GitHub与GitLab的区别https://thinkwon.blog.csdn.net/article/details/101470086
    

    GitLab
     

    GitKraken
     

    Navicat
     

    并发编程
     

    基础知识
     

    序号内容链接地址
    1并发编程的优缺点https://thinkwon.blog.csdn.net/article/details/102020811
    2线程的状态和基本操作https://thinkwon.blog.csdn.net/article/details/102027115
    3进程和线程的区别(超详细)https://thinkwon.blog.csdn.net/article/details/102021274
    4创建线程的四种方式https://thinkwon.blog.csdn.net/article/details/102021143
    

    并发理论
     

    序号内容链接地址
    1Java内存模型https://thinkwon.blog.csdn.net/article/details/102073578
    2重排序与数据依赖性https://thinkwon.blog.csdn.net/article/details/102073858
    3as-if-serial规则和happens-before规则的区别https://thinkwon.blog.csdn.net/article/details/102074107
    4Java并发理论总结https://thinkwon.blog.csdn.net/article/details/102074440
    

    并发关键字
     

    序号内容链接地址
    1Java并发关键字-synchronizedhttps://thinkwon.blog.csdn.net/article/details/102243189
    2Java并发关键字-volatilehttps://thinkwon.blog.csdn.net/article/details/102243670
    3Java并发关键字-finalhttps://thinkwon.blog.csdn.net/article/details/102244477
    

    Lock体系
     

    待整理：
     

    公平锁 & 非公平锁
     

    乐观锁 & 悲观锁
     

    可重入锁 & 不可重入锁
     

    互斥锁 & 共享锁
     

    死锁
     

    序号内容链接地址
    1Lock简介与初识AQShttps://thinkwon.blog.csdn.net/article/details/102468837
    2AQS(AbstractQueuedSynchronizer)详解与源码分析https://thinkwon.blog.csdn.net/article/details/102469112
    3ReentrantLock(重入锁)实现原理与公平锁非公平锁区别https://thinkwon.blog.csdn.net/article/details/102469388
    4读写锁ReentrantReadWriteLock源码分析https://thinkwon.blog.csdn.net/article/details/102469598
    5Condition源码分析与等待通知机制https://thinkwon.blog.csdn.net/article/details/102469889
    6LockSupport详解https://thinkwon.blog.csdn.net/article/details/102469993
    

    并发容器
     

    序号内容链接地址
    1并发容器之ConcurrentHashMap详解(JDK1.8版本)与源码分析https://thinkwon.blog.csdn.net/article/details/102506447
    2并发容器之ConcurrentLinkedQueue详解与源码分析https://thinkwon.blog.csdn.net/article/details/102508089
    3并发容器之CopyOnWriteArrayList详解https://thinkwon.blog.csdn.net/article/details/102508258
    4并发容器之ThreadLocal详解https://thinkwon.blog.csdn.net/article/details/102508381
    5ThreadLocal内存泄漏分析与解决方案https://thinkwon.blog.csdn.net/article/details/102508721
    6并发容器之BlockingQueue详解https://thinkwon.blog.csdn.net/article/details/102508901
    7并发容器之ArrayBlockingQueue与LinkedBlockingQueue详解https://thinkwon.blog.csdn.net/article/details/102508971
    

    线程池
     

    序号内容链接地址
    1线程池ThreadPoolExecutor详解https://thinkwon.blog.csdn.net/article/details/102541900
    2Executors类创建四种常见线程池https://thinkwon.blog.csdn.net/article/details/102541990
    3线程池之ScheduledThreadPoolExecutor详解https://thinkwon.blog.csdn.net/article/details/102542299
    4FutureTask详解https://thinkwon.blog.csdn.net/article/details/102542404
    

    原子操作类
     

    序号内容链接地址
    1原子操作类总结https://thinkwon.blog.csdn.net/article/details/102556910
    

    并发工具
     

    序号内容链接地址
    1并发工具之CountDownLatch与CyclicBarrierhttps://thinkwon.blog.csdn.net/article/details/102556958
    2并发工具之Semaphore与Exchangerhttps://thinkwon.blog.csdn.net/article/details/102557034
    

    并发实践
     

    序号内容链接地址
    1实现生产者消费者的三种方式https://thinkwon.blog.csdn.net/article/details/102557126
    

    数据结构与算法
     

    数据结构
     

    序号内容链接地址
    1红黑树详细分析(图文详解)，看了都说好https://thinkwon.blog.csdn.net/article/details/102571535
    

    1、数组
2、栈
3、队列
4、链表
5、树
	二叉树
    完全二叉树
    平衡二叉树
    二叉查找树（BST）
    红黑树
    B，B+，B*树
    LSM 树

字段是不是数据结构

     

    算法
     

    语言只是编程工具，算法才是编程之魂！
     

    1、排序算法：快速排序、归并排序、计数排序
2、搜索算法：回溯、递归、剪枝
3、图论：最短路径、最小生成树、网络流建模
4、动态规划：背包问题、最长子序列、计数问题
5、基础技巧：分治、倍增、二分法、贪心算法

宽度优先搜索
深度优先搜索
广度优先
双指针
扫描线

朴素贝叶斯
推荐算法

     

    排序算法
     

    序号内容链接地址
    1史上最全经典排序算法总结(Java实现)https://thinkwon.blog.csdn.net/article/details/95616819
    2冒泡排序（Bubble Sort）https://thinkwon.blog.csdn.net/article/details/101534473
    3选择排序（Selection Sort）https://thinkwon.blog.csdn.net/article/details/101534721
    4插入排序（Insertion Sort）https://thinkwon.blog.csdn.net/article/details/101537804
    5希尔排序（Shell Sort）https://thinkwon.blog.csdn.net/article/details/101538166
    6归并排序（Merge Sort）https://thinkwon.blog.csdn.net/article/details/101538756
    7快速排序（Quick Sort）https://thinkwon.blog.csdn.net/article/details/101543580
    8堆排序（Heap Sort）https://thinkwon.blog.csdn.net/article/details/101543941
    9计数排序（Counting Sort）https://thinkwon.blog.csdn.net/article/details/101544159
    10桶排序（Bucket Sort）https://thinkwon.blog.csdn.net/article/details/101544356
    11基数排序（Radix Sort）https://thinkwon.blog.csdn.net/article/details/101545529
    

    LeetCode
     

    序号内容链接地址
    1LeetCode第1题 两数之和(Two Sum)https://thinkwon.blog.csdn.net/article/details/103113049
    2LeetCode第3题 无重复字符的最长子串(Longest Substring Without Repeating Characters)https://thinkwon.blog.csdn.net/article/details/103113969
    3LeetCode第7题 整数反转(Reverse Integer)https://thinkwon.blog.csdn.net/article/details/103113167
    4LeetCode第9题 回文数(Palindrome Number)https://thinkwon.blog.csdn.net/article/details/103113151
    5LeetCode第13题 罗马数字转整数(Roman to Integer)https://thinkwon.blog.csdn.net/article/details/103113519
    6LeetCode第14题 最长公共前缀(Longest Common Prefix)https://thinkwon.blog.csdn.net/article/details/103113700
    7LeetCode第20题 有效的括号(Valid Parentheses)https://thinkwon.blog.csdn.net/article/details/103113848
    8LeetCode第26题 删除排序数组中的重复项(Remove Duplicates from Sorted Array)https://thinkwon.blog.csdn.net/article/details/103113097
    

    数据库
     

    Oracle
     

    MySQL
     

    数据库基础知识
     

    序号内容链接地址
    1MySQL语句分类https://thinkwon.blog.csdn.net/article/details/106610851
    2MySQL插入语句insert into,insert ignore into,insert into … on duplicate key update,replace into-解决唯一键约束https://thinkwon.blog.csdn.net/article/details/106610789
    3MySQL复制表的三种方式https://thinkwon.blog.csdn.net/article/details/106610810
    4MySQL删除表的三种方式https://thinkwon.blog.csdn.net/article/details/106610831
    5MySQL中count(字段) ，count(主键 id) ，count(1)和count(*)的区别https://thinkwon.blog.csdn.net/article/details/106610859
    

    数据类型
     

    引擎
     

    索引
     

    三大范式
     

    常用SQL语句
     

    存储过程与函数
     

    视图
     

    MySQL优化
     

    事务
     

    数据备份与还原
     

    Redis
     

    序号内容链接地址
    1Redis总结https://thinkwon.blog.csdn.net/article/details/99999584
    2Redis使用场景https://thinkwon.blog.csdn.net/article/details/101521497
    3Redis数据类型https://thinkwon.blog.csdn.net/article/details/101521724
    4Redis持久化https://thinkwon.blog.csdn.net/article/details/101522209
    5Redis过期键的删除策略https://thinkwon.blog.csdn.net/article/details/101522970
    6Redis数据淘汰策略https://thinkwon.blog.csdn.net/article/details/101530624
    7Redis与Memcached的区别https://thinkwon.blog.csdn.net/article/details/101530406
    8Redis常见面试题(精简版)https://thinkwon.blog.csdn.net/article/details/103522351
    9Redis中缓存雪崩、缓存穿透等问题的解决方案https://thinkwon.blog.csdn.net/article/details/103402008
    10阿里云Redis开发规范学习总结https://thinkwon.blog.csdn.net/article/details/103400250
    11Redis开发常用规范https://thinkwon.blog.csdn.net/article/details/103401781
    12这可能是最中肯的Redis规范了https://thinkwon.blog.csdn.net/article/details/103401978
    

    Java虚拟机
     

    深入理解Java虚拟机
     

    序号内容链接地址
    1深入理解Java虚拟机-走近Javahttps://thinkwon.blog.csdn.net/article/details/103804387
    2深入理解Java虚拟机-Java内存区域与内存溢出异常https://thinkwon.blog.csdn.net/article/details/103827387
    3深入理解Java虚拟机-垃圾回收器与内存分配策略https://thinkwon.blog.csdn.net/article/details/103831676
    4深入理解Java虚拟机-虚拟机执行子系统https://thinkwon.blog.csdn.net/article/details/103835168
    5深入理解Java虚拟机-程序编译与代码优化https://thinkwon.blog.csdn.net/article/details/103835883
    6深入理解Java虚拟机-高效并发https://thinkwon.blog.csdn.net/article/details/103836167
    

    架构设计
     

    高可用架构
     

    高并发架构
     

    可伸缩架构
     

    集群
     

    设计模式
     

    常用设计模式
     

    创建型：
     单例模式、工厂模式、抽象工厂模式
     

    结构型：
     适配器模式、外观模式、代理模式、装饰器模式
     

    行为型：
     观察者模式、策略模式、模板模式
     

    序号内容链接地址
    1设计模式https://thinkwon.blog.csdn.net/article/details/96829572
    

    创建型模式
     

    序号内容链接地址
    1抽象工厂模式https://thinkwon.blog.csdn.net/article/details/101382584
    2单例模式https://thinkwon.blog.csdn.net/article/details/101382855
    3工厂模式https://thinkwon.blog.csdn.net/article/details/101383285
    4建造者模式https://thinkwon.blog.csdn.net/article/details/101383401
    5原型模式https://thinkwon.blog.csdn.net/article/details/101383491
    

    结构型模式
     

    序号内容链接地址
    1代理模式https://thinkwon.blog.csdn.net/article/details/101384436
    2过滤器模式https://thinkwon.blog.csdn.net/article/details/101384514
    3桥接模式https://thinkwon.blog.csdn.net/article/details/101384584
    4适配器模式https://thinkwon.blog.csdn.net/article/details/101384619
    5外观模式https://thinkwon.blog.csdn.net/article/details/101384676
    6享元模式https://thinkwon.blog.csdn.net/article/details/101384716
    7装饰器模式https://thinkwon.blog.csdn.net/article/details/101384753
    8组合模式https://thinkwon.blog.csdn.net/article/details/101384786
    

    行为型模式
     

    序号内容链接地址
    1备忘录模式https://thinkwon.blog.csdn.net/article/details/101383582
    2策略模式https://thinkwon.blog.csdn.net/article/details/101383647
    3迭代器模式https://thinkwon.blog.csdn.net/article/details/101383722
    4访问者模式https://thinkwon.blog.csdn.net/article/details/101383780
    5观察者模式https://thinkwon.blog.csdn.net/article/details/101383872
    6解释器模式https://thinkwon.blog.csdn.net/article/details/101383930
    7空对象模式https://thinkwon.blog.csdn.net/article/details/101384001
    8命令模式https://thinkwon.blog.csdn.net/article/details/101384090
    9模板模式https://thinkwon.blog.csdn.net/article/details/101384138
    10责任链模式https://thinkwon.blog.csdn.net/article/details/101384195
    11中介者模式https://thinkwon.blog.csdn.net/article/details/101384251
    12状态模式https://thinkwon.blog.csdn.net/article/details/101384315
    

    J2EE模式
     

    序号内容链接地址
    1MVC模式https://thinkwon.blog.csdn.net/article/details/101381701
    2传输对象模式https://thinkwon.blog.csdn.net/article/details/101382134
    3服务定位器模式https://thinkwon.blog.csdn.net/article/details/101382179
    4拦截过滤器模式https://thinkwon.blog.csdn.net/article/details/101382210
    5前端控制器模式https://thinkwon.blog.csdn.net/article/details/101382247
    6数据访问对象模式https://thinkwon.blog.csdn.net/article/details/101382287
    7业务代表模式https://thinkwon.blog.csdn.net/article/details/101382356
    8组合实体模式https://thinkwon.blog.csdn.net/article/details/101382390
    

    实践应用
     

    序号内容链接地址
    1业务复杂=if else？刚来的大神竟然用策略+工厂彻底干掉了他们！https://thinkwon.blog.csdn.net/article/details/102924813
    

    应用框架
     

    如何学习一个框架或者技术
     

    •  
      是什么，简介，概述
       
    •  
      有什么用，用途，使用场景
       
    •  
      怎么用，在实际开发中的应用，注意事项
       
    •  
      优缺点
       
    •  
      框架原理，工作流程，工作原理
       
    •  
      常见面试题
       
    •  
      源码分析，核心类，核心方法，设计模式
       
    •  
      发布博客，在开发和实践中，博客反馈中持续改进
       
    •  
      与同事朋友交流，技术论坛，技术分享中持续丰富知识
       
     

    常用框架
     

    •  
      集成开发工具（IDE）：Eclipse、MyEclipse、Spring Tool Suite（STS）、Intellij IDEA、NetBeans、JBuilder、JCreator
       
    •  
      JAVA服务器：tomcat、jboss、websphere、weblogic、resin、jetty、apusic、apache
       
    •  
      负载均衡：nginx、lvs
       
    •  
      web层框架：Spring MVC、Struts2、Struts1、Google Web Toolkit（GWT）、JQWEB
       
    •  
      服务层框架：Spring、EJB
       
    •  
      持久层框架：Hibernate、MyBatis、JPA、TopLink
       
    •  
      数据库：Oracle、MySql、MSSQL、Redis
       
    •  
      项目构建：maven、ant
       
    •  
      持续集成：Jenkins
       
    •  
      版本控制：SVN、CVS、VSS、GIT
       
    •  
      私服：Nexus
       
    •  
      消息组件：IBM MQ、RabbitMQ、ActiveMQ、RocketMq
       
    •  
      日志框架：Commons Logging、log4j 、slf4j、IOC
       
    •  
      缓存框架：memcache、redis、ehcache、jboss cache
       
    •  
      RPC框架：Hessian、Dubbo
       
    •  
      规则引擎：Drools
       
    •  
      工作流：Activiti
       
    •  
      批处理：Spring Batch
       
    •  
      通用查询框架：Query DSL
       
    •  
      JAVA安全框架：shiro、Spring Security
       
    •  
      代码静态检查工具：FindBugs、PMD
       
    •  
      Linux操作系统：CentOS、Ubuntu、SUSE Linux、
       
    •  
      常用工具：PLSQL Developer（Oracle）、Navicat（MySql）、FileZilla（FTP）、Xshell（SSH）、putty（SSH）、SecureCRT（SSH）、jd-gui（反编译）
       
     

    Spring
     

    序号内容链接地址
    1Spring简介、设计理念、优缺点、应用场景https://thinkwon.blog.csdn.net/article/details/102810748
    2Spring模块组成(框架组成、整体架构、体系架构、体系结构)https://thinkwon.blog.csdn.net/article/details/102810819
    3Spring容器中bean的生命周期https://thinkwon.blog.csdn.net/article/details/102866432
    4控制反转(IoC)与依赖注入(DI)详解https://thinkwon.blog.csdn.net/article/details/102912332
    

    《Spring实战》读书笔记
     

    序号内容链接地址
    1《Spring实战》读书笔记-第1章 Spring之旅https://thinkwon.blog.csdn.net/article/details/103097364
    2《Spring实战》读书笔记-第2章 装配Beanhttps://thinkwon.blog.csdn.net/article/details/103527675
    3《Spring实战》读书笔记-第3章 高级装配https://thinkwon.blog.csdn.net/article/details/103536621
    4《Spring实战》读书笔记-第4章 面向切面的Springhttps://thinkwon.blog.csdn.net/article/details/103541166
    5《Spring实战》读书笔记-第5章 构建Spring Web应用程序https://thinkwon.blog.csdn.net/article/details/103550083
    6《Spring实战》读书笔记-第6章 渲染Web视图https://thinkwon.blog.csdn.net/article/details/103559672
    7《Spring实战》读书笔记-第7章 Spring MVC的高级技术https://thinkwon.blog.csdn.net/article/details/103562467
    

    Spring MVC
     

    MyBatis
     

    序号内容链接地址
    1MyBatis官方文档https://thinkwon.blog.csdn.net/article/details/100887995
    2MyBatis官方文档-简介https://thinkwon.blog.csdn.net/article/details/100887076
    3MyBatis官方文档-入门https://thinkwon.blog.csdn.net/article/details/100887176
    4MyBatis官方文档-XML 配置https://thinkwon.blog.csdn.net/article/details/100887349
    5MyBatis官方文档-XML 映射文件https://thinkwon.blog.csdn.net/article/details/100887478
    6MyBatis官方文档-动态 SQLhttps://thinkwon.blog.csdn.net/article/details/100887702
    7MyBatis官方文档-Java APIhttps://thinkwon.blog.csdn.net/article/details/100887746
    8MyBatis官方文档-SQL 语句构建器类https://thinkwon.blog.csdn.net/article/details/100887821
    9MyBatis官方文档-日志https://thinkwon.blog.csdn.net/article/details/100887951
    10MyBatis功能架构https://thinkwon.blog.csdn.net/article/details/101295025
    11MyBatis工作原理https://thinkwon.blog.csdn.net/article/details/101293609
    12MyBatis核心类https://thinkwon.blog.csdn.net/article/details/101293216
    13MyBatis面试宝典https://thinkwon.blog.csdn.net/article/details/101292950
    14MyBatis实现一对一，一对多关联查询https://thinkwon.blog.csdn.net/article/details/101322334
    15MyBatis缓存https://thinkwon.blog.csdn.net/article/details/101351212
    

    MyBatis 源码分析
     

    序号内容链接地址
    1MyBatis 源码分析 - MyBatis入门https://thinkwon.blog.csdn.net/article/details/114808852
    2MyBatis 源码分析 - 配置文件解析过程https://thinkwon.blog.csdn.net/article/details/114808962
    3MyBatis 源码分析 - 映射文件解析过程https://thinkwon.blog.csdn.net/article/details/115423167
    4MyBatis 源码分析 - SQL 的执行过程https://thinkwon.blog.csdn.net/article/details/115603376
    5MyBatis 源码分析 - 内置数据源https://thinkwon.blog.csdn.net/article/details/116331419
    6MyBatis 源码分析 - 缓存原理https://thinkwon.blog.csdn.net/article/details/116809942
    7MyBatis 源码分析 - 插件机制https://thinkwon.blog.csdn.net/article/details/116809961
    

    Quartz
     

    序号内容链接地址
    1Quartz简介https://thinkwon.blog.csdn.net/article/details/109936696
    

    Hibernate
     

    Shiro
     

    Spring Security
     

    Netty
     

    搜索引擎
     

    Lucene/Solr
     

    Elasticsearch
     

    ELK
     

    中间件
     

    消息中间件
     

    RabbitMQ
     

    RocketMQ
     

    ActiveMQ
     

    Kafka
     

    远程过程调用中间件
     

    Dubbo
     

    数据访问中间件
     

    Sharding JDBC
     

    MyCat
     

    Web应用服务器
     

    Tomcat
     

    待整理：Tomcat各组件作用 Tomcat集群 Tomcat面试题
     

    序号内容链接地址
    1Win10安装Tomcat服务器与配置环境变量https://thinkwon.blog.csdn.net/article/details/102622905
    2Linux(CentOS7)安装Tomcat与设置Tomcat为开机启动项https://thinkwon.blog.csdn.net/article/details/102717537
    3Tomcat与JDK版本对应关系，Tomcat各版本特性https://thinkwon.blog.csdn.net/article/details/102622738
    4Tomcat目录结构https://thinkwon.blog.csdn.net/article/details/102619466
    5Tomcat乱码与端口占用的解决方案https://thinkwon.blog.csdn.net/article/details/102622824
    6Tomcat系统架构与请求处理流程https://thinkwon.blog.csdn.net/article/details/102676442
    7史上最强Tomcat8性能优化https://thinkwon.blog.csdn.net/article/details/102744033
    

    Nginx
     

    缓存
     

    本地缓存
     

    客户端缓存
     

    服务端缓存
     

    ​ web缓存，Redis，Memcached，Ehcache
     

    其他
     

    Zookeeper
     

    微服务与分布式
     

    Spring Boot
     

    序号内容链接地址
    1application.yml与bootstrap.yml的区别https://thinkwon.blog.csdn.net/article/details/100007093
    2一分钟了解约定优于配置https://thinkwon.blog.csdn.net/article/details/101703815
    

    Spring Cloud
     

    序号内容链接地址
    1Spring Cloud入门-十分钟了解Spring Cloudhttps://thinkwon.blog.csdn.net/article/details/103715146
    2Spring Cloud入门-Eureka服务注册与发现(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103726655
    3Spring Cloud入门-Ribbon服务消费者(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103729080
    4Spring Cloud入门-Hystrix断路器(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103732497
    5Spring Cloud入门-Hystrix Dashboard与Turbine断路器监控(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103734664
    6Spring Cloud入门-OpenFeign服务消费者(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103735751
    7Spring Cloud入门-Zuul服务网关(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103738851
    8Spring Cloud入门-Config分布式配置中心(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103739628
    9Spring Cloud入门-Bus消息总线(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103753372
    10Spring Cloud入门-Sleuth服务链路跟踪(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103753896
    11Spring Cloud入门-Consul服务注册发现与配置中心(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103756139
    12Spring Cloud入门-Gateway服务网关(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103757927
    13Spring Cloud入门-Admin服务监控中心(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103758697
    14Spring Cloud入门-Oauth2授权的使用(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103761687
    15Spring Cloud入门-Oauth2授权之JWT集成(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103763364
    16Spring Cloud入门-Oauth2授权之基于JWT完成单点登录(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103766368
    17Spring Cloud入门-Nacos实现注册和配置中心(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103769680
    18Spring Cloud入门-Sentinel实现服务限流、熔断与降级(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103770879
    19Spring Cloud入门-Seata处理分布式事务问题(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103786102
    20Spring Cloud入门-汇总篇(Hoxton版本)https://thinkwon.blog.csdn.net/article/details/103786588
    

    服务注册发现
     

    服务配置
     

    负载均衡
     

    服务调用
     

    服务限流
     

    熔断降级
     

    网关路由
     

    服务权限
     

    链路追踪
     

    分布式事务
     

    分布式缓存
     

    分布式会话
     

    日志收集
     

    服务监控
     

    消息驱动
     

    数据处理流
     

    自动化测试与部署
     

    第三方支持
     

    分布式协调服务Zookeeper
     

    程序员的一些思考
     

    序号内容链接地址
    1程序员写个人技术博客的价值与意义https://thinkwon.blog.csdn.net/article/details/102980571
    2Java知识体系最强总结(2020版)https://thinkwon.blog.csdn.net/article/details/103592572
    3博客之星，有你的鼓励更精彩https://thinkwon.blog.csdn.net/article/details/112517796
    

    团队与项目管理
     

    需求调研
     

    项目管理
     

    序号内容链接地址
    1Worktile、Teambition与Tower项目管理软件对比https://thinkwon.blog.csdn.net/article/details/106064807
    

    代码管理
     

    文档管理
     

    序号内容链接地址
    1几款常见接口管理平台对比https://thinkwon.blog.csdn.net/article/details/106064883
    2Swagger2常用注解说明https://thinkwon.blog.csdn.net/article/details/107477801
    

    测试
     

    Python
     

    序号内容链接地址
    1Win10安装Python3.9https://thinkwon.blog.csdn.net/article/details/112411897
    2Anaconda安装https://thinkwon.blog.csdn.net/article/details/112412165
    3PyCharm2020.3.2安装https://thinkwon.blog.csdn.net/article/details/112412497
    4PyCharm常用配置和常用插件https://thinkwon.blog.csdn.net/article/details/112412783
    

    运维
     

    常规监控
     

    APM
     

    持续集成(CI/CD)：Jenkins，环境分离
     

    自动化运维：Ansible，puppet，chef
     

    测试：TDD 理论，单元测试，压力测试，全链路压测，A/B 、灰度、蓝绿测试
     

    虚拟化：KVM，Xen，OpenVZ
     

    容器技术：Docker
     

    云技术：OpenStack
     

    DevOps
     

    操作系统
     

    计算机操作系统
     

    计算机原理
     

    Linux
     

    CPU
     

    进程，线程，协程
     

    CentOS8
     

    序号内容链接地址
    1VMware Workstation Pro 16搭建CentOS8虚拟机集群https://thinkwon.blog.csdn.net/article/details/115058171
    2CentOS8安装Dockerhttps://thinkwon.blog.csdn.net/article/details/115056214
    3CentOS8搭建Nacos1.4.0集群https://thinkwon.blog.csdn.net/article/details/115056401
    4CentOS8安装GitLab13.7.2https://thinkwon.blog.csdn.net/article/details/115056528
    5CentOS8安装MySQL8https://thinkwon.blog.csdn.net/article/details/115055934
    

    推荐书籍
     

    序号内容链接地址
    1读书清单-计算机https://thinkwon.blog.csdn.net/article/details/108077754
    

    读书笔记
     

    序号内容链接地址
    1高效休息法-读书笔记https://thinkwon.blog.csdn.net/article/details/118638191
    2斯坦福高效睡眠法-读书笔记https://thinkwon.blog.csdn.net/article/details/108349844
    3高效能人士的七个习惯-读书笔记https://thinkwon.blog.csdn.net/article/details/108941111
    4富爸爸穷爸爸-读书笔记https://thinkwon.blog.csdn.net/article/details/109261723
    5如何阅读一本书-读书笔记https://thinkwon.blog.csdn.net/article/details/115422659
    6人性的弱点-读书笔记https://thinkwon.blog.csdn.net/article/details/116809824
    7麦肯锡极简工作法-读书笔记https://thinkwon.blog.csdn.net/article/details/118638191
    

    云计算
     

    IaaS、SaaS、PaaS、虚拟化技术、openstack、Serverlsess
     

    搜索引擎
     

    Solr、Lucene、Nutch、Elasticsearch
     

    权限管理
     

    Shiro、Spring Security
     

    区块链
     

    哈希算法、Merkle树、公钥密码算法、共识算法、Raft协议、Paxos 算法与 Raft 算法、拜占庭问题与算法、消息认证码与数字签名
    收起
    展开全文
    Java基础知识 并发编程 数据结构与算法 数据库 JVM

  • MySQL 面试题

     万次阅读 多人点赞 2019-09-02 16:03:33
    但后者在排序时会消耗更多内存，因为 ORDER BY col 采用 fixed_length 计算 col 长度(memory引擎也一样) 。所以，实际场景下，选择合适的 varchar 长度还是有必要的。 ? int(11) 中的 11 代表什么涵义？ int... 
    MySQL 面试题
     

    MySQL 涉及的内容非常非常非常多，所以面试题也容易写的杂乱。当年，我们记着几个一定要掌握的重心：
     

     
 
    重点的题目添加了【重点】前缀。
     

     

    1. 索引。
    2. 锁。
    3. 事务和隔离级别。
     

    因为 MySQL 还会有部分内容和运维相关度比较高，所以本文我们分成两部分【开发】【运维】两部分。
     

    • 对于【开发】部分，我们需要掌握。
    • 对于【运维】部分，更多考验开发的知识储备情况，当然能回答出来是比较好的，特别是对于高级开发工程师、架构师等。
     

    开发
     

    为什么互联网公司一般选择 MySQL 而不是 Oracle?
     

    免费、流行、够用。
     

    ? 当然，这个回答要稍微润色下。不过一般，很少问这个问题了。
     

    数据库的三范式是什么？什么是反模式？
     

     
 
    艿艿：重点在于反模式的回答。实际开发中，不会严格遵守三范式。
     

     

    胖友直接看 《服务端指南 数据存储篇 | MySQL（07） 范式与反模式》 。
     

    MySQL 有哪些数据类型？
     

    MySQL 支持多种类型，大致可以分为三类：数值、日期/时间和字符串(字符)类型。具体可以看看 《MySQL 数据类型》 文档。
     

    • 正确的使用数据类型，对数据库的优化是非常重要的。
     

    ? MySQL 中 varchar 与 char 的区别？varchar(50) 中的 50 代表的涵义？
     

    • 1、varchar 与 char 的区别，char 是一种固定长度的类型，varchar 则是一种可变长度的类型。
    • 2、varchar(50) 中 50 的涵义最多存放 50 个字符。varchar(50) 和 (200) 存储 hello 所占空间一样，但后者在排序时会消耗更多内存，因为 ORDER BY col 采用 fixed_length 计算 col 长度(memory引擎也一样)。所以，实际场景下，选择合适的 varchar 长度还是有必要的。
     

    ? int(11) 中的 11 代表什么涵义？
     

    int(11) 中的 11 ，不影响字段存储的范围，只影响展示效果。具体可以看看 《MySQL 中 int 长度的意义》 文章。
     

    ? 金额(金钱)相关的数据，选择什么数据类型？
     

    • 方式一，使用 int 或者 bigint 类型。如果需要存储到分的维度，需要 *100 进行放大。
    • 方式二，使用 decimal 类型，避免精度丢失。如果使用 Java 语言时，需要使用 BigDecimal 进行对应。
     

    ? 一张表，里面有 ID 自增主键，当 insert 了 17 条记录之后，删除了第 15,16,17 条记录，再把 MySQL 重启，再 insert 一条记录，这条记录的 ID 是 18 还是 15？
     

    • 一般情况下，我们创建的表的类型是 InnoDB ，如果新增一条记录（不重启 MySQL 的情况下），这条记录的 ID 是18 ；但是如果重启 MySQL 的话，这条记录的 ID 是 15 。因为 InnoDB 表只把自增主键的最大 ID 记录到内存中，所以重启数据库或者对表 OPTIMIZE 操作，都会使最大 ID 丢失。
    • 但是，如果我们使用表的类型是 MyISAM ，那么这条记录的 ID 就是 18 。因为 MyISAM 表会把自增主键的最大 ID 记录到数据文件里面，重启 MYSQL 后，自增主键的最大 ID 也不会丢失。
     

    最后，还可以跟面试官装个 x ，生产数据，不建议进行物理删除记录。
     

    ? 表中有大字段 X(例如：text 类型)，且字段 X 不会经常更新，以读为为主，请问您是选择拆成子表，还是继续放一起?写出您这样选择的理由
     

    •  
      拆带来的问题：连接消耗 + 存储拆分空间。
       
  
       
   
      如果能容忍拆分带来的空间问题，拆的话最好和经常要查询的表的主键在物理结构上放置在一起(分区) 顺序 IO ，减少连接消耗，最后这是一个文本列再加上一个全文索引来尽量抵消连接消耗。
       
  
       
    •  
      不拆可能带来的问题：查询性能。
       
  
       
   
      如果能容忍不拆分带来的查询性能损失的话，上面的方案在某个极致条件下肯定会出现问题，那么不拆就是最好的选择。
       
  
       
     

    实际场景下，例如说商品表数据量比较大的情况下，会将商品描述单独存储到一个表中。即，使用拆的方案。
     

    MySQL 有哪些存储引擎？
     

    MySQL 提供了多种的存储引擎：
     

    • InnoDB
    • MyISAM
    • MRG_MYISAM
    • MEMORY
    • CSV
    • ARCHIVE
    • BLACKHOLE
    • PERFORMANCE_SCHEMA
    • FEDERATED
    • …
     

    具体每种存储引擎的介绍，可以看看 《数据库存储引擎》 。
     

    ? 如何选择合适的存储引擎？
     

    提供几个选择标准，然后按照标准，选择对应的存储引擎即可，也可以根据 常用引擎对比 来选择你使用的存储引擎。使用哪种引擎需要根据需求灵活选择，一个数据库中多个表可以使用不同的引擎以满足各种性能和实际需求。使用合适的存储引擎，将会提高整个数据库的性能。
     

    1.  
      是否需要支持事务。
       
    2.  
      对索引和缓存的支持。
       
    3.  
      是否需要使用热备。
       
    4.  
      崩溃恢复，能否接受崩溃。
       
    5.  
      存储的限制。
       
    6.  
      是否需要外键支持。
       
  
       
   
      艿艿：目前开发已经不考虑外键，主要原因是性能。具体可以看看 《从 MySQL 物理外键开始的思考》 文章。
       
  
       
     

    目前，MySQL 默认的存储引擎是 InnoDB ，并且也是最主流的选择。主要原因如下：
     

    • 【最重要】支持事务。
    • 支持行级锁和表级锁，能支持更多的并发量。
    • 查询不加锁，完全不影响查询。
    • 支持崩溃后恢复。
     

    在 MySQL5.1 以及之前的版本，默认的存储引擎是 MyISAM ，但是目前已经不再更新，且它有几个比较关键的缺点：
     

    • 不支持事务。
    • 使用表级锁，如果数据量大，一个插入操作锁定表后，其他请求都将阻塞。
     

     
 
    艿艿：也就是说，我们不需要花太多力气在 MyISAM 的学习上。
     

     

    ? 请说明 InnoDB 和 MyISAM 的区别
     

    InnoDBMyISAM
    事务支持不支持
    存储限制64TB无
    锁粒度行锁表锁
    崩溃后的恢复支持不支持
    外键支持不支持
    全文检索5.7 版本后支持支持
    

    更完整的对比，可以看看 《数据库存储引擎》 的 「常用引擎对比」 小节。
     

    ? 请说说 InnoDB 的 4 大特性？
     

     
 
    艿艿：貌似我面试没被问过…反正，我是没弄懂过~~
     

     

    • 插入缓冲(insert buffer)
    • 二次写(double write)
    • 自适应哈希索引(ahi)
    • 预读(read ahead)
     

    ? 为什么 SELECT COUNT(*) FROM table 在 InnoDB 比 MyISAM 慢？
     

    对于 SELECT COUNT(*) FROM table 语句，在没有 WHERE 条件的情况下，InnoDB 比 MyISAM 可能会慢很多，尤其在大表的情况下。因为，InnoDB 是去实时统计结果，会全表扫描；而 MyISAM 内部维持了一个计数器，预存了结果，所以直接返回即可。
     

    详细的原因，胖友可以看看 《高性能 MySQL 之 Count 统计查询》 博客。
     

    ? 各种不同 MySQL 版本的 Innodb 的改进？
     

     
 
    艿艿：这是一个选择了解的问题。
     

     

    MySQL5.6 下 Innodb 引擎的主要改进：
     

    1. online DDL
    2. memcached NoSQL 接口
    3. transportable tablespace（ alter table discard/import tablespace）
    4. MySQL 正常关闭时，可以 dump 出 buffer pool 的（ space， page_no），重启时 reload，加快预热速度
    5. 索引和表的统计信息持久化到 mysql.innodb_table_stats 和 mysql.innodb_index_stats，可提供稳定的执行计划
    6. Compressed row format 支持压缩表
     

    MySQL5.7 下 Innodb 引擎的主要改进：
     

    •  
      1、修改 varchar 字段长度有时可以使用
       
  
       
   
      这里的“有时”，指的是也有些限制。可见 《MySQL 5.7 online ddl 的一些改进》 。
       
  
       
    •  
      2、Buffer pool 支持在线改变大小
       
    •  
      3、Buffer pool 支持导出部分比例
       
    •  
      4、支持新建 innodb tablespace，并可以在其中创建多张表
       
    •  
      5、磁盘临时表采用 innodb 存储，并且存储在 innodb temp tablespace 里面，以前是 MyISAM 存储
       
    •  
      6、透明表空间压缩功能
       
     

    重点】什么是索引？
     

    索引，类似于书籍的目录，想找到一本书的某个特定的主题，需要先找到书的目录，定位对应的页码。
     

    MySQL 中存储引擎使用类似的方式进行查询，先去索引中查找对应的值，然后根据匹配的索引找到对应的数据行。
     

    ? 索引有什么好处？
     

    1. 提高数据的检索速度，降低数据库IO成本：使用索引的意义就是通过缩小表中需要查询的记录的数目从而加快搜索的速度。
    2. 降低数据排序的成本，降低CPU消耗：索引之所以查的快，是因为先将数据排好序，若该字段正好需要排序，则正好降低了排序的成本。
     

    ? 索引有什么坏处？
     

    1. 占用存储空间：索引实际上也是一张表，记录了主键与索引字段，一般以索引文件的形式存储在磁盘上。
    2. 降低更新表的速度：表的数据发生了变化，对应的索引也需要一起变更，从而减低的更新速度。否则索引指向的物理数据可能不对，这也是索引失效的原因之一。
     

    ? 索引的使用场景？
     

    •  
      1、对非常小的表，大部分情况下全表扫描效率更高。
       
    •  
      2、对中大型表，索引非常有效。
       
    •  
      3、特大型的表，建立和使用索引的代价随着增长，可以使用分区技术来解决。
       
  
       
   
      实际场景下，MySQL 分区表很少使用，原因可以看看 《互联网公司为啥不使用 MySQL 分区表？》 文章。
       
   
      对于特大型的表，更常用的是“分库分表”，目前解决方案有 Sharding Sphere、MyCAT 等等。
       
  
       
     

    ? 索引的类型？
     

    索引，都是实现在存储引擎层的。主要有六种类型：
     

    •  
      1、普通索引：最基本的索引，没有任何约束。
       
    •  
      2、唯一索引：与普通索引类似，但具有唯一性约束。
       
    •  
      3、主键索引：特殊的唯一索引，不允许有空值。
       
    •  
      4、复合索引：将多个列组合在一起创建索引，可以覆盖多个列。
       
    •  
      5、外键索引：只有InnoDB类型的表才可以使用外键索引，保证数据的一致性、完整性和实现级联操作。
       
    •  
      6、全文索引：MySQL 自带的全文索引只能用于 InnoDB、MyISAM ，并且只能对英文进行全文检索，一般使用全文索引引擎。
       
  
       
   
      常用的全文索引引擎的解决方案有 Elasticsearch、Solr 等等。最为常用的是 Elasticsearch 。
       
  
       
     

    具体的使用，可以看看 《服务端指南 数据存储篇 | MySQL（03） 如何设计索引》 。
     

    ? MySQL 索引的“创建”原则？
     

     
 
    注意，是“创建”噢。
     

     

    •  
      1、最适合索引的列是出现在 WHERE 子句中的列，或连接子句中的列，而不是出现在 SELECT 关键字后的列。
       
    •  
      2、索引列的基数越大，索引效果越好。
       
  
       
   
      具体为什么，可以看看如下两篇文章：
       
    
  
       
    •  
      3、根据情况创建复合索引，复合索引可以提高查询效率。
       
  
       
   
      因为复合索引的基数会更大。
       
  
       
    •  
      4、避免创建过多的索引，索引会额外占用磁盘空间，降低写操作效率。
       
    •  
      5、主键尽可能选择较短的数据类型，可以有效减少索引的磁盘占用提高查询效率。
       
    •  
      6、对字符串进行索引，应该定制一个前缀长度，可以节省大量的索引空间。
       
     

    ? MySQL 索引的“使用”注意事项？
     

     
 
    注意，是“使用”噢。
     

     

    •  
      1、应尽量避免在 WHERE 子句中使用 != 或 <> 操作符，否则将引擎放弃使用索引而进行全表扫描。优化器将无法通过索引来确定将要命中的行数,因此需要搜索该表的所有行。
       
  
       
   
      注意，column IS NULL 也是不可以使用索引的。
       
  
       
    •  
      2、应尽量避免在 WHERE 子句中使用 OR 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描，如：SELECT id FROM t WHERE num = 10 OR num = 20 。
       
    •  
      3、应尽量避免在 WHERE 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描。
       
    •  
      4、应尽量避免在 WHERE 子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描。
       
    •  
      5、不要在 WHERE 子句中的 = 左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。
       
    •  
      6、复合索引遵循前缀原则。
       
    •  
      7、如果 MySQL 评估使用索引比全表扫描更慢，会放弃使用索引。如果此时想要索引，可以在语句中添加强制索引。
       
    •  
      8、列类型是字符串类型，查询时一定要给值加引号，否则索引失效。
       
    •  
      9、LIKE 查询，% 不能在前，因为无法使用索引。如果需要模糊匹配，可以使用全文索引。
       
     

    关于这块，可以看看 《服务端指南 数据存储篇 | MySQL（04） 索引使用的注意事项》 文章，写的更加细致。
     

    ? 以下三条 SQL 如何建索引，只建一条怎么建？
     

    WHERE a = 1 AND b = 1
WHERE b = 1
WHERE b = 1 ORDER BY time DESC


     

    • 以顺序 b , a, time 建立复合索引，CREATE INDEX table1_b_a_time ON index_test01(b, a, time)。
    • 对于第一条 SQL ，因为最新 MySQL 版本会优化 WHERE 子句后面的列顺序，以匹配复合索引顺序。
     

    ? 想知道一个查询用到了哪个索引，如何查看?
     

    EXPLAIN 显示了 MYSQL 如何使用索引来处理 SELECT 语句以及连接表,可以帮助选择更好的索引和写出更优化的查询语句。
     

    使用方法，在 SELECT 语句前加上 EXPLAIN 就可以了。 《MySQL explain 执行计划详细解释》 。
     

    【重点】MySQL 索引的原理？
     

    解释 MySQL 索引的原理，篇幅会比较长，并且网络上已经有靠谱的资料可以看，所以艿艿这里整理了几篇，胖友可以对照着看。
     
 

    下面，艿艿对关键知识做下整理，方便胖友回顾。
     

    几篇好一点的文章:
     

    《MySQL索引背后的数据结构及算法原理》
     

    《MySQL 索引原理》
     

    《深入理解 MySQL 索引原理和实现 —— 为什么索引可以加速查询？》
     

    MySQL 有哪些索引方法？
     

    在 MySQL 中，我们可以看到两种索引方式：
     
 

    什么是 B-Tree 索引？
     

    B-Tree 是为磁盘等外存储设备设计的一种平衡查找树。因此在讲 B-Tree 之前先了解下磁盘的相关知识。
     

    • 系统从磁盘读取数据到内存时是以磁盘块（block）为基本单位的，位于同一个磁盘块中的数据会被一次性读取出来，而不是需要什么取什么。
    • InnoDB存储引擎中有页（Page）的概念，页是其磁盘管理的最小单位。InnoDB 存储引擎中默认每个页的大小为 16 KB，可通过参数 innodb_page_size 将页的大小设置为 4K、8K、16K ，在 MySQL 中可通过如下命令查看页的大小：
     

    mysql> show variables like 'innodb_page_size';

     

    • 而系统一个磁盘块的存储空间往往没有这么大，因此 InnoDB 每次申请磁盘空间时都会是若干地址连续磁盘块来达到页的大小 16KB 。InnoDB 在把磁盘数据读入到磁盘时会以页为基本单位，在查询数据时如果一个页中的每条数据都能有助于定位数据记录的位置，这将会减少磁盘 I/O 次数，提高查询效率。
     

    B-Tree 结构的数据可以让系统高效的找到数据所在的磁盘块。为了描述B-Tree，首先定义一条记录为一个二元组 [key, data] ，key 为记录的键值，对应表中的主键值，data 为一行记录中除主键外的数据。对于不同的记录，key值互不相同。
     

    一棵 m 阶的 B-Tree 有如下特性：
     

    1. 每个节点最多有 m 个孩子。 
  
      • 除了根节点和叶子节点外，其它每个节点至少有 Ceil(m/2) 个孩子。
      • 若根节点不是叶子节点，则至少有 2 个孩子。
       
    2. 所有叶子节点都在同一层，且不包含其它关键字信息。
    3. 每个非叶子节点包含 n 个关键字信息（P0,P1,…Pn, k1,…kn） 
  
      • 关键字的个数 n 满足：ceil(m/2)-1 <= n <= m-1
      • ki(i=1,…n) 为关键字，且关键字升序排序。
      • Pi(i=0,…n) 为指向子树根节点的指针。P(i-1) 指向的子树的所有节点关键字均小于 ki ，但都大于 k(i-1) 。
       
     

    B-Tree 中的每个节点根据实际情况可以包含大量的关键字信息和分支，如下图所示为一个 3 阶的 B-Tree：
     

    B-Tree 的结构
     

    • 每个节点占用一个盘块的磁盘空间，一个节点上有两个升序排序的 key 和三个指向子树根节点的 point ，point 存储的是子节点所在磁盘块的地址。两个 key 划分成的三个范围域，对应三个 point 指向的子树的数据的范围域。
    • 以根节点为例，key 为 17 和 35 ，P1 指针指向的子树的数据范围为小于 17 ，P2 指针指向的子树的数据范围为 [17~35] ，P3 指针指向的子树的数据范围为大于 35 。
     

    模拟查找 key 为 29 的过程：
     

    • 1、根据根节点找到磁盘块 1 ，读入内存。【磁盘I/O操作第1次】
    • 2、比较 key 29 在区间（17,35），找到磁盘块 1 的指针 P2 。
    • 3、根据 P2 指针找到磁盘块 3 ，读入内存。【磁盘I/O操作第2次】
    • 4、比较 key 29 在区间（26,30），找到磁盘块3的指针P2。
    • 5、根据 P2 指针找到磁盘块 8 ，读入内存。【磁盘I/O操作第3次】
    • 6、在磁盘块 8 中的 key 列表中找到 eky 29 。
     

    分析上面过程，发现需要 3 次磁盘 I/O 操作，和 3 次内存查找操作。由于内存中的 key 是一个有序表结构，可以利用二分法查找提高效率。而 3 次磁盘 I/O 操作是影响整个 B-Tree 查找效率的决定因素。B-Tree 相对于 AVLTree 缩减了节点个数，使每次磁盘 I/O 取到内存的数据都发挥了作用，从而提高了查询效率。
     

    什么是 B+Tree 索引？
     

    B+Tree 是在 B-Tree 基础上的一种优化，使其更适合实现外存储索引结构，InnoDB存储引擎就是用 B+Tree 实现其索引结构。
     

    从上一节中的 B-Tree 结构图中可以看到，每个节点中不仅包含数据的 key 值，还有 data 值。而每一个页的存储空间是有限的，如果 data 数据较大时将会导致每个节点（即一个页）能存储的 key 的数量很小，当存储的数据量很大时同样会导致 B-Tree 的深度较大，增大查询时的磁盘 I/O 次数，进而影响查询效率。在 B+Tree 中，所有数据记录节点都是按照键值大小顺序存放在同一层的叶子节点上，而非叶子节点上只存储 key 值信息，这样可以大大加大每个节点存储的 key 值数量，降低 B+Tree 的高度。
     

    B+Tree 相对于 B-Tree 有几点不同：
     

    • 非叶子节点只存储键值信息。
    • 所有叶子节点之间都有一个链指针。
    • 数据记录都存放在叶子节点中。
     

    将上一节中的 B-Tree 优化，由于 B+Tree 的非叶子节点只存储键值信息，假设每个磁盘块能存储 4 个键值及指针信息，则变成 B+Tree 后其结构如下图所示：
     

    B+Tree 的结构
     

    • 通常在 B+Tree 上有两个头指针，一个指向根节点，另一个指向关键字最小的叶子节点，而且所有叶子节点（即数据节点）之间是一种链式环结构。因此可以对 B+Tree 进行两种查找运算：一种是对于主键的范围查找和分页查找，另一种是从根节点开始，进行随机查找。
     

    可能上面例子中只有 22 条数据记录，看不出 B+Tree 的优点，下面做一个推算：
     

    • InnoDB 存储引擎中页的大小为 16KB，一般表的主键类型为 INT（占用4个字节） 或 BIGINT（占用8个字节），指针类型也一般为 4 或 8 个字节，也就是说一个页（B+Tree 中的一个节点）中大概存储 16KB/(8B+8B)=1K 个键值（因为是估值，为方便计算，这里的 K 取值为〖10〗^3）。也就是说一个深度为 3 的 B+Tree 索引可以维护10^3 *10^3 *10^3 = 10亿 条记录。
    • 实际情况中每个节点可能不能填充满，因此在数据库中，B+Tree 的高度一般都在 2~4 层。MySQL 的 InnoDB 存储引擎在设计时是将根节点常驻内存的，也就是说查找某一键值的行记录时最多只需要 1~3 次磁盘 I/O 操作。
     

    B+Tree 有哪些索引类型？
     

    在 B+Tree 中，根据叶子节点的内容，索引类型分为主键索引和非主键索引。
     

    • 主键索引的叶子节点存的数据是整行数据( 即具体数据 )。在 InnoDB 里，主键索引也被称为聚集索引（clustered index）。
    • 非主键索引的叶子节点存的数据是整行数据的主键，键值是索引。在 InnoDB 里，非主键索引也被称为辅助索引（secondary index）。
     

    辅助索引与聚集索引的区别在于辅助索引的叶子节点并不包含行记录的全部数据，而是存储相应行数据的聚集索引键，即主键。当通过辅助索引来查询数据时，需要进过两步：
     

    • 首先，InnoDB 存储引擎会遍历辅助索引找到主键。
    • 然后，再通过主键在聚集索引中找到完整的行记录数据。
     

    另外，InnoDB 通过主键聚簇数据，如果没有定义主键，会选择一个唯一的非空索引代替，如果没有这样的索引，会隐式定义个主键作为聚簇索引。
     

    再另外，可能有胖友有和艿艿的一样疑惑，在辅助索引如果相同的索引怎么存储？最终存储到 B+Tree 非子节点中时，它们对应的主键 ID 是不同的，所以妥妥的。如下图所示：
     

    相同的索引怎么存储
     

    聚簇索引的注意点有哪些？
     

    聚簇索引表最大限度地提高了 I/O 密集型应用的性能，但它也有以下几个限制：
     

    •  
      1、插入速度严重依赖于插入顺序，按照主键的顺序插入是最快的方式，否则将会出现页分裂，严重影响性能。因此，对于 InnoDB 表，我们一般都会定义一个自增的 ID 列为主键。
       
  
       
   
      关于这一点，可能面试官会换一个问法。例如，为什么主键需要是自增 ID ，又或者为什么主键需要带有时间性关联。
       
  
       
    •  
      2、更新主键的代价很高，因为将会导致被更新的行移动。因此，对于InnoDB 表，我们一般定义主键为不可更新。
       
  
       
   
      MySQL 默认情况下，主键是允许更新的。对于 MongoDB ，其 主键是不允许更新的。
       
  
       
    •  
      3、二级索引访问需要两次索引查找，第一次找到主键值，第二次根据主键值找到行数据。
       
  
       
   
      当然，有一种情况可以无需二次查找，基于非主键索引查询，但是查询字段只有主键 ID ，那么在二级索引中就可以查找到。
       
  
       
    •  
      4、主键 ID 建议使用整型。因为，每个主键索引的 B+Tree 节点的键值可以存储更多主键 ID ，每个非主键索引的 B+Tree 节点的数据可以存储更多主键 ID 。
       
     

    什么是索引的最左匹配特性？
     

    当 B+Tree 的数据项是复合的数据结构，比如索引 (name, age, sex) 的时候，B+Tree 是按照从左到右的顺序来建立搜索树的。
     

    • 比如当 (张三, 20, F) 这样的数据来检索的时候，B+Tree 会优先比较 name 来确定下一步的所搜方向，如果 name 相同再依次比较 age 和 sex ，最后得到检索的数据。
    • 但当 (20, F) 这样的没有 name 的数据来的时候，B+Tree 就不知道下一步该查哪个节点，因为建立搜索树的时候 name 就是第一个比较因子，必须要先根据 name 来搜索才能知道下一步去哪里查询。
    • 比如当 (张三, F) 这样的数据来检索时，B+Tree 可以用 name 来指定搜索方向，但下一个字段 age 的缺失，所以只能把名字等于张三的数据都找到，然后再匹配性别是 F 的数据了。
     

    这个是非常重要的性质，即索引的最左匹配特性。
     

    MyISAM 索引实现？
     

    MyISAM 索引的实现，和 InnoDB 索引的实现是一样使用 B+Tree ，差别在于 MyISAM 索引文件和数据文件是分离的，索引文件仅保存数据记录的地址。
     

    MyISAM 索引与 InnoDB 索引的区别？
     

    • InnoDB 索引是聚簇索引，MyISAM 索引是非聚簇索引。
    • InnoDB 的主键索引的叶子节点存储着行数据，因此主键索引非常高效。
    • MyISAM 索引的叶子节点存储的是行数据地址，需要再寻址一次才能得到数据。
    • InnoDB 非主键索引的叶子节点存储的是主键和其他带索引的列数据，因此查询时做到覆盖索引会非常高效。
     

    【重点】请说说 MySQL 的四种事务隔离级别？
     

    •  
      1、插入速度严重依赖于插入顺序，按照主键的顺序插入是最快的方式，否则将会出现页分裂，严重影响性能。因此，对于 InnoDB 表，我们一般都会定义一个自增的 ID 列为主键。
       
  
       
   
      关于这一点，可能面试官会换一个问法。例如，为什么主键需要是自增 ID ，又或者为什么主键需要带有时间性关联。
       
  
       
    •  
      2、更新主键的代价很高，因为将会导致被更新的行移动。因此，对于InnoDB 表，我们一般定义主键为不可更新。
       
  
       
   
      MySQL 默认情况下，主键是允许更新的。对于 MongoDB ，其 主键是不允许更新的。
       
  
       
    •  
      3、二级索引访问需要两次索引查找，第一次找到主键值，第二次根据主键值找到行数据。
       
  
       
   
      当然，有一种情况可以无需二次查找，基于非主键索引查询，但是查询字段只有主键 ID ，那么在二级索引中就可以查找到。
       
  
       
    •  
      4、主键 ID 建议使用整型。因为，每个主键索引的 B+Tree 节点的键值可以存储更多主键 ID ，每个非主键索引的 B+Tree 节点的数据可以存储更多主键 ID 。
       
    •  
      1、插入速度严重依赖于插入顺序，按照主键的顺序插入是最快的方式，否则将会出现页分裂，严重影响性能。因此，对于 InnoDB 表，我们一般都会定义一个自增的 ID 列为主键。
       
  
       
   
      关于这一点，可能面试官会换一个问法。例如，为什么主键需要是自增 ID ，又或者为什么主键需要带有时间性关联。
       
  
       
    •  
      2、更新主键的代价很高，因为将会导致被更新的行移动。因此，对于InnoDB 表，我们一般定义主键为不可更新。
       
  
       
   
      MySQL 默认情况下，主键是允许更新的。对于 MongoDB ，其 主键是不允许更新的。
       
  
       
    •  
      3、二级索引访问需要两次索引查找，第一次找到主键值，第二次根据主键值找到行数据。
       
  
       
   
      当然，有一种情况可以无需二次查找，基于非主键索引查询，但是查询字段只有主键 ID ，那么在二级索引中就可以查找到。
       
  
       
    •  
      4、主键 ID 建议使用整型。因为，每个主键索引的 B+Tree 节点的键值可以存储更多主键 ID ，每个非主键索引的 B+Tree 节点的数据可以存储更多主键 ID 。
       
    •  
      1、插入速度严重依赖于插入顺序，按照主键的顺序插入是最快的方式，否则将会出现页分裂，严重影响性能。因此，对于 InnoDB 表，我们一般都会定义一个自增的 ID 列为主键。
       
  
       
   
      关于这一点，可能面试官会换一个问法。例如，为什么主键需要是自增 ID ，又或者为什么主键需要带有时间性关联。
       
  
       
    •  
      2、更新主键的代价很高，因为将会导致被更新的行移动。因此，对于InnoDB 表，我们一般定义主键为不可更新。
       
  
       
   
      MySQL 默认情况下，主键是允许更新的。对于 MongoDB ，其 主键是不允许更新的。
       
  
       
    •  
      3、二级索引访问需要两次索引查找，第一次找到主键值，第二次根据主键值找到行数据。
       
  
       
   
      当然，有一种情况可以无需二次查找，基于非主键索引查询，但是查询字段只有主键 ID ，那么在二级索引中就可以查找到。
       
  
       
    •  
      4、主键 ID 建议使用整型。因为，每个主键索引的 B+Tree 节点的键值可以存储更多主键 ID ，每个非主键索引的 B+Tree 节点的数据可以存储更多主键 ID 。
       
     

    事务就是对一系列的数据库操作（比如插入多条数据）进行统一的提交或回滚操作，如果插入成功，那么一起成功，如果中间有一条出现异常，那么回滚之前的所有操作。
     

    这样可以防止出现脏数据，防止数据库数据出现问题。
     

    事务的特性指的是？
     

    指的是 ACID ，如下图所示：
     

    事务的特性
     

    1. 原子性 Atomicity ：一个事务（transaction）中的所有操作，或者全部完成，或者全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被恢复（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。即，事务不可分割、不可约简。
    2. 一致性 Consistency ：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设约束、触发器、级联回滚等。
    3. 隔离性 Isolation ：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同级别，包括读未提交（Read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（Serializable）。
    4. 持久性 Durability ：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。
     

    事务的并发问题？
     

    实际场景下，事务并不是串行的，所以会带来如下三个问题：
     

    • 1、脏读：事务 A 读取了事务 B 更新的数据，然后 B 回滚操作，那么 A 读取到的数据是脏数据。
    • 2、不可重复读：事务 A 多次读取同一数据，事务 B 在事务 A 多次读取的过程中，对数据作了更新并提交，导致事务 A 多次读取同一数据时，结果不一致。
    • 3、幻读：系统管理员 A 将数据库中所有学生的成绩从具体分数改为 ABCDE 等级，但是系统管理员 B 就在这个时候插入了一条具体分数的记录，当系统管理员 A 改结束后发现还有一条记录没有改过来，就好像发生了幻觉一样，这就叫幻读。
     

    小结：不可重复读的和幻读很容易混淆，不可重复读侧重于修改，幻读侧重于新增或删除。解决不可重复读的问题只需锁住满足条件的行，解决幻读需要锁表。
     

    MySQL 事务隔离级别会产生的并发问题？
     

    •  
      READ UNCOMMITTED（未提交读）：事务中的修改，即使没有提交，对其他事务也都是可见的。
       
  
       
   
      会导致脏读。
       
  
       
    •  
      READ COMMITTED（提交读）：事务从开始直到提交之前，所做的任何修改对其他事务都是不可见的。
       
  
       
   
      会导致不可重复读。
       
   
      这个隔离级别，也可以叫做“不可重复读”。
       
  
       
    •  
      REPEATABLE READ（可重复读）：一个事务按相同的查询条件读取以前检索过的数据，其他事务插入了满足其查询条件的新数据。产生幻行。
       
  
       
   
      会导致幻读。
       
  
       
    •  
      SERIALIZABLE（可串行化）：强制事务串行执行。
       
     

    事务隔离级别脏读不可重复读幻读
    读未提交（read-uncommitted）是是是
    读已提交（read-committed）否是是
    可重复读（repeatable-read）否否是（x）
    串行化（serializable）否否否
    

    • MySQL 默认的事务隔离级别为可重复读（repeatable-read） 。
    • 上图的 <X> 处，MySQL 因为其间隙锁的特性，导致其在可重复读（repeatable-read）的隔离级别下，不存在幻读问题。也就是说，上图 <X> 处，需要改成“否”！！！！
    • ? 记住这个表的方式，我们会发现它是自左上向右下是一个对角线。当然，最好是去理解。
    • 具体的实验，胖友可以看看 《MySQL 的四种事务隔离级别》 。
     

    【重点】请说说 MySQL 的锁机制？
     

    表锁是日常开发中的常见问题，因此也是面试当中最常见的考察点，当多个查询同一时刻进行数据修改时，就会产生并发控制的问题。MySQL 的共享锁和排他锁，就是读锁和写锁。
     

    • 共享锁：不堵塞，多个用户可以同时读一个资源，互不干扰。
    • 排他锁：一个写锁会阻塞其他的读锁和写锁，这样可以只允许一个用户进行写入，防止其他用户读取正在写入的资源。
     

    ? 锁的粒度？
     

    • 表锁：系统开销最小，会锁定整张表，MyIsam 使用表锁。
    • 行锁：最大程度的支持并发处理，但是也带来了最大的锁开销，InnoDB 使用行锁。
     

    ? 什么是悲观锁？什么是乐观锁？
     

    1）悲观锁
     

    它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）。
     

    在悲观锁的情况下，为了保证事务的隔离性，就需要一致性锁定读。读取数据时给加锁，其它事务无法修改这些数据。修改删除数据时也要加锁，其它事务无法读取这些数据。
     

    2）乐观锁
     

    相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。
     

    而乐观锁机制在一定程度上解决了这个问题。乐观锁，大多是基于数据版本（ Version ）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个 “version” 字段来实现。读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。
     

    什么是死锁？
     

    多数情况下，可以认为如果一个资源被锁定，它总会在以后某个时间被释放。而死锁发生在当多个进程访问同一数据库时，其中每个进程拥有的锁都是其他进程所需的，由此造成每个进程都无法继续下去。简单的说，进程 A 等待进程 B 释放他的资源，B 又等待 A 释放他的资源，这样就互相等待就形成死锁。
     

    虽然进程在运行过程中，可能发生死锁，但死锁的发生也必须具备一定的条件，死锁的发生必须具备以下四个必要条件：
     

    • 互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。
    • 请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。
    • 不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。
    • 环路等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合 {P0，P1，P2，•••，Pn} 中的 P0 正在等待一个 P1 占用的资源；P1 正在等待 P2 占用的资源，……，Pn 正在等待已被 P0 占用的资源。
     

    下列方法有助于最大限度地降低死锁：
     

    •  
      设置获得锁的超时时间。
       
  
       
   
      通过超时，至少保证最差最差最差情况下，可以有退出的口子。
       
  
       
    •  
      按同一顺序访问对象。
       
  
       
   
      这个是最重要的方式。
       
  
       
    •  
      避免事务中的用户交互。
       
    •  
      保持事务简短并在一个批处理中。
       
    •  
      使用低隔离级别。
       
    •  
      使用绑定连接。
       
     

    ? MySQL 中 InnoDB 引擎的行锁是通过加在什么上完成(或称实现)的？为什么是这样子的？？
     

    InnoDB 是基于索引来完成行锁。例如：SELECT * FROM tab_with_index WHERE id = 1 FOR UPDATE 。
     

    • FOR UPDATE 可以根据条件来完成行锁锁定，并且 id 是有索引键的列,如果 id 不是索引键那么 InnoDB 将完成表锁，并发将无从谈起。
     

    【重要】MySQL 查询执行顺序？
     

    MySQL 查询执行的顺序是：
     

    (1)     SELECT
(2)     DISTINCT <select_list>
(3)     FROM <left_table>
(4)     <join_type> JOIN <right_table>
(5)     ON <join_condition>
(6)     WHERE <where_condition>
(7)     GROUP BY <group_by_list>
(8)     HAVING <having_condition>
(9)     ORDER BY <order_by_condition>
(10)    LIMIT <limit_number>

     

    具体的，可以看看 《SQL 查询之执行顺序解析》 文章。
     

    【重要】聊聊 MySQL SQL 优化？
     

    可以看看如下几篇文章：
     
 

    另外，除了从 SQL 层面进行优化，也可以从服务器硬件层面，进一步优化 MySQL 。具体可以看看 《MySQL 数据库性能优化之硬件优化》 。
     

    编写 SQL 查询语句的考题合集
     
 

    MySQL 数据库 CPU 飙升到 500% 的话，怎么处理？
     

    当 CPU 飙升到 500% 时，先用操作系统命令 top 命令观察是不是 mysqld 占用导致的，如果不是，找出占用高的进程，并进行相关处理。
     

     
 
    如果此时是 IO 压力比较大，可以使用 iostat 命令，定位是哪个进程占用了磁盘 IO 。
     

     

    如果是 mysqld 造成的，使用 show processlist 命令，看看里面跑的 Session 情况，是不是有消耗资源的 SQL 在运行。找出消耗高的 SQL ，看看执行计划是否准确， index 是否缺失，或者实在是数据量太大造成。一般来说，肯定要 kill 掉这些线程(同时观察 CPU 使用率是否下降)，等进行相应的调整(比如说加索引、改 SQL 、改内存参数)之后，再重新跑这些 SQL。
     

     
 
    也可以查看 MySQL 慢查询日志，看是否有慢 SQL 。
     

     

    也有可能是每个 SQL 消耗资源并不多，但是突然之间，有大量的 Session 连进来导致 CPU 飙升，这种情况就需要跟应用一起来分析为何连接数会激增，再做出相应的调整，比如说限制连接数等。
     

    ? 在 MySQL 服务器运行缓慢的情况下输入什么命令能缓解服务器压力？
     

    1）检查系统的状态
     

    通过操作系统的一些工具检查系统的状态，比如 CPU、内存、交换、磁盘的利用率，根据经验或与系统正常时的状态相比对，有时系统表面上看起来看空闲，这也可能不是一个正常的状态，因为 CPU 可能正等待IO的完成。除此之外，还应观注那些占用系统资源(CPU、内存)的进程。
     

    • 使用 sar 来检查操作系统是否存在 IO 问题。
    • 使用 vmstat 监控内存 CPU 资源。
    • 磁盘 IO 问题，处理方式：做 raid10 提高性能 。
    • 网络问题，telnet 一下 MySQL 对外开放的端口。如果不通的话，看看防火墙是否正确设置了。另外，看看 MySQ L是不是开启了 skip-networking 的选项，如果开启请关闭。
     

    2）检查 MySQL 参数
     

    • max_connect_errors
    • connect_timeout
    • skip-name-resolve
    • slave-net-timeout=seconds
    • master-connect-retry
     

    3）检查 MySQL 相关状态值
     

    • 关注连接数
    • 关注下系统锁情况
    • 关注慢查询（slow query）日志
     

    Innodb 的事务与日志的实现方式
     

    ? 有多少种日志？
     

    • redo 日志
    • undo 日志
     

    ? 日志的存放形式？
     

    • redo：在页修改的时候，先写到 redo log buffer 里面， 然后写到 redo log 的文件系统缓存里面(fwrite)，然后再同步到磁盘文件（fsync）。
    • undo：在 MySQL5.5 之前，undo 只能存放在 ibdata* 文件里面， 5.6 之后，可以通过设置 innodb_undo_tablespaces 参数把 undo log 存放在 ibdata* 之外。
     

    ? 事务是如何通过日志来实现的，说得越深入越好
     

     
 
    艿艿：这个流程的理解还是比较简单的，实际思考实现感觉还是蛮复杂的。
     

     

    基本流程如下：
     

    • 因为事务在修改页时，要先记 undo ，在记 undo 之前要记 undo 的 redo， 然后修改数据页，再记数据页修改的 redo。 redo（里面包括 undo 的修改）一定要比数据页先持久化到磁盘。
    • 当事务需要回滚时，因为有 undo，可以把数据页回滚到前镜像的状态。
    • 崩溃恢复时，如果 redo log 中事务没有对应的 commit 记录，那么需要用 undo 把该事务的修改回滚到事务开始之前。如果有 commit 记录，就用 redo 前滚到该事务完成时并提交掉。
     

    MySQL binlog 的几种日志录入格式以及区别
     

    ? 各种日志格式的涵义
     

    binlog 有三种格式类型，分别如下：
     

    1）Statement
     

    每一条会修改数据的 SQL 都会记录在 binlog 中。
     

    •  
      优点：不需要记录每一行的变化，减少了 binlog 日志量，节约了 IO，提高性能。(相比 row 能节约多少性能与日志量，这个取决于应用的 SQL 情况，正常同一条记录修改或者插入 row 格式所产生的日志量还小于 Statement 产生的日志量，但是考虑到如果带条件的 update 操作，以及整表删除，alter 表等操作，ROW 格式会产生大量日志，因此在考虑是否使用 ROW 格式日志时应该跟据应用的实际情况，其所产生的日志量会增加多少，以及带来的 IO 性能问题。)
       
    •  
      缺点：由于记录的只是执行语句，为了这些语句能在 slave 上正确运行，因此还必须记录每条语句在执行的时候的一些相关信息，以保证所有语句能在 slave 得到和在 master 端执行时候相同 的结果。另外 MySQL 的复制，像一些特定函数功能，slave 可与 master 上要保持一致会有很多相关问题(如 sleep() 函数，last_insert_id()，以及 user-defined functions(udf) 会出现问题)。
       
    •  
      使用以下函数的语句也无法被复制：
       
  
      •  
        LOAD_FILE()
         
      •  
        UUID()
         
      •  
        USER()
         
      •  
        FOUND_ROWS()
         
      •  
        SYSDATE() (除非启动时启用了 --sysdate-is-now 选项)
         
    
         
     
        同时在 INSERT …SELECT 会产生比 RBR 更多的行级锁 。
         
    
         
       
     

    2）Row
     

    不记录 SQL 语句上下文相关信息，仅保存哪条记录被修改。
     

    • 优点：binlog 中可以不记录执行的 SQL 语句的上下文相关的信息，仅需要记录那一条记录被修改成什么了。所以 rowlevel 的日志内容会非常清楚的记录下每一行数据修改的细节。而且不会出现某些特定情况下的存储过程，或 function ，以及 trigger 的调用和触发无法被正确复制的问题。
    • 缺点：所有的执行的语句当记录到日志中的时候，都将以每行记录的修改来记录，这样可能会产生大量的日志内容,比如一条 Update 语句，修改多条记录，则 binlog 中每一条修改都会有记录，这样造成 binlog 日志量会很大，特别是当执行 alter table 之类的语句的时候，由于表结构修改，每条记录都发生改变，那么该表每一条记录都会记录到日志中。
     

    3）Mixedlevel
     

    是以上两种 level 的混合使用。
     

    • 一般的语句修改使用 Statement 格式保存 binlog 。
    • 如一些函数，statement 无法完成主从复制的操作，则采用 Row 格式保存 binlog 。
     

    MySQL 会根据执行的每一条具体的 SQL 语句来区分对待记录的日志形式，也就是在 Statement 和 Row 之间选择 一种。
     

    新版本的 MySQL 中对 row level 模式也被做了优化，并不是所有的修改都会以 row level 来记录。
     

    • 像遇到表结构变更的时候就会以 Statement 模式来记录。
    • 至于 Update 或者 Delete 等修改数据的语句，还是会记录所有行的变更，即使用 Row 模式。
     

    ? 适用场景？
     

    在一条 SQL 操作了多行数据时， Statement 更节省空间，Row 更占用空间。但是， Row 模式更可靠。
     

    因为，互联网公司，使用 MySQL 的功能相对少，基本不使用存储过程、触发器、函数的功能，选择默认的语句模式，Statement Level（默认）即可。
     

    ? 结合第一个问题，每一种日志格式在复制中的优劣？
     

    • Statement 可能占用空间会相对小一些，传送到 slave 的时间可能也短，但是没有 Row 模式的可靠。
    • Row 模式在操作多行数据时更占用空间，但是可靠。
     

    所以，这是在占用空间和可靠之间的选择。
     

    如何在线正确清理 MySQL binlog？
     

    MySQL 中的 binlog 日志记录了数据中的数据变动，便于对数据的基于时间点和基于位置的恢复。但日志文件的大小会越来越大，占用大量的磁盘空间，因此需要定时清理一部分日志信息。
     

    # 首先查看主从库正在使用的binlog文件名称
show master(slave) status

# 删除之前一定要备份
purge master logs before'2017-09-01 00:00:00'; # 删除指定时间前的日志
purge master logs to'mysql-bin.000001'; # 删除指定的日志文件

# 自动删除：通过设置binlog的过期时间让系统自动删除日志
show variables like 'expire_logs_days'; # 查看过期时间
set global expire_logs_days = 30; # 设置过期时间

     

    MySQL 主从复制的流程是怎么样的？
     

    MySQL 的主从复制是基于如下 3 个线程的交互（多线程复制里面应该是 4 类线程）：
     

    • 1、Master 上面的 binlog dump 线程，该线程负责将 master 的 binlog event 传到 slave 。
    • 2、Slave 上面的 IO 线程，该线程负责接收 Master 传过来的 binlog，并写入 relay log 。
    • 3、Slave 上面的 SQL 线程，该线程负责读取 relay log 并执行。
    • 4、如果是多线程复制，无论是 5.6 库级别的假多线程还是 MariaDB 或者 5.7 的真正的多线程复制， SQL 线程只做 coordinator ，只负责把 relay log 中的 binlog 读出来然后交给 worker 线程， woker 线程负责具体 binlog event 的执行。
     

    ? MySQL 如何保证复制过程中数据一致性？
     

    • 1、在 MySQL5.5 以及之前， slave 的 SQL 线程执行的 relay log 的位置只能保存在文件（ relay-log.info）里面，并且该文件默认每执行 10000 次事务做一次同步到磁盘， 这意味着 slave 意外 crash 重启时， SQL 线程执行到的位置和数据库的数据是不一致的，将导致复制报错，如果不重搭复制，则有可能会导致数据不一致。 
  
      • MySQL 5.6 引入参数 relay_log_info_repository，将该参数设置为 TABLE 时， MySQL 将 SQL 线程执行到的位置存到 mysql.slave_relay_log_info 表，这样更新该表的位置和 SQL 线程执行的用户事务绑定成一个事务，这样 slave 意外宕机后，slave 通过 innodb 的崩溃恢复可以把 SQL 线程执行到的位置和用户事务恢复到一致性的状态。
       
    • 2、MySQL 5.6 引入 GTID 复制，每个 GTID 对应的事务在每个实例上面最多执行一次， 这极大地提高了复制的数据一致性。
    • 3、MySQL 5.5 引入半同步复制， 用户安装半同步复制插件并且开启参数后，设置超时时间，可保证在超时时间内如果 binlog 不传到 slave 上面，那么用户提交事务时不会返回，直到超时后切成异步复制，但是如果切成异步之前用户线程提交时在 master 上面等待的时候，事务已经提交，该事务对 master 上面的其他 session 是可见的，如果这时 master 宕机，那么到 slave 上面该事务又不可见了，该问题直到 5.7 才解决。
    • 4、MySQL 5.7 引入无损半同步复制，引入参 rpl_semi_sync_master_wait_point，该参数默认为 after_sync，指的是在切成半同步之前，事务不提交，而是接收到 slave 的 ACK 确认之后才提交该事务，从此，复制真正可以做到无损的了。
    • 5、可以再说一下 5.7 的无损复制情况下， master 意外宕机，重启后发现有 binlog 没传到 slave 上面，这部分 binlog 怎么办？？？分 2 种情况讨论， 1 宕机时已经切成异步了， 2 是宕机时还没切成异步？？？ 这个怎么判断宕机时有没有切成异步呢？？？ 分别怎么处理？？？
     

    ? MySQL 如何解决主从复制的延时性？
     

    5.5 是单线程复制，5.6 是多库复制（对于单库或者单表的并发操作是没用的），5.7 是真正意义的多线程复制，它的原理是基于 group commit， 只要 master 上面的事务是 group commit 的，那 slave 上面也可以通过多个 worker线程去并发执行。 和 MairaDB10.0.0.5 引入多线程复制的原理基本一样。
     

    ? 工作遇到的复制 bug 的解决方法？
     

    5.6 的多库复制有时候自己会停止，我们写了一个脚本重新 start slave 。
     

    ? 你是否做过主从一致性校验，如果有，怎么做的，如果没有，你打算怎么做？
     

    主从一致性校验有多种工具 例如 checksum、mysqldiff、pt-table-checksum 等。
     

    聊聊 MySQL 备份方式？备份策略是怎么样的？
     

    具体的，胖友可以看看 《MySQL 高级备份策略》 。主要有几个知识点：
     

    •  
      数据的备份类型
       
  
      •  
        【常用】完全备份
         
    
         
     
        这是大多数人常用的方式，它可以备份整个数据库，包含用户表、系统表、索引、视图和存储过程等所有数据库对象。但它需要花费更多的时间和空间，所以，一般推荐一周做一次完全备份。
         
    
         
      •  
        增量备份
         
    
         
     
        它是只备份数据库一部分的另一种方法，它不使用事务日志，相反，它使用整个数据库的一种新映象。它比最初的完全备份小，因为它只包含自上次完全备份以来所改变的数据库。它的优点是存储和恢复速度快。推荐每天做一次差异备份。
         
    
         
      •  
        【常用】事务日志备份
         
    
         
     
        事务日志是一个单独的文件，它记录数据库的改变，备份的时候只需要复制自上次备份以来对数据库所做的改变，所以只需要很少的时间。为了使数据库具有鲁棒性，推荐每小时甚至更频繁的备份事务日志。
         
    
         
      •  
        文件备份
         
    
         
     
        数据库可以由硬盘上的许多文件构成。如果这个数据库非常大，并且一个晚上也不能将它备份完，那么可以使用文件备份每晚备份数据库的一部分。由于一般情况下数据库不会大到必须使用多个文件存储，所以这种备份不是很常用。
         
    
         
       
    •  
      备份数据的类型
       
  
      • 热备份
      • 温备份
      • 冷备份
       
    •  
      备份工具
       
  
      • cp
      • mysqldump
      • xtrabackup
      • lvm2 快照
       
     

    MySQL 几种备份方式？
     

    MySQL 一般有 3 种备份方式。
     

    1）逻辑备份
     

    使用 MySQL 自带的 mysqldump 工具进行备份。备份成sql文件形式。
     

    • 优点：最大好处是能够与正在运行的 MySQL 自动协同工作，在运行期间可以确保备份是当时的点，它会自动将对应操作的表锁定，不允许其他用户修改(只能访问)。可能会阻止修改操作。SQL 文件通用方便移植。
    • 缺点：备份的速度比较慢。如果是数据量很多的时候，就很耗时间。如果数据库服务器处在提供给用户服务状态，在这段长时间操作过程中，意味着要锁定表(一般是读锁定，只能读不能写入数据)，那么服务就会影响的。
     

    2）物理备份
     

     
 
    艿艿：因为现在主流是 InnoDB ，所以基本不再考虑这种方式。
     

     

    直接拷贝只适用于 MyISAM 类型的表。这种类型的表是与机器独立的。但实际情况是，你设计数据库的时候不可能全部使用 MyISAM 类型表。你也不可能因为 MyISAM 类型表与机器独立，方便移植，于是就选择这种表，这并不是选择它的理由。
     

    • 缺点：你不能去操作正在运行的 MySQL 服务器(在拷贝的过程中有用户通过应用程序访问更新数据，这样就无法备份当时的数据)，可能无法移植到其他机器上去。
     

    3）双机热备份。
     

    当数据量太大的时候备份是一个很大的问题，MySQL 数据库提供了一种主从备份的机制，也就是双机热备。
     

    • 优点：适合数据量大的时候。现在明白了，大的互联网公司对于 MySQL 数据备份，都是采用热机备份。搭建多台数据库服务器，进行主从复制。
     

    数据库不能停机，请问如何备份? 如何进行全备份和增量备份?
     

    可以使用逻辑备份和双机热备份。
     

    • 完全备份：完整备份一般一段时间进行一次，且在网站访问量最小的时候，这样常借助批处理文件定时备份。主要是写一个批处理文件在里面写上处理程序的绝对路径然后把要处理的东西写在后面，即完全备份数据库。
    • 增量备份：对 ddl 和 dml 语句进行二进制备份。且 5.0 无法增量备份，5.1 后可以。如果要实现增量备份需要在 my.ini 文件中配置备份路径即可，重启 MySQL 服务器，增量备份就启动了。
     

    ? 你的备份工具的选择？备份计划是怎么样的？
     

    视库的大小来定，一般来说 100G 内的库，可以考虑使用 mysqldump 来做，因为 mysqldump 更加轻巧灵活，备份时间选在业务低峰期，可以每天进行都进行全量备份(mysqldump 备份出来的文件比较小，压缩之后更小)。
     

    100G 以上的库，可以考虑用 xtrabackup 来做，备份速度明显要比 mysqldump 要快。一般是选择一周一个全备，其余每天进行增量备份，备份时间为业务低峰期。
     

    备份恢复时间是多长？
     

    物理备份恢复快，逻辑备份恢复慢。
     

    这里跟机器，尤其是硬盘的速率有关系，以下列举几个仅供参考：
     

    • 20G 的 2 分钟（mysqldump）
    • 80G 的 30分钟（mysqldump)
    • 111G 的 30分钟（mysqldump)
    • 288G 的 3 小时（xtrabackup)
    • 3T 的 4 小时（xtrabackup)
     

    逻辑导入时间一般是备份时间的 5 倍以上。
     

    备份恢复失败如何处理？
     

    首先在恢复之前就应该做足准备工作，避免恢复的时候出错。比如说备份之后的有效性检查、权限检查、空间检查等。如果万一报错，再根据报错的提示来进行相应的调整。
     

    ? mysqldump 和 xtrabackup 实现原理？
     

    1）mysqldump
     

    mysqldump 是最简单的逻辑备份方式。
     

    • 在备份 MyISAM 表的时候，如果要得到一致的数据，就需要锁表，简单而粗暴。
    • 在备份 InnoDB 表的时候，加上 –master-data=1 –single-transaction 选项，在事务开始时刻，记录下 binlog pos 点，然后利用 MVCC 来获取一致的数据，由于是一个长事务，在写入和更新量很大的数据库上，将产生非常多的 undo ，显著影响性能，所以要慎用。
    • 优点：简单，可针对单表备份，在全量导出表结构的时候尤其有用。
    • 缺点：简单粗暴，单线程，备份慢而且恢复慢，跨 IDC 有可能遇到时区问题
     

    2）xtrabackup
     

    xtrabackup 实际上是物理备份+逻辑备份的组合。
     

    • 在备份 InnoDB 表的时候，它拷贝 ibd 文件，并一刻不停的监视 redo log 的变化，append 到自己的事务日志文件。在拷贝 ibd 文件过程中，ibd文件本身可能被写”花”，这都不是问题，因为在拷贝完成后的第一个 prepare 阶段，xtrabackup 采用类似于 Innodb 崩溃恢复的方法，把数据文件恢复到与日志文件一致的状态，并把未提交的事务回滚。
    • 如果同时需要备份 MyISAM 表以及 InnoDB 表结构等文件，那么就需要用 flush tables with lock 来获得全局锁，开始拷贝这些不再变化的文件，同时获得 binlog 位置，拷贝结束后释放锁，也停止对 redo log 的监视。
     

    如何从 mysqldump 产生的全库备份中只恢复某一个库、某一张表？
     

    具体可见 《MySQL 全库备份中恢复某个库和某张表以及 mysqldump 参数 –ignore-table 介绍》 文章。
     

    聊聊 MySQL 集群?
     

     
 
    艿艿：这块艿艿懂的少，主要找了一些网络上的资料。
     

     
 

    ? 对于简历中写有熟悉 MySQL 高可用方案？
     

    我一般先问他现在管理的数据库架构是什么，如果他只说出了主从，而没有说任何 HA 的方案，那么我就可以判断出他没有实际的 HA 经验。
     

    不过这时候也不能就是断定他不懂 MySQL 高可用，也许是没有实际机会去使用，那么我就要问 MMM 以及 MHA 以及 MM + keepalived 等的原理、实现方式以及它们之间的优势和不足了，一般这种情况下，能说出这个的基本没有。
     

    • MMM 那东西好像不靠谱，据说不稳定，但是有人在用的，和 mysql-router 比较像，都是指定可写的机器和只读机器。
    • MHA 的话一句话说不完，可以搜索下相关博客。
     

    聊聊 MySQL 安全？
     

    感兴趣的胖友，可以看看：
     
 

    MySQL 有哪些日志？
     

    •  
      错误日志：记录了当 mysqld 启动和停止时，以及服务器在运行过程中发生任何严重错误时的相关信息。
       
    •  
      二进制文件：记录了所有的 DDL（数据定义语言）语句和 DML（数据操纵语言）语句，不包括数据查询语句。语句以“事件”的形式保存，它描述了数据的更改过程。（定期删除日志，默认关闭）。
       
  
       
   
      就是我们上面看到的 MySQL binlog 日志。
       
  
       
    •  
      查询日志：记录了客户端的所有语句，格式为纯文本格式，可以直接进行读取。（log 日志中记录了所有数据库的操作，对于访问频繁的系统，此日志对系统性能的影响较大，建议关闭，默认关闭）。
       
    •  
      慢查询日志：慢查询日志记录了包含所有执行时间超过参数long_query_time（单位：秒）所设置值的 SQL 语句的日志。（纯文本格式）
       
  
       
   
      重要，一定要开启。
       
  
       
     

    另外，错误日志和慢查询日志的详细解释，可以看看 《MySQL 日志文件之错误日志和慢查询日志详解》 文章。
     

    聊聊 MySQL 监控？
     

    你是如何监控你们的数据库的？
     

    监控的工具有很多，例如 Zabbix ，Lepus ，我这里用的是 Lepus 。
     

    对一个大表做在线 DDL ，怎么进行实施的才能尽可能降低影响？
     

    使用 pt-online-schema-change ，具体可以看看 《MySQL 大表在线 DML 神器–pt-online-schema-change》 文章。
     

    另外，还有一些其它的工具，胖友可以搜索下。
    收起
    展开全文
    mysql面试题

  • Java知识体系最强总结(2020版）

     千次阅读 多人点赞 2020-03-07 08:35:51
    序号 内容 链接地址 1 Java内存模型 https://blog.csdn.net/ThinkWon/article/details/102073578 2 重排序与数据依赖性 https://blog.csdn.net/ThinkWon/article/details/102073858 3 as-if-serial规则和happens-... 
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        java   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    测试开发笔记
    
                                    
                                    
                                            万次阅读
                                            多人点赞
                                    
                                2019-11-14 17:11:58
                            
    
                            
    
                                
    
                                    测试计划 集成测试阶段 概要设计子项 测试方案 具体内容 测试用例 整个系统最小单元 详细设计 函数 测试计划 单元测试 逻辑 测试方案 代码 测试用例 5.各阶段输入、输出标准以及入口、出口准则:（测试阶段过程要素）...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        测试开发   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    2019年常见Elasticsearch 面试题答案详细解析（下）
    
                                    
                                    
                                            千次阅读
                                            多人点赞
                                    
                                2019-12-26 15:51:03
                            
    
                            
    
                                
    
                                    （6）根据监控数据理解内存需求，合理配置各类circuit breaker，将内存溢出风险降低到最低            6、Elasticsearch 对于大数据量（上亿量级）的聚合如何实现？    Elasticsearch 提供的首个近似聚合是 ...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        Java   
                                        Java面试题   
                                        性能调优   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    前端面试题
    
                                    
                                    
                                            万次阅读
                                            多人点赞
                                    
                                2019-08-08 11:49:01
                            
    
                            
    
                                
    
                                    用js实现随机选取10–100之间的10个数字，存入一个数组，并排序。	60   把两个数组合并，并删除第二个元素。	61   怎样添加、移除、移动、复制、创建和查找节点（原生JS，实在基础，没细写每一步）	61   有这样一个...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        前端面试题   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    Java集合面试题
    
                                    
                                    
                                            万次阅读
                                            多人点赞
                                    
                                2019-06-25 14:46:19
                            
    
                            
    
                                
    
                                    基于应用的需求来选择使用正确类型的集合，这对性能来说是非常重要的。例如，如果元素的大小是固定的，并且知道优先级，我们将会使用一个 Array ，而不是 ArrayList 。   一些集合类允许我们指定他们的初始容量。...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        java集合面试题   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    C#基础教程-c#实例教程，适合初学者
    
                                    
                                    
                                            万次阅读
                                            多人点赞
                                    
                                2016-08-22 11:13:24
                            
    
                            
    
                                
    
                                    	增加安全：C#语言不支持指针，一切对内存的访问都必须通过对象的引用变量来实现，只允许访问内存中允许访问的部分，这就防止病毒程序使用非法指针访问私有成员。也避免指针的误操作产生的错误。CLR执行中间语言...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        c#   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    数据结构面试题
    
                                    
                                    
                                            千次阅读
                                            多人点赞
                                    
                                2018-01-22 10:21:28
                            
    
                            
    
                                
    
                                    算法设计的要求：正确性、可读性、健壮性、效率与低存储量需求                二 . 算法的复杂度      1. 算法的时间复杂度：指执行算法所需要的计算工作量      2. 算法的空间复杂度：执行这个算法所需要的内存...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        数据结构面试题   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    排序算法：桶排序、计数排序、基数排序
    
                                    
                                    
                                            千次阅读
                                    
                                2019-01-29 19:19:07
                            
    
                            
    
                                
    
                                    排序算法：冒泡排序、插入排序、选择排序、希尔排序  排序算法：归并排序、快速排序  排序算法：桶排序、计数排序、基数排序  排序算法：堆排序  十大排序算法小结  这篇博客将主要介绍三种时间复杂度是O(n)的排序...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    Flink1.11内存机制之进程内存及TaskManager内存
    
                                    
                                    
                                            千次阅读
                                    
                                2020-07-22 11:00:50
                            
    
                            
    
                                
    
                                    考虑到用户在 Flink 上运行的应用的多样性，尽管社区已经努力为所有配置项提供合理的默认值，仍无法满足所有情况下的需求。为了给用户生产提供最大化的价值， Flink 允许用户在整体上以及细粒度上对集群的内存分配...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        Flink1.11   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    分布式服务框架
    
                                    
                                    
                                            千次阅读
                                    
                                2016-01-29 10:42:11
                            
    
                            
    
                                
    
                                    垂直化的搜索引擎在分布式系统中是一个非常重要的角色，它既能够满足用户对于全文检索、模糊匹配的需求，解决数据库like 查询效率低下的问题，又能够解决分布式环境下，由于采用分库分表，或者使用NoSQL 数据库，...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        分布式   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    面试题精选:单链表排序也能玩出花来
    
                                    
                                    
                                            千次阅读
                                    
                                2020-10-01 11:16:54
                            
    
                            
    
                                
    
                                    单链表的排序在数据结构类的面试题中简直是集大成者，什么排序、链表、链表删除、添加…… 都能体现在单链表排序上，也非常考验候选者的编程基本功，思路说起来很简单，但能不能写出来又是另外一回事了。 有些人觉得...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        链表   
                                        算法   
                                        数据结构   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    JVM成神之路-Java内存模型（JMM）
    
                                    
                                    
                                            千次阅读
                                    
                                2018-07-03 15:32:05
                            
    
                            
    
                                
    
                                    Java 内存模型基础  什么是 Java 内存模型(JMM-共享内存模型)  内存模型描述了程序中各个变量（实例域、静态域和数组元素）之间的关系，以及在实际计算机系统中将变量存储到内存和从内存中取出变量这样的底层细节。...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        JMM   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    2019年常见ElasticSearch 面试题解析（上）
    
                                    
                                    
                                            千次阅读
                                            多人点赞
                                    
                                2019-12-25 19:39:24
                            
    
                            
    
                                
    
                                    （1）根据业务增量需求，采取基于日期模板创建索引，通过 roll over API 滚动索引；    （2）使用别名进行索引管理；    （3）每天凌晨定时对索引做 force_merge 操作，以释放空间；    （4）采取冷热分离机制，热...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        Java   
                                        Java面试题   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    排序（上）——为什么插入排序比冒泡排序更受欢迎？
    
                                    
                                    
                                            万次阅读
                                            多人点赞
                                    
                                2018-10-29 10:33:17
                            
    
                            
    
                                
    
                                    插入排序和冒泡排序的时间复杂度都是O(n2)，可实际开发中，为什么我们更倾向于使用插入排序算法呢？  评价一个排序算法，  从效率角度说，要考虑各种时间复杂度；数据量小时，时间复复杂度的系数、常数也要考虑；...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        算法   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    Linux 操作系统原理 — 内存 — 大页内存
    
                                    
                                    
                                            千次阅读
                                    
                                2020-06-20 13:32:13
                            
    
                            
    
                                
    
                                    文章目录目录前文列表大页内存Linux 的大页内存大页的实现原理大页内存配置透明巨型页 THP大页面对内存的影响大页内存的性能问题 前文列表 大页内存 在页式虚拟存储器中，会在虚拟存储空间和物理主存空间都分割为一...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    插入排序/选择排序/交换排序/归并排序/基数排序
    
                                    
                                    
                                            千次阅读
                                    
                                2016-12-18 22:35:15
                            
    
                            
    
                                
    
                                    数据处理时一个主要需求就是排序，目前主要的内存排序（处理的数据量百万级以下）主要基于关键字大小，具体可分一下几种：1. 插入排序：直接插入排序（稳定）和希尔排序（升级版，不稳定）; 直接插入排序，关键是在...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    Linux实用教程(第三版)
    
                                    
                                    
                                            万次阅读
                                            多人点赞
                                    
                                2019-08-27 22:55:59
                            
    
                            
    
                                
    
                                     Linux的内存管理采取的是分页存取机制，为了保证物理内存能得到充分的利用，内核会在适当的时候将物理内存中不经常使用的数据块自动交换到虚拟内存中，而将经常使用的信息保留到物理内存。 Linux系统会不时的进行...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        Linux   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    MQTT协议
    
                                    
                                    
                                            千次阅读
                                    
                                2016-04-26 21:48:31
                            
    
                            
    
                                
    
                                    MQTT协议摘要MQ遥测传输（MQ Telemetry Transport，MQTT）是一个轻...在嵌入设备中运行，处理器和内存资源有限。  该协议的特性包括： 使用发布/订阅消息模式，提供一对多的消息分发，解除应用程序耦合。 消息传输对有
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        MQTT协议   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    心理辅导平台设计
    
                                    
                                    
                                            千次阅读
                                    
                                2017-12-04 10:22:57
                            
    
                            
    
                                
    
                                    随着社会发展、生活节奏加快、矛盾冲突增加，人们对增进心理健康产生了越来越强烈的需求，心理咨询在我国形成需求市场，心理咨询业有了相当程度的发展。   中商情报网发布的《2010-2015年中国心理咨询业调研及发展...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        软件工程   
                                        设计   
                                        软件   
                                        聊天机器人   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    java内存模型
    
                                    
                                    
                                            千次阅读
                                    
                                2016-05-03 21:31:38
                            
    
                            
    
                                
    
                                    深入理解Java内存模型（一）——基础   并发编程模型的分类  在并发编程中，我们需要处理两个关键问题：线程之间如何通信及线程之间如何同步（这里的线程是指并发执行的活动实体）。通信是指线程之间以何种机制来...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        java   
                                        布局   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    八大内部排序+外部排序
    
                                    
                                    
                                            千次阅读
                                    
                                2019-07-12 21:42:21
                            
    
                            
    
                                
    
                                    排序划分    内部排序  1.直接插入排序  基本思想  通常人们整理桥牌的方法是一张一张的来，将每一张牌插入到其他已经有序的牌中的适当位置。在计算机的实现中，为了要给插入的元素腾出空间，我们需要将其余所有元素...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    七大内部排序算法总结（插入排序、希尔排序、冒泡排序、简单选择排序、快速排序、归并排序、堆排序）
    
                                    
                                    
                                            千次阅读
                                            多人点赞
                                    
                                2014-07-16 08:01:40
                            
    
                            
    
                                
    
                                    写在前面： ...对下面介绍的各个排序，我们假定所有排序的关键字都是整数、对传入函数的参数默认是已经检查好了的。只是简单的描述各个算法并给出了具体实现代码，并未做其他深究探讨。          基础知识：
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    各个排序算法及其时间复杂度
    
                                    
                                    
                                            千次阅读
                                    
                                2019-06-20 17:09:02
                            
    
                            
    
                                
    
                                    稳定的排序算法1.1 冒泡排序1.1.1 冒泡排序流程1.1.2 冒泡排序的实现1.2 插入排序1.2.1 插入排序流程1.2.2 插入排序的实现1.3 归并排序1.3.1 归并排序流程1.3.2 归并排序的实现1.4 桶排序1.4.1 桶排序流程1.4.2 桶...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        数据结构   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    mysql获取两个表中日期字段的最小差值
    
                                    
                                    
                                            千次阅读
                                    
                                2019-09-23 15:50:16
                            
    
                            
    
                                
    
                                    开发中碰到的需求，获取两个数据表中日期字段的差值，并且取得差值最小的那条数据。本篇文章主要讲述如果通过函数获取mysql的日期差值，实际编写时遇到的问题，并且分析需求，得出最终sql等。 二、表结构以及需求 1...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        mysql   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    java List Map String Object泛型通用排序 支持两个字段排序
    
                                    
                                    
                                            千次阅读
                                    
                                2018-05-02 18:01:05
                            
    
                            
    
                                
    
                                    公司有个公共的排序方法类，其中，字符串一个方法、日期字符串一个方法、数字一个方法等等；  我觉得这些方法都可以写成一个方法；  下面代码只针对List&amp;amp;amp;lt;Map&amp;amp;amp;lt;String, Object&...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        java   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    堆排序原理
    
                                    
                                    
                                            千次阅读
                                    
                                2018-09-21 00:21:22
                            
    
                            
    
                                
    
                                    堆   堆逻辑上是一棵完全二叉树。   其任何一非叶节点的关键字不大于或者不小于其左右孩子节点的...所以找出若干个数中最大/最小的前K个数，用堆排序是最好的。找K个最大数，用小顶堆；找K个最小数，用大顶堆。   
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                

            


            

                

                

                    
                    
空空如也

                

            


            

                

                

                    
                    
空空如也

                

            


            

                


 

 
 
         

            
                     


                    
                        1 
                    
                    
                        2 
                    
                    
                        3 
                    
                    
                        4 
                    
                    
                        5 
                    
                        ... 
                    
                        20 
                    

                    
            
        

   

                

                

            


        

    

    

        

            

                收藏数
                    47,933
            

            

                精华内容
                    19,173
            

        

        

            
热门标签

            
        


        


        

            关键字：
内存需求最小的排序