蚂蚁金服电话面试

今天把项目上线了，终于有一天早下班，在地铁上就接到蚂蚁金服的面试电话，猝不及防，在地铁上不方便，我就让他在十分钟后打电话给我。
十分钟后匆匆忙忙稍微找了个比较安静，其实也不安静的地方，面试官打电话给我了。
首先他自我介绍了一下，然后开始问问题了。

1、object里面有什么方法？为什么要有wait和notify方法？

2、wait和sleep和await的区别？

wait和sleep的区别

• 参考
• （来源）这两个方法来自不同的类分别是Thread和Object
• （是否释放锁）最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法(锁代码块和方法锁)
• （使用范围）wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用(使用范围)
• （异常）sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
• （功能）sleep方法属于Thread类中方法，表示让一个线程进入睡眠状态，等待一定的时间之后，自动醒来进入到可运行状态，不会马上进入运行状态，因为线程调度机制恢复线程的运行也需要时间，一个线程对象调用了sleep方法之后，并不会释放他所持有的所有对象锁，所以也就不会影响其他进程对象的运行。但在sleep的过程中过程中有可能被其他对象调用它的interrupt(),产生InterruptedException异常，如果你的程序不捕获这个异常，线程就会异常终止，进入TERMINATED状态，如果你的程序捕获了这个异常，那么程序就会继续执行catch语句块(可能还有finally语句块)以及以后的代码。
• 注意sleep()方法是一个静态方法，也就是说他只对当前对象有效，通过t.sleep()让t对象进入sleep，这样的做法是错误的，它只会是使当前线程被sleep 而不是t线程
• （如何唤醒）wait属于Object的成员方法，一旦一个对象调用了wait方法，必须要采用notify()和notifyAll()方法唤醒该进程;如果线程拥有某个或某些对象的同步锁，那么在调用了wait()后，这个线程就会释放它持有的所有同步资源，而不限于这个被调用了wait()方法的对象。wait()方法也同样会在wait的过程中有可能被其他对象调用interrupt()方法而产生 InterruptedException异常.
• 如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep/join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。
• 需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到wait()/sleep()/join()后，就会立刻抛出InterruptedException。
• （使用范围）wait()和notify()因为会对对象的“锁标志”进行操作，所以它们必须在synchronized函数或synchronized block中进行调用。如果在non-synchronized函数或non-synchronizedblock中进行调用，虽然能编译通过，但在运行时会发生illegalMonitorStateException的异常。
  • yield方法 暂停当前正在执行的线程对象。
    yield()方法是停止当前线程，让同等优先权的线程或更高优先级的线程有执行的机会。如果没有的话，那么yield()方法将不会起作用，并且由可执行状态后马上又被执行。 join方法是用于在某一个线程的执行过程中调用另一个线程执行，等到被调用的线程执行结束后，再继续执行当前线程。如：t.join();//主要用于等待t线程运行结束，若无此句，main则会执行完毕，导致结果不可预测。

wait和await的区别

在使用Lock之前，我们都使用Object 的wait和notify实现同步的。举例来说，一个producer和consumer，consumer发现没有东西了，等待，produer生成东西了，唤醒。

线程consumer	线程producer
synchronize(obj){ //没东西了，等待 obj.wait(); }	synchronize(obj){ //有东西了，唤醒 bj.notify(); }

有了lock后，世道变了，现在是：

线程consumer	线程producer
lock.lock(); condition.await(); lock.unlock();	lock.lock(); condition.signal(); lock.unlock();

为了突出区别，省略了若干细节。区别有三点：

1. lock不再用synchronize把同步代码包装起来；
2. 阻塞需要另外一个对象condition；
3. 同步和唤醒的对象是condition而不是lock，对应的方法是await和signal，而不是wait和notify
   为什么需要使用condition呢？简单一句话，lock更灵活。以前的方式只能有一个等待队列，在实际应用时可能需要多个，比如读和写。为了这个灵活性，lock将同步互斥控制和等待队列分离开来，互斥保证在某个时刻只有一个线程访问临界区（lock自己完成），等待队列负责保存被阻塞的线程（condition完成）。

通过查看ReentrantLock的源代码发现，condition其实是等待队列的一个管理者，condition确保阻塞的对象按顺序被唤醒。

1.object.wait()

使用方法:

线程A:

synchronized(obj){

obj.wait(); //此时当前线程释放obj锁，进入[等待状态]，等待其他线程执行obj.notify()时才有可能执行（有可能执行的意思可能有多个线程执行了wait）

A do something

}

线程C:

synchronized(obj){

obj.wait(); //此时当前线程释放obj锁，进入[等待状态]，等待其他线程执行obj.notify()时才有可能执行（有可能执行的意思可能有多个线程执行了wait）

C do something

}

线程B:

synchronized(obj){

obj.notify(); //此时当前线程释放obj锁，随机唤醒一个处于等待状态的线程，继续执行wait后面的程序。

}

假设三个线程执行顺序

线程A–>线程C–>线程B //没毛病，因为wait后是释放了锁的

所以问题来了：等待的线程中有A和C, B notify后，只会唤醒其中一个执行(notifyAll同样只有一个执行)；假如我们的需求是想让A线程执行，那么这种object的方式是无法控制的

2.所以condition来了

使用方法：注意condition是依赖ReentrantLock

ReentrantLock lock = new ReentrantLock(true);

Condition aCondition = reentrantLock.newCondition();

Condition cCondition = reentrantLock.newCondition();

线程A:

{

lock.lock();

aCondition.await(); //此时当前线程释放lock锁，进入[等待状态]，等待其他线程执行aCondition.signal()时才有可能执行

A do something

lock.unlock();

}

线程C:

{

lock.lock();

cCondition.await();

do something

lock.unlock();

}

线程B:

{

lock.lock();

aCondition.signal(); //此时当前线程释放lock锁，随机唤醒一个处于等待状态等待aCondition的线程，继续执行await后面的程序。

//cCondition.signal(); 此时当前线程释放lock锁，随机唤醒一个处于等待状态等待cCondition的线程，继续执行await后面的程序。

lock.unlock();

}

所以通过condition与object进行线程通信的区别已经很明显了，condition更加灵活。

个人理解，本质上来讲：

多线程环境的下，线程直接的互斥[执行]依靠的应该是锁Lock，线程的之间的[通信]依靠的应该是条件Condition/信号，一般情况下lock确实可以同时满足做这两个事情，所以在Object的方式满足了这个一般情况，但是肯定会有复杂的场景比如刚才例子中，需要让满足一定条件的线程执行，仅仅依靠锁是不能完美解决的。所以condition实际上分离了执行和通信。

3、join和yield的区别？

yield()方法是停止当前线程，让同等优先权的线程或更高优先级的线程有执行的机会。如果没有的话，那么yield()方法将不会起作用，并且由可执行状态后马上又被执行。 join方法是用于在某一个线程的执行过程中调用另一个线程执行，等到被调用的线程执行结束后，再继续执行当前线程。如：t.join();//主要用于等待t线程运行结束，若无此句，main则会执行完毕，导致结果不可预测。

4、什么时候用synchronized什么时候用lock

synchronized原语和ReentrantLock在一般情况下没有什么区别，但是在非常复杂的同步应用中，请考虑使用ReentrantLock，特别是遇到下面2种需求的时候。
1.(响应中断)某个线程在等待一个锁的控制权的这段时间需要中断
2.（多线程交互）需要分开处理一些wait-notify，ReentrantLock里面的Condition应用，能够控制notify哪个线程
3.（公平锁和非公平锁（效率高））具有公平锁功能，每个到来的线程都将排队等候
https://blog.youkuaiyun.com/weixin_44578690/article/details/86624002#synchronizedlock_27

5、synchronized的原理

https://blog.youkuaiyun.com/javazejian/article/details/72828483#synchronized底层语义原理
同步代码块是使用monitorenter和monitorexit指令实现的，同步方法（在这看不出来需要看JVM底层实现）依靠的是方法修饰符上的ACC_SYNCHRONIZED实现
同步语句块的实现使用的是monitorenter 和 monitorexit 指令，其中monitorenter指令指向同步代码块的开始位置，monitorexit指令则指明同步代码块的结束位置，当执行monitorenter指令时，当前线程将试图获取 objectref(即对象锁) 所对应的 monitor 的持有权，当 objectref 的 monitor 的进入计数器为 0，那线程可以成功取得 monitor，并将计数器值设置为 1，取锁成功。如果当前线程已经拥有 objectref 的 monitor 的持有权，那它可以重入这个 monitor (关于重入性稍后会分析)，重入时计数器的值也会加 1。倘若其他线程已经拥有 objectref 的 monitor 的所有权，那当前线程将被阻塞，直到正在执行线程执行完毕，即monitorexit指令被执行，执行线程将释放 monitor(锁)并设置计数器值为0 ，其他线程将有机会持有 monitor 。值得注意的是编译器将会确保无论方法通过何种方式完成，方法中调用过的每条 monitorenter 指令都有执行其对应 monitorexit 指令，而无论这个方法是正常结束还是异常结束。为了保证在方法异常完成时 monitorenter 和 monitorexit 指令依然可以正确配对执行，编译器会自动产生一个异常处理器，这个异常处理器声明可处理所有的异常，它的目的就是用来执行 monitorexit 指令。从字节码中也可以看出多了一个monitorexit指令，它就是异常结束时被执行的释放monitor 的指令。
方法级的同步是隐式，即无需通过字节码指令来控制的，它实现在方法调用和返回操作之中。JVM可以从方法常量池中的方法表结构(method_info Structure) 中的 ACC_SYNCHRONIZED 访问标志区分一个方法是否同步方法。当方法调用时，调用指令将会 检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先持有monitor（虚拟机规范中用的是管程一词）， 然后再执行方法，最后再方法完成(无论是正常完成还是非正常完成)时释放monitor。在方法执行期间，执行线程持有了monitor，其他任何线程都无法再获得同一个monitor。如果一个同步方法执行期间抛 出了异常，并且在方法内部无法处理此异常，那这个同步方法所持有的monitor将在异常抛到同步方法之外时自动释放。
这便是synchronized锁在同步代码块和同步方法上实现的基本原理。同时我们还必须注意到的是在Java早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，而操作系统实现线程之间的切换时需要从用户态转换到核心态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，这也是为什么早期的synchronized效率低的原因。庆幸的是在Java 6之后Java官方对从JVM层面对synchronized较大优化，所以现在的synchronized锁效率也优化得很不错了，Java 6之后，为了减少获得锁和释放锁所带来的性能消耗，引入了轻量级锁和偏向锁，接下来我们将简单了解一下Java官方在JVM层面对synchronized锁的优化。
Java虚拟机对synchronized的优化
锁的状态总共有四种，无锁状态、偏向锁、轻量级锁和重量级锁。随着锁的竞争，锁可以从偏向锁升级到轻量级锁，再升级的重量级锁，但是锁的升级是单向的，也就是说只能从低到高升级，不会出现锁的降级，关于重量级锁，前面我们已详细分析过，下面我们将介绍偏向锁和轻量级锁以及JVM的其他优化手段，这里并不打算深入到每个锁的实现和转换过程更多地是阐述Java虚拟机所提供的每个锁的核心优化思想，毕竟涉及到具体过程比较繁琐，如需了解详细过程可以查阅《深入理解Java虚拟机原理》。

• 偏向锁
  偏向锁是Java 6之后加入的新锁，它是一种针对加锁操作的优化手段，经过研究发现，在大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，因此为了减少同一线程获取锁(会涉及到一些CAS操作,耗时)的代价而引入偏向锁。偏向锁的核心思想是，如果一个线程获得了锁，那么锁就进入偏向模式，此时Mark Word 的结构也变为偏向锁结构，当这个线程再次请求锁时，无需再做任何同步操作，即获取锁的过程，这样就省去了大量有关锁申请的操作，从而也就提供程序的性能。所以，对于没有锁竞争的场合，偏向锁有很好的优化效果，毕竟极有可能连续多次是同一个线程申请相同的锁。但是对于锁竞争比较激烈的场合，偏向锁就失效了，因为这样场合极有可能每次申请锁的线程都是不相同的，因此这种场合下不应该使用偏向锁，否则会得不偿失，需要注意的是，偏向锁失败后，并不会立即膨胀为重量级锁，而是先升级为轻量级锁。下面我们接着了解轻量级锁。

• 轻量级锁
  倘若偏向锁失败，虚拟机并不会立即升级为重量级锁，它还会尝试使用一种称为轻量级锁的优化手段(1.6之后加入的)，此时Mark Word 的结构也变为轻量级锁的结构。轻量级锁能够提升程序性能的依据是“对绝大部分的锁，在整个同步周期内都不存在竞争”，注意这是经验数据。需要了解的是，轻量级锁所适应的场景是线程交替执行同步块的场合，如果存在同一时间访问同一锁的场合，就会导致轻量级锁膨胀为重量级锁。

• 自旋锁
  轻量级锁失败后，虚拟机为了避免线程真实地在操作系统层面挂起，还会进行一项称为自旋锁的优化手段。这是基于在大多数情况下，线程持有锁的时间都不会太长，如果直接挂起操作系统层面的线程可能会得不偿失，毕竟操作系统实现线程之间的切换时需要从用户态转换到核心态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，因此自旋锁会假设在不久将来，当前的线程可以获得锁，因此虚拟机会让当前想要获取锁的线程做几个空循环(这也是称为自旋的原因)，一般不会太久，可能是50个循环或100循环，在经过若干次循环后，如果得到锁，就顺利进入临界区。如果还不能获得锁，那就会将线程在操作系统层面挂起，这就是自旋锁的优化方式，这种方式确实也是可以提升效率的。最后没办法也就只能升级为重量级锁了。

• 锁消除
  消除锁是虚拟机另外一种锁的优化，这种优化更彻底，Java虚拟机在JIT编译时(可以简单理解为当某段代码即将第一次被执行时进行编译，又称即时编译)，通过对运行上下文的扫描，去除不可能存在共享资源竞争的锁，通过这种方式消除没有必要的锁，可以节省毫无意义的请求锁时间，如下StringBuffer的append是一个同步方法，但是在add方法中的StringBuffer属于一个局部变量，并且不会被其他线程所使用，因此StringBuffer不可能存在共享资源竞争的情景，JVM会自动将其锁消除。

/**
 * Created by zejian on 2017/6/4.
 * Blog : http://blog.youkuaiyun.com/javazejian [原文地址,请尊重原创]
 * 消除StringBuffer同步锁
 */
public class StringBufferRemoveSync {

    public void add(String str1, String str2) {
        //StringBuffer是线程安全,由于sb只会在append方法中使用,不可能被其他线程引用
        //因此sb属于不可能共享的资源,JVM会自动消除内部的锁
        StringBuffer sb = new StringBuffer();
        sb.append(str1).append(str2);
    }

    public static void main(String[] args) {
        StringBufferRemoveSync rmsync = new StringBufferRemoveSync();
        for (int i = 0; i < 10000000; i++) {
            rmsync.add("abc", "123");
        }
    }

}

6、线程的几种状态？

NEW、RUNNABLE、（BLOCKED、WAITING、TIMED_WAITING）、TERMINATED
查看

7、线程池的优势？线程池的原理

线程池的优势

1、（重用）重用存在的线程、减少对象创建、消亡的开销、性能佳
2、（控制并发）可以有效控制最大并发线程数，提高系统资源利用率，同时可以避免过多资源竞争，避免阻塞
3、（定时功能）提供定时、定期执行、单线程、并发控制等功能

线程池原理

public ThreadPoolExecutor(int corePoolSize,
                               int maximumPoolSize,
                               long keepAliveTime,
                               TimeUnit unit,
                               BlockingQueue<Runnable> workQueue,
                               RejectedExecutionHandler handler) 

corePoolSize：线程池核心线程数量
workQueue：存放任务的队列
maximumPoolSize:线程池最大线程数量
keepAliveTime：当活跃线程数大于核心线程数时，空闲的多余线程最大存活时间
unit：存活时间的单位
handler：超出线程范围和队列容量的任务的处理程序（拒绝策略）
线程池的实现原理：
提交一个任务到线程池中，线程池的处理流程如下：
1、判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。
2、线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。
3、判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

参考：https://www.cnblogs.com/dongguacai/p/6030187.html

8、ThreadLocal的原理？ThreadLocal有什么问题？如何解决？

请参考这里
回答完threadLocal的时候，面试官就说抓重点，把东西回答完就可以，不要绕。可能当时太紧张了，也没有准备好，回答的不清晰，不够镇定啊。
接下去就问看过什么源码。我回答hashMap和netty

9、看过什么源码？netty的三层模型？为什么用netty？什么是零拷贝？

netty基本组件

为什么用netty，netty的高性能体现

1、异步非阻塞io
2、高效的Reactor线程模型
3、volatile的大量、正确使用
4、cas和原子类的广泛使用
5、线程安全容器的使用
6、通过读写锁提高并发性能
7、高性能的序列化框架
8、零拷贝、IO性能优化
9、TCP参数可以灵活配置

什么是零拷贝

使用堆外内存，也就是直接内存，避免从堆到内存的拷贝。

10、netty如何使用堆外内存？堆外内存如何分配如何回收？

体现

1、netty的接收和发送byteBuffer采用DIRECT BUFFERS，使用堆外直接内存进行socket直接读写，不需要进行字节流缓冲区的二次拷贝。如果使用传统的堆内存（HEAP BUFFERS）进行socket读写，jvm会将堆内存拷贝一份到直接内存中，然后才写入到socket里面。相比于堆外直接内存，消息在发送过程中多了一次缓冲区的内存拷贝。
2、netty提供了CompositeByteBuf类，它可以将多个ByteBuf合并为一个逻辑上的ByteBuf，避免了传统通过内存拷贝的方式将几个小Buffer合成一个大的Buffer
3、通过FileRegion包装的FileChannel.tranferTo方法实现文件传输，可以直接将文件缓冲区的数据发送到目标Channel，避免了传统通过循环write方式导致内存拷贝问题。
4、通过wrap操作，我们可以将byte[]数组、ByteBuf、ByteBuffer等包装成一个Netty ByteBuf对象，进而避免了拷贝操作。

堆外内存如何分配回收

https://blog.youkuaiyun.com/weixin_44578690/article/details/86649967

• unpooled
  • 非unsafe：通过buffer索引操作数组(buffer底层最终通过unsafe)
  • unsafe：通过UNSAFE（内存地址+偏移量）操作buffer(buffer底层最终通过unsafe)
• pooled
  • 1、从对象池里面拿到PooledByteBuf进行复用
  • 2、从缓存上面进行分配
    • 1、找到对应size的MemoryRegionCache
    • 2、从queue中弹出一个entry给ByteBuf初始化
    • 3、将弹出的entry扔到对象池里面复用。
  • 3、从内存堆里面进行内存分配（如果在缓存上分配不成功，就在内存堆里面分配）
    • page级别内存分配
      • 1、尝试在现有的chunk上面分配内存。
      • 2、如果现有的chunk分配不成功，那就创建一个chunk进行内存分配
      • 3、初始化PooledByteBuf，也就是将PooledByteBuf需要的内存指向chunk的内存。
    • subpage级别内存分配
      • 1、定位一个subpage对象
      • 2、初始化subpage
      • 3、初始化pooledByteBuf

11、BIO、NIO、AIO的区别

从一些线程的角度去回答

这些答得不太好，看过很久了，突然想不起来。
面试官又开始说我说得不清晰了，估计就是我对这些印象有点模糊，我就说太久了忘记了，面试官说你没有把东西转换为自己的，然后就很好心的提醒我，以后回答别的面试官，要清晰，阿里的面试官还是很好的。
接下去。

12、平时用什么数据库？mysql设计注意什么？索引讲一下？mysql的引擎选择。

mysql设计

• 1、适度冗余， 让query尽量减少join
• 虽然optimizer会对query进行一定的优化，但有时候遇见复杂的join，优化效果并不令人满意，再加上本来join的性能开销，所以需要尽量的减少join，而需要通过冗余来实现。比如：有两个数据表分别为用户信息表和用户发帖表，在展示发帖列表时，如果没有冗余的话，两个表要join以取得想要的发帖信息和用户昵称，但如果考虑冗余，用户昵称占用空间不大，如果在发帖表里增加这么一个字段的话，在展示列表时就不用做join操作了，性能会得到很大的改善。
  但冗余也会带来一些问题，比如在发帖表里增加了用户昵称字段，就得维护两份用户昵称数据，为了保证数据的一致性，在用户昵称发生改变时，就得向两个表做更新操作，程序中就得做更多的处理。但相比的话，更新频率显然不及查询频率，这样通过增加少量的更新操作会换来更大的性能提升，这也是在项目中经常采用的优化手段。
• 2、选择合适的数据类型
  要选择合适的数据类型必须要先了解不同数据类型间的差异。
  数字类型有整数类型和浮点数类型，还有一类是通过二进制格式以字符串来存放的数字类型，如DECIMAL(size,d)，其存放长度主要通过定义的size决定，size定义多大，则实际存放就有多长。默认的size为10，d为0。这种类型的存放长度较长而且完全可以用整形来代替实现，所以不推荐使用。
  时间类型主要使用DATE，DATETIME和TIMESTAMP三种类型，TIMESTAMP占用存储空间最少，只要4个字节，其它两种类型都要占用8个字节。从存储内容来看，TIMESTAMP只能存储1970年之后的时间，另外两种都能存储从1001开始的时间。
  特别要说明的是varchar类型，varchar(size)，在mysql5.0.3之前size表示的是字节数，mysql5.0.3之后size表示的是字符数。这里我们只关注mysql5.0.3之后的表示，size表示的字符数最大限制和字符集有关，如果是gbk编码，最大长度为(65535-1-2)/2=32766，减1的原因是实际行存储从第二个字节开始，减2的原因是varchar头部的2个字节表示长度，除2因为是gbk编码；如果是utf8编码，最大长度为(65535-1-2)/3=21844。
  如果数据量一样，但数据类型更小的话，数据存放同样的数据就会占用更少的空间，这样检索同样的数据所带来的IO消耗自然会降低，性能也就很自然的得到提升。此外，mysql对不同类型的数据，处理方式也不一样，比如在运算或者排序操作中，越简单的数据类型操作性能越高，所以对于要频繁进行运算或者排序的字段尽量选择简单的数据类型。
• 3、大字段垂直分拆
  所谓的大字段，没有一个很严格的标准，常用的是如果一个字段的大小占整条记录的50%以上，我们就视为其为大字段。大字段垂直分拆相比适度冗余是完全相反的操作，适度冗余是将别的表中的字段放进一个表中，而大字段分拆是将自身的大字段拆分出去放进另一个表中。
  这两个优化策略貌似是矛盾的，但要根据具体的应用场景来分析，适度冗余是因为在频率较高的查询中要使用该字段，为了减少join的性能开销。而大字段垂直分拆是将在查询中不使用的大字段拿出去，虽然不使用该字段但mysql在查询时并不是只需要访问需要查询的那几个字段，而是读取所有的字段，所以即使不使用字段，mysql也会读取该字段，为了节省IO开销，所以将查询中不常使用的大字段分拆出去。比如：拿博客系统为例，常用的作法是将博客内容从博客列表里分拆出去建立一个博客内容表，因为访问博客列表时并不需要读取博客内容，分拆出去之后，访问博客列表的性能将会大大的提升。但同时访问博客内容时就得做一次join操作了，性能对比的话，join操作两个表是一对一的关系，性能开销会很低。
• 4、大表水平分拆
  举例说明：在一个论坛系统里，管理员经常会发一些帖子，这些帖子要求在每个分类列表里都要置顶。
  设计方案一：在发帖表里增加一列用来标示是否是管理员发帖，这样在每个分类列表展示时就需要对发帖表查询两次，一次是置顶帖，一次是普通帖，然后将两次结果合并。如果发帖表内容较大时，查询置顶帖的性能开销会比较大。
  设计方案二：将置顶帖存放在一个单独的置顶表里。因为置顶帖数量相比会很少，但访问频率很高，这样从发帖表里分拆开来，访问的性能开销会少很多。

MyISAM和InnoDB

参考

1. 事务支持
   MyISAM不支持事务，而InnoDB支持。InnoDB的AUTOCOMMIT默认是打开的，即每条SQL语句会默认被封装成一个事务，自动提交，这样会影响速度，所以最好是把多条SQL语句显示放在begin和commit之间，组成一个事务去提交。
   MyISAM是非事务安全型的，而InnoDB是事务安全型的，默认开启自动提交，宜合并事务，一同提交，减小数据库多次提交导致的开销，大大提高性能。
2. 全文索引
   MyISAM：支持(FULLTEXT类型的)全文索引
   InnoDB：不支持(FULLTEXT类型的)全文索引，但是innodb可以使用sphinx插件支持全文索引，并且效果更好。
   全文索引是指对char、varchar和text中的每个词（停用词除外）建立倒排序索引。MyISAM的全文索引其实没啥用，因为它不支持中文分词，必须由使用者分词后加入空格再写到数据表里，而且少于4个汉字的词会和停用词一样被忽略掉。
   另外，MyIsam索引和数据分离，InnoDB在一起，MyIsam天生非聚簇索引，最多有一个unique的性质，InnoDB的数据文件本身就是主键索引文件，这样的索引被称为“聚簇索引”
3. 查询效率
   没有where的count()使用MyISAM要比InnoDB快得多。因为MyISAM内置了一个计数器，count()时它直接从计数器中读，而InnoDB必须扫描全表。所以在InnoDB上执行count()时一般要伴随where，且where中要包含主键以外的索引列。为什么这里特别强调“主键以外”？因为InnoDB中primary index是和raw data存放在一起的，而secondary index则是单独存放，然后有个指针指向primary key。所以只是count()的话使用secondary index扫描更快，而primary key则主要在扫描索引同时要返回raw data时的作用较大。MyISAM相对简单，所以在效率上要优于InnoDB，小型应用可以考虑使用MyISAM。
4. 外键
   MyISAM：不支持
   InnoDB：支持

通过上述的分析，基本上可以考虑使用InnoDB来替代MyISAM引擎了，原因是InnoDB自身很多良好的特点，比如事务支持、存储 过程、视图、行级锁定等等，在并发很多的情况下，相信InnoDB的表现肯定要比MyISAM强很多。另外，任何一种表都不是万能的，只用恰当的针对业务类型来选择合适的表类型，才能最大的发挥MySQL的性能优势。如果不是很复杂的Web应用，非关键应用，还是可以继续考虑MyISAM的，这个具体情况可以自己斟酌.
MyISAM和InnoDB两者的应用场景：

1. MyISAM管理非事务表。它提供高速存储和检索，以及全文搜索能力。如果应用中需要执行大量的SELECT查询，那么MyISAM是更好的选择。
2. InnoDB用于事务处理应用程序，具有众多特性，包括ACID事务支持。如果应用中需要执行大量的INSERT或UPDATE操作，则应该使用InnoDB，这样可以提高多用户并发操作的性能。

13、索引需要注意什么？为什么联合索引是遵循最左匹配原则？b+ tree

索引的最左匹配特性

参考
当b+树的数据项是复合的数据结构，比如(name,age,sex)的时候，b+数是按照从左到右的顺序来建立搜索树的，比如当(张三,20,F)这样的数据来检索的时候，b+树会优先比较name来确定下一步的所搜方向，如果name相同再依次比较age和sex，最后得到检索的数据；但当(20,F)这样的没有name的数据来的时候，b+树就不知道下一步该查哪个节点，因为建立搜索树的时候name就是第一个比较因子，必须要先根据name来搜索才能知道下一步去哪里查询。比如当(张三,F)这样的数据来检索时，b+树可以用name来指定搜索方向，但下一个字段age的缺失，所以只能把名字等于张三的数据都找到，然后再匹配性别是F的数据了， 这个是非常重要的性质，即索引的最左匹配特性。

最后还是一样的，提醒我答题一定要思路清晰，遇到别的面试官也要这样，这位面试官真是很好的。
大概想起这些题目，不过还是打了45分钟，肯定是我太啰嗦了，面试官苦口婆心教导我，还要我回去好好准备下那些没有回答好的问题。