分类 面试 下的文章

1、什么是阻塞队列?阻塞队列的实现原理是什么?如何使用阻塞队列来实现生产者-消费者模型?

阻塞队列是一个支持两个附加操作的队列。
这两个附加的操作是:队列为空时,获取元素的线程会等待队列变为非空。当队列满时,存储元素的线程会等待队列可用。
阻塞队列常用于生产者和消费者的场景,生产者时往队列里添加元素的线程,消费者时从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器,而消费者也只从容器中拿元素。

JDK7 提供了7个阻塞队列。分别是:ArrayBlockingQueue:一个由数据结构组成的有界阻塞队列。
LinkedBlockingQueue:一个由链表结构组成的有界阻塞队列。
PriorityBlockingQueue:一个支持优先级排序的无界阻塞队列。
DelayQueue:一个使用优先级队列实现的无界阻塞队列。
SynchronousQueue:一个不存储元素的阻塞队列。
LinkedTransferQueue:一个由链表结构组成的无界阻塞队列。
LinkedBlockingDeque:一个由链表结构组成的双向阻塞队列。

Java5 之前实现同步存取时,可以使用普通的一个集合,然后在使用线程的协作和线程同步可以实现生产者,消费者模式,主要的技术就是用好 wait,notify,notifyAll,sychronized 这些关键字。而在 Java5 之后,可以使用阻塞队列来实现,此方法大大减少了代码量,使得多线程编程更加容易,安全方面也有保障。

BlockingQueue 接口时 Queue 的子接口,它的主要用途并不是作为容器,而是作为线程同步的工具,因此他具有一个很明显的特性,当生产者线程试图向 BlockingQueue 放入元素时,如果队列已满,则线程被阻塞,当消费者试图从中取出一个元素时,如果队列为空,则该线程会被阻塞,正是因为他所具有这个特性,所以在程序中多个线程交替向 BlockingQueue 中放入元素,取出元素,它可以很好的控制线程之间的通信。

阻塞队列使用最经典的场景就是 socket 客户端数据的读取和解析,读取数据的线程不断将数据放入队列,然后解析线程不断从队列取数据解析。

2、java中有几种方法可以实现一个线程?

继承 Thread 类
实现 Runnable() 接口
实现 Callable 接口,需要实现的是 call() 方法

3、什么是 Callable 和 Future?

Callable 接口类似于 Runnable,从名字就可以看出来了,但是 Runnable 不会返回结果,并且无法抛出返回结果的异常,而 Callable 功能更强大一些,被线程执行后,可以返回值,这个返回值可以被 Future 拿到,也就是说,Future可以拿到异步执行任务的返回值。
可以认为是带有回调的 Runnable。
Funture 接口表示异步任务,是还没有完成的任务给出的未来结果。所以说,Callable 用于产生结果,Future 用于获取结果。

4、什么是 FutureTask?使用 ExecutorService 启动任务。

在 Java 并发程序中 FutureTask 表示一个可以取消的异步运算。它有启动和取消运算、查询运算是否完成和取回返回结果等方法。只有当运算完成的时候结果才能取回,如果运算尚未完成 get 方法将会阻塞。一个 FutureTask 对象可以对调用了 Callable 和 Runnable 的对象进行包装,由于 FutureTask 也是调用了 Runnable 接口,所以它可以提交给 Executor 来执行。

5、什么是并发容器的实现?

何为同步容器:可以简单地理解为通过 synchronized 来实现同步的容器,如果有多个线程调用同步容器的方法,它们将会串行执行。比如 Vector, Hashtable 以及 Collections.synchronizedSet,synchronizedList 等方法返回的容器。可以通过查看 Vector,Hashtable 等这些同步容器的实现代码,可以看到这些容器实现线程安全的方式就是将他们的状态封装起来,并在需要同步的方法上加上关键字 synchronized。

并发容器使用了与同步容器完全不同的加锁策略来提供更高的并发行和伸缩性,例如在 ConcurrentHashMap 中采用了一种粒度更细的加锁机制,可以称为分段锁,在这种锁机制下,允许任意数量的读线程并发地访问 map,并且执行读操作的线程和写操作的线程也可以并发的访问 map,同时允许一定数量的写操作线程并发地修改 map,所以它可以在并发环境下实现更高的吞吐量。

6、多线程同步和互斥有几种实现方法,都是什么?

线程同步是指线程之间所具有的一种制约关系,一个线程的执行依赖于另一个线程的消息,当它没有得到另一个线程的消息时应等待,直到消息到达时才被唤醒。

线程互斥是指对于共享的进程系统资源,在各单个线程访问时的排他性。当有若干个线程都要使用某一共享资源时,任何时刻最多只允许一个线程去使用,其他要使用该资源的线程必须等待,直到占用资源者释放该资源。线程互斥可以看成是一种特殊的线程同步。
线程间的同步方法大体可分为两类:用户模式和内核模式。顾名思义,内核模式就是指利用系统内核对象的单一性进行同步,使用时需要切换内核态和用户态,而用户模式就是不需要切换到内核态,只在用户态完成操作。

用户模式下的方法有:原子操作(例如一个单一的全局变量),临界区。内核模式下的方法有:事件、信号量、互斥量。

7、什么是竞争条件?你怎样发现和解决竞争?

当多个进程都企图对共享数据进行某种处理,而最后的结果又取决于进程运行的顺序时,则我们认为这发生了竞争条件。

8、你将如何使用 thread dump?你将如何分析 thread dump?
![]()

新建状态(New)
用 new 语句创建的线程处于新建状态,此时他和其他 Java 对象一样,仅仅在 堆区 中被分配了内存。

就绪状态(Runnable)
当一个线程对象被创建后,其他线程调用它的 start() 方法,该线程就进入就绪状态,Java 虚拟机会为他创建 方法调用栈和程序计数器。处于这个状态的线程位于可运行池中,等待获得 CPU 的使用权。

运行状态(Running)
处于这个状态的线程占用 CPU,执行程序代码。只有处于就绪状态的线程才有机会转到运行状态。

阻塞状态(Blocked)
阻塞状态是指线程因为某些原因放弃 CPU,暂时停止运行。当线程处于阻塞状态时,Java虚拟机不会给线程分配 CPU。直到线程重新进入就绪状态,它才有机会转到运行状态。
阻塞状态可分为以下3种:
位于对象等待池中的阻塞状态(Blocked in object‘s wait pool):当线程处于运行状态时,如果执行了某个对象的 wait()方法,Java虚拟机就会把线程放到这个对象的等待池中,这涉及到“线程通信”的内容。
位于对象锁池中的阻塞状态(Blocked in object’s lock pool):当线程处于运行状态时,试图获得某个对象的同步锁时,如果该对象的同步锁已经被其他进程占用,Java虚拟机就会把这个线程放到这个对象的锁池中,这涉及到“线程同步”的内容。
其他阻塞状态(Otherwise Blocked):当前线程执行了 sleep() 方法,或者调用了其他线程的 join() 方法,或者发生了 I/O请求 时,就会进入这个状态。

死亡状态(Dead)
当线程退出 run() 方法时,就进入死亡状态,该线程结束生命周期。

9、为什么我们调用 start() 方法时会执行 run() 方法,为什么我们不能直接调用 run() 方法?

当你调用 start() 方法时你将创建新的线程,并且执行在 run() 方法里的代码。
但是如果你直接调用 run() 方法,他不会创建新的线程也不会执行调用线程的代码,只会把 run方法 当作普通方法去执行。

10、Java 中你怎样唤醒一个阻塞的线程?

在 Java 发展史上曾经使用 suspend()、resume() 方法对于线程进行阻塞唤醒,但随之出现很多问题,比较经典的还是死锁问题。
解决方案可以 使用以对象为目标的阻塞。即利用 Object 类的 wait() 和 notify() 方法实现线程阻塞。
首先,wait、notify 方法是针对对象的,调用任意对象的 wait() 方法都将导致线程阻塞,阻塞的同时也将释放该对象的锁,相应地,调用任意对象的 notify() 方法则将随机解除该对象阻塞的线程,但他需要重新获取对象的锁,直到获取成功才能往下执行;其他,wait、notify 方法必须在 synchronized块 或 方法中被调用,并且要保证同步块或方法的 锁对象 与调用 wait、notify 方法的对象是同一个,如此一来在调用 wait 之前当前线程就已经成功获取某对象的锁,执行 wait 阻塞后当前线程就将之前获取的对象锁释放。

11、在 Java 中 CyclicBarriar 和 CountdownLatch 有什么区别?

CyclicBarrier 可以重复使用,而 CountdownLatch 不能重复使用。

Java 的 concurrent 包里面的 CountdownLatch 其实可以把它看作一个计数器,只不过这个计数器的操作是原子操作,同时只能有一个线程去操作这个计数器,也就是同时只能有一个线程去减这个计数器里面的值。
你可以向 CountDownLatch 对象设置一个初始的数字作为计数值,任何调用这个对象的 await() 方法都会阻塞,直到这个计数器的计数值被其他的线程减为0为止。
所以在当前计数到达零之前, await 方法会一直受阻塞。之后,会释放所有等待的线程,await 的所有后续调用都将立即返回。这种现象只出现一次——计数器无法被重置。如果需要重置计数,请考虑使用 CyclicBarrier。
CoutDownLatch 的一个非常经典的应用场景是:有一个任务想要往下执行,但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这个想要继续往下执行的任务调用一个 CountDownLatch 对象的 countDown() 方法,这个调用 await() 方法的任务将一直阻塞等待,直到这个 CountDownLatch 对象的计数值减到0为止。
CyclicBarrier 一个同步辅助类,它允许一组线程相互等待,直到到达某个公共屏障点(common barrier point)。在涉及一组固定大小的线程的程序中,这些线程必须不时地相互等待,此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用,所以称它为循环的 barrier。 

12、什么是不可变对象,它对写并发应用有什么帮助?

不可变对象(Immutable Objects)即对象一旦被创建他的状态(对象的数据,也即对象属性值)就不能改变,反之即为可变对象(Mutable Objects)
不可变对象的类即为不可变类。Java 平台类库中包含许多不可变类,如 String、基本类型的包装类、BigInteger 和 BigDecimal 等。
不可变对象天生是线程安全的。他们的常量(域)是在构造函数中创建的。既然他们的状态无法改变,这些常量永远不会变。
不可变对象永远是线程安全的。

只有满足如下状态,一个对象才是不可变的:
他的状态不能在创建后再被修改。
所有的域都是 final 类型。
他被正确创建(创建期间没有发生 this 引用的溢出)。

13、如何停止一个正在运行的线程?

使用共享变量的方式
在这种方式中,之所以引入共享变量,是因为该变量可以被多个执行相同任务的线程用来作为是否中断的信号,通知中断线程的执行。

使用 interrupt 方法终止线程
如果一个线程由于等待某些事件的发生而被阻塞,又该怎么停止该线程呢?这种情况经常会发生,比如当一个线程由于需要等候键盘输入而被阻塞,或者调用 Thread.join() 方法,或者 Thread.sleep() 方法,在网络中调用 ServerSocket.accept() 方法,或者调用了 DatagramSocket.receive() 方法时,都有可能导致线程阻塞,使线程处于不可运行状态,即使主程序中将该线程的共享变量设置为 true,但该线程此时根本无法检查循环标志,当然也就无法立即中断。这里我们给出的建议是,不要使用 stop() 方法,而是使用 Thread 提供的 interrupt() 方法,因为该方法虽然不会中断一个正在运行的进程,但是它可以使一个被阻塞的线程提前结束阻塞状态,退出阻塞代码。

14、java 如何实现多线程之间的通讯和协作?

中断和共享变量

15、notify() 和 notifyall() 有什么区别?

当一个线程进入 wait 之后,就必须等其他线程 notify/notifyall,使用 notifyall 可以唤醒所有处于 wait 状态的线程,使其重新进入锁的争夺队列中,而 notify 只能唤醒一个。

如果没把握,建议 notifyAll,防止 notify 因为信号丢失而造成程序异常。

1、在 Java 中守护线程和本地线程区别?

java 中的线程分为两种:守护线程和用户线程。
任何线程都可以设置为守护线程和用户线程,通过方法 Thread.setDaemon(bool on);true 则把该线程设置为守护线程,反之为用户线程。Thread.setDaemon() 必须在 Thread.start() 之前调用,否则运行时会抛出异常。

两者的区别:
唯一的区别是判断虚拟机(JVM)何时离开,Daemon 是为其它线程提供服务,如果全部的 User Thread 已经撤离,Daemon 没有客服务的线程,JVM 撤离。也可以理解为守护线程是 JVM 自动创建的线程(但不一定),用户线程是程序创建的线程;比如 JVM 的垃圾回收线程是一个守护线程,当所有的线程已经撤离,不再产生垃圾,守护线程自然就没事可干了,当垃圾回收线程是 Java 虚拟机上仅剩的线程时,Java 虚拟机会自动离开。

扩展:Thread Dump 打印出来的线程信息, 含有 daemon 字样的线程即为守护线程,可能会有:服务守护进程、编译守护进程、windows下的监听 Ctrl+break 的守护进程,Finalizer守护进程、引用处理守护进程、GC守护进程。

2、线程与进程的区别?

进程是操作系统分配资源的最小单元,线程是操作系统调度的最小单元。
一个程序至少有一个进程,一个进程至少有一个线程。

3、什么是多线程中的上下文切换?

多线程会共同使用一组计算机上的CPU,而线程数大于给程序分配的CPU数量时,为了让各个线程都有执行的机会,就需要轮转使用CPU。不同的线程切换使用CPU发生的切换数据等就是上下文切换。

在上下文切换过程中,CPU 会停止处理当前运行的程序,并保存当前程序运行的具体位置以便之后继续运行。从这个角度来看,上下文切换有点像我们同时阅读几本书,在来回切换书本的同时我们需要记住每本书当前读到的页码。在程序中,上下文切换过程中的“页码”信息是保存在进程控制块(PCB)中的。PCB 还经常被称作“切换帧”(switchframe)。“页码”信息会一直保存到 CPU 的内存中,直到他们被再次使用。
上下文切换是存储和恢复 CPU 状态的过程,它使得线程执行能够从中断点恢复执行。上下文切换是多任务操作系统和多线程环境的基本特征。

4、死锁与活锁的区别,死锁与饥饿的区别?

死锁:是指两个或两个以上的进程(或线程)在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,他们都将无法推进下去。

产生死锁的必要条件:互斥条件:所谓互斥就是进程在某一时间内独占资源。
请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放。
不剥夺条件:进程已获得资源,在未使用完之前,不能强行剥夺。
循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

活锁:任务或者执行者没有被阻塞,由于某些条件没有满足,导致一直重复尝试,失败,尝试,失败。

活锁和死锁的区别在于,处于活锁的实体是在不断的改变状态,所谓的“活”,而处于死锁的实体表现为等待;活锁有可能自行解开,死锁则不能。

饥饿:一个或者多个线程因为种种原因无法获得所需要的资源,导致一直无法执行的状态。

Java 中导致饥饿的原因:高优先级线程吞噬所有的低优先级线程的 CPU时间。
线程被永久堵塞在一个等待进行同步块的状态,因为其他线程总能在它之前持续地对该同步块进行访问。
线程在等待一个本身也处于永久等待完成的对象(比如调用这个对象的 wait方法),因为其他线程总是被持续地唤醒。

5、Java 中用到的线程调度算法是什么?

采用时间片轮转的方式。可以设置线程的优先级,会映射到下层的系统上面的优先级上,如非特别需要,尽量不要用,防止线程饥饿。

计算机通常只有一个 CPU,在任意时刻只能执行一条机器指令,每个线程只有获得 CPU 的使用权才能执行指令。所谓多线程的并发运行,其实是指从宏观上看,各个线程轮流获得 CPU 的使用权,分别执行各自的任务。在运行池中,会有多个处于就绪状态的线程在等待 CPU,Java 虚拟机的一项任务就是负责线程的调度,线程调度是指按照特定机制为多个线程分配 CPU 的使用权。

有两种调度模型:分时调度模型 和 抢占式调度模型。

分时调度模型是指让所有的线程轮流获得 cpu 的使用权,并且平均分配每个线程占用 cpu 的时间片。

Java虚拟机采用抢占式调度模型,是指优先让可运行池中优先级高的线程占用 CPU,如果可运行池中的线程优先级相同,那么就随机选择一个线程,使其占用 CPU。处于运行状态的线程会一直运行,直至他不得不放弃 CPU。

6、什么是线程组,为什么在 Java 中不推荐使用?

ThreadGroup类,可以把线程归属到某一个线程组中,线程组中可以有线程对象,也可以有线程组,组中还可以有线程,这样的组织结构有点类似于树的形式。
为什么不推荐使用?因为你使用有很多的安全隐患吧,没有具体追究,如果需要使用,推荐使用线程池。

线程组和线程池是两个不同的概念,他们的作用完全不同,前者是为了方便线程的管理,后者是为了管理线程的生命周期,复用线程,减少创建销毁线程的开销。

7、为什么使用 Executor 框架比使用应用创建和管理线程好?

为什么使用 Executor 线程池框架
每次执行任务创建线程 new Thread() 比较消耗性能,创建一个线程是比较耗时、耗资源的。
调用 new Tread() 创建的线程缺乏管理,被称之为野线程,而且可以无限制地创建,线程之间的相互竞争会导致过多占用系统资源而导致系统瘫痪,还有线程之间的频繁交替也会消耗很多系统资源。
直接使用 new Thread() 启动的线程不利于扩展,比如定时执行、定期执行、定时定期执行、线程中断等都不便实现。

使用 Executor 线程池框架的优点
能复用已存在并空闲的线程从而减少线程对象的创建从而减少了消亡线程的开销。
可有效控制最大并发线程数,提高系统资源使用率,同时避免过多资源竞争。
框架中已经有定时、定期、单线程、并发数控制等功能。

综上所述使用线程池框架Executor能更好的管理线程、提高系统资源使用率。

8、在 Java 中 Executor 和 Executors 的区别?

Executors 工具类的不同方法按照我们的需求创建了不同的线程池,来满足业务的需要。
Executor 接口对象能执行我们的线程任务。
ExecutorService 接口继承了 Executor 接口并进行了扩展,提供了更多的方法,我们能获得任务执行的状态并且可以获取任务的返回值。
使用 ThreadPoolExecutor 可以创建自定义线程池。
Future 表示异步计算的结果,它提供了检查计算是否完成的方法,以等待计算的完成,并可以使用 get()方法 获取计算的结果。

9、什么是 Executors 框架?

Executor 框架是一个根据一组执行策略调用,调度,执行和控制的异步任务的框架。
无限制的创建线程会引起应用程序内存的溢出。所以创建一个线程池是个更好的解决方法,因为可以限制线程的数量并且可以回收再利用这些线程。利用 Executors 框架可以非常方便的创建一个线程池。

10、什么是原子操作?在 Java Concurrency API 中有哪些原子类?

原子操作意为”不可被中断的一个或一系列操作“。
处理器使用基于 对缓存加锁 或 总线加锁 的方式来实现 多处理器之间的原子操作。
在 Java 中可以通过 锁 和 循环CAS 的方式来实现原子操作。CAS操作 —— Compare & Set,或是 Compare & Swap,现在几乎所有的 CPU指令 都支持 CAS 的原子操作。
原子操作是指一个不受其他操作影响的操作任务单元。原子操作是在多线程环境下避免数据不一致必须的手段。
int++ 并不是一个原子操作,所以当一个线程读取它的值并加1时,另外一个线程有可能会读到之前的值,这就会引发错误。
为了解决这个问题,必须保证增加操作是原子的,在 JDK1.5之前我们可以使用同步技术来做到这一点。到 JDK1.5, java.util.concurrent.atomic 包提供了 int 和 long 类型的原子包装类,它们可以自动的保证对于他们的操作是原子的并且不需要使用同步。
java.util.concurrent 这个包里面提供了一组原子类。其基本的特性就是在多线程环境下,当有多个线程同时执行这些类的实例包含的方法时,具有排他性,即当某个线程进入方法,执行其中的指令时,不会被其他线程打断,而别的线程就像自旋锁一样,一直等到该方法执行完成,才由 JVM 从等待队列中选择另一个线程进入,这只是一种逻辑上的理解。

原子类:AtomicBoolean,AtomicInteger,AtomicLong,AtomicReference
原子数组:AtomicIntegerArray,AtomicLongArray,AtomicReferenArray
原子属性更新器:AtomicLongFieldUpdater,AtomicIntegerFieldUpdater,AtomicReferenceFieldUpdater
解决 ABA 问题的原子类:AtomicMarkableReference(通过引入一个 boolean 来反映中间有没有变过),AtomicStampedReference(通过引入一个 int 累加来反应中间有没有变过)。

10.1 ABA问题

11、Java Concurrency API 中的 Lock 接口是什么?对比同步他有什么优势?

Lock 接口比同步方法和同步块提供了更具扩展性的锁操作。
他们允许更加灵活的结构,可以具有完全不同的性质,并且可以支持多个相关类的条件对象。

它的优势有:
可以使锁更公平
可以使线程在等待锁的时候响应中断
可以使线程尝试获取锁,并在无法获取锁的时候立即返回或者等待一段时间
可以在不同的范围,以不同的顺序获取和释放锁

整体上来说 Lock 是 synchronized 的扩展版, Lock 提供了无条件的、可轮询的(tryLock 方法)、定时的(tryLock 带参方法)、可中断的(lockInterruptibly)、可多条件队列的(newCondition 方法)锁操作。另外 Lock 的实现类基本都支持非公平锁(默认)和公平锁,synchronized 只支持非公平锁,当然,在大部分情况下,非公平锁是高效的选择。

1、为什么要尽量设定一个主键?

主键是数据库确保数据行在整张表唯一性的保障,即使业务上本张表没有主键,也建议添加一个自增长的ID列作为主键。
设定了主键之后,在后续的删改查的时候可能更加快速以及确保操作数据范围安全。

2、主键使用自增ID还是UUID?

UUID 是指Universally Unique Identifier,翻译为中文是通用唯一识别码,UUID 的目的是让分布式系统中的所有元素都能有唯一的识别信息。如此一来,每个人都可以创建不与其它人冲突的 UUID,就不需考虑数据库创建时的名称重复问题。
推荐使用自增ID,不要使用UUID。
因为在InnoDB存储引擎中,主键索引是作为聚簇索引存在的,也就是说,主键索引的B+树叶子节点上存储了主键索引以及全部的数据(按照顺序),如果主键索引是自增ID,那么只需要不断向后排列即可,如果是UUID,由于到来的ID与原来的大小不确定,会造成非常多的数据插入,数据移动,然后导致产生很多的内存碎片,进而造成插入性能的下降。
总之,在数据量大一些的情况下,用自增键性能会好一些。
关于主键是聚簇索引,如果没有主键,InnoDB会选择一个唯一键来作为聚簇索引,如果没有唯一键,会生成一个隐式的主键。

3、字段为什么要求定义为not null?

null值会占用更多的字节,且会在程序中造成很多与预期不符的情况。

4、如果要存储用户的密码散列,应该使用什么字段进行存储?

密码散列,盐,用户身份证号等固定长度的字符串应该使用char而不是varchar来存储,这样可以节省空间且提高检索效率。

[参考:码匠笔记]

1、什么是事务?

事务是一系列的操作,他们要符合ACID特性。
最常见的理解就是:事务中的操作要么全部成功,要么全部失败,但是只是这样还不够的。

2、ACID是什么?

A=Atomicity
原子性,要么全部成功,要么全部失败,不可能只执行一部分操作。

C=Consistency
系统(数据库)总是从一个一致性的状态转移到另一个一致性的状态,不会存在中间状态。

I-Isolation
隔离性:通常来说,一个事务在完全提交之前,对其他事务是不可见的。(有例外情况)

D=Durability
持久性,一旦事务提交,那么就永远是这样子了,哪怕系统崩溃也不会影响到这个事务的结果。

3、同时有多个事务在进行会怎么样呢?

多事务的并发进行一般会造成以下几个问题:
脏读:A事务读取到了B事务未提交的内容,而B事务后面进行了回滚。
不可重复读:当设置A事务只能读取B事务已经提交的部分,会造成在A事务内的两次查询,结果竟然不一样,因为在此期间B事务进行了提交操作。
幻读:A事务读取了一个范围的内容,而同时B事务在此期间插入了一条数据,造成“幻觉”。

4、怎么解决这些问题呢?MySQL的事务隔离级别了解吗?

MySQL的四种隔离级别如下:
1、未提交读
   这就是上面所说的例外情况,这个隔离级别下,其他事务可以看到本事务没有提交的部分修改。因此会造成脏读的问题(读取到 
   了其他事务未提交的部分,而之后该事务进行了回滚)。
这个级别的性能没有足够大的优势,但是又有很多的问题,因此很少使用。
2、已提交读
   其他事务只能读取到本事务已经提交的部分。这个隔离级别有不可重复读的问题,在同一个事务内的两次读取,拿到的结果竟 
   然不一样,因为另外一个事务对数据进行了修改。
3、可重复读
   可重复读隔离级别解决了上面不可重复读的问题,但是仍然有一个新问题,就是 幻读,当你读取 id>10 的数据行时,对涉及到 
   的所有行加上了读锁,此外另外一个事务新插入了一条 id=11 的数据,因为是新插入的,所以不会触发上面的锁的排斥,那么 
   进行本事务进行下一次的查询时会发现有一条 id=11 的数据,而上次的查询操作并没有获取到,再进行插入时会有主键冲突的 
   问题。
4、可串行化
   这是最高的隔离级别,可以解决上面提到的所有问题,因为他强制将所有的操作串行执行,这会导致并发性能急速下降,因此也 
   不是很常用。

5、InnoDB使用的是哪种隔离级别呢?

InnoDB默认使用的是可重复读隔离级别。

1、什么是索引?

索引是一种数据结构,可以帮助我们快速的进行数据的查找。

2、索引是个什么样的数据结构呢?

索引的数据结构和具体存储引擎的实现有关,在MySQL中使用较多的索引有Hash索引,B+索引等。
而我们经常使用的InnoDB存储引擎的默认索引实现为:B+树索引。

3、Hash索引和B+树索引有什么区别或者说优劣呢?

首先要知道Hash索引和B+树索引的底层实现原理:
Hash索引底层就是hash表,进行查找时,调用一次hash函数就可以获取到相应的键值,之后进行回表查询获得实际数据。
B+树底层实现是多路平衡查找树,对于每一次的查询都是从根结点出发,查找到叶子节点方可获得所查键值,然后根据查询判断是否需要回表查询数据。

那么可以看出他们有以下不同:
1、hash索引进行等值查询更快(一般情况下),但是却无法进行范围查询。
   因为在hash索引中经过hash函数建立索引之后,索引的顺序与原顺序无法保持一致,不能支持范围查询。
   而B+树的所有节点皆遵循(左节点小于父节点,右节点大于父节点,多叉树也类似),天然支持范围。
2、hash索引不支持使用索引进行排序,原理同上。
3、hash索引不支持模糊查询以及多列索引的最左前缀匹配,原理也是因为hash函数的不可预测,AAAA和AAAB的索引没有相关性。
4、hash索引任何时候都避免不了回表查询数据,而B+树在符合某些条件(聚簇索引,覆盖索引等)的时候可以只通过索引完成查询。
5、hash索引虽然在等值查询上较快,但是不稳定,性能不可预测,当某个键值存在大量重复的时候,发生hash碰撞,此时效率可能 
   极差,而B+树的查询效率比较稳定,对于所有的查询都是从根节点到叶子节点,其树的高度极低。

因此,在大多数情况下,直接选择B+树索引可以获得稳定且较好的查询速度,而不使用hash索引。

4、什么是聚簇索引?

在B+树的索引中,叶子节点可能存储了当前的key值,也可能存储了当前的key值以及整行的数据,这就是聚簇索引和非聚簇索引。
在InnoDB中,只有主键索引是聚簇索引,如果没有主键,则挑选一个唯一键建立聚簇索引,如果没有唯一键,则隐式的生成一个键来建立聚簇索引。
当查询使用聚簇索引时,在对应的叶子节点,可以获取到整行数据,因此不用再次进行回表查询。

5、非聚簇索引一定会回表查询么?

不一定,这涉及到查询语句所要求的字段是否全部命中了索引,如果全部命中了索引,那么就不必再进行回表查询。

举个简单的例子,假设我们在员工表的年龄上建立了索引,那么当进行 select age from employee where age < 20 的查询时,在索引的叶子节点上,已经包含了age信息,不会再次进行回表查询。

6、在建立索引的时候,都有哪些需要考虑的因素呢?

建立索引的时候一般要考虑到字段的使用频率,经常作为条件进行查询的字段比较合适。
如果需要建立联合索引的话,还需要考虑联合索引中的顺序。
此外,也要考虑其他方面,比如防止过多的所有对表造成太大的压力,这些都和实际的表结构以及查询方式有关。

7、联合索引是什么?为什么需要注意联合索引中的顺序?

MySQL可以使用多个字段同时建立一个索引,叫做联合索引。
在联合索引中,如果想要命中索引,需要按照建立索引的字段顺序挨个使用,否则无法命中索引。

具体原因为:
MySQL使用索引时需要索引有序,假设现在建立了 "name,age,school" 的联合索引,那么索引的排序为:先按照 name 排序,如果 name 相同,则按照 age 排序,如果 age 的值也相等,则按照 school 进行排序。
当进行查询时,此时索引仅仅按照 name 严格有序,因此必须首先使用 name 字段进行等值查询,之后对于匹配到的列而言,其按照 age字段 严格有序,此时可以使用 age 字段用作索引查找...以此类推,因此在建立联合索引的时候应该注意索引列的顺序,一般情况下,将查询需求频繁或者字段选择性高的列放在前面。此外可以根据特例的查询或者表结构进行单独的调整。

8、创建的索引有没有被使用到?或者说怎么才可以知道这条语句运行很慢的原因?

MySQl提供了 explain命令 来查看语句的执行计划,MySQL在执行某个语句之前,会将该语句过一遍查询优化器,之后会拿到对语句的分析,也就是执行计划,其中包含了许多信息,可以通过其中和索引有关的信息来分析是否命中了索引,例如 possible_key, key, key_len等字段,分别说明了此语句可能会使用的索引,实际使用的索引以及使用的索引长度。

9、那么在哪些情况下会发生针对该列创建了索引但是在查询的时候的时候并没有使用呢?

使用不等于查询
列参与了数学运算或者函数
在字符串 like 时左边是通配符,类似于 '%aaa'。
当mysql分析全表扫描比使用索引快的时候不使用索引。
当使用联合索引,前面一个条件为范围查询,后面的即使符合最左前缀原则,也无法使用索引。

以上情况,MySQL无法使用索引。