java学习笔记记录

Java内存模型：

Java虚拟机规范中将Java运行时数据分为六种。

1.程序计数器：是一个数据结构，用于保存当前正常执行的程序的内存地址。Java虚拟机的多线程就是经过线程轮流切换并分配处理器时间来实现的，为了线程切换后能恢复到正确的位置，每条线程都须要一个独立的程序计数器，互不影响，该区域为“线程私有”。

2.Java虚拟机栈：线程私有的，与线程生命周期相同，用于存储局部变量表，操做栈，方法返回值。局部变量表放着基本数据类型，还有对象的引用。

3.本地方法栈：跟虚拟机栈很像，不过它是为虚拟机使用到的Native方法服务。

4.Java堆：全部线程共享的一块内存区域，对象实例几乎都在这分配内存。

5.方法区：各个线程共享的区域，储存虚拟机加载的类信息，常量，静态变量，编译后的代码。

6.运行时常量池：表明运行时每一个class文件中的常量表。包括几种常量：编译时的数字常量、方法或者域的引用。

 

类加载器工做机制： 
1.装载：将Java二进制代码导入jvm中，生成Class文件。 
2.链接：a）校验：检查载入Class文件数据的正确性 b）准备：给类的静态变量分配存储空间 c）解析：将符号引用转成直接引用 
3：初始化：对类的静态变量，静态方法和静态代码块执行初始化工做。

双亲委派模型：类加载器收到类加载请求，首先将请求委派给父类加载器完成 
用户自定义加载器->应用程序加载器->扩展类加载器->启动类加载器。

 

java代理机制

代理的共有优势：业务类只须要关注业务逻辑自己，保证了业务类的重用性。 
Java静态代理： 
代理对象和目标对象实现了相同的接口，目标对象做为代理对象的一个属性，具体接口实现中，代理对象能够在调用目标对象相应方法先后加上其余业务处理逻辑。 
缺点：一个代理类只能代理一个业务类。若是业务类增长方法时，相应的代理类也要增长方法。 
Java动态代理： 
Java动态代理是写一个类实现InvocationHandler接口，重写Invoke方法，在Invoke方法能够进行加强处理的逻辑的编写，这个公共代理类在运行的时候才能明确本身要代理的对象，同时能够实现该被代理类的方法的实现，而后在实现类方法的时候能够进行加强处理。 
实际上：代理对象的方法 = 加强处理 + 被代理对象的方法

JDK和CGLIB生成动态代理类的区别： 
JDK动态代理只能针对实现了接口的类生成代理（实例化一个类）。此时代理对象和目标对象实现了相同的接口，目标对象做为代理对象的一个属性，具体接口实现中，能够在调用目标对象相应方法先后加上其余业务处理逻辑 
CGLIB是针对类实现代理，主要是对指定的类生成一个子类（没有实例化一个类），覆盖其中的方法 。 
Spring AOP应用场景 
性能检测，访问控制，日志管理，事务等。 
默认的策略是若是目标类实现接口，则使用JDK动态代理技术，若是目标对象没有实现接口，则默认会采用CGLIB代理

 

Java GC 

在何时：

1.新生代有一个Eden区和两个survivor区，首先将对象放入Eden区，若是空间不足就向其中的一个survivor区上放，若是仍然放不下就会引起一次发生在新生代的minor GC，将存活的对象放入另外一个survivor区中，而后清空Eden和以前的那个survivor区的内存。在某次GC过程当中，若是发现仍然又放不下的对象，就将这些对象放入老年代内存里去。

2.大对象以及长期存活的对象直接进入老年区。

3.当每次执行minor GC的时候应该对要晋升到老年代的对象进行分析，若是这些立刻要到老年区的老年对象的大小超过了老年区的剩余大小，那么执行一次Full GC以尽量地得到老年区的空间。

对什么东西：从GC Roots搜索不到，并且通过一次标记清理以后仍没有复活的对象。

作什么： 
新生代：复制清理； 
老年代：标记-清除和标记-压缩算法； 
永久代：存放Java中的类和加载类的类加载器自己。

GC Roots都有哪些： 
1. 虚拟机栈中的引用的对象 
2. 方法区中静态属性引用的对象，常量引用的对象 
3. 本地方法栈中JNI（即通常说的Native方法）引用的对象。

 

ThreadLocal(线程变量副本)

Synchronized实现内存共享，ThreadLocal为每一个线程维护一个本地变量。

采用空间换时间，它用于线程间的数据隔离，为每个使用该变量的线程提供一个副本，每一个线程均可以独立地改变本身的副本，而不会和其余线程的副本冲突。

ThreadLocal类中维护一个Map，用于存储每个线程的变量副本，Map中元素的键为线程对象，而值为对应线程的变量副本。

ThreadLocal在Spring中发挥着巨大的做用，在管理Request做用域中的Bean、事务管理、任务调度、AOP等模块都出现了它的身影。

Spring中绝大部分Bean均可以声明成Singleton做用域，采用ThreadLocal进行封装，所以有状态的Bean就可以以singleton的方式在多线程中正常工做了。

 

Synchronized 与Lock都是可重入锁，同一个线程再次进入同步代码的时候.可使用本身已经获取到的锁。

Synchronized是悲观锁机制，独占锁。而Locks.ReentrantLock是，每次不加锁而是假设没有冲突而去完成某项操做，若是由于冲突失败就重试，直到成功为止。 
ReentrantLock适用场景

1. 某个线程在等待一个锁的控制权的这段时间须要中断
2. 须要分开处理一些wait-notify，ReentrantLock里面的Condition应用，可以控制notify哪一个线程，锁能够绑定多个条件。
3. 具备公平锁功能，每一个到来的线程都将排队等候。

 

Volatile和Synchronized四个不一样点： 

1 粒度不一样，前者针对变量 ，后者锁对象和类 
2 syn阻塞，volatile线程不阻塞 
3 syn保证三大特性，volatile不保证原子性 
4 syn编译器优化，volatile不优化 
volatile具有两种特性： 
1. 保证此变量对全部线程的可见性，指一条线程修改了这个变量的值，新值对于其余线程来讲是可见的，但并非多线程安全的。 
2. 禁止指令重排序优化。 
Volatile如何保证内存可见性: 
1.当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量刷新到主内存。 
2.当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。

同步：就是一个任务的完成须要依赖另一个任务，只有等待被依赖的任务完成后，依赖任务才能完成。 
异步：不须要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工做，只要本身任务完成了就算完成了，被依赖的任务是否完成会通知回来。（异步的特色就是通知）。 
打电话和发短信来比喻同步和异步操做。 
阻塞：CPU停下来等一个慢的操做完成之后，才会接着完成其余的工做。 
非阻塞：非阻塞就是在这个慢的执行时，CPU去作其余工做，等这个慢的完成后，CPU才会接着完成后续的操做。 
非阻塞会形成线程切换增长，增长CPU的使用时间能不能补偿系统的切换成本须要考虑。

 

wait()和sleep()的区别

sleep来自Thread类，和wait来自Object类

调用sleep()方法的过程当中，线程不会释放对象锁。而调用 wait 方法线程会释放对象锁

sleep睡眠后不出让系统资源，wait让出系统资源其余线程能够占用CPU

sleep(milliseconds)须要指定一个睡眠时间，时间一到会自动唤醒

 

CAS（Compare And Swap） 无锁算法： 
CAS是乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知此次竞争中失败，并能够再次尝试。CAS有3个操做数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改成B，不然什么都不作。

 

 

SpringMVC运行原理 
1. 客户端请求提交到DispatcherServlet 
2. 由DispatcherServlet控制器查询HandlerMapping，找到并分发到指定的Controller中。 
4. Controller调用业务逻辑处理后，返回ModelAndView 
5. DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图 
6. 视图负责将结果显示到客户端

 

Spring IOC （控制反转，依赖注入）

Spring支持三种依赖注入方式，分别是属性（Setter方法）注入，构造注入和接口注入。

在Spring中，那些组成应用的主体及由Spring IOC容器所管理的对象被称之为Bean。

Spring的IOC容器经过反射的机制实例化Bean并创建Bean之间的依赖关系。 
简单地讲，Bean就是由Spring IOC容器初始化、装配及被管理的对象。 
获取Bean对象的过程，首先经过Resource加载配置文件并启动IOC容器，而后经过getBean方法获取bean对象，就能够调用他的方法。 
Spring Bean的做用域： 
Singleton：Spring IOC容器中只有一个共享的Bean实例，通常都是Singleton做用域。 
Prototype：每个请求，会产生一个新的Bean实例。 
Request：每一次http请求会产生一个新的Bean实例。

 

servlet和Filter的区别： 
整的流程是：Filter对用户请求进行预处理，接着将请求交给Servlet进行处理并生成响应，最后Filter再对服务器响应进行后处理。

Filter有以下几个用处： 
Filter能够进行对特定的url请求和相应作预处理和后处理。 
在HttpServletRequest到达Servlet以前，拦截客户的HttpServletRequest。 
根据须要检查HttpServletRequest，也能够修改HttpServletRequest头和数据。 
在HttpServletResponse到达客户端以前，拦截HttpServletResponse。 
根据须要检查HttpServletResponse，也能够修改HttpServletResponse头和数据。

实际上Filter和Servlet极其类似，区别只是Filter不能直接对用户生成响应。实际上Filter里doFilter()方法里的代码就是从多个Servlet的service()方法里抽取的通用代码，经过使用Filter能够实现更好的复用。

Filter和Servlet的生命周期： 
1.Filter在web服务器启动时初始化 
2.若是某个Servlet配置了 1 ，该Servlet也是在Tomcat（Servlet容器）启动时初始化。 
3.若是Servlet没有配置1 ，该Servlet不会在Tomcat启动时初始化，而是在请求到来时初始化。 
4.每次请求， Request都会被初始化，响应请求后，请求被销毁。 
5.Servlet初始化后，将不会随着请求的结束而注销。 
6.关闭Tomcat时，Servlet、Filter依次被注销。

 

HashMap与HashTable的区别。 
一、HashMap是非线程安全的，HashTable是线程安全的。 
二、HashMap的键和值都容许有null值存在，而HashTable则不行。 
三、由于线程安全的问题，HashMap效率比HashTable的要高。

HashMap的实现机制： 
1. 维护一个每一个元素是一个链表的数组，并且链表中的每一个节点是一个Entry[]键值对的数据结构。 
2. 实现了数组+链表的特性，查找快，插入删除也快。 
3. 对于每一个key,他对应的数组索引下标是 int i = hash(key.hashcode)&(len-1); 
4. 每一个新加入的节点放在链表首，而后该新加入的节点指向原链表首

 

HashMap，ConcurrentHashMap与LinkedHashMap的区别

1. ConcurrentHashMap是使用了锁分段技术技术来保证线程安全的，锁分段技术：首先将数据分红一段一段的存储，而后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其余段的数据也能被其余线程访问
2. ConcurrentHashMap 是在每一个段（segment）中线程安全的
3. LinkedHashMap维护一个双链表，能够将里面的数据按写入的顺序读出

ConcurrentHashMap应用场景

1：ConcurrentHashMap的应用场景是高并发，可是并不能保证线程安全，而同步的HashMap和HashMap的是锁住整个容器，而加锁以后ConcurrentHashMap不须要锁住整个容器，只须要锁住对应的Segment就行了，因此能够保证高并发同步访问，提高了效率。

2：能够多线程写。 
ConcurrentHashMap把HashMap分红若干个Segmenet 
1.get时，不加锁，先定位到segment而后在找到头结点进行读取操做。而value是volatile变量，因此能够保证在竞争条件时保证读取最新的值，若是读到的value是null，则可能正在修改，那么就调用ReadValueUnderLock函数，加锁保证读到的数据是正确的。 
2.Put时会加锁，一概添加到hash链的头部。 
3.Remove时也会加锁，因为next是final类型不可改变，因此必须把删除的节点以前的节点都复制一遍。 
4.ConcurrentHashMap容许多个修改操做并发进行，其关键在于使用了锁分离技术。它使用了多个锁来控制对Hash表的不一样Segment进行的修改。

ConcurrentHashMap的应用场景是高并发，可是并不能保证线程安全，而同步的HashMap和HashTable的是锁住整个容器，而加锁以后ConcurrentHashMap不须要锁住整个容器，只须要锁住对应的segment就行了，因此能够保证高并发同步访问，提高了效率。

ConcurrentHashMap可以保证每一次调用都是原子操做，可是并不保证屡次调用之间也是原子操做。

 

ThreadPoolExecutor 的内部工做原理 
有了以上定义好的数据，下面来看看内部是如何实现的 。 Doug Lea 的整个思路总结起来就是 5 句话： 
1. 若是当前池大小 poolSize 小于 corePoolSize ，则建立新线程执行任务。 
2. 若是当前池大小 poolSize 大于 corePoolSize ，且等待队列未满，则进入等待队列 
3. 若是当前池大小 poolSize 大于 corePoolSize 且小于 maximumPoolSize ，且等待队列已满，则建立新线程执行任务。 
4. 若是当前池大小 poolSize 大于 corePoolSize 且大于 maximumPoolSize ，且等待队列已满，则调用拒绝策略来处理该任务。 
5. 线程池里的每一个线程执行完任务后不会马上退出，而是会去检查下等待队列里是否还有线程任务须要执行，若是在 keepAliveTime 里等不到新的任务了，那么线程就会退出。

Executor包结构

CopyOnWriteArrayList : 写时加锁，当添加一个元素的时候，将原来的容器进行copy，复制出一个新的容器，而后在新的容器里面写，写完以后再将原容器的引用指向新的容器，而读的时候是读旧容器的数据，因此能够进行并发的读，但这是一种弱一致性的策略。 使用场景：CopyOnWriteArrayList适合使用在读操做远远大于写操做的场景里，好比缓存。