- JVM基本概念
- 双亲委派
- OSGI 动态模型系统
- 结构集成关系和实现
- List
- set
- Map
- java多线程并发
- Synchronized 作用
- ReentrantLock
- 非公平锁
- 公平锁
- ReentrantLock 与synchronized
- Semaphore 信号量
- 线程唤醒 notify
- 其他方法
- 线程上下文切换
- 进程
- 上下文
- 寄存器
- 程序计数器
- 切换帧 PCB
- 上下文切换的活动
- 引起线程上下文切换的原因
- 同步锁与死锁
- 线程池的原理
- JAVA 阻塞队列原理
- CyclicBarrier、CountDownLatch、Semaphore
- ThreadLocal 作用 线程本地存储
- synchronized 和 ReentrantLock 的区别
- ConcurrentHashMap
- Java 中用到的线程调度
- 进程调度算法
- 什么是 CAS （ 比较并交换-乐观锁机制-自旋锁 ）
- 概念及特性
- 什么是 AQS （ 抽象的队列同步器 ）
- JAVA 基础
- Spring 原理
JVM基本概念
jvm是可运行javadiam的假象计算机，包括一套字节码指令集，一组寄存器、一个栈、一个垃圾回收器、堆和一个储存方法域 jvm是运行在操作系统之上的，它与硬件没有直接的交互。
运行过程
我们都知道java源文件，通过编译器，能够产生响应的.Class文件，也就是字节码文件，而字节码文件又通过java虚拟机中的解释器，编译成特定机器上的机器码。
也即是：
java源文件 -> 编译器 ->字节码文件
字节码文件 -> JVM -> 机器码
每一个种平台的解释器是不同的，但是实现的虚拟机是相同的，也就是java为什么能够跨平台的原因了，当一个程序从开始运行，这时虚拟机就开始实例化了，多个程序启动就会存在多个虚拟机实例，程序退出或者关闭，则虚拟机实例消亡了，多个虚拟机实例之间数据不能共享。
线程
这里所说的线程指的线程程序执行过程中的一个线程实体，jvm允许一个应用并发执行多个线程，hotspot jvm 中的java线程与远程操作系统线程又直接的映射关系吗，当线程本地存储、缓冲区分配，同步对象、栈、程序计数器等准备好以后，操作系统负责调度所有线程，并把它们分派到任何可用的cpu上，当原生线程初始化完毕，就会调用和java线程的run（）方法，当线程结束是会释放原生线程和java线程的所有资源。
HotSpot JVM后台运行的系统线程主要有下面几个
虚拟机线程 VM thread
这个线程等待jvm到达安全点操作出现，这些操作必须要在独立的线程里执行，因为当堆修改无法进行时，线程都需要jvm位于安全点，这些操作的类型有 stop-the-world垃圾回收，线程栈dump，线程暂停、线程偏向锁（biased locking）解除
偏向锁
偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁，降低获取锁的代价。
在大多数情况下，锁总是由同一线程多次获得，不存在多线程竞争，所以出现了偏向锁。其目标就是在只有一个线程执行同步代码块时能够提高性能。
当一个线程访问同步代码块并获取锁时，会在Mark Word里存储锁偏向的线程ID。在线程进入和退出同步块时不再通过CAS操作来加锁和解锁，而是检测Mark Word里是否存储着指向当前线程的偏向锁,有则直接进入。只有线程第一次获取锁的时候会进行一次CAS操作引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径，因为轻量级锁的获取及释放依赖多次CAS原子指令，而偏向锁只需要在置换ThreadID的时候依赖一次CAS原子指令即可。
线程不会主动释放偏向锁，除非有别的线程来竞争偏向锁。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有字节码正在执行），它会首先暂停拥有偏向锁的线程，判断锁对象是否处于被锁定状态。撤销偏向锁后恢复到无锁（标志位为“01”）或轻量级锁（标志位为“00”）的状态。
偏向锁在JDK 6及以后的JVM里是默认启用的。可以通过JVM参数关闭偏向锁：-XX:-UseBiasedLocking=false，关闭之后程序默认会进入轻量级锁状态。
线程栈dump
通过jstack生成线程dump文件的时候。
周期性任务线程
这线程负责定时器时间也就是中断，用来调度周期性的操作的执行。
GC线程
编译器线程
信号分发器线程
这个线程接受发送到jvm的信号并调用适当的jvm方法处理
jvm内存区域
jvm内存区域主要分为线程私有区域：程序计数器、虚拟机栈、本地方法栈
线程共享区域： java堆、方法区、直接内存
线程私有数据区域声明周期与线程相同，依赖用户线程的启动/结束，而创建/销毁在hotspot vm内，每个线程都与操作系统的本地线程直接映射，因此这部分内存区域的存/否跟随本地线程的生/死对应。
线程共享区域随虚拟机的启动、关闭而创建、销毁
直接内存并不是jvm运行时数据区的一部分，但也会被频繁的使用:jdk1.4引入的NIO提供了基于Channel与buffer的io方式，它可以使用Native函数库直接分配堆外内存，然后使用DirectByteBuffer对象组欧威这块内存的引用进行操作,这样就避免了再java对和Native堆中来回复制数据，因此在一些场景中可以显著提高性能。
程序计数器 线程私有
一块较小的内存区域，是当前线程所执行的字节码的行号指示器，每条线程都要有一个独立的程序计数器，这类内存也称为 线程私有的内存。
正在执行Java方法话，计数器记录的是虚拟机字节码指令的地址 当前指令的地址，如果还是native方法，则为空
这个内存区域是唯一一个在虚拟机中没有规定任务OutOfMemoryError情况的区域
虚拟机栈 线程私有
是描述java方法执行的内存模型，每个方法在执行的同时都会创建也给栈帧 stack frame。用于存储局部变量表、操作数栈、动态联机、方法出口等信息，每一个方法从调用直至执行完成的过程, 就对应着一个栈帧在虚拟机栈中入栈到出栈的过程，
栈帧 frame 是用来储存疏忽和部分过程结果的数据结构，同时也被用来处理动态链接(Dynamic Linking)、方法返回值和异常分派（ Dispatch Exception）。栈帧随着方法调用而创建，随着方法调用结束而销毁，无论方法是正常完场还是异常完场，抛出了再方法内未被捕获的异常 都算作方法结束。
本地方法栈 线程私有
本地方法区和java stack作用类似，区域是虚拟机栈为执行java方法服务，而本地方法栈则为Native方法服务，如果一个JVM实现使用C-linkage模型来支持Native调用，那么该栈将会是一个c栈，但HotSpot VM直接把本地方法栈和虚拟机栈合二为一。
堆 Heap-线程共享-运行时数据区
堆是被线程贡献的一块区域，创建的对象和数据都储存在java堆内存中，也是垃圾收集器进行垃圾手机的最重要的内存区域，由于现代vm采用分代手机算法，因此java堆从GC角度还是可以细分为：新生代( Eden 区 、 From Survivor 区 和 To Survivor 区和老年代。
方法区、永久代 线程共享
即我们常说的永久代(Permanent Generation）。用于存储被jvm加载的类信息、常量、静态变量，即时编译器编译后的代码等数据，Hotspot vm把GC分代收集扩展至方法区，即使用java堆的永久代来实现方法区，这样hotspot的垃圾收集器就可以想管理java堆一样管理这部分内存，而不必为方法区开发专门的内存管理器，永久=带的内存回收的主要目标是针对常量池的回收和类型的卸载，因此受益一般很小。
运行时常量池（Runtime Constant Pool）是方法区的一部分，Class文件中除了有类的版本、字段、方法、接口等描述信息外，还要一项信息是常量池（Constant Pool Table）。用于存放编译期间生成的各种字面量和符号引用，这部分内容将在类加载后放到方法区的运行时常量池，java虚拟机对class文件的每一部分 自然也包括常量池的格式都有严格的规定，每一个字节用于存储那种数据都必须符合规范上的要求，这样才会被虚拟机认可、装载和执行。
JVM 运行时内存
java堆从GC的角度还可以细分为：新生代( Eden 区 、 From Survivor 区 和 To Survivor 区）和老年代。
新生代 Young
新生代是用来存放新生的对象，一般占据堆的1/3空间，由于频繁的创建对象，所以新生代会频繁发MinorGC进行垃圾回收，新生代又分为Eden区，ServivorFrom，servivorTo三个区。
Eden区
java新生对象的出生地，如果创建的对象占用内存很大，则直接分配到老年代，当Eden区内存不够的时候就会触发MinorGC，对新生代区进行一次垃圾回收
ServivorFrom
ServivorTo
MinorGC的过程
复制
清空
互换
MinorGC采用复制算法
- eden,servivorFrom复制到ServivorTo，年龄+1
首先Eden和ServivorFrom区域中存活的对象复制到ServivorTo区域，如果有对象的年龄已经达到了老年的标准，则赋值到老年代区，同时这些对象的年龄+1,如果ServivorTo不够位置了就放到老年区。
- 清空Eden、ServivorFrom
然后，清空Eden和ServivorFrom中的对象
- ServivorTo和ServivorFrom互换
原ServivorTo成为下一次GC的ServivorFrom区
老年 代
主要存放应用程序中生命周期常的内存对象。
老年代的对象比较稳定，所以MajorGC不会频繁的执行，在进行MajorGC前一般都先进了一次MinorGC，使得新生代的对象晋身入老年代，导致空间不够用才触发，当无法找到足够大的连续空间分配给新创建的较大的对象时，也会提前触发一次MajorGC进行垃圾回收腾出空间
majorGC采用标记清除算法，首先扫描一次所有老年代，标记出存活的对象，然后会后没有标记的对象，MajorGC的耗时比较长，因为要扫描再回收，MajorGC会产生碎片，为了减少内存损耗，我们一般需要进行合并或者标记出来方便下次直接分配，当老年代也满了装不下的时候，就会排除OOM（Out of Memory）异常。
永久代
指内存得永久保存区域，主要存放Class和Meta元数据的信息，Class在被加载的时候被放入永久区域，他和存放实例的区域不同，GC不会再主程序运行期间对永久区域进行清理，所以这也导致了永久代的区域会随着加载class的增多而膨胀，最红排除OOM异常
java8 与元数据
在java8 中，永久代已经被移除了，被一个成为 元数据区 （元空间）的区域所取代，元空间和永久代类型，元空间和永久代最大的区域在于，元空间并不在虚拟机中，而是使用本地内存，因此，默认情况下，元空间的大小仅受本地内存限制，类的元数据放入native memory，字符串池和类的静态变量放入java堆，这样可以加载多少类的元数据就不再由MaxPermSize 控制, 而由系统的实际可用空间来控制。
2.4. 垃圾回收与算法
如何确定垃圾
引用计数法
在java中，引用和对象时有关联的，如果要操作对象则必须用引用进行。因此，很显然一个简单的办法是通过引用计数来判断一个对象是否可以回收，简单的说即一个对象如果没有任何阈值关联的引用，即他们的引用都不为0，则说明对象不太可能在再被用到，那么这个对象就是可回收的对象。
可达性分析
为了解决引用计数法的循环引用问题，java使用了可达性分析的方法，通过一些列的 GCroots 对象作为起点搜索，如果在 gcroots和一个对象之间没有可达路径，则称为该对象时不可达的。更要注意的是，不可达对象不等价于可回收对象，不可达对象变为可回收对象至少要经过两次标记过程，两次标记后仍然是可回收对象，则面临回收
标记清除算法 mark-sweep
最基础的垃圾回收算法，分为两个阶段，标记和清除，标记阶段标记出所有需要回收的对象，清除阶段回收被标记的对象所占用的空间，如图：
从图中我们就可以发现，该算法最大的问题就是内存碎片话严重，后续可能发生大对象不能张可以利用空间的问题。
复制算法
为了解决Mark-sweep 算法内存碎片化的缺陷而被剔除的算法，按内存得容量将内存划分为等大小的两块，每次只使用其中的一块，当这一块内存满后将尚存活的对象复制到另一块上去，把已使用的内存清掉。如图：
这种算法虽然实现简单，内存效率该，不易产生碎片，但是最大的问题是可用内存被压缩到原本的一般，且存活对象增多的话，copying算法的效率会大大降低。
标记整理算法 Mark-Compact
结合了以上两个算法，为了避免缺陷而提出。标记阶段和mark-sweep算法相同，标记后不是清理对象，而是将存活对象移向内存的一端，然后清除端边界外的对象，如图
分代收集算法
分代收集算法是目前大部分jvm所采用的方法，其核心思想是根据对象存活的不同生命周期将内存划分为不同的域，一般情况下将GC堆划分为老生代(Tenured/Old Generation)和新生代（Young Generation）。老生代的特点是每次垃圾回收只有少量对象需要被回收，新生代的特点是每次垃圾回收时都有大量垃圾需要被回收，因为可以根据不同区域选择不同的算法。
新生代与复制算法
目前大部分jvm的gc对于新生代都采取Copying算法，因为新生代中每次垃圾回收都要回收大部分对象，即要复制的操作比较少，但通常并不是按照1:1来划分新生代的，一般新生代划分一块较大的Eden空间和较小的Survivor空间(From Space, To Space)，每次使用Eden空间和其中一块的Survivor空间，当进行回收时，将该两块空间中还存活的的对象复制到另一块Survivor空间中。
老年代与标记复制算法
而老年代因为每次只回收少量对象，因此采用Mark-Compact算法
- java虚拟机提到过的处于方法区的永生带(Permanet Generation)，它用来储存class类，常量，方法描述等，对于永生代的回收主要包括废弃常量和无用的类。
- 对象的内存分配主要在新生代的Eden space和Survivor space的from space（Survivor 目前存放对象的那一块），少数情况会直接分配到老年代。
- 当新生代的Eden Space和From space空间不足时就会发生一次GC，进行GC后，Eden space和from space区的存货对象会被挪到TO space，然后将Eden space和From Space进行清理。
- 如果TO space无法足够存储某个对象，则将这个对象存储到老生代。
- 在进行gc后，使用的便是Eden space和to space了，如此反复循环。
- 当对象在Survivor去躲过一次后，其分代年龄就会+1，默认情况下年龄到达15的对象就会移到老年代中。
java中四种引用类型
强引用
在java中最常见的就是强引用，把一个对下赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，他是不可能被垃圾回收机制回收的。即使该对象以后永远都不会被用到JVM也不会回收，因此强引用时造成java内存泄漏的而主要原因之一软引用
软引用需要用softReference类来实现的，对于只有软引用的对象来说，当系统内存足够是它是不会被回收，当系统内存空间不足时它会被回收，软引用通常在堆内存敏感的程序中。String s = new String("Frank"); // 创建强引用与String对象关联，现在该String对象为强可达状态SoftReference<String> softRef = new SoftReference<String>(s); // 再创建一个软引用关联该对象s = null; // 消除强引用，现在只剩下软引用与其关联，该String对象为软可达状态s = softRef.get(); // 重新关联上强引用
弱引用
弱引用需要用weakReference类来来实现，它比软引用的生命周期更短，对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管jvm的内存空间是否足够，总会回收该对象占用的内存。
可以配和引用队列使用，在弱引用回收的时候会被加入到引用队列中。Object obj = new Object();WeakReference<Object> wf = new WeakReference<Object>(obj);wf.get();//获取对象
虚引用
虚引用需要PhantomReference类来实现，它不能单独使用后，必须和引用队列联合使用，虚引用的主要作用是跟踪对象被垃圾回收的状态。
虚引用和弱引用的区别在于：虚引用的使用必须和引用队列（Reference Queue）联合使用。
Object obj = new Object();ReferenceQueue referenceQueue = new ReferenceQueue();PhantomReference phantomReference = new PhantomReference(object， queue);
GC 分代收集算法和分区收集算法
分代收集算法
当前主流vm垃圾收集都采用 分代收集(Generational Collection)算法，这种算法会根据对象存活周期的不同将内存划分为几块，如jvm中的新生代、老年代、永久代，这样就可以根据各代特点分别采用最合适的gc算法
在新生代-复制算法
每次垃圾收集都能发现大批对象已死，只有少量存活，因此选用复制算法，只需要付出少量存活对象的复制成本就可以完成收集。
在老年代-标记整理算法
因为对象存活率高、没有额外空间对它进行分配担保。就必须采用 标记-清理 或 标记-整理 算法来进行回收，不必进行内存复制，且直接腾出空闲内存。
分代收集算法
分区算法则将整个堆空间划分为连续的不同小区间，每个小区间独立使用，独立回收，这样做的好处是可以控制一次回收多少个小区间，根据目标停顿时间，每次合理地回收若干小区间 而不是整个对，从而减少一次GC所产生的停顿。
GC垃圾收集器
java堆内存被划分为新生代和老年代两部分，新生代主要使用复制和标记-清除垃圾回收算法，老年代主要使用标记-整理垃圾回收算法，因此java虚拟机中针对新生代和老年代分别提供了多种不同的垃圾收集器，jdk1,6中 sun hotspot虚拟机的垃圾收集器如下：
Serial垃圾收集器 单线程 复制算法
serial是最基本垃圾收集器，使用复制算法，曾经是jdk1.3.1之前新生代唯一的垃圾收集器，Serial是一个单线程的收集器，它不但只会使用一个cpu或者一条线程去完成垃圾收集工作，并且在进行垃圾收集的同时目标性暂停其他所有工作线程，直到垃圾收集结束。
Serial垃圾收集器虽然在收集垃圾过程中，需要暂停所有其他的工作线程，但是它简单高修奥，对于单个cpu环境来说，没有线程交互的开销，可以获得最高的单线程垃圾收集效率，因此Serial垃圾收集器亦然是java虚拟机在运行Client模式下默认的新生代垃圾收集器。
ParNew垃圾收集器 Serial+ 多线程
ParNew垃圾收集器起始是serial收集器的多线程版本，也使用复制算法，除了使用多线程进行垃圾收集之外，其余的行为和serial收集器完全一样，ParNew垃圾收集器在垃圾收集过程中同样也要暂停所有其余的工作线程。
ParNew收集器默认开启和cpu数据相同的线程数，可以通过-XX:ParallelGCThreads参数来限定垃圾收集器的线程数，【Parallel：平行的】
ParNew虽然是除了多线程外和serial收集器几乎完全一样，但是ParNew垃圾收集器是喝多java虚拟机在server模式下新生代的默认垃圾收集器。
Parallel Scavenge 收集器
Parallel Scavenge收集器也是一个新生代垃圾收集器，同样使用复制算法，也是一个多线程的垃圾收集器，他重点关注的是一个程序达到一个可控制的吞吐量（Thoughtput cpu用于运行用户代的时间/cpu总消耗时间，即吞吐量=运行用户代码时间//(运行用户代码时间+垃圾收集时间)），高吞吐量可以最高效率地利用cpu时间，尽快地完成程序的运算任务，主要使用与在后台运算而不需要太多交互的任务，自适应调整策略也是ParallelScavenge收集器与ParNew收集器的一个重要区别。
Serial old 收集器 单线程标记整理算法
Serial old是serial垃圾收集器年老代版本，它同样是个单线程的收集器，使用标记-整理算法，这个收集器也主要是运行在Client默认的java虚拟机默认的老年代垃圾收集器。
在server 模式下，主要有两个用途:
- 在jdk1.5之前版本中与新生代的Parallel Scavenge收集器搭配使用
- 作为老年代中使用cms收集器的后备垃圾收集方案。
新生代Serial与老年代Serial old 搭配垃圾收集过程图
新生代Parallel Scavenge收集器与ParNew收集器工作原理类似，都是多线程的收集器，都使用的复制算法，在垃圾收集过程中都需要暂停所有的工作线程，新生代parallel Scavenge/ParNew 与老年代Serial old搭配垃圾收集过程图:
parallel old 收集器 多线程标记整理算法
Parallel old收集器是Parallel Scavenge的老年代版本，使用多线程的标记-整理算法，在jdk1.6才开始提供
在jdk1.6之前，新生代使用ParallelScavenge收集器只能搭配老年代的serial old收集器，只能保证新生代的吞吐量优先，无法保证整体的吞吐量，Parallel old正是为了在老年代提供同样的吞吐量有限的垃圾收集器，如果系统对吞吐量要求比较高，可以有限考虑新生代Parallel Scavenge和老年代 Parallel old 收集器的搭配策略
新生代Parallel scavenge和老年代 parallel old收集器搭配运行的过程图
cms收集器 多线程标记清除算法
ConCurrent mark sweep(cms)收集器是一种老年代垃圾收集器，其最主要的目标是获取最短垃圾回收停顿时间，和其他老年代使用标记-整理算法不同，它使用多线程的标记-清除算法。最短的垃圾收集停顿时间可以为交互比较高的程序提高用户体验。
CMS工作机制相比其他垃圾收集器来说更复杂，整个过程分为以下四个阶段：
初始标记
知识标记一下GC ROOTs能直接关联的对象，速度很快，仍然需要暂停所有的工作线程。
并发标记
进行GC Roots跟踪的过程，和用户线程一起工作，不需要暂停工作线程。
重新标记
为了修正正在并发标记期间，因用户程序继续运行而导致标记产生变动的那一部分对象的标记，仍然需要暂停所有的工作线程
并发清除
清除GC Roots 不可达对象，和用户线程一起工作，不需要暂停工作线程，由于耗时最长并发标记和并发清除过程中，卡机收集器线程可以和用户现在一起并发工作，所以总体上来看CMS收集器的内存回收和用户线程是一起并发地执行。
CMS收集器工作过程
G1收集器
Garbage first 垃圾收集器是目前垃圾收集器理论发展的最前沿成功，相比cms收集器，G1收集器两个最出去的改进是:
- 基于标记-整理算法，不产生内存碎片
- 可以非常精确控制停顿时间，在不牺牲吞吐量的前提下，实现低停顿垃圾回收
G1收集器避免全区域垃圾收集，它把堆内存划分为大小固定的几个独立区域，并且跟踪这些区域的垃圾收集进度，同时在后台维护一个优先级列表，每次根据所允许的收集时间，优先回收垃圾最多的区域，区域划分和优先级区域回收机制，确保G1收集器可以在有限时间获得最高的垃圾收集效率。
java IO/NIO
阻塞io模型
最传统的一种io模型，即在读写数据过程中会发生阻塞现象，当用户线程发出io请求之后，内核回去查看数据是否就绪，如果没有就绪就会等待数据就绪，而数据线程就会处于阻塞状态，用户线程交出cpu，当数据就绪之后，内核会将数据拷贝到用户线程，并返回结果给用户线程，用户线程才解除block状态，典型的阻塞io模型的例子为：data=socket.read();如果数据没有就绪，就会一直阻塞在read方法。
非阻塞IO模型
当用户线程发起一个read操作后，并不需要等待，而是马上就得到了一个结果，如果结果是一个error是，它指定数据还没有准备好，于是它马上就会将数据拷贝到了用户线程，然后返回，所以事实上，在非阻塞IO模型中，用户线程需要不断第询问内核数据是否就绪，也就说非阻塞IO不会交出CPU，而会一直占用cpu,典型的非阻塞IO模型一般如下:
while(true){data = socket.read();if(data!= error){处理数据break;}}
但是对于非阻塞IO就有一个非常眼红的问题，在while循环中需要不断地去询问内核数据是否就绪，这样导致cpu占用率非常高，因此一般情况下很少使用while循环这种方式来读取数据。
多路复用IO模型
多路复用IO模型是目前使用得比较多的模型，javaNIO实际上就是多路复用IO，在多路复用IO模型中，会有一个线程不断去轮询多个socket的状态，只有当socket真正有读写事件时，才真正调用实际的io读写操作，因为在多路复用io模型中，只需要使用一个线程就可以管理多个socket，系统不需要建立新的新进程或者线程，也不必维护这些线程和进程，并且只有在真正有socket读写事件进行时，才会使用复用IO资源，所以它大大减少了资源占用，在java nio中，是通过 selector.select()去查询每个通道是否有到达事件，如果没有事件，则一直阻塞在哪里，因此这种方式导致用户线程的阻塞，在多路复用io模型中，通过一个线程就可以管理多个socket，只有socket真正有读写事件发生才会占用资源来进行实际的读写操作，因此，多路复用io比较适合连接数比较多的情况。
另外多路复用io为何比非阻塞io模型的效率高是因为在非阻塞io中，不断地询问socket状态是通过用户线程去进行的，而在多路复用io中，轮询每个socket状态是内核在进行的，这个效率要比用户线程高的多。
不过要注意的是，多路复用io模型是通过轮询的范式来检测是否有事件到达，并且堆到达的时间逐一进行响应，因此对于多路复用io模型来说，一旦事件响应体很大，那么就会导致后续的事件迟迟得不到处理，并且会影响新的事件轮询。
信号驱动IO模型
在信号驱动IO模型中，当用户线程发起一个IO请求操作，会给对应的socket注册一个信号函数，然后用户线程会继续执行，当内核数据就绪就会发送一个消耗给用户线程，用户线程接受到信号之后，便在信号函数中调用IO读写操作来进行实际的io请求操作。
异步IO模型
异步IO模型才是最理想的IO模型，在异步IO模型中，当用户线程发起read操作之后，立刻就可以开始去做其他的事。而另一方面，从内核的角度，当它受到一个asynchronous read之后，它会立刻返回，说明read请求已经成功发起了，因此不会对用户线程产生任何block，然后，内核会给你用户发送一个信号，告诉read操作完成了，也就说用户完全不需要实际操作整个io，只需要先发起一个请求，当接受内核返回的成功信号时表示io操作已经完成，可以直接去使用数据了。
也就是说在异步io模型中，IO操作的两个阶段都不会阻塞用户线程，这两个阶段都是由内核自动自动完成，然后发送一个信号告知用户线程操作完成，用户线程中不需要再次调用io函数进行具体的读写，这点和信号驱动模型有所不同，在信号驱动模型中，当用户线程接受信号表示数据就绪，然后需要yoghurt线程调用io函数进行实际的读写操作，而异步io模型中吗，收到信号表示io操作已经完成了，不需要再在用户线程中调用IO函数进行实际的读写操作。
注意:异步IO模型是需要操作系统底层的支持，在java7中，提供了 Asynchronous IO
java IO包
java NIO
NIO主要有三大核心部分，Channel（通道）Buffer（缓冲区）Selector（选择器），传统IO基于字节流和字符流进行操作，而NIO基于Channel和Buffer缓存区进行操作，数据总是从通道读取到缓冲区中，或者从缓存区写入到通道中,Selector 选择区用于监听多个通道的事件，比如 连接打开，数据到达，因此，单个线程可以监听多个数据通道。
NIO和传统IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓存区的。
NIO的缓冲区
java io面向流意味着每次从流中读取一个或者多个字节，直至读取所有字节，他们没有被缓存在任何地方，此外，他不能去取前后移动流中的数据。 如果需要前后移动从流中读取的数据，需要先将他缓存到一个缓冲区。NIO的缓冲导向方法不同。数据读取到它一个稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。
NIO的非阻塞
io的各种流是阻塞的，这意味着，当一个线程调用read或者write是，该线程被阻塞，知道一些数据被读取，或者数据完全写入，该县层在此期间不能再干任何事情了，NIO的非阻塞模式，使一个线程从某个通过发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做任何事情，非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待他完全写入，这个线程同事可以去做别的事情，线程通常将非阻塞IO的空闲时间用于其他通道上执行io操作，所以一个单独的线程显著可以管理多个输入和输出通过（channel）。
channel
首先说一下Channel，国内大多翻译成通道，channel和io中的stream流是差不多的一个登记，只不过Stream是单向的，比如：InputStream、outputStream，而channel是双向的，既可以用来进行读取操作，又可以进行写操作。NIO中的Channel的主要实现有：
- FileChannel
- DatagramChannel
- SocketChannel
- ServerSocketChannel
这里看名字就可以猜出所以然来，分别对应文件IO、UDP、和TCP（server和client）。下面演示的案例基本上就是围绕着四个类型的Channel进行陈述的。
Buffer
buffer顾名思义，缓冲区，实际上就是一个容器，是一个连接数组，Channel提供从 文件、网络读取数据的取到，但是读取或写入的数据都必须经由Buffer。
上面的图描述了从一个客户端向服务端发送数据，然后服务端接受数据的过程，客户端发送数据时，必须先将数据存入buffer中，然后将buffer中的内容写入通道。服务端这边接受数据必须通过Channel将数据写入到Buffer中，然后在从Buffer中取出数据来处理。
在NIO中，buffer是一个顶级父类，它是一个抽象类，常用的Buffer的子类有：ByteBuffer、IntBuffer、CharBuffer、LongBuffer、DoubleBuffer、FloatBuffer、ShortBuffer
Selector
selector类是NIO的核心类，Selector能够监测多个注册的通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行响应的处理，这样一来，只是用一个单一线程就可以管理多个通道，也就是管理多个连接，这个试的只有在连接真正有读写事件发生时，才会调用函数进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程，并且避免了多线程之间的上下文切换导致的开销。
JVM类加载机制
JVM类加载机制分为五个部分，加载、验证、准备、解析、初始化。下面我们就分别来看一下这五个过程
加载
加载是类加载过程中的一个阶段，这个节点会在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的入口，注意这里不一定非要从一个class文件获取，这里既可以从zip包中读取，比如从jar包和war包中读取，也可以在运行时计算生成动态代理，也可以由其他文件生成比如 将jsp文件转换成对应的class类。
验证
这一阶段的主要目的是为了确保Class文件的字节流中包含的信息是否服务当前虚拟机的要求，并且不会危害虚拟机自身的安全。
准备
准备阶段是正时为类变量分配内存并设置类变量的初始阶段，即在方法区中分配这些变量所使用的内存空间，注意这里所说的初始值概念，比如一个类变量定义为:
public static int v = 8080;
实际上变量v在准备阶段过后的初始值是0而不是8080，将v赋值为8080的put static指令是程序被编译后，存放与类构造器client方法之中。
但注意如果声明为：
public static final int v= 8080;
在编译阶段会为v生成ConstantValue属性，在准备阶段虚拟机会根据ConstantValue属性将v赋值为8080
解析
解析阶段是指虚拟机将常量池中的符号引用替换为直接引用的过程，符号引用就是class文件中的：
CONSTANT_CLASS_INFOCONSTANT_Field_INFOCONSTANT_METHOD_INFO
符号引用
符号引用与虚拟机实现的布局无关，引用的目标并不一定要已经加载到内存中，各种虚拟机实现的内存可以各不相同，但是他们能接受的符号引用必须是一直的，因为符号引用的字面量明确定义在java虚拟机规范的class文件格式中。
直接引用
直接引用可以是指向目标的指针，相对偏移量或是一个能间接定位到目标的句柄，如果有了直接引用，那引用的目标必定已经在内存中存在。
初始化
初始化阶段是类加载最后一个阶段，前面的类加载阶段之后，处理加载阶段可以自定义类加载器意外，其他操作都是有jvm主导，到了初始阶段，才开始真正执行类中定义的java程序代码。
类构造器 client
初始化阶段是执行类构造器
注意一下几种情况不会执行类的初始化：
- 通过子类引用父类的静态字段，只会触发父类的初始化，而不会触发子类的初始化，
- 定义对象数据，不会触发该类的初始化
- 常量在编译期间会存入调用类的常量池中，本质上并没有直接引用定义常量的类，不会触发定义常量所在的类
- 通过类名获取Class对象，不会触发类的初始化
- 通过Class.forName加载指定类时，如果指定参数Initialize为false时，也不会触发类初始化，起始这个参数是告诉虚拟机，是否要对类进行初始化曹组
- 通过ClassLoader默认的loadClass方法，也不会触发触发初始化动作
类加载器
虚拟机设计团队把加载动作放在jvm外部实现，以便让应用程序决定如何获取所需的类，jvm提供了三种类加载器：启动类类加载器 BOOTStrap ClassLoader
负责加载JAVA_HOME\lib目录中的，或通过-Xbootclasspath参数指定路径中的，且被虚拟机认可（或按文件名识别，如rt.jar）的类扩展类加载器 Extension ClassLoader
负责记载JAVA_HOME\lib\ext的，或通过java.ext.dirs系统变量指定路径中的类库应用程序类加载器 Application ClassLoader
负责加载用户路劲classpath上的类库
jvm通过双亲委派模型进行类的记载，当然我们也可以通过集成java.lang.ClassLoader实现自定义的类加载器
双亲委派
当一个类加载请求，他首先不会尝试自己加载这个类，二货思把这个请求委派给你父类去完成，没一个层次类加载器都是如此,因此所有的加载请求都应该传送到启动类加载其中，只有当父类加载反馈自己无法完成这个请求的时候，（在他的加载路径下没有找到所需要加载的Class),子类加载器才会尝试自己去加载。
采用双亲委派的一个好吃是比如加载位于rt.jar包中的类java.lang.Object,不管是哪个加载器加载这个类，最终都是委托给顶层的启动类加载器进行加载，这样就保证了使用不同的类加载最终都是同一个Obejct对象。
OSGI 动态模型系统
OSGI（Open Service Gateway Initiative），是面向java的动态模型系统，是java动态模块化系统的一些列规范
动态改变构造
OSGI服务平台提供在多种网络设备上无需重启的动态改变构造的功能，为了最小化耦合度和促使这些耦合度可管理，OSGI技术提供一种面向服务的架构，它能使这些组价动态地发现对方。
模块化变成与热插拔
OSGI 旨在实现java程序升级更新时，可以只停用、重新安装然后启动程序其中的一部分，这对企业级程序开发来说是非常具有诱惑力的特性。
OSGI描述了一个很美好的模块化开发目标，而且定义了实现这个目标的所需服务与架构，同时也有成熟的框架进行实现支持，但并非所有的应用都适合采用osgi作为基础架构，它在提供强大功能同时，也引入了额外的复杂度，因为不遵守了类加载的双亲委派模型。
结构集成关系和实现
集合类存放与java.uti包中，主要三种：set集合，list列表包含queue和map映射
- Collection：collection是集合List、Set、Queue的最基本的接口
- iterator：迭代器，可以通过迭代器遍历集合中的数据
- Map： 是映射表的基础接口
List
java的List是非常常用的数据类型，List是有序的Collection。javaList一共三个实现类：分别是ArrayList、Vector、LinkedList。
ArrayList 数组
ArrayList 是最长用的List实现类，内部是通过数组实现的，它允许元素进行快速随机访问，数组的缺点是每个元素之间不能由间隔，当数组大小不满足是需要增加存储能力，就要将已经有数组的数据复制到新的储存空间中，当ArrayList的中间位置插入或者删除元素时，需要堆数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不合适插入和删除。
Vector 数组实现、线程同步
Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此访问它比ArrayList慢。
LinkedList 链表
LinkedList是用链表的结构储存数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢，另外，他还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当做栈、队列和双向队列使用。
set
Set注定独一无二的性质，该体系集合用于存储无序（存入和取出的顺序不一定相同）元素，值不能重复，对象的相等本性是对象hashCode值（java是依据对象的内存地址计算出的此序号）判断的。 如果想让两个不同的对象视为相等的，就必须覆盖Object的hashCode方法和equals方法。
HashSet Hash表
哈希表存存放的是哈希值，HashSet储存元素的顺序并不是按照存入时的顺序（和List显然不同的）而是按照哈希值来存的所以取数据也是按照哈希值取得。元素的哈希值是通过元素的HashCode方法来获取的，HashSet首先判断两个元素的哈希值，如果哈希值一样，接着会比较equals方法如果equls结果为true，HashSet就视为同一个元素，如果equals为false就不是同一个元素。
哈希值相同equals为false的元素时怎么储存呢。就是在同样的哈希值下顺延（可以认为哈希值相同的元素放在一个哈希桶中）。也就是哈希一样的存一列。
HashSet通过hashCode值来确定元素在内存中的位置，一个hashCode位置上可以存放多个元素。
hashcode介绍
hashcode的作用是获取哈希码，也称为散列码，它实际上是返回一个int帧数，这个哈希码的作用是确定该对象在哈希表中的索引位置，hashcode方法定义在jdk的Object类中，这就以为者java中任何类都包含hashCode函数，另外需要注意的是Obejct的Hashcode方法是Native方法，该方法通常用来将对象的内存地址转换为整数之后返回。
为什么要有hashcode
当你把对象hashset是，hashSet会先计算对象的hashcode值来判断对象的位置，同时也会与其他已经添加的对象的hashcode值做比较，如果没有相符的hashcode相同的对象，hashset会假设对象没有重复出现，但是如果发现有相同的hashcode值的对象，这是会调用equals法来检验hashcode相等的对象是否真的相同，如果两者相同，hashset就不会让其添加操作成功，如果不同就会重新散列到其他位置，这样就大大减少了equals的次数，响应的提高的执行的速度。
public static int hashCode(Object a[]) {if (a == null)return 0;int result = 1;for (Object element : a)result = 31 * result + (element == null ? 0 : element.hashCode());return result;}
以字符串”123”为例：字符’1’的ascii码是49，hashCode = （49 31 + 50） 31 + 51或者这样看：hashCode=（’1’ 31 + ‘2’ ） 31 + ‘3’可见实际可以看作是一种权重的算法，在前面的字符的权重大。这样有个明显的好处，就是前缀相同的字符串的hash值都落在邻近的区间。
好处有两点：
可以节省内存，因为hash值在相邻，这样hash的数组可以比较小。比如当用HashMap，以String为key时。
hash值相邻，如果存放在容器，比好HashSet，HashMap中时，实际存放的内存的位置也相邻，则存取的效率也高。（程序局部性原理）以31为倍数，原因了31的二进制全 1，则可以有效地离散数据
为什么使用 31？
是因为他是一个奇素数。如果乘数是偶数，并且乘法溢出的话，信息就会丢失，因为与2相乘等价于移位运算（低位补0）。使用素数的好处并不很明显，但是习惯上使用素数来计算散列结果。 31 有个很好的性能，即用移位和减法来代替乘法，可以得到更好的性能： 31 * i == (i << 5）- i 移位计算比乘法快很多。
如何解决hash冲突
解决hash冲突的方法：
- 拉链法：hashMap，HashSet起始都是采用拉链法解决哈希冲突的，就是在每个位同实现的时候，我们采用链表（1.8之后采用链表+红黑树）的数据结构来去存取发生哈希冲突的输入域的关键字（也就是被哈希哈数映射到同一个位桶上的关键字）
- 开放地址：开放地址法有个非常关键的特征，所有输入的元素的元素全部存放在hash表里，位桶的实现是不需要任何的链表来实现的，换句话说，也就是是这个哈希表的装载因子不会超过1 ，他的实现是在插入一个元素的时候，先通过哈希函数进行判断，若是发生哈希冲突，就以当前地址为基准，根据再寻址的方法 探查序列一直往后查找，去寻找下一个地址，若发生重入再去寻找，直至找到下一个空的地址。
- 在散列法 再散列法起始很简单，就是再使用哈希函数去散列一个输入的时候，输出是同一个位置就再次散列，直至不发生冲突，缺点L每次冲突都要重新散列，计算时间增加
建立公共溢出区，建立公共溢出区，存放所有hash冲突的数据。
TreeSet
TreeSet是使用二叉树的原理对新add（）的对象按照指定的顺序排序（升序、降序），每增加一个对象的都会进行排序，将对象插入的二叉树指定的位置。
- Integer和Striing对象都可以进行模型的TreeSet排序，而自定义类的对象时不可用的，自己定义的类必须实现Comparable接口，并且覆盖写响应的CompareTo函数，才可以正常使用。
- 在重写compare函数时，要返回响应的值才能使用TreeSet按照一定的规则来排序
- 在比较此对象与指定对象的顺序，如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数
LinkedHashSet （ HashSet+LinkedHashMap ）
对于LinkedHashSet而言，它集成与HashSet、又基于LinkedHashMap来实现的。LinkedHashSet底层使用LinkedHashMap来保存所有元素，它继承与HashSet，其所有的方法操作上又与HashSet相同，因此LinkedHashSet的实现上非常简单，只提供了四个构造方法，并通过传递一个标识参数，调用父类的构造器，底层构造一个LinkedHashMap来实现，在相关操作上于父类HashSet的操作相同，直接调用父类HashSet的方法即可。
Map
HashMap（数组+链表+红黑树）
HashMap根据键的hashCode储存数据，大多数情况下可以直接定位到它的值，因而具有很快的访问速度，但遍历顺序却是不确定的，HashMap最多只允许一条记录的键为null，运行多条记录的值为null，HashMap非线程安全的，即任一时刻可以有多个线程同事写HashMap，可能会导致数据的不一致，如果需要满足线程安全，可以用Collections的synchronizedMap方法使HashMap具有线程安全的能力，或者使用ConcurrentHashMap，我们用下面这张图来介绍hashMapd的结构。
java7实现
java7 HashMap结构
大方向上，HashMap里面是一个数组，然后数组中每个元素时同一个单向链表，上图中，每个绿色的实体是嵌套类Entry的实体，Entry包含四个属性:key，value，hash值和用于单向链表的next。
- capacity：当前数组容量，始终保持2^n,可以扩容，扩容后数组大小为当前2倍
- loadFactor：负载引子，默认为0.75
- threshold：扩容的阈值，等于 capacity*loadfactor
java8 实现
java8 对hashMap进行了一些修改，最大的不同即使利用了红黑树，所以其由数组+链表+红黑树组成。
根据java7 HashMap的介绍，我们知道，查找的时候，根据hash值我们能够快速定位到数组的下标，但是之后的话，需要顺着链表一个个比较下去才能找到我们需要的。时间复杂度取决于链表的长度。‘
ConcurrentHashMa
Segment 段
ConcurrentHashMap和HashMap思路是差不多的，但是因为它支持并发操作，所以要复杂一些，整个ConcurrentHashMap由一个个Sagment组成，Segment组成，segment代表部分或一段的意思，所以很多地方都会将其描述为分段锁，注意，行文中，很多地方用”槽”来代表一个Segment。
线程安全（Segment 继承 ReentrantLock 加）
简单理解就是，concurrentHashMap是一个Segment组数，Segment通过集成ReentrantLock来进行加锁，所以每次需要加锁的操作锁住的是一个Segment，这样只要保证每个Segment是线程安全的，也就实现了全局的线程安全。
并行度 默认16
concurrentcyLevel ： 并行级别、并发数、Segment数，怎么翻译不重要，理解它。默认是16，也就是说ConcurrentHashMap有16个Segments，所以理论上，这个时候，最多可以同时支持16个线程并发写，只要它们的操作分别分布在不同的segment上，这个值可以在初始化的时候设置为其他值，但是一旦初始化以后，它是不可以扩容的，再具体到每个Segment内部，其实每个Segment很想之前介绍的HashMap，不过它要保证现场安全，所以处理起来麻烦些。
java8 实现 引入红黑树
java8 对ConcurrentHashMap进行比较大的改动，java8也引入了红黑树。
java8 ConcurrentHashMap结构
HashTable 线程安全
Hashtable是遗留类，很多映射的常用功能与HashMap类似，不同的是它继承子Dictionary类，斌企鹅是线程安全的，任一世家你只有一个线程能写HashTable，并发性不如ConcurrentHashMap，因为ConcurrentHashMap引入分段锁，HashTable不见以在新代码中使用，不需要线程安全的场合可以用HashMap替换，需要线程安全的场合可以用ConcurrentHashMap替换
TreeMap 可排序
TreeMap 实现SortMap接口，能够把它保存的记录根据键排序，默认是按键值的升序排序，也可以指定排序的比较器，当用Iterator遍历TreeMap时，得到的记录是排过序的，
如果使用排序的映射，建议使用TreeMap。
在使用TreeMap时，key必须实现Comparable接口或者在构造TreeMap传入自定义的Comparator，否则会在运行时抛出java.lang.ClassCastException.
https://www.ibm.com/developerworks/cn/java/j-lo-tree/index.html
LinkHashMap 记录插入顺序
LinkedHashMap是HashMap的一个子类，保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的，也可以在构造器带参数，按照访问次数排序。
http://www.importnew.com/28263.html
http://www.importnew.com/20386.html#comment-648123
java多线程并发
java并发知识库
JAVA线程实现、创建方式
集成Thread类
Thread类本质上是实现了Runnable接口的一个实例，代表一个现成的实例，启动线程的唯一方法就是通过Thread类的start()实例方法，start方法是一个native方法，它将启动一个新线程，并执行run() 方法。
1）编写一个类MyThread继承Thread，重写run方法2）新建MyThread的实例3）调用start方法public class MyThread extends Thread {@Overridepublic void run() {try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("MyThread.run()");}}MyThread myThread = new MyThread();myThread.start();
实现Runnable接口
如果自己的类已经extends另一个类，就无法直接extends Thread,此时，可以实现一个Runnable接口
1）创建一个类CreateThreadDemo2，实现Runnable接口，重写run方法2）新建CreateThreadDemo2对象task3）新建Thread对象，并指向对象task4）调用start方法public class MyThreadRunnable implements Runnable{@Overridepublic void run() {System.out.println("实现Runnable接口创建线程");}}MyThreadRunnable myThreadRunnable = new MyThreadRunnable();Thread thread = new Thread(myThreadRunnable);thread.start();
ExecutorService、Callable、Future有返回值线程
有返回值的任务实现Callable接口，类似的，无返回值的任务必须Runnable接口，执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExectorService就可以实现有返回值的多线程了
基于线程池的方式
线程和数据库连接这些咨询员都是非常宝贵的资源，那么每次需要的时候创建，不需要的时候销毁，是非常浪费资源的，那么我们就可以使用缓存的策略马爷就是使用线程池。
四种线程池
java里面线程成的顶级接口是Executor，但是严格意义上讲Exceutor并不是一个线程池，而是一个执行线程的工具。真正的线程池的接口是ExectorService。
newCachedThreadPool
创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可以用是将重用它们，对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能，调用execute将重用以前构造的线程，如果线程可用，如果现有线程没有可用的，则创建一个新线程并添加到池中，终止并从缓存中移除那些已有60秒未被使用的线程，因此吗，长时间保持空闲的线程池不会使用任何资源。
newFixedThreadPool
创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程，在任意点，在多数nThreads线程会处理任务的活动状态，如果在所有线程处于活动状态时提交附加恩物，则在有可用线程之前，附加任务将在队列中等待，如果在滚逼的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务，在某个线程被显示地关闭之前，池中的变成将一直存在。
newScheduledThreadPool
创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行任务。
newSingleThreadExecutor
Executors.newSingleThreadExecutor()返回一个线程池，这个线程池只有一个线程，这个线程池可用在线程死后或发生异常时重新启动一个线程来代替原来的线程继续执行下去。
public class MainTest {public static void main(String[] args) {//1 newFixedThreadPool// 线程数固定的线程池ExecutorService executorService = Executors.newFixedThreadPool(4);//3 newScheduledThreadPool//它的核心线程数是固定的，对于非核心线程救护可以说是没有限制的，并且当非核心线程处于限制状态的时候就会立即回收//延迟一定时间后之心runable任务，延迟一定时间后执行callable任务，延迟一定使劲后，以间隔period时间的频率周期性的执行任务ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(4);scheduledExecutorService.schedule(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + "延迟三秒执行");}}, 3, TimeUnit.SECONDS);scheduledExecutorService.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + "延迟三秒后每隔2秒执行");}}, 3, 2, TimeUnit.SECONDS);}//2 newCachedThreadPool 核心线程数为0，线程池的最大线程数Integer.Max_Value,而Integer.Max_Value是一个很大的数，// 也差不多可以说这个线程池中的最大线程数可以任意大public static ExecutorService newCachedThreadPool(){return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60l, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());}//4 通过Executors中的newSingleThreadExector方法来创建，在这个线程池中又一个核心线程，对于任务队列没有大小限制，也就以为者这一个任务处于活动状态时，其他//任务都会在任务队列中排队等候一次执行。//newSingleThreadExecutor 将所有的外接任务同一到一个线程中支持，所以这这个任务执行纸巾啊我们不需要处理线程同步的问题public static ExecutorService newSingleThreadExecutor(){return new ThreadPoolExecutor(1, 1, 0L,TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());}}
线程生命周期 状态
当线程创建并启动以后，它既不是已启动就进入执行状态，也不是一直处于执行状态，当线程的生命周期中，它要经过新建new、就绪Runable、运行running、阻塞Blocked、死亡Dead 5中状态，尤其是当线程启动以后，它不可能一直霸占着cpu独自运行，所以cpu需要在多条线程之间切换，于是线程状态也会多次在运行、堵塞之间切换
新建状态
当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时仅有JVM为其分配内存。并初始化其成员变量的值。
就绪状态
当线程对象调用了start()方法之后，该线程处于就绪状态，java虚拟机会为其创建方法调用栈和程序技术器，等待调度运行
运行状态
如果处于就绪装填的线程获得了cpu，开始执行run方法的线程执行体，则该线程处于运行状态，
阻塞状态
阻塞状态是指线程因为某种原因放弃了cpu使用权，也即让出了cpu tinelics，暂时停止运行，直至线程进行可运行runable状态，才有机会再次获得cpu timeslice转到运行runing状态，阻塞的情况分为三种。
等待阻塞（o.waur->等待队列）
运行 running的线程执行o.wait()方法，JVM会把该线程放入等待队列（waiting queue）中，
同步阻塞 lock->锁池
运行running的现场在获取对象的同步锁时，若该同步锁被别的线程占用，则jvm会把该线程放入锁池lock pool中
其他阻塞 sleep join
运行running的线程执行Thread.sleep或t.join方法，或者发出了io请求时，jvm会把该线程设置阻塞创天，当sleep庄毅啊超时，join等待线程终止或者超时，或者io处理完毕时，线程重新转入可运行状态
线程死亡DEAD
线程会以下三种方式结束，结束后就是死亡状态
正常结束
- run或call方法执行完成，线程正常结束
异常结束
- 线程抛出一个未捕获的Exception或Error
调用stop
- 直接调用该线程的stop方法来结束该线程 该方法通常容易导致死锁，不推荐使用
终止线程4 种方式
正常运行结束
使用退出标志退出线程
一般run方法执行完，线程就会正常结束，然后，尝尝有些线程是伺候线程，它们需要长时间运行，只有在外部某些条件满足的情况下，才能关闭这些线程，使用一个变量来控制循环，例如：最直接的方法就是设一个boolean类型的标志，并通过设置这个标志位true或false来控制while玄幻是否退出，代码示例：
public class ThreadSafe extends Thread {public volatile boolean exit = false;public void run() {while (!exit){//do something}}}
定义了一个退出标志exit，当exit为ture是，while循环退出，exit的默认值为false在定义exit时，使用了一个java关键字volatile，这个关键字的目的是使exit同步，也就是说在同一时刻只能由一个线程来修改exit的值。
interrupt方法结束线程
使用interrupt方法来中断线程有两种情况
线程处于阻塞状态，如使用了sleep，同步把锁的wait，socket中的receiver,accept等方法时，会使线程处于阻塞创意啊，当调用线程的interrupt方法时，会抛出InterruptException 异常，阻塞中的那个方法抛出这个异常，通过代码捕获该异常，然后brank跳出循环状态，从而让我们有机会技术这个线程的执行，通常很多人认为只要调用interrupt方法线程就会结束，实际上市错的，一定要先捕获InterruptedExceptio
然后通过break来跳出循环，才能正常的结束run方法
线程未处于阻塞状态: 使用isInterrupt判断线程中断标志来退出循环，每当使用interrupt方法时，中断标志就会置true，和使用自定义的标志来控制玄幻是一样的道理
public static void main(String[] args) {Thread t1 = new Thread(()->{while (!Thread.currentThread().isInterrupted()){System.out.println("我在执行");}});t1.start();new Thread(()->{try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {e.printStackTrace();}t1.interrupt();}).start();}
stop方法终止线程 线程不安全
程序中可以直接使用thread.stop()来强行终止线程，但是stop方法时很危险的，就像突然关闭计算机电源，而不是正常程序关机一样，可能会产生不可预料的结果不安全主要是Thread.stop()嗲用之后，床架子线程的线程就会抛出ThreadDeatherror的错误，并且会释放子线程所有持有的所有锁，一般任何进行加锁的代码块，都是为了保护数据的一致性，如果在调用thread.stop()后导致了该线程所持有的所有锁突然释放（不可控制），那么被保护的数据就有可能呈现不一致性，其他线程在使用这些被破坏的数据时，有可能导致一些很奇怪的应用程序错误，因此，并不推荐使用stop方法来终止线程
sleep与wait区域
- 对于sleep方法，我们首先要知道该方法是属于Thread类中的，而wait()方法是属于object类的
- sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态亦然保持者，当指定的时间到了又会自动恢复运行状态
- 在调用sleep方法的过程中，线程不会释放对象锁
- 而当嗲用wait()方法的时候，线程会放弃对象锁，进入对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进行对象锁定池准备获取对象锁进入运行状态
start与run区间
- start() 方法来启动线程，真正实现了多线程运行，这时武勋等待run方法代码执行完毕，可以直接继续执行下面的代码
- 通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行
方法run称为线程体，它包含了要执行的这个现成的内容，线程就进入了运行状态，开始运行run函数当中的代码，run方法运行结束，此线程终止，然后cpu 再调度其他线程
JAVA后台程序
定义 守护线程-也成 服务线程，他是后台线程的，它有一个特性，即为用户线程 提供公共服务，在没有用户线程可服务时会自动离开 ```java public class DeamTestMain { public static void main(String[] args) {
Thread thread = new Thread(() -> {});thread.setDaemon(true);thread.start();
}
}
2. 优先级 守护线程的优先级比较低，用于为系统中的其他对象和线程提供服务。2. 设置 通过setDeemon(true)来设置线程位守护线程，将一个用户线程设置为守护线程的方式是在线程对象的Daemon方法2. 在Daemon线程中产生的新线程也是Daemon的2. 线程则是JVM级别的，以Tomcat为例，如果你在wbe应用中启动了一个线程，这个线程的生命周期并不会和web应用程序保持同步，也就是说，即使你停止了web应用，这个线程依旧是活跃的。2. example 垃圾回收线程就是经典的守护线程，当我们程序中不再有任何运行的Thread，程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是jvm上仅剩的线程时，垃圾回收线程会自动离开，它始终在低级别的状态中运行，用户实时监控和管理系统中的可回收资源2. 声明周期 守护线程（daemon）是运行在后台的一种特殊进程，他独立于控制中孤单并且周期性低执行某种任务或等待处理某些发生的事件，也就是说守护线程不依赖于中断，但是依赖于系统，于系统 同生共死 当jvm中所有的线程都是守护线程的时候，JVM就可以退出了，。如果还有一个或以上的非守护线程则jvm不会退出。<a name="pgsEs"></a>### JAVA锁<a name="gx5sb"></a>#### 乐观锁乐观锁是一个种思想，即认为读多写少，遇到并发写的可能性比较低，每次拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在次掐尖别人有没有去更新这个数据，采取在写时限度出当前版本号，然后加锁操作（比较上一次的版本号，如果一样则更新），如果失败则要重复度-比较-写的操作。<br />java中的乐观锁基本上都是通过CAS操作实现的，CAS是一种更新的原子操作，比较当前值跟传入值是否一样，一样则更新，否则失败<a name="UQERc"></a>### 悲观锁悲观锁也是一种悲观 思想，即认为写多，遇到并发写的可能性高，每次去拿数据的时候都认为别人会修改，所以每次在读写数据的时候，都会上锁，这样别人想读写这个数据就会block，直到拿到锁。java中的悲观锁就是Synchronized，AQS框架下的锁则是先尝试cas乐观锁去获取锁，获取不到，才会转换为悲观锁，比如 RetreenLock、<a name="EPntc"></a>### 自旋锁自旋锁的原理非常简单，如果持有锁的线程能在短时间内释放资源，那么那些等待竞争的线程即不要做内核态和用户态之间的转换进入阻塞挂起状态，它们只需要等一等(自旋),等待持有锁的线程释放锁后即可立即获取锁，这样就避免用户线程和内核线程的切换的消耗<br />线程自旋是需要消耗cpu资源的，说白了就是让cpu在做无用功没如果一直获取不到锁，拿线程也不能一直占用cpu自旋做无用功，所以需要设定一个自旋等待的最大时间。<br />如果持有锁的线程执行的时间超过自旋等待的最大时间仍没有释放锁，就会导致其他争用锁<br />的 线程在最大等待时间内还获取不到锁，这时争用线程会停止自旋进入阻塞状态。```java/*** @Auther: liyanhao* @Description: 自旋锁* @Date: 2022/5/15 10:12* @Version: v1.0*/public class SpinLockMainTest {AtomicReference<Thread> atomicReference = new AtomicReference<>();public void myLock() {System.out.println(Thread.currentThread().getName() + "/t" + "come in");while (!atomicReference.compareAndSet(null, Thread.currentThread())) {System.out.println(Thread.currentThread().getName()+"正在自旋获取锁....");}System.out.println(Thread.currentThread().getName()+"获取锁成功，执行业务操作");}public void myUnlock() {atomicReference.compareAndSet(Thread.currentThread(), null);System.out.println(Thread.currentThread().getName()+"释放自旋锁");}public static void main(String[] args) {//测试自旋锁SpinLockMainTest spinLockMainTest = new SpinLockMainTest();new Thread(() -> {try {spinLockMainTest.myLock();TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();} finally {spinLockMainTest.myUnlock();}}, "线程A").start();new Thread(()->{spinLockMainTest.myLock();try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}finally {spinLockMainTest.myUnlock();}},"线程B").start();}}
自旋锁的优缺点
自旋锁尽可能的减少了线程的阻塞，这对于锁的竞争不激烈，且占用锁时间非常端的代码来说性能能大幅提升，因为字段锁的消耗会小于线程阻塞挂起在唤醒的操作得消耗，这些操作会导致线程发生两次上下文切换，。
但是如果锁的竞争激烈，或者持有锁的线程需要长时间占用锁执行同步块，这时候就不适合使用自旋锁了，因为自旋锁在获取锁前一直都是占用cpu做无用功的，占用xx不xx，同时有大量线程在竞争一个锁，会导致获取锁的时间很长，线程自旋的消耗大于线程阻塞挂起操作得消耗，其他需要cpu的线程又不能获取到cpu，造成cpu的浪费，所以这种情况下我们要关闭自旋锁
自旋锁时间阈值 (1.6引入了适用性自旋锁)
自旋锁的牧师是为了占用cpu的资源不释放，等到获取到锁立即进行处理，但是如何去选择自旋的执行时间呢，如果自旋执行是时间太长会有大量的线程处于自旋状态占用cpu资源，进而影响整体系统的性能，因此自旋的周期选的额外重要。
JVM对于自旋周期的选择，JDK1.5 这个限度的是一定的写死的，在1.6引入了适应性自旋锁，适应性自旋锁以为者自旋的时间不在是固定得了，而是由前一次在同一锁上的自选时间以及锁的拥有者的状态来决定的，基本上认为一个线程上下文切换的时间是最佳的一个时间，同时jvm还针对当qiancpu的符合情况做了较多的优化，如果平均负载小于cpus则一直自旋，如果超过(cpus/2)个线程正在自旋，则后来线程直接苏泽，如果正在自旋的线程发现Owner发生了变化则延迟自旋时间(自旋计数)或进入阻塞。如果cpu处于节电模式则停止自旋，自旋时间的最坏勤快是cpu 的存储延迟(cpu a储存了一个数据，到cpu b得到这个数据直接的时间差)，自旋会适当放弃线程优先级之间的差异
Synchronized 作用
- 作用于方法时锁住的是对象的实例 this
- 当做用静态时，锁住的是Class实例，又因为class的相关数据存储在永久带PermGen(jdk1.8 则是metaspace)，永久带是全局共享的，因此静态方法锁住响度昂与类的一个全局锁，会锁住所有锁住该方法的线程
synchronized作用于一个对象实例时，锁住的是所有以该对象为锁的代码块，它有多个队列，当多个线程一起访问某个对象监视器的时候，对象监视器会将这些线程储存在不同的容器中
Synchronized 核心组件
Wait set 那些调用wait方法被阻塞的线程被放置在这里
- Contention list 竞争队里，所有请求锁的线程首先被放在这个竞争队列中
- Entry List Contention List 中那些有资格称为候选资源的线程被移动到Entry List中
- onDeck 任意时刻，最多只有一个线程正在竞争锁资源，该线程称为OnDeck
- Owner 当前已经获取到所有资源的线程被称为Owner
- ！Owner 当前释放的锁的线程
Synchronized 实现
- JVM每次从队列的尾部取出一个数据用于锁竞争候选者OnDeck，但是并发情况下ContentionList会被大量的并发线程进行CAS访问，为了降低对尾部元素的竞争吗，JVM会将一部分线程移动到EntryLlist中作为候选竞争者
- Ownner线程会在unlock时，将ContentionList中的部分线程迁移到EntryList中，并制定EntryList中的某个线程位OnDeck线程 一般是最先进去的线程
- Owner 线程不是直接把锁传递给OnDeck线程么日式把锁竞争的权利交给你OnDeck，OnDeck需要重新获取竞争所，虽然这样牺牲了一些公平性，但是能极大的提示系统的吞吐量，在jvm中，也把这种选择行为称之为 竞争切换
- OnDeck 线程获取到锁资源后会变成Owner线程，而没有得到锁资源的仍然停留在EntryList中，如果Owner线程被wait方法阻塞，则转移到WaitSet队列中，知道某个时刻通过notify或者notuifyall唤醒，会重新进去EntryList中
- 处于COntentionList、entryList、waitSet中的线程都处于阻塞状态，该阻塞是有操作系统来完成的 Linux内核下采用pthread_mutex_lock 内核函数实现的
- Synchronized是非公平锁，synchronized在线程进入ContentionList时，等待的线程会先尝试自旋获取锁，如果获取不到就进入ContentionList,这明显对于已经进入队列的线程是不公平的，还有一个不公平的事情就是自旋获取锁的线程还可能直接抢占OnDeck线程的锁资源。
- 每个对象都有monitor对象，加锁就是在竞争monitor对象，代码块加锁是在前后分别加上monitorenter和monitorexit指令来实现的，方法加锁是通过一个标记来判断的
- synchronized是一个重量级操作，需要调用操作系统相关接口，性能是低效的，有可能给线程加锁消耗的时间比有用操作消耗的时间更多。
- java1.6 synchronized进行很多的优化，有适应自旋、锁删除、锁粗化、轻量级锁及偏向锁等，效率有了本质上的提高，在之后退出的java1.7与java1.8中，均对该关键字的实现激励做了优化，引入了偏向锁和轻量级锁，都在对象头中有标记位，不需要经过操作系统进行加锁
- 锁可以从偏向锁升级到轻量级锁，在升级到重量级锁，这种升级过程叫锁膨胀
- java1.6 中默认是开启偏向锁和请谅解锁的，可以通过-XX:-UseBiasedLocking 来禁用偏向锁
ReentrantLock
ReentrantLock集成接口Lock并实现了接口中定义的方法，他是一种可重入锁，除了能完成synchronized锁能完成的所哟工作外，还提供了诸如可响应中断锁、可轮询锁请求、定时锁等避免多线程死锁的方法
Lock接口的主要方法
- void lock() 执行次方法是，如果锁处于空闲状态，当前线程将获取到锁，相反，如果锁已经被其他线程持有，将禁用当前线程，直到当前线程获取到锁
- boolean tryLock() 如果锁可用，则获取锁，并立即返回true，否则返回fasle，该方法和lock（）的区别在于，tryLock知识试图获取锁，如果锁不可用，不会导致当前线程被禁用，当前线程仍然继续往下执行代码，而lock方法则是一定要获取到锁，如果锁不可用，就一直等待，在未获得锁之前，当前线程并不继续往下执行
- void unlock 执行此方法时，当前线程将释放持有的锁，锁只能由持有者释放，如果线程并不持有锁，却执行该方法，可能导致异常的发生
- condition newCondition()：条件对象，获取等待通知组件，该组件和当前锁绑定，当前线程只有获取了锁，才能调用该组件的await()方法，调用后，当前线程才能释放锁。
- getHoldCount() 查询当前线程保持此锁的次数，也就是执行此线程执行lock方法的次数
- getQueueLength() 返回正在等待获取锁的线程估计数，比如启动10个线程吗，1个线程获得锁，此时返回的是9.
- getWaitQueueLength （Condition condition）返回等待与此锁相关的给定条件的线程估计数，比如10个线程，用同一个condition对象，并且此时这10个线程都执行了condition对象的await方法，那么此时执行次方法返回10
- hasWaiters (Condition condition) 查询是否有线程等待与此锁有关的给定条件，condition，对于指定condition对象，有多少线程指定 了condition.await方法
- hasQueuedThread（Thread thread）查询给定线程是否等待获取此锁
- hasQueuedThreads 是否有线程等待此锁
- isFair 该锁是否公平
- isHeldByCurrentThread 当前线程是否保持锁定，线程执行lock方法的前后分别是false和true
- isLock() 此锁是否有任意线程占用
- LockInterrupoybly() 如果当前线程未被中断，获取锁
- tryLock() 尝试获取锁，尽在调用锁未被线程zhanyong，获得锁。
tryLock(long timeout TimeUnit unit) 如果锁在给定等待时间内没有别另外一个线程保持，则获取该锁。
非公平锁
JVM 按随机、就近分配的机制则称为不公平锁，ReentrantLock 在构造函数中提供了了是否公平锁的初始化方式，默认是非公平锁，非公平锁实际执行的效率要远远超出公平锁，除非程序有特殊需要，否则最常用非公平锁的分配机制。
公平锁
公平锁指的是在锁的分配机制上市公平的，通常先对锁提出获取请求的线程会先被分配到锁，ReentrantLock在构造函数中提供了是否公平锁的初始化方式定义公平锁
ReentrantLock 与synchronized
ReentrantLock通过方法Lock()与unLock()进行加锁与解锁操作，与synchronized会被jvm自动解锁机制不同，ReentrantLock加锁后需要手动进行解锁，为了避免程序出现异常无法正常解锁的情况，使用ReentrantLock必须在finally控制中进行解锁操作，
- ReentranLock相比synchronize的的优势是可中断、公平锁、多个锁，这种情况下需要使用ReentrantLock
public class MyService {private Lock lock = new ReentrantLock();//Lock lock=new ReentrantLock(true);//公平锁//Lock lock=new ReentrantLock(false);//非公平锁private Condition condition=lock.newCondition();//创建 Conditionpublic void testMethod() {try {lock.lock();//lock 加锁//1：wait 方法等待：//System.out.println("开始 wait");condition.await();//通过创建 Condition 对象来使线程 wait，必须先执行 lock.lock 方法获得锁//:2：signal 方法唤醒condition.signal();//condition 对象的 signal 方法可以唤醒 wait 线程for (int i = 0; i < 5; i++) {System.out.println("ThreadName=" + Thread.currentThread().getName()+ (" " + (i + 1)));}} catch (InterruptedException e) {e.printStackTrace();}finally13/04/2018 Page 68 of 283{lock.unlock();}}}
Condition类和Object类锁方法区别
- Condition类的awiat方法和Object类的wait方法等效
- Condition类的singnal方法和Object类的notify方法等效
- Condition类的SingnalAll方法和Object类的notifyAll方法等效
ReentrantLock类可以唤醒指定条件的线程，而Object的唤醒是随机的。
tryLock和Lock和LockInterruptibly的区别
tryLock 能获得锁就返货true，不能立即返回false，tryLock（long timeout,Timeunit unit），可以增加是啊金限制，如果超过时间段还没有火器的锁，返回false
- lock能获得锁就返回true，不能的话就一直等待获得锁
- lock和lockINterruptibly，如果两个线程分别执行者两个方法，但此方法中断者两个线程，lock不会抛出异常，而 lockInterruptibly 会抛出异常。
Semaphore 信号量
semaphore是一种基于计数的信号量，它可以设定一个阈值，基于此，多个线程竞争获取许可信号，做完自己的申请后归还，超过阈值后，线程申请许可信号将会被阻塞，Semaphore可以用来构建一些对象池，资源池之类的，比如数据库连接池。
实现互斥锁(计数器为1)
我们可以创建计数为1 的semaphore，将其作为一种类似互斥锁的机制，这也叫二元信号量。表示两种互坼状态。 ```java // 创建一个计数阈值为 5 的信号量对象 // 只能 5 个线程同时访问 Semaphore semp = new Semaphore(5); try { // 申请许可 semp.acquire(); try { // 业务逻辑 13/04/2018 Page 69 of 283 } catch (Exception e) { } finally { // 释放许可 semp.release(); } } catch (InterruptedException e) { }
<a name="aJoIg"></a>##### Semaphore 与ReentrantLockSemaphore基本能完成ReentrantLock的所有工作。使用方法也阈值类似，通过acquire()与release()方法获得和释放临界资源，经实测，Semaphone.acquire()方法默认为可响应中断锁，与ReentrantLock.lockInterruptibly()作用效果一致，也就是说在等待临界资源的过程中可以被Thread.interrept()方法打断<br />此外Semphore也实现了可轮询的锁请求和定时锁的功能，除了方法名tryAcquire与tryLock不同，使用方法域ReentrantLock几乎一致，Semaphore也提供了公平与非公平锁的机制，也可在构造函数中进行设定。<br />Semaphore的锁释放操作也由手动进行，因此与ReentrantLock一样，为避免线程因抛出异常而无法正常释放锁的情况发生，释放锁操作也必须在finally代码块中完成。<a name="vK6xQ"></a>#### AtomicInteger首先说明。此处AtomicInteger，一个提供原子操作得Integer的类，常见的还有AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference等，他们的实现原理相同，区别在于运行对象类型的不同，令人兴奋的的，同AtomicInteger<V>将一个对象的所有操作转化成原子操作<br />我们知道，在多线程程序中，注意++i或i++等运算不具有原子性，是不安全的线程操作之一，通常我们会使用synchronized将该插座变成一个原子操作，但JVM为此类操作特意提供了一些同步类，使得使用更佳方便，且使程序运行效率变得更高，通过相关资料显示，通常AtomicInteger的性能是ReentanLock的好几倍<a name="AC1Kg"></a>#### 可重入锁 递归锁本文及里边讲的广义上的可重入锁，而不是单只java下的ReentrantLock，可重入锁，也叫做递归锁，值的同一线程外城函数获得锁之后，内层递归函数仍然有获取该锁的代码，但不收影响，在java环境下ReentrantLock和synchronized都是可重入锁。<a name="QVjMj"></a>#### 公平锁与非公平锁公平锁Fair<br />加锁前检查是否有排队等待的线程，有限排队等待的线程，先来先得<br />非公平锁nonfair<br />加锁是不考虑排队等待问题，直接尝试获取锁，获取不到自动到队尾等待1. 非公平锁性能比公平锁高5~10倍，因为公平锁需要在多核的情况下维护一个队列1. java的synchronized是非公平锁，ReentrantLock默认是lock()方式采用的非公平锁。<a name="NSsUQ"></a>#### ReadWiteLock读写锁为了提高性能，java提供了读写锁，在读的地方使用读锁，在写的地方使用写锁，灵活控制，如如没有写锁的情况下，读是无阻塞的，在一定程序上程序的执行效率。读写锁分为读锁和写锁，多少读锁不互斥，读锁与写锁互斥，这时由jvm自己控制的，你只要上号响应的锁即可。<br />**读锁**<br />如果你的代码只读数据，可以很多人同时读，但是不能同时写，那就上读锁。 <br />**写锁**<br />如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁，总之，读的是海上读锁，写的时候上写锁。<br />java中读写锁有个接口java.util.concurrent.locks.ReadWriteLock 也 有 具 体 的 实 现<br />ReentrantReadWriteLock。<a name="ZfAir"></a>#### 共享锁和独占锁java并发包提供的加锁模式分为独占锁和共享锁，ReentrantLock就是独占方式实现的互斥锁。独占锁是一种悲观保守的加锁策略，它避免了读/读冲突，如某个只读线程获取锁，则其他读线程都只能等待，这种情况下就限制了不必要的并发性，因为读操作并不会影响数据的一致性。<a name="EEoBf"></a>#### 共享锁共享锁则运行多个线程同事获取锁，并发访问共享资源，如：ReadWriteLock 。共享锁则是一种乐观锁，它放宽了加锁策略，允许多个读操作得线程同是访问共享资源。1. AQS的内部类Node定义了两个常量SHARED和EXCLUSIVE, 他们分别表示了AQS队列中等待线程的锁获取模式1. java 并发包中提供了ReadwriterLock，读写锁，它运行一个资源可以被多个读操作访问，或者一个写操作访问，但是两者不能同时进行。<a name="Sykik"></a>#### 重量级锁 Mutex LockSynchronized 是通过对象内部的一个监视器锁(monitor)来实现的，但是监视器本质又是依赖于底层的操作系统的Mutex Lock来实现的，而操作系统实现线程之间的切换就需要从用户态转换到核心态。这个成本非常高，状态之间的转换需要相对较长的时间，这就是为什么Synchronized效率地的原因，因此，这种依赖于操作系统Mutex Lock所实现的锁我们称之为重量级锁，JDK中对Synchronized做的种种优化，其核心都是为了减少这种重量级锁的使用。jdk1.6以后，为了减少获得锁和释放锁带来的性能消耗，提供性能，引入 轻量级锁 和偏向锁。<a name="etLwK"></a>#### 轻量级锁锁的状态共有四种: 无锁状态、偏向锁、轻量级锁和重量级锁。<br />**锁升级：**<br />随着锁的竞争，锁可以从偏向锁升级到轻量级锁，再升级到重量级锁，但是锁的升级是单向的，也就是说只能从地到高升级，不会出现锁的降级。<br />**轻量级锁 **相对于使用操作系统互斥量来实现的传统锁而言的，但是，首先需要强调一点的是，轻量级锁并不是用来代替重量级锁的，它的本意是在没有多线程竞争的前提下，减少传统的重量使用产生的性能的消耗。在解释轻量级锁的的执行之前，先明白一点，轻量级锁所适应的场景是线程交替执行的同步块的情况，如果存在访问同一锁的情况，就会导致轻量级锁膨胀为重量级锁。<a name="Hj3hB"></a>#### 偏向锁hotspot 的作者经过以往的研究发现大多数情况下锁不仅不存在多线程竞争的，而且总是由同一线程多次获得，偏向锁的目的是在某个线程获得锁之后，消除这个线程重入CAS的开销，开启来让这个线程得到了偏护，引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径。因为轻量级锁的获取及释放多次CAS原子指令，而偏向锁只需要在置换ThreadID的时候依赖一次CAS原子治理（由于一旦出现多线程竞争的勤快就必须撤销偏向锁，所以偏向锁的撤销操作得性能损耗必须小于节省下来的CAS原子治理的性能消耗）。上面说过，轻量级锁是为了在线程交替执行同步块时提高性能，而偏向锁则是在只有一个线程执行同步块时进一步提高性能。<a name="s0Shg"></a>#### 分段锁分段锁也并非一种实际的锁，而是一种思想ConcurrentHashMap是学习分段锁的最好实践<a name="zlTjJ"></a>#### 锁优化**减少锁持有时间**<br />只用在有线程安全要求的程序上加锁<br />**减小锁的颗粒度**<br />将大对象 这种对象可能会诶很多线程访问，拆成小对象，大大增加并行度，降低锁竞争，降低了锁的竞争，偏向锁，轻量级锁成功率才会提高，最典型的减小锁颗粒度的案例就是ConcurrentHashMap.<br />**锁分离**<br />最常见的锁分离就是读写锁ReadWriteLock，根据功能进行分离成读锁和写锁，这样读读不互斥，读写互斥，写写互斥，即保证了线程安全，又提高了性能。JDK冰雹1，读写分离思想可以延伸，知识操作互不影响，锁就可以分离，比如 LinkedBlockingQueue从头部取出，从尾部放数据。<br />**锁粗化**<br />通常情况下，为了保证多线程间的有效并发，会要求每个线程持有锁的时间尽量端，即在使用完公共资源后，应该立即是否锁，否则，凡是都有一个读，如果对同一个锁不同的进行请求、同步和释放。其本身也会消耗系统宝贵的资源，反为不利于性能的优化。<br />**锁消除**<br />锁消除是在编译器级别的事情，在即时编译器时，如果发生不可能被共享的对象，则可以消除这些对象的锁操作，多数是因为程序员编码不规范引起的。<a name="Z16sU"></a>### 线程的基本方法线程先关的基本方法有wait、notify、notifyall、sleep、join、yield等<br /><a name="baj9e"></a>#### 线程等待 wait调用该方法的线程进入WAITING状态，只有等待另外的通知或被中断才会返，需要注意的是调用wait()方法后，会释放对象的锁。因此，wait方法一般用在同步方法快或者同步代码快中。<a name="ktX2p"></a>#### 线程睡眠 sleepsleep导致当前线程休眠，与wiait方法不同的是sleep不会释放当前占有的锁，sleep会导致线程进行timed-Wating装填，而wait方法会导致当前线程进入wariting状态。<a name="pzBKf"></a>#### 线程中断 interrupt中断一个线程，基本意是给这个线程一个通知信号，会影响这个线程内部的一个中断标识为，这个线程本身并不会因此而改变状态 如阻塞、终止等。1. 调用interrupt 方法并不会中断一个正在运行的线程，也就是说出游Running状态的线程并不会因为被中断而被终止，仅仅改变了内部维护的中断标识位而已。1. 弱调用sleep而线程处于TIMED-WATIng装填，这时调用interrupt方法，会抛出InterruptedException，从而使线程提前结束TIMED-WATING 状态。1. 许多声明抛出InterruptedException的方法 如Thread.sleep，抛出异常前，都会清除中断标识位，所以抛出异常后，调用 isInterrupted()方法将会返回 false。1. 中断状态是线程固有的一个标识位，可以通过此标识位安全的种植线程，比如 ，你想种植一个线程的tread的时候，可以调用thread.interrupt方法，在线程run方法内部可以根据thread.isInterrupted()的值来优雅的终止线程。<a name="lRjqJ"></a>#### Join等待其他线程终止join方法，等待其他线程终止，在当前线程中调用一个现成的join方法，则当前线程转为阻塞状态，回到另一个线程结束，当前线程再由阻塞状态转为就绪状态，等待cpu的宠幸，<a name="MfR5B"></a>#### 为什么要用join方法很多情况下，主线程生成启动了子线程，需要用到子线程返回的记过，也就是需要主线程需要在子线程结束后在再结束，这时候就要用到join方法。```javaystem.out.println(Thread.currentThread().getName() + "线程运行开始!");Thread6 thread1 = new Thread6();thread1.setName("线程 B");thread1.join();System.out.println("这时 thread1 执行完毕之后才能执行主线程");
线程唤醒 notify
Object类中的notify方法，唤醒在此对象监视器上等待的单个线程，如果所有线程都在此对象上等待，则会选择唤醒其中一个线程，选择是任意的，并在堆实现作出觉得是发送，线程通过调用其中一个线程wait方法。在对象的监视器上等待，直到当前线程放弃此对象上的锁定，才能继续执行被唤醒的线程，被唤醒的线程将以常规方式与在该对象上主导同步的其他所有线程进行竞争，类似的方法还有notifyall，唤醒再次监视器商等待的所有线程。
其他方法
- sleep() 强迫一个线程休眠N毫秒
- isAlive() 判断一个线程是否存活
- join() 等待线程终止
- ActiveCount() 程序中活跃的线程数
- enumerate() 枚举程序中的线程
- currentThread() 等到当前线程
- isDaemon（） 一个线程是否为守护线程
- setDaemon() 设置一个线程Wie守护线程 用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束
- setName 为线程设置一个名称
- wait 强迫一个线程等待
- notify 通知一个线程继续运行
- getPriority获得一个线程的优先级
- setPriority 获得一个现成的优先级
线程上下文切换
巧妙地利用了时间片轮转的方式，cpu给每个任务都服务一定的时间，然后把当前的任务状态保存下来，在加载下一任务的状态后，继续服务下一任务，任务的状态保存及再加载，这段过程就叫做上下文切换，时间片轮转的方式使多个任务在同一颗cpu上执行变成了可能。
进程
有时候也称做任务 是指一个程序运行的实例，在linux系统中，线程就是能并行运行并且与他们的父进程 创建他们的进程共享同一地址空间，一段内存区域和其他资源的轻量级的进程。
上下文
寄存器
是CPU内部的数量较少但是速度很快的内存，与之对应的是cpu外部相对较慢的RAM主内存，寄存器通过对常用值 通常是运行的中间值 的快速访问来提高计算机程序的运行的速度
程序计数器
是一个专用的寄存器，用于表明指令序列中CPU正在执行的位置，存的值为正在执行的指令的位置或者下一个将要被执行的指令的位置，具体依赖于特定的系统。
切换帧 PCB
上下文切换可以任务时内存 操作系统的核心，在cpu上对于进程 包括线程 进行切换，上下文切换过程中的信息是保存在进程控制块中的。PCB还经常被成为 切换帧，信息会一直保存到CPU的内存中，直到他们被再次使用。
上下文切换的活动
- 挂起一个进程，将这个进程在CPU中的状态 上下文 存储与内存中的某处
- 在内存中检索下一个进程的上下文并将其在CPU的寄存器中恢复
跳转到程序计数器所指向的位置( 即跳转到进程被中断是的代码行)，以恢复该进程在程序中。
引起线程上下文切换的原因
当前执行任务的时间片用完之后，系统CPU正常调度下一个任务
- 当前执行任务碰到IO阻塞，调度器将此任务挂起你，继续下一个任务
- 多个任务抢占锁资源，当前任务没有抢到锁资源，被调度器挂起，继续下一任务
- 用户代码挂起当前任务，让出CPU时间
-
同步锁与死锁
同步锁
当多个线程同时访问同一个数据时，很容易出现问题，为了避免这种情况出现，我们要保证线程同步互斥，就是指并发执行的多个线程，在同一时间内只允许一个线程访问共享数据。java中可以使用synchronized关键字来取得一个对象的同步锁。
死锁
何为死锁，就是多个线程同事被阻塞，它们中的一个或者全部都在等待某个资源被释放。
线程池的原理
线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行，他的主要特点为：线程复用；控制最大并发数，管理线程。
线程复用
每一个Thread的类都有一个start方法，当调用start启动线程时java虚拟机就会调用该类的run方法，那么该类的run方法中就是调用了Runable对象的run方法，我们可以继续重写Thread类，其start方法中添加不断循环调用传递过来的Runable对象，这就是线程池的实现原理，循环方法中不断获取Runable是用queue实现的，在获取下一个Runable之前可以使阻塞的。
线程池的组成
一般的线程池的主要分为一下四个部分:
线程池管理器：用于创建并管理线程池
- 工作线程：线程池中的线程
- 任务接口:每个任务必须实现的接口，用于工作线程调度其运行
- 任务队列:用于存放待处理的任务，提供一种缓冲机制
java中的线程池是通过Executor框架实现的，该框架找那个用到了Executo、Executors、ExecutorService,ThreadPoolExecutor、Callable和Future、FutureTask这几个类。
ThreadPoolExecutor的构造方法如下：
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize, long keepAliveTime,TimeUnit unit, BlockingQueue<Runnable> workQueue) {this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), defaultHandler);}
- corePoolSize 指定了线程池的中的线程数量
- maximumPoolSize 指定了线程池中的最大线程数
- KeepAliveTime 当前线程池数量超过corePoolSize时，多余的空闲现成的额存活时间，即多长时间会被小伙
- unit keepaliveTime的时间单位
- workQueue 任务队列，被提交但尚未被创建的任务
- threadFactory 线程工厂，用于创建线程，一般用默认的即可
- handler 拒绝策略，当恩物太多来不及处理，如果拒绝任务
拒绝策略
线程池中的线程已经用完了，无法继续为新任务服务，同时，等待队里也已经满了，再也塞不下新任务了，这时候我们就需要拒绝策略机制喝的处理这个问题。
JDK内置的拒绝策略如下：
- AbortPolicy 直接抛出异常，阻止系统正常运行
- CallerRunsPolicy 主要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务，显然这样做不会真的额丢弃任务，但是任务提交的性能极有可能会急剧下降。意思如果主线程调用，则会阻塞主线程
- DiscardOldestPolicy 丢弃最老的一个请求，也就是即将被执行的一个任务，并尝试再次提交当前任务
- DiscardPolicy 该策略默默地丢弃无法处理的任务，不予以任何处理，如果运行丢弃任务。这是最好的一种方案
以上内置策略均实现了RejectedExecutionHandler接口，若上策略仍无法满足实际需要，完全可以自己扩展RejectedExecutionHandler接口
java线程池工作过程
- 线程池刚创建时，里面没有一个线程，任务队列是作为参数传进来的，不过，就算队列里边有任务，线程池也不会马上执行它们。
- 当调用Execute() 方法添加一个任务时，线程池会做如下判断
- 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务
- 如果正在运行的线程数大于或等于corepoosize，那么将这个任务放入队列
- 如果队列满了，而且正在 运行的线程数量小于maximumPoolSize，那么还要创建非核心线程数立刻运行这个任务
- 如果队列满了，而且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会抛出一个RejectExecutionException
- 当一个线程完成任务时，它会从队列取下一个任务来执行
- 当一个线程无事可做，超过一定的时间keepAliveTime时，线程池会判断，如果当前运行的线程数大于corepoolsize，那么这个线程就会被停掉，所以线程池的所有任务完成后，他最终会收缩到corePoolSize的大小
JAVA 阻塞队列原理
阻塞队列，关键字是阻塞，先理解阻塞的含义，在阻塞队列中，线程阻塞有这样的两者情况
- 当队列中没有数据的情况下，消费端的所有线程都会自动阻塞 挂起，回到有数据放入队列
- 当队列中填满数据的情况下，生产者端的所有线程都会被自动阻塞 挂起，直到队列中有空的位置，线程被自动唤醒
阻塞队列的主要方法
| 方法类型 | 抛出异常 | 特殊值 | 阻塞 | 超时 |
|---|---|---|---|---|
| 插入 | add(e) | offer(e) | put(e) | offer(e,time,unit) |
| 移除 | remove() | poll() | take() | poll(time,unit) |
| 查询 | element() | peek() | 不可用 | 不可用 |
- 抛出异常 抛出一个异常
- 特殊值 返回一个特殊值 null或false 视情况而定
- 阻塞 在成功操作之前，一直阻塞线程
- 超时 放弃前只在最大的时间内阻塞
插入操作:
- public abstaact boolean add(e ParamE) 将指定元素插入此队列中，如果立即可行且不会违反容量限制，成功返回true，如果当前没有可用的空间，则抛出ILLegalStatExecption，如果该元素时NULL，则会抛出NULLPointException异常
- public abstact boolean offer(E paramE) 将指定元素插入此队列中，如果立即可行且不会违反容量限制，成功时返回true，如果当前没有可用的空间，则返回false
public abstract void put （E paramE） throws interruptEdException 指定元素插入此队列中，将等待可用的空间。如果必要
public void put(E paramE) throws InterruptedException {checkNotNull(paramE);ReentrantLock localReentrantLock = this.lock;localReentrantLock.lockInterruptibly();try {while (this.count == this.items.length)this.notFull.await();//如果队列满了，则线程阻塞等待enqueue(paramE);13/04/2018 Page 81 of 283localReentrantLock.unlock();} finally {localReentrantLock.unlock();}}
offer(E o, long timeout，TimeOut unit) 可用设定在指定的时间内，还不能往队列中加入BlockingQueue ，则返回失败
获取数据的操作
- poll(time) 取走BlockIngQueue 里排在首位的对象，若不能立即取出，则可以等time参数规定的时间，取不到时返回null
- poll(long timeout,TimeUnit unit) 从BlockingQueue取出一个队首的对象，如果在指定时间内，队列一旦有数据可取，则立即返回队列中的数据，否则知道时间超过没有数据可取，返回失败
- take() 取走BlockingQueue 里排在首位的对象，若BlockingQueue为空，阻断进入等待状态知道BlockingQueue有新的数据被加入
drainTo() 一次性从BlockingQueue获取所有可用的数据对象 还可以指定获取数据的个数，通过该方法，可以提升获取数据效率，不需要多次分批加锁或释放锁
java中的阻塞队列
ArrayBlockingQueue 由数组结构组成的有界阻塞队列,
- LinkedBlockingQueue 由链表结构组成的有界阻塞队列
- PriorityBlockingQueue 支持优先级排序的无界阻塞队列
- DelayQueue 使用优先级队列实现的无界阻塞队列
- SynchronizedTransferQueue 不储存元素的阻塞队列
- LinkedTransferQueue 由链表结构组成的无界阻塞队列
- LinkedBlockingDequeue 由链表结构组成的双向阻塞队列
ArrayBlockingQueue 公平、非公平
用数组实现的有界阻塞队里额，此队列按照先进先出FIFO的原则对元素进行排序默认情况下不保证访问者公平的访问队列， 所谓公平访问队列是指阻塞的所有生趁着线程或消费者线程，当队列不可用是，可以按照阻塞的先后顺序访问队列，即先阻塞的生产者线程，可以先往队列里插入元素，先阻塞的消费者线程，可以先从队列里获取元素，通常情况下为了保证公平性会降低吞吐量，我们可以使用一下代码创建一个公平的阻塞队里。
ArrayBlockQueue fairQueue = new ArrayBlockQueue(1000,true);
LinkedBlockingQueue 两个队列里锁提高并发
基于链表的阻塞队列，同ArrayListBlockingQueue类似，此队列按照先进先出FIFO的原则对元素进行排序，而LInkedBlockingQueue之所以能够高效的处理并发数据，还因为其对生产者和消费者端分别采用了独立的锁来控制数据同步，这也以为者在高并发的情况下生产者和消费者可以并行地操作队列中的数据，由此来提高整个队列的并发性能
LinkedBlockingQueue会默认一个类似无限大小的容量 Integer.Max_value。
PriorityBlockQueue compareTo排序实现优先
是一个支持优先级的无界队列，默认情况下元素采取自然顺序升序排序，可以自定义实现compareTo() 方法来指定元素进行排序规则，或者初始化PriorityBlockQueue时，指定构造参数Comparator来对元素进行排序，需要注意啊的是不能保证同优先级元素的顺序。
DelayQueue 缓存失效、定时任务
是一个支持延时获取元素的无界阻塞队列，队列使用PriorityQueue来实现，队列中的元素必须实现Delayed接口，在创建元素时可以指定多久才能从队列中获取当前元素，只有在延迟期满时才能从队列中提取元素，我们可以将DelayQueue运用在一下应用场景:
- 缓存系统的设计，可以用DelayQueue保存缓存元素的有效期，使用一个小城循环查询DelayQueue，一旦能从DelayQueue中获取元素时，表示缓存有效期到了。
定时任务调度，使用DelayQueue保存当前将会指定的任务时执行时间，一旦从DelayQueue中获取到任务就开始执行，比如Timerqueue就是使用DelayQueue实现的。
SynchronizedQueue 不存储数据、可用于传递数据
是一个不储存元素的阻塞队列，每一个put操作必须等待一个take操作，否则不能继续添加元素，SynchronizedQueue可用常一个传球手，负责生产者线程处理的数据直接传递给消费者线程，队列本省并不储存任何元素，非常适合用于传递性场景，比如在一个线程使用的数据，传递给另外一个线程使用，SynchronizedQueue的吞吐量高于LinkdedBlockQueue和ArrayBlockingQueue。
LinkedTransferQueue
是一个有链表结构组成的无界阻塞TranSferQueue队列，相对于其他阻塞队列，LinkedTransferQueue多了tayTransfer和transfer方法。
transfer方法，如果当前有消费在正在等待接受元素，消费者使用take方法后置代时间限制的poll方法，transfer方法可以吧生产者方法会量元素存放到队列的tail节点，并等到该元素被消费者消费了才返回
- tryTransfer方法 则是用来试探下生产者传入的元素是否能直接传给消费者，如果每消费者等待接受元素，则返回false，和transfer方法的却别是tryTransfer方法无论消费者是否接受，方法立即返回，而transfer方法是必须等到消费者消费了才返回。
对于带有时间限制的tryTransfer(E e，long timeout，TimeUnit unit)方法，真是试图把生产者传入的元素直接传给消费者，但是如果消费者没有消费该元素，等待指定的时间再返回，如果超时还没有消费者，则返回false，如果在超时时间内消费了元素，则返回ture
LinkedBlockingDeque
是一个有由链表结构组成的双向阻塞队列，所谓双向队列指的你可以从队列的两端插入和移除元素，双端队列因为多了一个操作队列的额入口，在多线程同时 入队时，也就减少了一半的竞争，子昂比企业的阻塞队里额，LinkedBlockingDeque多了addfirst、addLast、offerFirst，offerLast、peekFirst、peekLast等方法，以first单词结尾的方法，表示插入、获取peek或移除双端队列的第一个元素，以last残次结尾的方法，表示插入，获取或移除双队列的最后一个元素，另外插入方法add等同于addLast，移除方法remove等效与removefirst，但是take方法却等同于takeFirsrt，不知道是不是jdk的bug没使用，使用时还是用带有First和Last后缀的方法更清楚。
在初始化LinkedBlockDeque的时可以设置容量防止其过度膨胀，另外双向阻塞对垒可以运用在 工作窃取模式中。
CyclicBarrier、CountDownLatch、Semaphore
CountDownLatch 线程计数器
CountDownLatch 类位于java.util.concurrent包下，利用它可以实现类似计数器的功能，比如有一个任务A,它要等待其他四个任务来执行完毕之后才能开始执行，此时就可以利用CountDownLatch来实现这种功能了。
final CountDownLatch latch = new CountDownLatch(2);new Thread(){public void run() {System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");Thread.sleep(3000);System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");latch.countDown();};}.start();new Thread(){ public void run() {System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");Thread.sleep(3000);System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");latch.countDown();};}.start();System.out.println("等待 2 个子线程执行完毕...");latch.await();System.out.println("2 个子线程已经执行完毕");System.out.println("继续执行主线程");}
CyclicBarrier 会还栅栏 等待至barrier状态再全部同时执行
字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后在全部同时执行，叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用，我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了
CyclicBarrier 中最重要的方法就是await方法了，他有2个重载版本
- public int await 用来怪气当前线程，直至所有线程到达barrier状态再同时执行后续任务
public int await 让这些线程等待至一定的时间，如果还有线程没有到达barrier状态直接让到达barrier的线程执行后续任务
//CyclicBarrier//栅栏类似于闭锁，它能阻塞一组线程直到某个事件的发生public static void main1(String[] args) {int NUMBER = 7;CyclicBarrier cyclicBarrier = new CyclicBarrier(NUMBER, () -> {System.out.println("集齐" + NUMBER + "颗龙珠,现在召唤神龙!!!!!!!!!");});for (int i = 0; i < 7; i++) {new Thread(()->{System.out.println("集齐第"+Thread.currentThread().getName()+" 颗龙珠");try {TimeUnit.SECONDS.sleep(3);cyclicBarrier.await();} catch (InterruptedException e) {e.printStackTrace();} catch (BrokenBarrierException e) {e.printStackTrace();}},i+"").start();}}
Semaphore 信号量 控制同时访问线程的个数
Semaphore翻译成字面意思为信号量，Semaphore可以控制同时访问的线程费事，通过acquire（）获取前一个许可，如没有就等待，而release释放一个许可
Semaphore类中比较重要的几个方法public void acquire 用来获取一个许可，若无须看可能获得，则会一直等待，知道获取许可
- public void acquire(int permits): 获取permits个许可
- release() 释放许可，注意释放许可之前，必须先获得许可
- elease(int permits) { }:释放 permits 个许可
上面四个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法，
- public boolean tryAcquire():尝试获取一个许可，若获取成功，则立即返回 true，若获取失
败，则立即返回 false - public boolean tryAcquire(long timeout, TimeUnit unit):尝试获取一个许可，若在指定的
时间内获取成功，则立即返回 true，否则则立即返回 false - public boolean tryAcquire(int permits):尝试获取 permits 个许可，若获取成功，则立即返
回 true，若获取失败，则立即返回 false - public boolean tryAcquire(int permits, long timeout, TimeUnit unit): 尝试获取 permits
个许可，若在指定的时间内获取成功，则立即返回 true，否则则立即返回 false - 还可以通过 availablePermits()方法得到可用的许可数目
若一个工厂有5 台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完
了，其他工人才能继续使用。那么我们就可以通过 Semaphore 来实现
//Semaphore//Semaphore（信号量）是用来控制同时访问特定资源的线程数量，通过协调各个线程以保证合理地使用公共资源。@Testpublic void TestSemaphore(){Semaphore semaphore = new Semaphore(3);for (int i = 0; i < 6; i++) {new Thread(()->{System.out.println(Thread.currentThread().getName()+" 找到车位了");try {semaphore.acquire();System.out.println(Thread.currentThread().getName()+" 抢到这位了");TimeUnit.SECONDS.sleep(3);} catch (Exception e) {e.printStackTrace();}finally {System.out.println(Thread.currentThread().getName()+"溜了溜了");}},i+"").start();}}
CountDownLatch 和 CyclicBarrier 都能够实现线程之间的等待，只不过它们侧重点不
同；CountDownLatch 一般用于某个线程 A 等待若干个其他线程执行完任务之后，它才
13/04/2018 Page 87 of 283
执行；而 CyclicBarrier 一般用于一组线程互相等待至某个状态，然后这一组线程再同时
执行；另外，CountDownLatch 是不能够重用的，而 CyclicBarrier 是可以重用的。
Semaphore 其实和锁有点类似，它一般用于控制对某组资源的访问权限。
volatile 关键字的作用 变量可见性、进制重排序
java语音提供了一种削弱的同步机制，即volatile变量，用来确保将变量的更新操作通知到其他线程，volatile变量就别两种特性，volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读volatile类型的变量是总会返回最新写入的值。
变量的可见性
其一的保证线程变量对所有线程可见，这里的可见性指的是当一个线程修改了变量的值，那么新的值对于其他线程是可以立即获取的。
进制指令重排序
volatile禁止了指令重排序，
比sychronized更轻量级的同步锁。
在访问volatile变量时，不会执行加锁的操作，因此也就不会使用线程阻塞，因此volatile变量是一种比synchronized关键字更轻量级的同步锁机制，volatile适合这种场景，一个变量被多个线程共享，线程直接给这个变量赋值
当堆非volatile变量进行读写的时候，每个线程先从内存拷贝变量到CPU缓存中，如果计算机有多个CPU没每个线程可能在不同的cpu上被处理，这意味着每个线程都可以拷贝到不同的cpu cache中，而声明变量是volatile是，jvm保证了每次读取变量都从内存中读，跳过了CPUcache这一步。
适用场景
值得说明的是对 volatile 变量的单次读/写操作可以保证原子性的，如 long 和 double 类型变量，但是并不能保证 i++这种操作的原子性，因为本质上 i++是读、写两次操作。在某些场景下可以代替 Synchronized。但是,volatile 的不能完全取代 Synchronized 的位置，只有在一些特殊的场景下，才能适用 volatile。总的来说，必须同时满足下面两个条件才能保证在并发环境的线程安
全：
- 变量的写操作不依赖与当前值比如i++,或者说是单纯的变量赋值boolean flag = true;
该变量没有包含在具体其他变量的不变式中，也就是说，不同的volatile变量直接，不能互相依赖，只有在状态真正独立于程序内其他内容时才能使用volatile
如何在两个线程之间共享数据
Java 里面进行多线程通信的主要方式就是共享内存的方式，共享内存主要的关注点有两个：可见性和有序性原子性。Java 内存模型（JMM）解决了可见性和有序性的问题，而锁解决了原子性的问题，理想情况下我们希望做到“同步”和“互斥”。有以下常规实现方法：
将数据抽象成一个类：将数据抽象成一个类，并将对这个数据的操作做为这类的方法，这么设计可以很容易的做到同步，只要在方法上加synchronized
public class MyData {private int j=0;public synchronized void add(){j++;System.out.println("线程"+Thread.currentThread().getName()+"j 为："+j);}public synchronized void dec(){j--;System.out.println("线程"+Thread.currentThread().getName()+"j 为："+j);}public int getData(){return j;}}public class AddRunnable implements Runnable{MyData data;public AddRunnable(MyData data){this.data= data;}13/04/2018 Page 89 of 283public void run() {data.add();}}public class DecRunnable implements Runnable {MyData data;public DecRunnable(MyData data){this.data = data;}public void run() {data.dec();}}public static void main(String[] args) {MyData data = new MyData();Runnable add = new AddRunnable(data);Runnable dec = new DecRunnable(data);for(int i=0;i<2;i++){new Thread(add).start();new Thread(dec).start();}
将 Runnable 对象作为一个类的内部类，共享数据作为这个类的成员变量，每个线程对共享数据的操作方法也封装在外部类，以便实现对数据的各个操作的同步和互斥，作为内部类的各个 Runnable 对象调用外部类的这些方法。
ThreadLocal 作用 线程本地存储
ThreadLocal很多地方叫做线程本地变量，也有些地方叫做线程本地存储，ThreadLocal 的作用
是提供线程内的局部变量。这种遍历在线程的生命周期内其作用，减少一个线程内多个函数或者组件之间一些公共遍历的传递的复杂度
ThreadLocalMap （线程的一个属性）
- 每个线程中都有一个自己的 ThreadLocalMap 类对象，可以将线程自己的对象保持到其中，
各管各的，线程可以正确的访问到自己的对象。
- 将一个共用的 ThreadLocal 静态实例作为 key，将不同对象的引用保存到不同线程的
ThreadLocalMap 中，然后在线程执行的各处通过这个静态 ThreadLocal 实例的 get()方法取
得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。
- ThreadLocalMap起始就是线程里面的一个属性，它在Thread类中定义。ThreadLocal.ThreadLocalMap threadLocals = null;
synchronized 和 ReentrantLock 的区别
两者的共同点：
- 都是用来协调多线程对共享对象、变量的访问
- 都是可重入锁，同一线程可以多次访问获得同一个锁
-
两者的不同点：
ReentrantLock 显示的获得、释放锁，synchronized 隐式获得释放锁
- ReentrantLock 可响应中断、可轮回，synchronized 是不可以响应中断的，为处理锁的
不可用性提供了更高的灵活性
- ReentrantLock 是 API 级别的，synchronized 是 JVM 级别的
- ReentrantLock 可以实现公平锁
- ReentrantLock 通过 Condition 可以绑定多个条件
- 底层实现不一样， synchronized 是同步阻塞，使用的是悲观并发策略，lock 是同步非阻
塞，采用的是乐观并发策略
- Lock 是一个接口，而 synchronized 是 Java 中的关键字，synchronized 是内置的语言
实现。
- synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；
而 Lock 在发生异常时，如果没有主动通过 unLock()去释放锁，则很可能造成死锁现象，
因此使用 Lock 时需要在 finally 块中释放锁。
- Lock 可以让等待锁的线程响应中断，而 synchronized 却不行，使用 synchronized 时，
等待的线程会一直等待下去，不能够响应中断。
- 通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。
- Lock 可以提高多个线程进行读操作的效率，既就是实现读写锁等。
ConcurrentHashMap
减小锁粒度
减小锁粒度是指缩小锁定对象的范围，从而减小锁冲突的可能性，从而提高系统的并发能力。减
小锁粒度是一种削弱多线程锁竞争的有效手段，这种技术典型的应用是 ConcurrentHashMap(高
性能的 HashMap)类的实现。对于 HashMap 而言，最重要的两个方法是 get 与 set 方法，如果我
们对整个 HashMap 加锁，可以得到线程安全的对象，但是加锁粒度太大。Segment 的大小也被
称为 ConcurrentHashMap 的并发度。
ConcurrentHashMap 分段锁
ConcurrentHashMap，它内部细分了若干个小的 HashMap，称之为段(Segment)。默认情况下
一个 ConcurrentHashMap 被进一步细分为 16 个段，既就是锁的并发度。
如果需要在 ConcurrentHashMap 中添加一个新的表项，并不是将整个 HashMap 加锁，而是首
先根据hashcode得到该表项应该存放在哪个段中，然后对该段加锁，并完成put操作。在多线程
环境中，如果多个线程同时进行put操作，只要被加入的表项不存放在同一个段中，则线程间可以
做到真正的并行。
ConcurrentHashMap 是由 Segment 数组结构和 HashEntry 数组结构组成。Segment 是一种可
重入锁 ReentrantLock，在 ConcurrentHashMap 里扮演锁的角色，HashEntry 则用于存储键值
对数据。一个 ConcurrentHashMap 里包含一个 Segment 数组，Segment 的结构和 HashMap
类似，是一种数组和链表结构， 一个 Segment 里包含一个 HashEntry 数组，每个 HashEntry 是
一个链表结构的元素， 每个 Segment 守护一个 HashEntry 数组里的元素,当对 HashEntry 数组的
数据进行修改时，必须首先获得它对应的 Segment 锁。
Java 中用到的线程调度
抢占式调度：
抢占式调度指的是每条线程执行的时间、线程的切换都由系统控制，系统控制指的是在系统某种
运行机制下，可能每条线程都分同样的执行时间片，也可能是某些线程执行的时间片较长，甚至
某些线程得不到执行的时间片。在这种机制下，一个线程的堵塞不会导致整个进程堵塞。
协同式调度：
协同式调度指某一线程执行完后主动通知系统切换到另一线程上执行，这种模式就像接力赛一样，
一个人跑完自己的路程就把接力棒交接给下一个人，下个人继续往下跑。线程的执行时间由线程
本身控制，线程切换可以预知，不存在多线程同步问题，但它有一个致命弱点：如果一个线程编
写有问题，运行到一半就一直堵塞，那么可能导致整个系统崩溃。
JVM 的线程调度实现（抢占式调度）
ava 使用的线程调使用抢占式调度，Java 中线程会按优先级分配 CPU 时间片运行，且优先级越高
越优先执行，但优先级高并不代表能独自占用执行时间片，可能是优先级高得到越多的执行时间
片，反之，优先级低的分到的执行时间少但不会分配不到执行时间。
线程让出 cpu 的情况
- 当前运行线程主动放弃 CPU，JVM 暂时放弃 CPU 操作（基于时间片轮转调度的 JVM 操作系
统不会让线程永久放弃 CPU，或者说放弃本次时间片的执行权），例如调用 yield()方法。
当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队
列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采
用 FCFS 算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，
使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机，特点是：算法比较
简单，可以实现基本上的公平。
- 短作业(进程)优先调度算法
短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们
调入内存运行。而短进程优先(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程，
将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重
新调度。该算法未照顾紧迫型作业。
高优先权优先调度算法
为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入了最高优先权优先(FPF)调度
算法。当把该算法用于作业调度时，系统将从后备队列中选择若干个优先权最高的作业装入内存。
当用于进程调度时，该算法是把处理机分配给就绪队列中优先权最高的进程。
- 非抢占式优先权算法
在这种方式下，系统一旦把处理机分配给就绪队列中优先权最高的进程后，该进程便一直执行下
去，直至完成；或因发生某事件使该进程放弃处理机时。这种调度算法主要用于批处理系统中；
也可用于某些对实时性要求不严的实时系统中。
- 抢占式优先权调度算法
在这种方式下，系统同样是把处理机分配给优先权最高的进程，使之执行。但在其执行期间，只
要又出现了另一个其优先权更高的进程，进程调度程序就立即停止当前进程(原优先权最高的进程)
的执行，重新将处理机分配给新到的优先权最高的进程。显然，这种抢占式的优先权调度算法能
更好地满足紧迫作业的要求，故而常用于要求比较严格的实时系统中，以及对性能要求较高的批
处理和分时系统中。
- 高响应比优先调度算法
在批处理系统中，短作业优先算法是一种比较好的算法，其主要的不足之处是长作业的运行
得不到保证。如果我们能为每个作业引入前面所述的动态优先权，并使作业的优先级随着等待时
间的增加而以速率a 提高，则长作业在等待一定的时间后，必然有机会分配到处理机。该优先权的
变化规律可描述为：
(1) 如果作业的等待时间相同，则要求服务的时间愈短，其优先权愈高，因而该算法有利于
短作业。
(2) 当要求服务的时间相同时，作业的优先权决定于其等待时间，等待时间愈长，其优先权
愈高，因而它实现的是先来先服务。
(3) 对于长作业，作业的优先级可以随等待时间的增加而提高，当其等待时间足够长时，其
优先级便可升到很高，从而也可获得处理机。简言之，该算法既照顾了短作业，又考虑了作业到
达的先后次序，不会使长作业长期得不到服务。因此，该算法实现了一种较好的折衷。当然，在
利用该算法时，每要进行调度之前，都须先做响应比的计算，这会增加系统开销
基于时间片的轮转调度算法
- 时间片轮转法
在早期的时间片轮转法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度
时，把 CPU 分配给队首进程，并令其执行一个时间片。时间片的大小从几 ms 到几百 ms。当执行
的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，
并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执
行一个时间片。这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处
理机执行时间。
- 时间片轮转法
(1) 应设置多个就绪队列，并为各个队列赋予不同的优先级。第一个队列的优先级最高，第二
个队列次之，其余各队列的优先权逐个降低。该算法赋予各个队列中进程执行时间片的大小也各
不相同，在优先权愈高的队列中，为每个进程所规定的执行时间片就愈小。例如，第二个队列的
时间片要比第一个队列的时间片长一倍，……，第 i+1 个队列的时间片要比第 i 个队列的时间片长
一倍。
(2) 当一个新进程进入内存后，首先将它放入第一队列的末尾，按 FCFS 原则排队等待调度。当
轮到该进程执行时，如它能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时
尚未完成，调度程序便将该进程转入第二队列的末尾，再同样地按 FCFS 原则等待调度执行；如果
它在第二队列中运行一个时间片后仍未完成，再依次将它放入第三队列，……，如此下去，当一个
长作业(进程)从第一队列依次降到第 n 队列后，在第 n 队列便采取按时间片轮转的方式运行。
(3) 仅当第一队列空闲时，调度程序才调度第二队列中的进程运行；仅当第 1～(i-1)队列均空时，
才会调度第 i 队列中的进程运行。如果处理机正在第 i 队列中为某进程服务时，又有新进程进入优
先权较高的队列(第 1～(i-1)中的任何一个队列)，则此时新进程将抢占正在运行进程的处理机，即
由调度程序把正在运行的进程放回到第 i 队列的末尾，把处理机分配给新到的高优先权进程。
在多级反馈队列调度算法中，如果规定第一个队列的时间片略大于多数人机交互所需之处理时间
时，便能够较好的满足各种类型用户的需要。
什么是 CAS （ 比较并交换-乐观锁机制-自旋锁 ）
概念及特性
CAS（Compare And Swap/Set）比较并交换，CAS 算法的过程是这样：它包含 3 个参数
CAS(V,E,N)。V 表示要更新的变量(内存值)，E 表示预期值(旧的)，N 表示新值。当且仅当 V 值等
于 E 值时，才会将 V 的值设为 N，如果 V 值和 E 值不同，则说明已经有其他线程做了更新，则当
前线程什么都不做。最后，CAS 返回当前 V 的真实值。
CAS 操作是抱着乐观的态度进行的(乐观锁)，它总是认为自己可以成功完成操作。当多个线程同时
使用 CAS 操作一个变量时，只有一个会胜出，并成功更新，其余均会失败。失败的线程不会被挂
起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作。基于这样的原理，
CAS 操作即使没有锁，也可以发现其他线程对当前线程的干扰，并进行恰当的处理。
原子包 java.util.concurrent.atomic（锁自旋）
JDK1.5 的原子包：java.util.concurrent.atomic 这个包里面提供了一组原子类。其基本的特性就
是在多线程环境下，当有多个线程同时执行这些类的实例包含的方法时，具有排他性，即当某个
线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等
到该方法执行完成，才由 JVM 从等待队列中选择一个另一个线程进入，这只是一种逻辑上的理解。
相对于对于 synchronized 这种阻塞算法，CAS 是非阻塞算法的一种常见实现。由于一般 CPU 切
换时间比 CPU 指令集操作更加长， 所以 J.U.C 在性能上有了很大的提升。如下代码：
ublic class AtomicInteger extends Number implements java.io.Serializable {private volatile int value;public final int get() {return value;}public final int getAndIncrement() {for (;;) { //CAS 自旋，一直尝试，直达成功int current = get();int next = current + 1;if (compareAndSet(current, next))return current;}}public final boolean compareAndSet(int expect, int update) {return unsafe.compareAndSwapInt(this, valueOffset, expect, update);}}
getAndIncrement 采用了 CAS 操作，每次从内存中读取数据然后将此数据和+1 后的结果进行
CAS 操作，如果成功就返回结果，否则重试直到成功为止。而 compareAndSet 利用 JNI 来完成
CPU 指令的操作。
ABA 问题
CAS 会导致“ABA 问题”。CAS 算法实现一个重要前提需要取出内存中某时刻的数据，而在下时
刻比较并替换，那么在这个时间差类会导致数据的变化。
比如说一个线程 one 从内存位置 V 中取出 A，这时候另一个线程 two 也从内存中取出 A，并且
two 进行了一些操作变成了 B，然后 two 又将 V 位置的数据变成 A，这时候线程 one 进行 CAS 操
作发现内存中仍然是 A，然后 one 操作成功。尽管线程 one 的 CAS 操作成功，但是不代表这个过
程就是没有问题的。
部分乐观锁的实现是通过版本号（version）的方式来解决 ABA 问题，乐观锁每次在执行数据的修
改操作时，都会带上一个版本号，一旦版本号和数据的版本号一致就可以执行修改操作并对版本
号执行+1 操作，否则就执行失败。因为每次操作的版本号都会随之增加，所以不会出现 ABA 问
题，因为版本号只会增加不会减少。
什么是 AQS （ 抽象的队列同步器 ）
AbstractQueuedSynchronizer 类如其名，抽象的队列式的同步器，AQS 定义了一套多线程访问
共享资源的同步器框架，许多同步类实现都依赖于它，如常用的
ReentrantLock/Semaphore/CountDownLatch。
它维护了一个 volatile int state（代表共享资源）和一个 FIFO 线程等待队列（多线程争用资源被
阻塞时会进入此队列）。这里 volatile 是核心关键词，具体 volatile 的语义，在此不述。state 的
访问方式有三种:
getState()
setState()
compareAndSetState()
AQS 定义两种资源共享方式
Exclusive 独占资源 -ReentrantLock
Exclusive（独占，只有一个线程能执行，如 ReentrantLock）
Share 共享资源 -Semaphore/CountDownLatch
Share（共享，多个线程可同时执行，如 Semaphore/CountDownLatch）。
AQS只是一个框架，具体资源的获取/释放方式交由自定义同步器去实现，AQS这里只定义了一个
接口，具体资源的获取交由自定义同步器去实现了（通过state的get/set/CAS)之所以没有定义成
abstract，是因为独占模式下只用实现 tryAcquire-tryRelease，而共享模式下只用实现
tryAcquireShared-tryReleaseShared。如果都定义成abstract，那么每个模式也要去实现另一模
式下的接口。不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实
现共享资源 state 的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/
唤醒出队等），AQS 已经在顶层实现好了。自定义同步器实现时主要实现以下几种方法：
1． isHeldExclusively()：该线程是否正在独占资源。只有用到 condition 才需要去实现它。
2． tryAcquire(int)：独占方式。尝试获取资源，成功则返回 true，失败则返回 false。
3． tryRelease(int)：独占方式。尝试释放资源，成功则返回 true，失败则返回 false。
4． tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0 表示成功，但没有剩余
可用资源；正数表示成功，且有剩余资源。
5． tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回
true，否则返回 false。
同步器 的实现是 ABS 核心（ state 资源状态计数）
同步器的实现是 ABS 核心，以 ReentrantLock 为例，state 初始化为 0，表示未锁定状态。A 线程
lock()时，会调用 tryAcquire()独占该锁并将 state+1。此后，其他线程再 tryAcquire()时就会失
败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放
锁之前，A 线程自己是可以重复获取此锁的（state 会累加），这就是可重入的概念。但要注意，
获取多少次就要释放多么次，这样才能保证 state 是能回到零态的。
以 CountDownLatch 以例，任务分为 N 个子线程去执行，state 也初始化为 N（注意 N 要与
线程个数一致）。这 N 个子线程是并行执行的，每个子线程执行完后 countDown()一次，state
会 CAS 减 1。等到所有子线程都执行完后(即 state=0)，会 unpark()主调用线程，然后主调用线程
就会从 await()函数返回，继续后余动作。
ReentrantReadWriteLock 实现独占和共享两种
以 CountDownLatch 以例，任务分为 N 个子线程去执行，state 也初始化为 N（注意 N 要与
线程个数一致）。这 N 个子线程是并行执行的，每个子线程执行完后 countDown()一次，state
会 CAS 减 1。等到所有子线程都执行完后(即 state=0)，会 unpark()主调用线程，然后主调用线程
就会从 await()函数返回，继续后余动作。
ReentrantReadWriteLock 实现独占和共享两种
一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现 tryAcquire-
tryRelease、tryAcquireShared-tryReleaseShared 中的一种即可。但 AQS 也支持自定义同步器
同时实现独占和共享两种方式，如 ReentrantReadWriteLock。
JAVA 基础
JAVA 异常分类及处理
概念
如果某个方法不能按照正常的途径完成任务，就可以通过另一种路径退出方法。在这种情况下
会抛出一个封装了错误信息的对象。此时，这个方法会立刻退出同时不返回任何值。另外，调用
这个方法的其他代码也无法继续执行，异常处理机制会将代码执行交给异常处理器。
Throwable 是 Java 语言中所有错误或异常的超类。下一层分为 Error 和 Exception
Error
Error 类是指 java 运行时系统的内部错误和资源耗尽错误。应用程序不会抛出该类对象。如果
出现了这样的错误，除了告知用户，剩下的就是尽力使程序安全的终止。
Exception （ RuntimeException、CheckedException )
Exception 又 有 两 个 分 支 ， 一 个 是 运 行 时 异 常 RuntimeException ， 一 个 是
CheckedException。
RuntimeException 如 ： NullPointerException 、 ClassCastException ； 一 个 是 检 查 异 常
CheckedException，如 I/O 错误导致的 IOException、SQLException。 RuntimeException 是
那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。 如果出现 RuntimeException，那么一
定是程序员的错误.
检查异常 CheckedException：一般是外部错误，这种异常都发生在编译阶段，Java 编译器会强
制程序去捕获此类异常，即会出现要求你把这段可能出现异常的程序进行 try catch，该类异常一
般包括几个方面：
1. 试图在文件尾部读取数据
2. 试图打开一个错误格式的 URL
3. 试图根据给定的字符串查找 class 对象，而这个字符串表示的类并不存在
异常的处理方式
遇到问题不进行具体处理，而是继续抛给调用者 （ throw,throws ）
抛出异常有三种形式，一是 throw,一个 throws，还有一种系统自动抛异常。
try catch 捕获异常针对性处理方式
Throw 和 throws 的区别
位置不同
- throws 用在函数上，后面跟的是异常类，可以跟多个；而 throw 用在函数内，后面跟的
是异常对象。
功能不同：
- throws 用来声明异常，让调用者只知道该功能可能出现的问题，可以给出预先的处理方
式；throw抛出具体的问题对象，执行到throw，功能就已经结束了，跳转到调用者，并
将具体的问题对象抛给调用者。也就是说 throw 语句独立存在时，下面不要定义其他语
句，因为执行不到。 - throws 表示出现异常的一种可能性，并不一定会发生这些异常；throw 则是抛出了异常，
执行 throw 则一定抛出了某种异常对象。 - 两者都是消极处理异常的方式，只是抛出或者可能抛出异常，但是不会由函数去处理异
常，真正的处理异常由函数的上层调用处理JAVA 反射
动态语言
动态语言，是指程序在运行时可以改变其结构：新的函数可以引进，已有的函数可以被删除等结
构上的变化。比如常见的 JavaScript 就是动态语言，除此之外 Ruby,Python 等也属于动态语言，
而 C、C++则不属于动态语言。从反射角度说 JAVA 属于半动态语言。
反射机制概念 （运行状态中知道类所有的属性和方法）
在 Java 中的反射机制是指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法；
并且对于任意一个对象，都能够调用它的任意一个方法；这种动态获取信息以及动态调用对象方
法的功能成为 Java 语言的反射机制。
反射的应用场合
编译时类型和运行时类型
在 Java 程序中许多对象在运行是都会出现两种类型：编译时类型和运行时类型。 编译时的类型由
声明对象时实用的类型来决定，运行时的类型由实际赋值给对象的类型决定 。如：
Person p=new Student();
其中编译时类型为 Person，运行时类型为 Student。
的编译时类型无 法获取具体方法
程序在运行时还可能接收到外部传入的对象，该对象的编译时类型为 Object,但是程序有需要调用
该对象的运行时类型的方法。为了解决这些问题，程序需要在运行时发现对象和类的真实信息。
然而，如果编译时根本无法预知该对象和类属于哪些类，程序只能依靠运行时信息来发现该对象
和类的真实信息，此时就必须使用到反射了。
Java 反射 API
反射 API 用来生成 JVM 中的类、接口或则对象的信息。
- Class 类：反射的核心类，可以获取类的属性，方法等信息。
- Field 类：Java.lang.reflec 包中的类，表示类的成员变量，可以用来获取和设置类之中的属性
值。 - Method 类： Java.lang.reflec 包中的类，表示类的方法，它可以用来获取类中的方法信息或
者执行方法。 - Constructor 类： Java.lang.reflec 包中的类，表示类的构造方法。
反射使用步骤（获取 Class 对象、调用对象方法）
- 获取想要操作的类的 Class 对象，他是反射的核心，通过 Class 对象我们可以任意调用类的方
法。 - 调用 Class 类中的方法，既就是反射的使用阶段。
- 使用反射 API 来操作这些信息。
获取 Class 对象的 3 种方法
调用某个对象的 getClass() 方法
Person p=new Person();
Class clazz=p.getClass();
调用某个类的 class 属性来获取该类对应的 Class 对象
Class clazz=Person.class;
使用 Class 类中的 forName() 静态方法 ( 最安全 / 性能最好 )
Class clazz=Class.forName(“类的全路径”); (最常用)
当我们获得了想要操作的类的 Class 对象后，可以通过 Class 类中的方法获取并查看该类中的方法
和属性。
//获取 Person 类的 Class 对象Class clazz=Class.forName("reflection.Person");13/04/2018 Page 105 of 283//获取 Person 类的所有方法信息Method[] method=clazz.getDeclaredMethods();for(Method m:method){System.out.println(m.toString());}//获取 Person 类的所有成员属性信息Field[] field=clazz.getDeclaredFields();for(Field f:field){System.out.println(f.toString());}//获取 Person 类的所有构造方法信息Constructor[] constructor=clazz.getDeclaredConstructors();for(Constructor c:constructor){System.out.println(c.toString());}
创建对象的两种方法
Class 对象的 newInstance()
- 使用 Class 对象的 newInstance()方法来创建该 Class 对象对应类的实例，但是这种方法要求
该 Class 对象对应的类有默认的空构造器。调用 Constructor 对象的 newInstance() - 先使用 Class 对象获取指定的 Constructor 对象，再调用 Constructor 对象的 newInstance()
方法来创建 Class 对象对应类的实例,通过这种方法可以选定构造方法创建实例。
//获取 Person 类的 Class 对象Class clazz=Class.forName("reflection.Person");//使用.newInstane 方法创建对象Person p=(Person) clazz.newInstance();//获取构造方法并创建对象Constructor c=clazz.getDeclaredConstructor(String.class,String.class,int.class);//创建对象并设置属性13/04/2018 Page 106 of 283Person p1=(Person) c.newInstance("李四","男",20);
JAVA 注解
概念
A nnotation（注解）是 Java 提供的一种对元程序中元素关联信息和元数据（metadata）的途径
和方法。Annatation(注解)是一个接口，程序可以通过反射来获取指定程序中元素的 Annotation
对象，然后通过该 Annotation 对象来获取注解中的元数据信息。
四种标注元注解
元注解的作用是负责注解其他注解。 Java5.0 定义了 4 个标准的 meta-annotation 类型，它们被
用来提供对其它 annotation 类型作说明。
@Target 修饰的对象范围
@Target说明了Annotation所修饰的对象范围： Annotation可被用于 packages、types（类、
接口、枚举、Annotation 类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数
和本地变量（如循环变量、catch 参数）。在 Annotation 类型的声明中使用了 target 可更加明晰
其修饰的目标
@Retention 定义 被保留的时间长短
Retention 定义了该 Annotation 被保留的时间长短：表示需要在什么级别保存注解信息，用于描
述注解的生命周期（即：被描述的注解在什么范围内有效），取值（RetentionPoicy）由：
SOURCE:在源文件中有效（即源文件保留）
CLASS:在 class 文件中有效（即 class 保留）
RUNTIME:在运行时有效（即运行时保留）
@Documented 描述-javadoc
@ Documented 用于描述其它类型的 annotation 应该被作为被标注的程序成员的公共 API，因
此可以被例如 javadoc 此类的工具文档化
@Inherited 阐述了某个被标注的类型是被继承的
@Inherited 元注解是一个标记注解，@Inherited 阐述了某个被标注的类型是被继承的。如果一
个使用了@Inherited 修饰的 annotation 类型被用于一个 class，则这个 annotation 将被用于该
class 的子类。
注解处理器
如果没有用来读取注解的方法和工作，那么注解也就不会比注释更有用处了。使用注解的过程中，
很重要的一部分就是创建于使用注解处理器。Java SE5扩展了反射机制的API，以帮助程序员快速
的构造自定义注解处理器。下面实现一个注解处理器。
package com.javase.annotation;import java.lang.annotation.*;import java.lang.reflect.Field;/*** @Auther: liyanhao* @Description: 自定义注解* @Date: 2022/5/18 12:04* @Version: v1.0*/@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface FruitProvider {//供应商编号public int id() default -1;//供应商名称public String name() default "";//供应商地址public String address() default "";}//注解的使用class Apple{@FruitProvider(id = 1,name = "陕西富士苹果",address = "陕西省西安延安路")private String appleProvider;public String getAppleProvider() {return appleProvider;}public void setAppleProvider(String appleProvider) {this.appleProvider = appleProvider;}}//注解处理器class FruitInfoUtil{public static void getFruitInfo(Class<?> clazz) {String strFruitProvider = "供应商";Field[] declaredFields =clazz.getDeclaredFields();//通过反射获取处理注解for (Field field : declaredFields) {if (field.isAnnotationPresent(FruitProvider.class)) {FruitProvider fruitProvider = field.getAnnotation(FruitProvider.class);//注解信息的处理地方strFruitProvider = "供应商编号:"+fruitProvider.id()+"供应商名称："+fruitProvider.address();System.out.println(strFruitProvider);}}}}class TestMain{public static void main(String[] args) {FruitInfoUtil.getFruitInfo(Apple.class);}}
JAVA 内部类
Java 类中不仅可以定义变量和方法，还可以定义类，这样定义在类内部的类就被称为内部类。根
据定义的方式不同，内部类分为静态内部类，成员内部类，局部内部类，匿名内部类四种。
静态内部类
定义在类内部的静态类，就是静态内部类。
package com.javase.innerClass;/*** @Auther: liyanhao* @Description: 内部类* @Date: 2022/5/18 12:37* @Version: v1.0*/public class InnerClass {private static int a;private int b;public static class Inner{public void print(){System.out.println(a);}}}
- 静态内部类可以访问外部类所有的静态变量和方法，即使是 private 的也一样。
- 静态内部类和一般类一致，可以定义静态变量、方法，构造方法等。
- 其它类使用静态内部类需要使用“外部类.静态内部类”方式，如下所示：Out.Inner inner =
new Out.Inner();inner.print(); - Java集合类HashMap内部就有一个静态内部类Entry。Entry是HashMap存放元素的抽象，
HashMap 内部维护 Entry 数组用了存放元素，但是 Entry 对使用者是透明的。像这种和外部
类关系密切的，且不依赖外部类实例的，都可以使用静态内部类。成员内部类
定义在类内部的非静态类，就是成员内部类。成员内部类不能定义静态方法和变量（final 修饰的
除外）。这是因为成员内部类是非静态的，类初始化的时候先初始化静态成员，如果允许成员内
部类定义静态变量，那么成员内部类的静态变量初始化顺序是有歧义的。 ```java package com.javase.innerClass;
/**
- @Auther: liyanhao
- @Description: 成员内部类
- @Date: 2022/5/18 12:40
@Version: v1.0 */ public class InnerClass2 { private static int a; private int b; public class Inner{
public void print(){System.out.println(a);System.out.println(b);}
} }
<a name="A7IEv"></a>#### 局部 内部类 （ 定义在方法中的类)定义在方法中的类，就是局部类。如果一个类只在某个方法中使用，则可以考虑使用局部类。```javapackage com.javase.innerClass;/*** @Auther: liyanhao* @Description: 局部内部类* @Date: 2022/5/18 12:42* @Version: v1.0*/public class InnerClass3 {private static int a;private int b;public void test(final int c) {final int d = 1;class Inner {public void print() {System.out.println(c);}}}}
匿名 内部类的使用
要继承一个父类或者实现一个接口、直接使用new 来生成一个对象的引用。
匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一
个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引
用。
package com.javase.innerClass;import org.junit.jupiter.api.Test;/*** @Auther: liyanhao* @Description: 鸟* @Date: 2022/5/18 12:45* @Version: v1.0*/public abstract class Bird {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}public abstract int fly();public static class Test {public void test(Bird bird) {System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");}}}class TestMain{public static void main(String[] args) {Bird.Test test = new Bird.Test();test.test(new Bird() {@Overridepublic int fly() {return 10000;}@Overridepublic String getName() {return "大雁";}});}}
JAVA 泛型
泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本
质是参数化类型，也就是说所操作的数据类型被指定为一个参数。比如我们要写一个排序方法，
能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，我们就可以使用 Java 泛型。
泛型方法 （ ）
你可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数
类型，编译器适当地处理每一个方法调用。
1. <? extends T>表示该通配符所代表的类型是 T 类型的子类。
2. <? super T>表示该通配符所代表的类型是 T 类型的父类。
package com.javase.generics;/*** @Auther: liyanhao* @Description: 泛型示例* @Date: 2022/5/18 12:52* @Version: v1.0*/public class GenericsDemo {public static <E> void printArray(E[] inputArray) {for (E element: inputArray) {System.out.printf( "%s ", element );}}}
泛型类
泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。和泛型方法一
样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，
也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，
这些类被称为参数化的类或参数化的类型。
package com.javase.generics;/*** @Auther: liyanhao* @Description: 泛型示例* @Date: 2022/5/18 12:52* @Version: v1.0*/public class GenericsDemo {public static <E> void printArray(E[] inputArray) {for (E element: inputArray) {System.out.printf( "%s ", element );}}}class Box<T> {private T t;public void add(T t) {this.t = t;}public T get(){return t;}}
类型通配符?
类 型 通 配 符 一 般 是 使 用 ? 代 替 具 体 的 类 型 参 数 。 例 如 List<?> 在 逻 辑 上 是
List
类型擦除
ava 中的泛型基本上都是在编译器这个层次来实现的。在生成的 Java 字节代码中是不包含泛
型中的类型信息的。使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉。这个
过程就称为类型擦除。如在代码中定义的 List
若有收获，就点个赞吧
0 人点赞
