发挥多核CPU 的优势
随着工业的进步， 现在的笔记本、 台式机乃至商用的应用服务器至少也都是双核的， 4 核、 8 核甚至 16 核的也都不少见， 如果是单线程的程序， 那么在双核 CPU 上就浪费了 50%， 在 4 核 CPU 上就浪费了 75%。 单核 CPU 上所谓的"多线程"那是假的多线程， 同一时间处理器只会处理一段逻辑， 只不过线程之间切换得比较快，看着像多个线程"同时"运行罢了。 多核 CPU 上的多线程才是真正的多线程， 它能让你的多段逻辑同时工作， 多线程，可以真正发挥出多核CPU 的优势来， 达到充分利用CPU 的目的。
防止阻塞
从程序运行效率的角度来看， 单核 CPU 不但不会发挥出多线程的优势， 反而会因为在单核CPU 上运行多线程导致线程上下文的切换， 而降低程序整体的效率。 但是单核 CPU 我们还是要应用多线程， 就是为了防止阻塞。 试想， 如果单核 CPU 使用单线程， 那么只要这个线程阻塞了， 比方说远程读取某个数据吧， 对端迟迟未返回又没有设置超时时间， 那么你的整个程序在数据返回回来之前就停止运行了。 多线程可以防止这个问题， 多条线程同时运行， 哪怕一条线程的代码执行读取数据阻塞， 也不会影响其它任务的执行。
便于建模
这是另外一个没有这么明显的优点了。 假设有一个大的任务 A， 单线程编程， 那么
就要考虑很多， 建立整个程序模型比较麻烦。 但是如果把这个大的任务 A 分解成
几个小任务， 任务B、 任务 C、 任务 D， 分别建立程序模型， 并通过多线程分别运
行这几个任务， 那就简单很多了。
进程和线程的主要差别在于它们是不同的操作系统资源管理方式。 进程有独立的地址空间， 一个进程崩溃后， 在保护模式下不会对其它进程产生影响， 而线程只是一个进程中的不同执行路径。 线程有自己的堆栈和局部变量， 但线程之间没有单独的地址空间， 一个线程死掉就等于整个进程死掉， 所以多进程的程序要比多线程的程序健壮， 但在进程切换时， 耗费资源较大， 效率要差一些。 但对于一些要求同时进行并且又要共享某些变量的并发操作， 只能用线程， 不能用进程。
只有调用了 start()方法， 才会表现出多线程的特性， 不同线程的 run()方法里面的代码交替执行。 如果只是调用 run()方法， 那么代码还是同步执行的， 必须等待一个线程的 run()方法里面的代码全部执行完毕之后， 另外一个线程才可以执行其 run()方法里面的代码。
NEW： 毫无疑问表示的是刚创建的线程， 还没有开始启动。
RUNNABLE: 表示线程已经触发 start()方式调用， 线程正式启动， 线程处于运行中状态。
BLOCKED： 表示线程阻塞， 等待获取锁， 如碰到 synchronized、 lock 等关键字等占用临界区的情况， 一旦获取到锁就进行 RUNNABLE 状态继续运行。
WAITING： 表示线程处于无限制等待状态， 等待一个特殊的事件来重新唤醒， 如通过wait()方法进行等待的线程等待一个 notify()或者 notifyAll()方法， 通过 join()方法进行等待的线程等待目标线程运行结束而唤醒， 一旦通过相关事件唤醒线程， 线程就进入了 RUNNABLE 状态继续运行。
TIMED_WAITING： 表示线程进入了一个有时限的等待， 如 sleep(3000)， 等待 3 秒后线程重新进行 RUNNABLE 状态继续运行。
TERMINATED： 表示线程执行完毕后， 进行终止状态。 需要注意的是， 一旦线程通过 start 方法启动后就再也不能回到初始 NEW 状态， 线程终止后也不能再回到RUNNABLE 状态。
两者都可以暂停线程的执行
类的不同：sleep() 是 Thread线程类的静态方法，wait() 是 Object类的方法。
是否释放锁：sleep() 不释放锁；wait() 释放锁。
用途不同：Wait 通常被用于线程间交互/通信，sleep 通常被用于暂停执行。
用法不同：wait() 方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的 notify()或者 notifyAll() 方法。sleep() 方法执行完成后，线程会自动苏醒。或者可以使用wait(longtimeout)超时后线程会自动苏醒。
volatile 关键字的作用主要有两个：
我们知道不用线程池的话， 每个线程都要通过 new Thread(xxRunnable).start()的方式来创建并运行一个线程， 线程少的话这不会是问题， 而真实环境可能会开启多个线程让系统和程序达到最佳效率， 当线程数达到一定数量就会耗尽系统的 CPU 和内存资源， 也会造成 GC频繁收集和停顿， 因为每次创建和销毁一个线程都是要消耗系统资源的， 如果为每个任务都创建线程这无疑是一个很大的性能瓶颈。 所以，线程池中的线程复用极大节省了系统资源， 当线程一段时间不再有任务处理时它也会自动销毁， 而不会长驻内存。
什么是线程池？
很简单， 简单看名字就知道是装有线程的池子， 我们可以把要执行的多线程交给线程池来处理， 和连接池的概念一样， 通过维护一定数量的线程池来达到多个线程的复用。
线程池的好处
我们知道不用线程池的话， 每个线程都要通过 new Thread(xxRunnable).start()的方式来创建并运行一个线程， 线程少的话这不会是问题， 而真实环境可能会开启多个线程让系统和程序达到最佳效率， 当线程数达到一定数量就会耗尽系统的 CPU 和内存资源， 也会造成 GC频繁收集和停顿， 因为每次创建和销毁一个线程都是要消耗系统资源的， 如果为每个任务都创建线程这无疑是一个很大的性能瓶颈。 所以，线程池中的线程复用极大节省了系统资源， 当线程一段时间不再有任务处理时它也会自动销毁， 而不会长驻内存。
线程池核心类
在 java.util.concurrent 包中我们能找到线程池的定义， 其中 ThreadPoolExecutor 是我们线程池核心类， 首先看看线程池类的主要参数有哪些。
如何提交线程
如可以先随便定义一个固定大小的线程池ExecutorService es = Executors.newFixedThreadPool(3);提交一个线程
es.execute(xxRunnble);
submit 和 execute 分别有什么区别呢？
如何关闭线程池
es.shutdown();不再接受新的任务， 之前提交的任务等执行结束再关闭线程池。
es.shutdownNow();不再接受新的任务， 试图停止池中的任务再关闭线程池， 返回所有未处理的线程list 列表。
两个看上去有点像的类， 都在 java.util.concurrent 下， 都可以用来表示代码运行到某个点上， 二者的区别在于：
死锁、 活锁、 饥饿是关于多线程是否活跃出现的运行阻塞障碍问题， 如果线程出现了这三种情况， 即线程不再活跃， 不能再正常地执行下去了。
死锁
死锁是多线程中最差的一种情况， 多个线程相互占用对方的资源的锁， 而又相互等对方释放锁， 此时若无外力干预， 这些线程则一直处理阻塞的假死状态， 形成死锁。举个例子， A 同学抢了 B 同学的钢笔， B 同学抢了 A 同学的书， 两个人都相互占用对方的东西， 都在让对方先还给自己自己再还， 这样一直争执下去等待对方还而又得不到解决， 老师知道此事后就让他们相互还给对方， 这样在外力的干预下他们才解决，计算机不像人如果发现这种情况没有外力干预还是会一直阻塞下去的。
活锁
活锁这个概念大家应该很少有人听说或理解它的概念， 而在多线程中这确实存在。活锁恰恰与死锁相反， 死锁是大家都拿不到资源都占用着对方的资源， 而活锁是拿到资源却又相互释放不执行。 当多线程中出现了相互谦让， 都主动将资源释放给别的线程使用， 这样这个资源在多个线程之间跳动而又得不到执行， 这就是活锁。
饥饿
我们知道多线程执行中有线程优先级这个东西， 优先级高的线程能够插队并优先执行， 这样如果优先级高的线程一直抢占优先级低线程的资源， 导致低优先级线程无法得到执行， 这就是饥饿。 当然还有一种饥饿的情况， 一个线程一直占着一个资源不放而导致其他线程得不到执行， 与死锁不同的是饥饿在以后一段时间内还是能够得到执行的， 如那个占用资源的线程结束了并释放了资源。
无锁
无锁， 即没有对资源进行锁定， 即所有的线程都能访问并修改同一个资源， 但同时只有一个线程能修改成功。无锁典型的特点就是一个修改操作在一个循环内进行，线程会不断的尝试修改共享资源， 如果没有冲突就修改成功并退出否则就会继续下一次循环尝试。 所以， 如果有多个线程修改同一个值必定会有一个线程能修改成功，而其他修改失败的线程会不断重试直到修改成功。 之前的文章我介绍过 JDK 的 CAS 原理及应用即是无锁的实现。可以看出， 无锁是一种非常良好的设计， 它不会出现线程出现的跳跃性问题， 锁使用不当肯定会出现系统性能问题， 虽然无锁无法全面代替有锁， 但无锁在某些场合下是非常高效的。
原子性
原子性是指一个线程的操作是不能被其他线程打断， 同一时间只有一个线程对一个变量进行操作。 在多线程情况下， 每个线程的执行结果不受其他线程的干扰， 比如说多个线程同时对同一个共享成员变量 n++100 次， 如果 n初始值为 0， n 最后的值应该是 100， 所以说它们是互不干扰的， 这就是传说的中的原子性。 但 n++并不是原子性的操作， 要使用 AtomicInteger 保证原子性。
可见性
可见性是指某个线程修改了某一个共享变量的值， 而其他线程是否可以看见该共享变量修改后的值。 在单线程中肯定不会有这种问题， 单线程读到的肯定都是最新的值， 而在多线程编程中就不一定了。 每个线程都有自己的工作内存， 线程先把共享变量的值从主内存读到工作内存， 形成一个副本， 当计算完后再把副本的值刷回主内存，从读取到最后刷回主内存这是一个过程， 当还没刷回主内存的时候这时候对其他线程是不可见的， 所以其他线程从主内存读到的值是修改之前的旧值。 像CPU 的缓存优化、 硬件优化、 指令重排及对 JVM 编译器的优化， 都会出现可见性的问题。
有序性
我们都知道程序是按代码顺序执行的， 对于单线程来说确实是如此， 但在多线程情况下就不是如此了。 为了优化程序执行和提高 CPU 的处理性能， JVM 和操作系统都会对指令进行重排， 也就说前面的代码并不一定都会在后面的代码前面执行， 即后面的代码可能会插到前面的代码之前执行， 只要不影响当前线程的执行结果。 所以，指令重排只会保证当前线程执行结果一致， 但指令重排后势必会影响多线程的执行结果。 虽然重排序优化了性能， 但也是会遵守一些规则的， 并不能随便乱排序，只是重排序会影响多线程执行的结果。
什么是守护线程？ 与守护线程相对应的就是用户线程， 守护线程就是守护用户线程， 当用户线程全部执行完结束之后， 守护线程才会跟着结束。 也就是守护线程必须伴随着用户线程， 如果一个应用内只存在一个守护线程，没有用户线程， 守护线程自然会退出。
如果异常没有被捕获该线程将会停止执行。 Thread.UncaughtExceptionHandler 是用于处理未捕获异常造成线程突然中断情况的一个内嵌接口。 当一个未捕获异常将造成线程中断的时候JVM会使用Thread.getUncaughtExceptionHandler()来查询线程的UncaughtExceptionHandler并将线程和异常作为参数传递给handler的uncaughtException()方法进行处理。
Yield 方法可以暂停当前正在执行的线程对象， 让其它有相同优先级的线程执行。它是一个静态方法而且只保证当前线程放弃 CPU 占用而不能保证使其它线程一定能占用 CPU， 执行yield()的线程有可能在进入到暂停状态后马上又被执行。
所谓重入锁， 指的是以线程为单位， 当一个线程获取对象锁之后， 这个线程可以再次获取本对象上的锁， 而其他的线程是不可以的。
多线程之间的通信可以通过多种方式实现，包括使用共享数据结构、使用锁、使用信号量、使用管道和队列等。下面是一些常用的通信方式：
synchronized关键字、ReentrantLock等，可以用于保护共享数据，并控制对共享资源的访问。Semaphore类是一个计数信号量，可以用于控制对共享资源的访问。ArrayBlockingQueue、LinkedBlockingQueue等，可以用于在多个线程之间传递数据。另外，Java的PipedInputStream和PipedOutputStream类可以用于线程之间的输入/输出通信。Object类提供了等待/通知机制，可以用于线程之间的同步。一个线程可以在某个对象上等待，直到另一个线程通知它继续执行。Future和Callable接口可以用于异步计算，并允许在计算完成时获取结果。ThreadLocal类可以用于为每个线程提供独立的变量副本，从而实现线程之间的隔离。请注意，使用synchronized关键字可以确保线程安全，但也会导致性能开销。因此，在使用synchronized时，应权衡线程安全和性能的需求。
java中的Fork/Join框架是一种用于实现并行处理的框架，它基于分治策略，将一个大的任务分解为若干个较小的子任务，然后递归地处理这些子任务，并将结果合并得到最终的结果。
Fork/Join框架主要由两部分组成：Fork和Join。在Fork阶段，将任务分解成若干个子任务，这些子任务可以被分配给不同的处理器（线程）执行。在Join阶段，处理器将执行完毕的子任务结果返回给父任务，然后父任务将子任务的结果进行合并，得到最终的结果。
Fork/Join框架的主要优点是可以充分利用多核处理器的计算能力，提高程序的执行效率。同时，它还提供了一些工具类和接口，使得开发人员可以更加方便地编写并行处理程序。
需要注意的是，使用Fork/Join框架需要谨慎处理线程安全问题，并确保任务分解和合并的正确性。此外，由于Fork/Join框架是基于分治策略的，因此对于一些递归算法（如快速排序、归并排序等）来说，使用Fork/Join框架可以更加方便地实现并行化处理。
OutOfMemoryError异常。ThreadDeath异常。这通常发生在线程被其他线程中断了，或者由于其他原因导致线程无法继续执行。StackOverflowError异常。如果线程深度递归调用或者创建了过多的局部变量，就可能导致栈溢出。Thread.currentThread().join()），就会抛出IllegalThreadStateException异常。RejectedExecutionException异常。这通常发生在线程池已满或关闭时提交任务。线程安全的集合：
Java提供了一些线程安全的集合类，如Vector和Hashtable。这些集合类在内部实现了同步机制，可以保证在多线程环境下对集合的访问是安全的。例如，Vector类的所有公共方法都是同步的，Hashtable类的所有公共方法也是同步的。
线程不安全的集合：
Java中大多数集合类都是线程不安全的，如ArrayList、LinkedList、HashSet和HashMap等。这些集合类没有内置的同步机制，因此在多线程环境下使用时需要额外的同步措施来保证线程安全。
如何保证线程安全：
对于线程不安全的集合，可以使用同步块或同步方法来保证线程安全。例如，可以使用Collections.synchronizedList()方法将一个非线程安全的列表转换为线程安全的列表，然后在访问该列表时使用同步块来保证线程安全。
另外，Java并发包（java.util.concurrent）提供了一些线程安全的集合类，如ConcurrentHashMap、CopyOnWriteArrayList和BlockingQueue等。这些集合类内部实现了复杂的同步机制，可以更好地处理并发访问的情况。
CAS， 全称为 Compare and Swap， 即比较-替换。 假设有三个操作数： 内存值 V、旧的预期值 A、 要修改的值 B， 当且仅当预期值 A 和内存值 V 相同时， 才会将内存值修改为 B 并返回 true， 否则什么都不做并返回 false。 当然 CAS 一定要 volatile变量配合， 这样才能保证每次拿到的变量是主内存中最新的那个值， 否则旧的预期值 A 对某条线程来说， 永远是一个不会变的值 A， 只要某次 CAS 操作失败， 永远都不可能成功。java.util.concurrent.atomic 包下面的 Atom****类都有 CAS 算法的应用。
可以使用Thread类的holdsLock()方法来检查当前线程是否持有某个对象的锁。
Object lock = new Object();
// ... 在某个线程中
if (Thread.holdsLock(lock)) {
System.out.println("当前线程持有锁");
} else {
System.out.println("当前线程不持有锁");
}
wait()方法之前，当前线程必须拥有对象的内部锁。这是为了确保线程安全，避免出现竞态条件。wait()方法通常位于同步块或同步方法中。这是因为wait()方法本身也是需要同步的，如果在没有同步的情况下调用，可能会出现不可预期的结果。wait()方法可以被中断，因此不能在这些代码块中使用。notify()或notifyAll()方法来实现。如果一个线程进入了等待状态，但没有其他线程来唤醒它，那么它将会永远地等待下去，直到程序结束。因此，必须正确地管理线程的等待和唤醒。wait()方法会抛出InterruptedException异常。因此，在使用wait()方法时，必须处理这个异常。ThreadLocal 的作用是提供线程内的局部变量， 这种变量在线程的生命周期内起作用， 减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。 用来解决数据库连接、 Session 管理等。
ReadWriteLock 是一个读写锁接口， ReentrantReadWriteLock 是 ReadWriteLock 接口的一个具体实现， 实现了读写的分离， 读锁是共享的， 写锁是独占的， 读和读之间不会互斥， 读和写、 写和读、 写和写之间才会互斥， 提升了读写的性能。
FutureTask 表示一个异步运算的任务， FutureTask 里面可以传入一个 Callable 的具体实现类， 可以对这个异步运算的任务的结果进行等待获取、 判断是否已经完成、取消任务等操作。
如果线程是因为调用了 wait()、 sleep()或者 join()方法而导致的阻塞， 可以中断线程，并且通过抛出InterruptedException 来唤醒它； 如果线程遇到了 IO 阻塞， 无能为力，因为 IO是操作系统实现的， Java 代码并没有办法直接接触到操作系统。
不可变对象保证了对象的内存可见性， 对不可变对象的读取不需要进行额外的同步手段， 提升了代码执行效率。
计算机通常只有一个 CPU，在任意时刻只能执行一条机器指令，每个线程只有获得CPU 的使用权才能执行指令。所谓多线程的并发运行，其实是指从宏观上看，各个线程轮流获得 CPU 的使用权，分别执行各自的任务。在运行池中，会有多个处于就绪状态的线程在等待 CPU，JAVA 虚拟机的一项任务就是负责线程的调度，线程调度是指按照特定机制为多个线程分配 CPU 的使用权。（Java是由JVM中的线程计数器来实现线程调度）
有两种调度模型：分时调度模型和抢占式调度模型。
分时调度模型是指让所有的线程轮流获得 cpu 的使用权，并且平均分配每个线程占用的 CPU的时间片这个也比较好理解。
Java虚拟机采用抢占式调度模型，是指优先让可运行池中优先级高的线程占用CPU，如果可运行池中的线程优先级相同，那么就随机选择一个线程，使其占用CPU。处于运行状态的线程会一直运行，直至它不得不放弃 CPU。
由于 Java 采用抢占式的线程调度算法， 因此可能会出现某条线程常常获取到 CPU控制权的情况， 为了让某些优先级比较低的线程也能获取到 CPU 控制权， 可以使用 Thread.sleep(0)手动触发一次操作系统分配时间片的操作， 这也是平衡 CPU 控制
权的一种操作。
我们知道的JVM内存区域有：堆和栈，这是一种泛的分法，也是按运行时区域的一种分法，堆是所有线程共享的一块区域，而栈是线程隔离的，每个线程互不共享。线程不共享区域每个线程的数据区域包括程序计数器、虚拟机栈和本地方法栈，它们都是在新线程创建时才创建的。
程序计数器（ProgramCounterRerister）
程序计数器区域一块内存较小的区域，它用于存储线程的每个执行指令，每个线程都有自己的程序计数器，此区域不会有内存溢出的情况。
虚拟机栈（VMStack）
虚拟机栈描述的是Java方法执行的内存模型，每个方法被执行的时候都会同时创建一个栈帧（StackFrame）用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。
本地方法栈（NativeMethodStack）
本地方法栈用于支持本地方法（native标识的方法，即非Java语言实现的方法）。虚拟机栈和本地方法栈，当线程请求分配的栈容量超过JVM允许的最大容量时抛出StackOverflowError异常。
线程共享区域
线程共享区域包含：堆和方法区。
堆（Heap）
堆是最常处理的区域，它存储在JVM启动时创建的数组和对象，JVM垃圾收集也主要是在堆上面工作。如果实际所需的堆超过了自动内存管理系统能提供的最大容量时抛出OutOfMemoryError异常。
方法区（MethodArea）
方法区是可供各条线程共享的运行时内存区域。存储了每一个类的结构信息，例如运行时常量池（RuntimeConstantPool）、字段和方法数据、构造函数和普通方法的字节码内容、还包括一些在类、实例、接口初始化时用到的特殊方法。当创建类和接口时，如果构造运行时常量池所需的内存空间超过了方法区所能提供的最大内存空间后就会抛出OutOfMemoryError。
运行时常量池（RuntimeConstantPool）
运行时常量池是方法区的一部分，每一个运行时常量池都分配在JVM的方法区中，在类和接口被加载到JVM后，对应的运行时常量池就被创建。运行时常量池是每一个类或接口的常量池（Constant_Pool）的运行时表现形式，它包括了若干种常量：编译器可知的数值字面量到必须运行期解析后才能获得的方法或字段的引用。如果方法区的内存空间不能满足内存分配请求，那Java虚拟机将抛出一个OutOfMemoryError异常。栈包含Frames，当调用方法时，Frame被推送到堆栈。一个Frame包含局部变量数组、操作数栈、常量池引用。
乐观锁： 对于并发间操作产生的线程安全问题持乐观状态， 乐观锁认为竞争不总是会发生， 因此它不需要持有锁， 将比较-替换这两个动作作为一个原子操作尝试去修改内存中的变量， 如果失败则表示发生冲突， 那么就应该有相应的重试逻辑。
悲观锁： 对于并发间操作产生的线程安全问题持悲观状态，悲观锁认为竞争总是会发生， 因此每次对某资源进行操作时， 都会持有一个独占的锁， 就像synchronized， 不管三七二十一， 直接上了锁就操作资源了。
同一时间只能有一条线程执行固定类的同步方法， 但是对于类的非同步方法， 可以多条线程同时访问。 所以， 这样就有问题了， 可能线程 A 在执行 Hashtable 的 put方法添加数据， 线程 B 则可以正常调用 size()方法读取 Hashtable 中当前元素的个数， 那读取到的值可能不是最新的， 可能线程 A 添加了完了数据， 但是没有对size++， 线程 B 就已经读取 size了， 那么对于线程 B 来说读取到的 size 一定是不准确的。 而给 size()方法加了同步之后， 意味着线程 B 调用 size()方法只有在线程 A调用 put 方法完毕之后才可以调用， 这样就保证了线程安全性CPU 执行代码， 执行的不是 Java 代码， 这点很关键， 一定得记住。 Java 代码最终是被翻译成机器码执行的， 机器码才是真正可以和硬件电路交互的代码。 即使你看到 Java 代码只有一行， 甚至你看到 Java 代码编译之后生成的字节码也只有一行， 也不意味着对于底层来说这句语句的操作只有一个。 一句"return count"假设被翻译成了三句汇编语句执行， 一句汇编语句和其机器码做对应， 完全可能执行完第一句， 线程就切换了。
同步块， 这意味着同步块之外的代码是异步执行的， 这比同步整个方法更提升代码的效率。
请知道一条原则： 同步的范围越小越好。
自旋锁是采用让当前线程不停地的在循环体内执行实现的， 当循环的条件被其他线程改变时才能进入临界区。
Java 不支持类的多重继承， 但允许你实现多个接口。 所以如果你要继承其他类， 也为了减少类之间的耦合性， Runnable 会更好。
notify()方法不能唤醒某个具体的线程， 所以只有一个线程在等待的时候它才有用武之地。而 notifyAll()唤醒所有线程并允许他们争夺锁确保了至少有一个线程能继续运行。
这是个设计相关的问题， 它考察的是面试者对现有系统和一些普遍存在但看起来不合理的事物的看法。 回答这些问题的时候， 你要说明为什么把这些方法放在 Object类里是有意义的， 还有不把它放在 Thread 类里的原因。 一个很明显的原因是JAVA 提供的锁是对象级的而不是线程级的， 每个对象都有锁， 通过线程获得。 如果线程需要等待某些锁那么调用对象中的wait()方法就有意义了。 如果 wait()方法定义在 Thread 类中， 线程正在等待的是哪个锁就不明显了。 简单的说， 由于 wait，notify 和 notifyAll 都是锁级别的操作， 所以把他们定义在 Object 类中因为锁属于对象。
主要是因为JavaAPI强制要求这样做，如果你不这么做，你的代码会抛出IllegalMonitorStateException异常。还有一个原因是为了避免wait和notify之间产生竞态条件。
处于等待状态的线程可能会收到错误警报和伪唤醒， 如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退出。 因此， 当一个等待线程醒来时， 不能认为它原来的等待状态仍然是有效的， 在 notify()方法调用之后和等待线程醒来之前这段时间它可能会改变。 这就是在循环中使用 wait()方法效果更好的原因， 你可以在 Eclipse 中创建模板调用 wait和 notify 试一试。
每个线程都有自己的栈内存， 用于存储本地变量， 方法参数和栈调用， 一个线程中存储的变量对其它线程是不可见的。 而堆是所有线程共享的一片公用内存区域。 对象都在堆里创建， 为了提升效率线程会从堆中弄一个缓存到自己的栈， 如果多个线程使用该变量就可能引发问题， 这时 volatile 变量就可以发挥作用了， 它要求线程从主存中读取变量的值。
单例模式即一个 JVM 内存中只存在一个类的对象实例分类
1、 懒汉式：类加载的时候就创建实例
2、 饿汉式：使用的时候才创建实例
阻塞式方法是指程序会一直等待该方法完成期间不做其他事情， ServerSocket 的 accept()方法就是一直等待客户端连接。 这里的阻塞是指调用结果返回之前，当前线程会被挂起， 直到得到结果之后才会返回。 此外， 还有异步和非阻塞式方法在任务完成前就返回。
当线程数小于最大线程池数 maximumPoolSize 时就会创建新线程来处理， 而线程数大于等于最大线程池数 maximumPoolSize 时就会执行拒绝策略。
synchronized关键字类似的功能，但是提供了更多的控制，比如可以中断等待中的线程。CyclicBarrier和CountDownLatch，它提供了更复杂的同步原语。Lock是一个接口，提供了比synchronized更灵活的同步控制；Condition则是一个类，它提供了线程之间的协调机制。死锁（Deadlock）指在两个或多个进程或线程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，这些进程或线程都将无法向前推进。
死锁通常发生在以下四个条件同时满足的情况下，这些条件又被称为Coffman条件或死锁的四个必要条件：
为了避免死锁，可以采取以下几种策略：
Future和Callable是Java并发库中的两个接口，它们可以让你获取异步计算的结果。你可以在一个线程中执行一个Callable任务，然后获取其返回的Future对象。然后，你可以调用Future对象的get()方法来获取结果。这种方式也可以处理多个线程之间的数据交换。
join()方法会等待当前线程完成，也就是说，它会阻塞当前线程，直到被调用join()的线程执行完毕。如果当前线程在等待过程中被其他线程中断，那么会抛出InterruptedException。
还有一个重载版本的join(long millis)方法，允许你指定一个超时时间。如果在这个超时时间内，被调用的线程还没有执行完毕，那么当前线程就会继续执行。如果在等待过程中当前线程被中断，那么也会抛出InterruptedException。
可以使用Semaphore类来限制同一时间运行的线程数量。Semaphore是一个计数信号量，可以用来控制对资源的访问。每个线程在运行之前都会尝试获取信号量。如果信号量不可用（即当前已经有3个线程在运行），那么线程将会等待，直到信号量变得可用。一旦线程获取到信号量，它就可以运行。当线程完成其工作后，它会释放信号量，允许其他线程获取信号量并运行。
采用实现 Runnable、Callable 接口的方式创建多线程。
优势是： 线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。在这种方式下，多个线程可以共享同一个 target 对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将 CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
劣势是： 编程稍微复杂，如果要访问当前线程，则必须使用 Thread.currentThread()方法。
使用继承 Thread 类的方式创建多线程
优势是： 编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread()方法，直接使用 this 即可获得当前线程。
劣势是： 线程类已经继承了 Thread 类，所以不能再继承其他父类。
Runnable 和 Callable 的区别
并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。
并行：单位时间内，多个处理器或多核处理器同时处理多个任务，是真正意义上的“同时进行”。
串行：有n个任务，由一个线程按顺序执行。由于任务、方法都在一个线程执行所以不存在线程不安全情况，也就不存在临界区的问题。
做一个形象的比喻：
线程调度器选择优先级最高的线程运行，但是，如果发生以下情况，就会终止线程的运行：
（1）线程体中调用了 yield 方法让出了对 cpu 的占用权利
（2）线程体中调用了 sleep 方法使线程进入睡眠状态
（3）线程由于 IO 操作受到阻塞
（4）另外一个更高优先级线程出现
（5）在支持时间片的系统中，该线程的时间片用完
在java中有以下3种方法可以终止正在运行的线程：
使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。
使用stop方法强行终止，但是不推荐这个方法，因为stop和suspend及resume一样都是过期作废的方法。
使用interrupt方法中断线程。
当一个线程对共享的数据进行操作时，应使之成为一个”原子操作“，即在没有完成相关操作之前，不允许其他线程打断它，否则，就会破坏数据的完整性，必然会得到错误的处理结果，这就是线程的同步。
在多线程应用中，考虑不同线程之间的数据同步和防止死锁。当两个或多个线程之间同时等待对方释放资源的时候就会形成线程之间的死锁。为了防止死锁的发生，需要通过同步来实现线程安全。
线程互斥是指对于共享的进程系统资源，在各单个线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。线程互斥可以看成是一种特殊的线程同步。
线程间的同步方法大体可分为两类：用户模式和内核模式。顾名思义，内核模式就是指利用系统内核对象的单一性来进行同步，使用时需要切换内核态与用户态，而用户模式就是不需要切换到内核态，只在用户态完成操作。
用户模式下的方法有：原子操作（例如一个单一的全局变量），临界区。内核模式下的方法有：事件，信号量，互斥量。
实现线程同步的方法：
Synchronized的语义底层是通过一个monitor（监视器锁）的对象来完成，每个对象有一个监视器锁(monitor)。每个Synchronized修饰过的代码当它的monitor被占用时就会处于锁定状态并且尝试获取monitor的所有权 ，过程：
1、如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。
2、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1。
3、如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。
synchronized是可以通过 反汇编指令 javap命令，查看相应的字节码文件。
重入锁是指一个线程获取到该锁之后，该线程可以继续获得该锁。底层原理维护一个计数器，当线程获取该锁时，计数器加一，再次获得该锁时继续加一，释放锁时，计数器减一，当计数器值为0时，表明该锁未被任何线程所持有，其它线程可以竞争获取锁。
synchronized 锁升级原理：在锁对象的对象头里面有一个 threadid 字段，在第一次访问的时候threadid 为空，jvm 让其持有偏向锁，并将 threadid 设置为其线程 id，再次进入的时候会先判断threadid 是否与其线程 id 一致，如果一致则可以直接使用此对象，如果不一致，则升级偏向锁为轻量级锁，通过自旋循环一定次数来获取锁，执行一定次数之后，如果还没有正常获取到要使用的对象，此时就会把锁从轻量级升级为重量级锁，此过程就构成了 synchronized 锁的升级。
锁的升级的目的：锁升级是为了减低了锁带来的性能消耗。在 Java 6 之后优化 synchronized 的实现方式，使用了偏向锁升级为轻量级锁再升级到重量级锁的方式，从而减低了锁带来的性能消耗。
偏向锁，顾名思义，它会偏向于第一个访问锁的线程，如果在运行过程中，同步锁只有一个线程访问，不存在多线程争用的情况，则线程是不需要触发同步的，减少加锁／解锁的一些CAS操作（比如等待队列的一些CAS操作），这种情况下，就会给线程加一个偏向锁。 如果在运行过程中，遇到了其他线程抢占锁，则持有偏向锁的线程会被挂起，JVM会消除它身上的偏向锁，将锁恢复到标准的轻量级锁。
轻量级锁是由偏向所升级来的，偏向锁运行在一个线程进入同步块的情况下，当第二个线程加入锁争用的时候，轻量级锁就会升级为重量级锁；
重量级锁是synchronized ，是 Java 虚拟机中最为基础的锁实现。在这种状态下，Java 虚拟机会阻
塞加锁失败的线程，并且在目标锁被释放的时候，唤醒这些线程。
（1）synchronized 是悲观锁，属于抢占式，会引起其他线程阻塞。
（2）volatile 提供多线程共享变量可见性和禁止指令重排序优化。
（3）CAS 是基于冲突检测的乐观锁（非阻塞）
synchronized 是和 if、else、for、while 一样的关键字，ReentrantLock 是类，这是二者的本质区别。既然 ReentrantLock 是类，那么它就提供了比synchronized 更多更灵活的特性，可以被继承、可以有方法、可以有各种各样的类变量。
synchronized 早期的实现比较低效，对比 ReentrantLock，大多数场景性能都相差较大，但是在Java 6 中对 synchronized 进行了非常多的改进。
相同点：两者都是可重入锁
两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。
主要区别如下：
Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：
能，Java 中可以创建 volatile 类型数组，不过只是一个指向数组的引用，而不是整个数组。意思是，如果改变引用指向的数组，将会受到 volatile 的保护，但是如果多个线程同时改变数组的元素，volatile 标示符就不能起到之前的保护作用了。
volatile 变量可以确保先行关系，即写操作会发生在后续的读操作之前, 但它并不能保证原子性。例如用 volatile 修饰 count 变量，那么 count++ 操作就不是原子性的。
而 AtomicInteger 类提供的 atomic 方法可以让这种操作具有原子性如getAndIncrement()方法会
原子性的进行增量操作把当前值加一，其它数据类型和引用变量也可以进行相似操作。
关键字volatile的主要作用是使变量在多个线程间可见，但无法保证原子性，对于多个线程访问同一个实例变量需要加锁进行同步。
虽然volatile只能保证可见性不能保证原子性，但用volatile修饰long和double可以保证其操作原子性。
所以从Oracle Java Spec里面可以看到：
synchronized 表示只有一个线程可以获取作用对象的锁，执行代码，阻塞其他线程。
volatile 表示变量在 CPU 的寄存器中是不确定的，必须从主存中读取。保证多线程环境下变量的可见性；禁止指令重排序。
区别
不可变对象保证了对象的内存可见性，对不可变对象的读取不需要进行额外的同步手段，提升了代码执行效率。
Lock 接口比同步方法和同步块提供了更具扩展性的锁操作。他们允许更灵活的结构，可以具有完全不同的性质，并且可以支持多个相关类的条件对象。
它的优势有：
（1）可以使锁更公平
（2）可以使线程在等待锁的时候响应中断
（3）可以让线程尝试获取锁，并在无法获取锁的时候立即返回或者等待一段时间
（4）可以在不同的范围，以不同的顺序获取和释放锁
整体上来说 Lock 是 synchronized 的扩展版，Lock 提供了无条件的、可轮询的(tryLock 方法)、定时的(tryLock 带参方法)、可中断的(lockInterruptibly)、可多条件队列的(newCondition 方法)锁操作。另外 Lock 的实现类基本都支持非公平锁(默认)和公平锁，synchronized 只支持非公平锁，当然，在大部分情况下，非公平锁是高效的择。
1、ABA 问题：
比如说一个线程 one 从内存位置 V 中取出 A，这时候另一个线程 two 也从内存中取出 A，并且 two 进行了一些操作变成了 B，然后 two 又将 V 位置的数据变成 A，这时候线程 one 进行 CAS 操作发现内存中仍然是 A，然后 one 操作成功。尽管线程 one 的 CAS 操作成功，但可能存在潜藏的问题。从Java1.5 开始 JDK 的 atomic包里提供了一个类 AtomicStampedReference 来解决 ABA 问题。
2、循环时间长开销大：
对于资源竞争严重（线程冲突严重）的情况，CAS 自旋的概率会比较大，从而浪费更多的 CPU 资源，效率低于 synchronized。
3、只能保证一个共享变量的原子操作：
当对一个共享变量执行操作时，我们可以使用循环 CAS 的方式来保证原子操作，但是对多个共享变量操作时，循环 CAS 就无法保证操作的原子性，这个时候就可以用锁。
简单来说就是原子类来实现CAS无锁模式的算法
Atomic包中的类基本的特性就是在多线程环境下，当有多个线程同时对单个（包括基本类型及引用类型）变量进行操作时，具有排他性，即当多个线程同时对该变量的值进行更新时，仅有一个线程能成功，而未成功的线程可以向自旋锁一样，继续尝试，一直等到执行成功。
Java通过Executors（jdk1.5并发包）提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
newCachedThreadPool
特点：newCachedThreadPool创建一个可缓存线程池，如果当前线程池的长度超过了处理的需要时，它可以灵活的回收空闲的线程，当需要增加时， 它可以灵活的添加新的线程，而不会对池的长度作任何限制
缺点：他虽然可以无线的新建线程，但是容易造成堆外内存溢出，因为它的最大值是在初始化的时候设置为 Integer.MAX_VALUE，一般来说机器都没那么大内存给它不断使用。当然知道可能出问题的点，就可以去重写一个方法限制一下这个最大值
总结：线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
newFixedThreadPool
特点：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。定长线程池的大小最好根据系统资源进行设置。
缺点：线程数量是固定的，但是阻塞队列是无界队列。如果有很多请求积压，阻塞队列越来越长，容易导致OOM（超出内存空间）
总结：请求的挤压一定要和分配的线程池大小匹配，定线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()
newScheduledThreadPool
特点：创建一个固定长度的线程池，而且支持定时的以及周期性的任务执行，类似于Timer（Timer是Java的一个定时器类）
缺点：由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务（比如：一个任务出错，以后的任务都无法继续）。
newSingleThreadExecutor
特点：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它，他必须保证前一项任务执行完毕才能执行后一项。保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
缺点：缺点的话，很明显，他是单线程的，高并发业务下有点无力
总结：保证所有任务按照指定顺序执行的，如果这个唯一的线程因为异常结束，那么会有一个新的
线程来替代它
ThreadGroup 类，可以把线程归属到某一个线程组中，线程组中可以有线程对象，也可以有线程组，组中还可以有线程，这样的组织结构有点类似于树的形式。线程组和线程池是两个不同的概念，他们的作用完全不同，前者是为了方便线程的管理，后者是为了管理线程的生命周期，复用线程，减少创建销毁线程的开销。
为什么不推荐使用线程组？因为使用有很多的安全隐患吧，没有具体追究，如果需要使用，推荐使用线程池。
如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任时，ThreadPoolTaskExecutor 定义一些策略:
因为HasTable的内部方法都被synchronized修饰了，所以是线程安全的。其他的都和HashMap一样。
ConcurrentHashMap是Java5中支持高并发、高吞吐量的线程安全HashMap实现。它由Segment数组结构和HashEntry数组结构组成。Segment数组在ConcurrentHashMap里扮演锁的角色，HashEntry则用于存储键-值对数据。一个ConcurrentHashMap里包含一个Segment数组，Segment的结构和HashMap类似，是一种数组和链表结构；一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素；每个Segment守护着一个HashEntry数组里的元素，当对HashEntry数组的数据进行修改时，必须首先获得它对应的Segment锁。
总结：
HashTable就是实现了HashMap加上了synchronized，而ConcurrentHashMap底层采用分段的数组+链表实现，线程安全
ConcurrentHashMap通过把整个Map分为N个Segment，可以提供相同的线程安全，但是效率提升N倍，默认提升16倍。
并且读操作不加锁，由于HashEntry的value变量是 volatile的，也能保证读取到最新的值。
Hashtable的synchronized是针对整张Hash表的，即每次锁住整张表让线程独占，ConcurrentHashMap允许多个修改操作并发进行，其关键在于使用了锁分离技术
扩容：段内扩容（段内元素超过该段对应Entry数组长度的75%触发扩容，不会对整个Map进行扩容），插入前检测需不需要扩容，有效避免无效扩容。
何为同步容器：可以简单地理解为通过 synchronized 来实现同步的容器，如果有多个线程调用同步容器的方法，它们将会串行执行。比如 Vector，Hashtable，以及Collections.synchronizedSet，synchronizedList 等方法返回的容器。可以通过查看 Vector，Hashtable 等这些同步容器的实现代码，可以看到这些容器实现线程安全的方式就是将它们的状态封装起来，并在需要同步的方法上加上关键字 synchronized。
并发容器使用了与同步容器完全不同的加锁策略来提供更高的并发性和伸缩性，例如在ConcurrentHashMap 中采用了一种粒度更细的加锁机制，可以称为分段锁，在这种锁机制下，允许任意数量的读线程并发地访问 map，并且执行读操作的线程和写操作的线程也可以并发的访问map，同时允许一定数量的写操作线程并发地修改 map，所以它可以在并发环境下实现更高的吞吐量。
消息队列很多人知道：消息队列是分布式系统中重要的组件，是系统与系统直接的通信
并发队列是什么：并发队列多个线程以有次序共享数据的重要组件
当队列阻塞队列为空的时，从队列中获取元素的操作将会被阻塞。
或者当阻塞队列是满时，往队列里添加元素的操作会被阻塞。
或者试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元
素。
试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他的线程使队列重新变得空闲
起来。
非堵塞队列：
ArrayDeque, （数组双端队列）：ArrayDeque （非堵塞队列）是JDK容器中的一个双端队列实现，内部使用数组进行元素存
储，不允许存储null值，可以高效的进行元素查找和尾部插入取出，是用作队列、双端队
列、栈的绝佳选择，性能比LinkedList还要好。
PriorityQueue, （优先级队列）：PriorityQueue （非堵塞队列） 一个基于优先级的无界优先级队列。优先级队列的元素按照其自
然顺序进行排序，或者根据构造队列时提供的 Comparator 进行排序，具体取决于所使用的构造
方法。该队列不允许使用 null 元素也不允许插入不可比较的对象
ConcurrentLinkedQueue, （基于链表的并发队列）：ConcurrentLinkedQueue （非堵塞队列）: 是一个适用于高并发场景下的队列，通过无锁的方
式，实现了高并发状态下的高性能。ConcurrentLinkedQueue的性能要好于BlockingQueue接
口，它是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。该队列不允
许null元素。
堵塞队列：
DelayQueue（基于时间优先级的队列，延期阻塞队列）：DelayQueue是一个没有边界BlockingQueue实现，加入其中的元素必需实现Delayed接口。当生产者线程调用put之类的方法加入元素时，会触发Delayed接口中的compareTo方法进行排序，也就是说队列中元素的顺序是按到期时间排序的，而非它们进入队列的顺序。排在队列头部的元素是最早到期的，越往后到期时间赿晚。
ArrayBlockingQueue, （基于数组的并发阻塞队列）：ArrayBlockingQueue是一个有边界的阻塞队列，它的内部实现是一个数组。有边界的意思是它的容量是有限的，我们必须在其初始化的时候指定它的容量大小，容量大小一旦指定就不可改变。ArrayBlockingQueue是以先进先出的方式存储数据
LinkedBlockingQueue, （基于链表的FIFO阻塞队列）：LinkedBlockingQueue阻塞队列大小的配置是可选的，如果我们初始化时指定一个大小，它就是有边界的，如果不指定，它就是无边界的。说是无边界，其实是采用了默认大小为Integer.MAX_VALUE的容量 。它的内部实现是一个链表。
LinkedBlockingDeque, （基于链表的FIFO双端阻塞队列）：LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列，即可以从队列的两端插入和移除元素。双向队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。相比于其他阻塞队列，LinkedBlockingDeque多了addFirst、addLast、peekFirst、peekLast等方法，以first结尾的方法，表示插入、获取获移除双端队列的第一个元素。以last结尾的方法，表示插入、获取获移除双端队列的最后一个元素。LinkedBlockingDeque是可选容量的，在初始化时可以设置容量防止其过度膨胀，如果不设置，默认
容量大小为Integer.MAX_VALUE。
PriorityBlockingQueue, （带优先级的无界阻塞队列）：priorityBlockingQueue是一个无界队列，它没有限制，在内存允许的情况下可以无限添加元素；它又是具有优先级的队列，是通过构造函数传入的对象来判断，传入的对象必须实现comparable接口。
SynchronousQueue （并发同步阻塞队列）：SynchronousQueue是一个内部只能包含一个元素的队列。插入元素到队列的线程被阻塞，直到另一个线程从队列中获取了队列中存储的元素。同样，如果线程尝试获取元素并且当前不存在任何元素，则该线程将被阻塞，直到线程将元素插入队列。
并发队列的常用方法
| 方法名 | 描述 |
|---|---|
| add() | 在不超出队列长度的情况下插入元素，可以立即执行，成功返回true， 如果队列满了就抛出异常。 |
| offer() | 在不超出队列长度的情况下插入元素的时候则可以立即在队列的尾部插 入指定元素,成功时返回true，如果此队列已满，则返回false。 |
| put() | 插入元素的时候，如果队列满了就进行等待，直到队列可用。 |
| take() | 从队列中获取值，如果队列中没有值，线程会一直阻塞，直到队列中有 值，并且该方法取得了该值。 |
| poll(long timeout, TimeUnit unit) | 在给定的时间里，从队列中获取值，如果没有取到会抛出异常。 |
| remainingCapacity() | 获取队列中剩余的空间。 |
| remove(Object o) | 从队列中移除指定的值。 |
| contains(Object o) | 判断队列中是否拥有该值。 |
| drainTo(Collection c) | 将队列中值，全部移除，并发设置到给定的集合中。 |