目录
线程除了用synchronized还能用什么，让你自己设计同步怎么设计，
在项目中遇到的难点，怎么解决的，具体说说.....要很具体
hashmap扩容机制
在HashMap的putVal方法中国，当添加完元素，size就会加一，然后会判断size（元素总数）是不是超过threshold（阈值），如果已经超过就会进行扩容。
如果是length是2的n次方，length must be a non-zero power of 2;则下面的等式成立。h&(length-1)=h%length等值不等效。h&(length-1)效率高于h%length;
(因为存储是用hash(key)%length来存储的，而h&(length-1)比h%length的效率高，所以想让存储时用h&(length-1)来替代，h%length就是要让两者变成一个等价关系，即h&(length-1)=h%length而确保两者为等价关系的条件就是length是2的n次方)。
HashMap的indexFor方法就已经使用了h&(lengh-1);
按位取与，作用上相当于取模mod或者取余%。hashCode不同也可能数组下标相同。
为什么HashMap的容量或之后的扩容，总是2的n次方?
这看上去很简单，其实很巧妙。
假设数组长度分别为15和16，优化后的hash码分别为8和9，那么&运算后的结果如下：
**从上面的例子中可以看出：当8、9两个数和(15-1)2=(1110)进行“&运算”的时候，产生了相同的结果，都为0100，也就是说它们会定位到数组中的同一个位置上去，这就产生了碰撞，8和9会被放到数组中的同一个位置上形成链表，那么查询的时候就需要遍历这个链表，得到8或者9，这样就降低了查询的效率。
**同时，我们也可以发现，当数组长度为15的时候，hash值会与(15-1)=(1110)进行“&运算”，那么最后一位永远是0，而0001，0011，0101，1001，1011，0111，1101这几个位置永远都不能存放元素了，空间浪费相当大，数组可以使用的位置比数组长度小了很多，这意味着进一步增加了碰撞的几率，减慢了查询的效率！
**而当数组长度为16时，即为2的n次方时，2n-1得到的二进制数的每个位上的值都为1(这是一个奇妙的世界)，这使得在低位上&时，得到的和原hash的低位相同，加之hash(int h)方法对key的hashCode的进一步优化，加入了高位计算，就使得只有相同的hash值的两个值才会被放到数组中的同一个位置上形成链表。
**所以说，当数组长度为2的n次幂的时候，不同的key算得得index相同的几率较小，那么数据在数组上分布就比较均匀，也就是说碰撞的几率小，相对的，查询的时候就不用遍历某个位置上的链表，这样查询效率也就较高了
综上所述 2的n次方-1得到的二进制每个位上的值都为1,而非2的n次方-1得到的二进制每个位上的值有可能为0,为0的后果就是造成有些位置永远不会被存放元素,即浪费空间又增加碰撞的几率,所以基于这个原因，在扩容时才都是长度*2
mysql存储引擎特点
myisam
特性
建表会生成frm MYD（特有） MYI（特有）三个文件
并发性及锁级别
表级锁并发性差
表损坏修复：不支持事务
可以使用check table tabklename和repair table tablename 来进行myisam表的检查和修复
还有mysql的工具myisamchk –help 来进行修复
MyISAM 支持数据压缩 myisampack *.MYI
对于已经压缩的表只能进行读操作
使用场景：
1.非事务型应用
2.只读类应用
3.空间类应用
innodb(mysql5.5及以后版本默认存储引擎):
事务型存储引擎，支持ACID
使用表空间进行数据存储
使用 show variables like ‘innodb_file_per_table’;查看表空间类型
on：独立表空间：tablename.ibd
off：系统表空间：ibdataX
修改这个参数使用set global innodb_file_per_table=on(off);来完成
两者之间的比较：
1.系统表空间无法简单的收缩文件大小，会造成较大的空间浪费（即删除无效数据之后不会改变文件的大小）
独立表空间可以通过optimize table命令收缩系统文件，这种方法不会影响数据表的正常使用
2.系统表空间会产生IO瓶颈
独立表空间可以同时向多个文件刷新数据（频繁写入的表）
建议：对innodb使用独立表空间
表转移的步骤
把原来存在与系统表空间中的表转移到独立表空间中的方法
步骤：
1.使用mysqldump导出所有数据库表数据
2.停止MySQL服务，修改参数，并删除Innodb相关文件
3.重启MySQL服务，重建Innodb系统表空间
4.重新导入数据
Innodb特性
Innodb是一种事务型存储引擎
完全支持事务的ACID特性
即原子性、一致性、隔离性、持久性
使用Redo Log和Undo Log来完成一致性
show variables like ‘innodb_log_buffer_size’; 查看redo 缓冲区大小
show variables like ‘innodb_log_file_in_group’; 查看log file数量
innodb支持行级锁
行级锁可以最大程度的支持并发
行级锁是由存储引擎层实现的
什么是锁
锁对主要作用是管理共享资源的并发访问
用于实现事务的隔离性
锁的类型
共享锁（读锁）
独占锁（写锁）
MySQL锁的粒度
表级锁（开销小，并发性低），通常在服务器层实现
行级锁（开销大，并发性高），只会在存储引擎层面进行实现
阻塞和死锁
innodb状态检查
show engine innodb status
适用场景：
mysql5.7之后已经支持全文索引以及空间函数
适用于大多数OLTP应用（On-Line Transaction Processing联机事务处理过程(OLTP)也称为面向交易的处理过程，其基本特征是前台接收的用户数据可以立即传送到计算中心进行处理，并在很短的时间内给出处理结果，是对用户操作快速响应的方式之一。）
CSV存储引擎
数据以文本方式存储在文件中
.CSV文件存储表内容
.CSM文件存储表的元数据如表状态和数据量
.frm文件存储表结构信息（mysql服务器层所使用）
特点
以CSV格式进行数据存储
所有列必须都是不能为NULL的
不支持索引（不适合大表，不适合在线处理）
可以对数据文件直接编辑，保存文本文件内容
使用场景
适合作为数据交换的中间表
电子表格->CSV文件->MySQL数据目录
数据->CSV文件->其他web程序
Archive存储引擎
以zlib对表数据进行压缩，磁盘I/O更少
数据存储在ARZ为后缀的文件中
特点：
只支持insert和select操作
只允许在自增ID列上加索引
索引的实现，用的什么数据结构，b+tree的特点
B树是一种多路自平衡搜索树，它类似普通的二叉树，但是B书允许每个节点有更多的子节点。B树示意图如下：
Paste_Image.png
B树的特点：
（1）所有键值分布在整个树中
（2）任何关键字出现且只出现在一个节点中
（3）搜索有可能在非叶子节点结束
（4）在关键字全集内做一次查找，性能逼近二分查找算法
B+树是B树的变体，也是一种多路平衡查找树，B+树的示意图为：
Paste_Image.png
从图中也可以看到，B+树与B树的不同在于：
（1）所有关键字存储在叶子节点，非叶子节点不存储真正的data
（2）为所有叶子节点增加了一个链指针
那么问题来了，为什么用B/B+树这种结构来实现索引呢？？
答：红黑树等结构也可以用来实现索引，但是文件系统及数据库系统普遍使用B/B+树结构来实现索引。mysql是基于磁盘的数据库，索引是以索引文件的形式存在于磁盘中的，索引的查找过程就会涉及到磁盘IO(为什么涉及到磁盘IO请看文章后面的附加理解部分)消耗，磁盘IO的消耗相比较于内存IO的消耗要高好几个数量级，所以索引的组织结构要设计得在查找关键字时要尽量减少磁盘IO的次数。为什么要使用B/B+树，跟磁盘的存储原理有关。
局部性原理与磁盘预读
为了提升效率，要尽量减少磁盘IO的次数。实际过程中，磁盘并不是每次严格按需读取，而是每次都会预读。磁盘读取完需要的数据后，会按顺序再多读一部分数据到内存中，这样做的理论依据是计算机科学中注明的局部性原理：
当一个数据被用到时，其附近的数据也通常会马上被使用
程序运行期间所需要的数据通常比较集中
（1）由于磁盘顺序读取的效率很高(不需要寻道时间，只需很少的旋转时间)，
因此对于具有局部性的程序来说，预读可以提高I/O效率.预读的长度一般为页(page)的整倍数。
（2）MySQL(默认使用InnoDB引擎),将记录按照页的方式进行管理,每页大小默认为16K(这个值可以修改)。linux 默认页大小为4K。
B-Tree借助计算机磁盘预读的机制，并使用如下技巧：
每次新建节点时，直接申请一个页的空间，这样就保证一个节点物理上也存储在一个页里，加之计算机存储分配都是按页对齐的，就实现了一个结点只需一次I/O。
假设 B-Tree 的高度为 h,B-Tree中一次检索最多需要h-1次I/O（根节点常驻内存），渐进复杂度为O(h)=O(logdN)O(h)=O(logdN)。一般实际应用中，出度d是非常大的数字，通常超过100，因此h非常小（通常不超过3，也即索引的B+树层次一般不超过三层，所以查找效率很高）。
而红黑树这种结构，h明显要深的多。由于逻辑上很近的节点（父子）物理上可能很远，无法利用局部性，所以红黑树的I/O渐进复杂度也为O(h)，效率明显比B-Tree差很多。
为什么mysql的索引使用B+树而不是B树呢？？
（1）B+树更适合外部存储(一般指磁盘存储),由于内节点(非叶子节点)不存储data，所以一个节点可以存储更多的内节点，每个节点能索引的范围更大更精确。也就是说使用B+树单次磁盘IO的信息量相比较B树更大，IO效率更高。
（2）mysql是关系型数据库，经常会按照区间来访问某个索引列，B+树的叶子节点间按顺序建立了链指针，加强了区间访问性，所以B+树对索引列上的区间范围查询很友好。而B树每个节点的key和data在一起，无法进行区间查找。
------------------------------------------------------------END----------------------------------------------------------------
附加理解知识点：
B树是为了磁盘或其他设备而设计的多岔（相对于二岔）平衡查找树。，所以B树又叫平衡多路查找树。一颗m阶的B树的特性为：
1：树中每个节点含有最多m个孩子(m > 2)。
2：除根节点和叶子节点外，其他每个中间节点都至少有[ceil(m/2)]个孩子，ceil为向上取整。（不是很明白。。。）
Paste_Image.png
3：所有叶子节点都出现在同一层，且叶子节点不包含任何关键字信息(可以看做是外部接点或查询失败的接点，实际上这些结点不存在，指向这些结点的指针都为null)
4：每个非叶子节点包含有n个关键字信息(n，P0，K1，P1，K2，P2，......，Kn，Pn)，其中：
a) Ki (i=1...n)为关键字，且关键字按顺序升序排序K(i-1)< Ki。
b) Pi为指向子树根的接点，且指针P(i-1)指向子树种所有结点的关键字均小于Ki，但都大于K(i-1)。
c) 关键字的个数n必须满足： [ceil(m / 2)-1]<= n <= m-1。
这三天摘抄自文末参考，大致理解一下就行。
比如，我们通过上面那张btree结构来查找29这个元素，查找过程为：
（1）根据根节点找到文件目录的跟磁盘块1，将其中的信息装入到内存中【磁盘IO操作第1次】
（2）此时内存中有两个文件名17,35和三个存储其他磁盘页面地址的数据（指针），根据算法我们发现17 < 29 <35，因此我们找到指针p2
（3）根据指针p2我们找到磁盘块3，并将其中信息装入到内存中【磁盘IO操作第2次】
（4）此时内存中有两个文件名26，30和三个存储其他磁盘页面地址的数据（指针），根据算法我们发现26 <29<30，因为我们找到指针p2
（5）根据指针p2我们定位到磁盘块8，并将其中信息装入内存【磁盘IO操作第3次】
（6）此时内存中有两个文件名28，29。根据算法我们查找到文件29，并定位了该文件内存的磁盘地址。
参考:
由 B-/B+树看 MySQL索引结构
BTree和B+Tree详解
MySQL B+树索引和哈希索引的区别 ,这篇文章还提到了与hash索引的比较
concurrenthashmap底层，锁机制...
https://www.cnblogs.com/banjinbaijiu/p/9147434.html
https://blog.csdn.net/zhouhongshu/article/details/78901530
线程除了用synchronized还能用什么，让你自己设计同步怎么设计，
为何要使用同步？
java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），
将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，
从而保证了该变量的唯一性和准确性。
1.同步方法
即有synchronized关键字修饰的方法。
由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，
内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。
代码如：
public synchronized void save(){}
注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类
2.同步代码块
即有synchronized关键字修饰的语句块。
被该关键字修饰的语句块会自动被加上内置锁，从而实现同步
代码如：
synchronized(object){
}
注：同步是一种高开销的操作，因此应该尽量减少同步的内容。
通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。
代码实例：
package com.xhj.thread;
/**
* 线程同步的运用
*
* @author XIEHEJUN
*
*/
public class SynchronizedThread {
class Bank {
private int account = 100;
public int getAccount() {
return account;
}
/**
* 用同步方法实现
*
* @param money
*/
public synchronized void save(int money) {
account += money;
}
/**
* 用同步代码块实现
*
* @param money
*/
public void save1(int money) {
synchronized (this) {
account += money;
}
}
}
class NewThread implements Runnable {
private Bank bank;
public NewThread(Bank bank) {
this.bank = bank;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
// bank.save1(10);
bank.save(10);
System.out.println(i + "账户余额为：" + bank.getAccount());
}
}
}
/**
* 建立线程，调用内部类
*/
public void useThread() {
Bank bank = new Bank();
NewThread new_thread = new NewThread(bank);
System.out.println("线程1");
Thread thread1 = new Thread(new_thread);
thread1.start();
System.out.println("线程2");
Thread thread2 = new Thread(new_thread);
thread2.start();
}
public static void main(String[] args) {
SynchronizedThread st = new SynchronizedThread();
st.useThread();
}
}
3.使用特殊域变量(volatile)实现线程同步
a.volatile关键字为域变量的访问提供了一种免锁机制，
b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新，
c.因此每次使用该域就要重新计算，而不是使用寄存器中的值
d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量
例如：
在上面的例子当中，只需在account前面加上volatile修饰，即可实现线程同步。
代码实例：
//只给出要修改的代码，其余代码与上同
class Bank {
//需要同步的变量加上volatile
private volatile int account = 100;
public int getAccount() {
return account;
}
//这里不再需要synchronized
public void save(int money) {
account += money;
}
｝
注：多线程中的非同步问题主要出现在对域的读写上，如果让域自身避免这个问题，则就不需要修改操作该域的方法。
用final域，有锁保护的域和volatile域可以避免非同步的问题。
4.使用重入锁实现线程同步
在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。
ReentrantLock类是可重入、互斥、实现了Lock接口的锁，
它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力
ReenreantLock类的常用方法有：
ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁
unlock() : 释放锁
注：ReentrantLock()还有一个可以创建公平锁的构造方法，但由于能大幅度降低程序运行效率，不推荐使用
例如：
在上面例子的基础上，改写后的代码为:
代码实例：
//只给出要修改的代码，其余代码与上同
class Bank {
private int account = 100;
//需要声明这个锁
private Lock lock = new ReentrantLock();
public int getAccount() {
return account;
}
//这里不再需要synchronized
public void save(int money) {
lock.lock();
try{
account += money;
}finally{
lock.unlock();
}
}
｝
注：关于Lock对象和synchronized关键字的选择：
a.最好两个都不用，使用一种java.util.concurrent包提供的机制，
能够帮助用户处理所有与锁相关的代码。
b.如果synchronized关键字能满足用户的需求，就用synchronized，因为它能简化代码
c.如果需要更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally代码释放锁
5.使用局部变量实现线程同步
如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，
副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。
ThreadLocal 类的常用方法
ThreadLocal() : 创建一个线程本地变量
get() : 返回此线程局部变量的当前线程副本中的值
initialValue() : 返回此线程局部变量的当前线程的"初始值"
set(T value) : 将此线程局部变量的当前线程副本中的值设置为value
例如：
在上面例子基础上，修改后的代码为：
代码实例：
//只改Bank类，其余代码与上同
public class Bank{
//使用ThreadLocal类管理共享变量account
private static ThreadLocal<Integer> account = new ThreadLocal<Integer>(){
@Override
protected Integer initialValue(){
return 100;
}
};
public void save(int money){
account.set(account.get()+money);
}
public int getAccount(){
return account.get();
}
}
注：ThreadLocal与同步机制
a.ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题。
b.前者采用以"空间换时间"的方法，后者采用以"时间换空间"的方式
6.使用阻塞队列实现线程同步
前面5种同步方式都是在底层实现的线程同步，但是我们在实际开发当中，应当尽量远离底层结构。
使用javaSE5.0版本中新增的java.util.concurrent包将有助于简化开发。
本小节主要是使用LinkedBlockingQueue<E>来实现线程的同步
LinkedBlockingQueue<E>是一个基于已连接节点的，范围任意的blocking queue。
队列是先进先出的顺序（FIFO），关于队列以后会详细讲解~
LinkedBlockingQueue 类常用方法
LinkedBlockingQueue() : 创建一个容量为Integer.MAX_VALUE的LinkedBlockingQueue
put(E e) : 在队尾添加一个元素，如果队列满则阻塞
size() : 返回队列中的元素个数
take() : 移除并返回队头元素，如果队列空则阻塞
代码实例：
实现商家生产商品和买卖商品的同步
1 package com.xhj.thread;
2
3 import java.util.Random;
4 import java.util.concurrent.LinkedBlockingQueue;
5
6 /**
7 * 用阻塞队列实现线程同步 LinkedBlockingQueue的使用
8 *
9 * @author XIEHEJUN
10 *
11 */
12 public class BlockingSynchronizedThread {
13 /**
14 * 定义一个阻塞队列用来存储生产出来的商品
15 */
16 private LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>();
17 /**
18 * 定义生产商品个数
19 */
20 private static final int size = 10;
21 /**
22 * 定义启动线程的标志，为0时，启动生产商品的线程；为1时，启动消费商品的线程
23 */
24 private int flag = 0;
25
26 private class LinkBlockThread implements Runnable {
27 @Override
28 public void run() {
29 int new_flag = flag++;
30 System.out.println("启动线程 " + new_flag);
31 if (new_flag == 0) {
32 for (int i = 0; i < size; i++) {
33 int b = new Random().nextInt(255);
34 System.out.println("生产商品：" + b + "号");
35 try {
36 queue.put(b);
37 } catch (InterruptedException e) {
38 // TODO Auto-generated catch block
39 e.printStackTrace();
40 }
41 System.out.println("仓库中还有商品：" + queue.size() + "个");
42 try {
43 Thread.sleep(100);
44 } catch (InterruptedException e) {
45 // TODO Auto-generated catch block
46 e.printStackTrace();
47 }
48 }
49 } else {
50 for (int i = 0; i < size / 2; i++) {
51 try {
52 int n = queue.take();
53 System.out.println("消费者买去了" + n + "号商品");
54 } catch (InterruptedException e) {
55 // TODO Auto-generated catch block
56 e.printStackTrace();
57 }
58 System.out.println("仓库中还有商品：" + queue.size() + "个");
59 try {
60 Thread.sleep(100);
61 } catch (Exception e) {
62 // TODO: handle exception
63 }
64 }
65 }
66 }
67 }
68
69 public static void main(String[] args) {
70 BlockingSynchronizedThread bst = new BlockingSynchronizedThread();
71 LinkBlockThread lbt = bst.new LinkBlockThread();
72 Thread thread1 = new Thread(lbt);
73 Thread thread2 = new Thread(lbt);
74 thread1.start();
75 thread2.start();
76
77 }
78
79 }
注：BlockingQueue<E>定义了阻塞队列的常用方法，尤其是三种添加元素的方法，我们要多加注意，当队列满时：
add()方法会抛出异常
offer()方法返回false
put()方法会阻塞
7.使用原子变量实现线程同步
需要使用线程同步的根本原因在于对普通变量的操作不是原子的。
那么什么是原子操作呢？
原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作
即-这几种行为要么同时完成，要么都不完成。
在java的util.concurrent.atomic包中提供了创建了原子类型变量的工具类，
使用该类可以简化线程同步。
其中AtomicInteger 表可以用原子方式更新int的值，可用在应用程序中(如以原子方式增加的计数器)，
但不能用于替换Integer；可扩展Number，允许那些处理机遇数字类的工具和实用工具进行统一访问。
AtomicInteger类常用方法：
AtomicInteger(int initialValue) : 创建具有给定初始值的新的AtomicInteger
addAddGet(int dalta) : 以原子方式将给定值与当前值相加
get() : 获取当前值
代码实例：
只改Bank类，其余代码与上面第一个例子同
1 class Bank {
2 private AtomicInteger account = new AtomicInteger(100);
3
4 public AtomicInteger getAccount() {
5 return account;
6 }
7
8 public void save(int money) {
9 account.addAndGet(money);
10 }
11 }
补充--原子操作主要有：
对于引用变量和大多数原始变量(long和double除外)的读写操作；
对于所有使用volatile修饰的变量(包括long和double)的读写操作。