一些常用的JAVA基础

1.volatile 关键字的作用是什么？是否能保证线程安全？

volatile让变量每次在使用的时候，都从主存中取。而不是从各个线程的“工作内存”。
volatile具有synchronized关键字的“可见性”，但是没有synchronized关键字的“并发正确性”，也就是说不保证线程执行的有序性，如果某一个操作是原子性的，则在此操作下，volatile是可以保证线程安全的，如果不是原子性的，则无法保证。

2.synchronized 关键字的作用是什么？使用时有哪些需要注意的地方？

synchronized是可重入锁。什么是 “可重入”，可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。可重入的实现原理：加锁次数计数器，每当有线程获取锁时，计数器加一，释放锁时，计数器减一，计数器为0，表示无锁状态。

synchronized关键字主要有以下几种用法（对象锁和类锁）：

//修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁（属于对象锁）
Public synchronized void method(){ 
          //do somethings
}

//修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁（属于对象锁）
Public void method(){
     synchronized(this){ 
       //do somethings     
     }
}

 synchronized(a){ //修饰代码块，方法内的变量加锁，进入同步代码库前要获得此变量的锁（属于对象锁）
Public void method(){
    A a = new A();
     //do somethings     
    }
}

//修饰静态方法，作用于当前类加锁，进入同步代码前要获得当前类的锁（类锁）
Public synchronized static void method(){         
        //do somethings 
 }   

//锁的对象是A.class类（类锁）
Public void method(){
       synchronized(A.class){    
       //do somethings     
     }
 }   

3.Hashmap的数据结构和存储原理？

HashMap的数据结构：HashMap利用hash表存储数据，通过hashcode对其内容进行高速查找，是无序的，本质上是使用数组来实现数据存储；

数组：因为数组的存储区是连续的，占用内存严重，所以空间复杂度要高，但是二分查找的时间复杂度低，所以易于寻址，支持随机查找，故查询数据较快，但是插入和删除需要重新计算数据下标，所以较慢；

链表：链表的存储区是离散的，占用内存比较宽松，所以空间复杂度较低，时间复杂度较高，寻址时需要遍历，所以查询较慢，但是插入和删除不需要重新计算下标，所以插入和删除较快。hash表是由数组和链表组成，寻址简单，插入和删除也简单;

存储：
int hash=key.hashCode(); //获取key的hashCode，这个值是一个固定的int值
int index=hash%Entry[].length。//获取数组下标：key的hash值对Entry数组长度进行取余
Entry[index]=value。
注意：假设两个key通过hash%Entry[].length得到的index同样。会不会覆盖？
是不会的。Entry类有一个next属性，作用是指向下一个Entry。打个例如， 第一个键值对A进来。通过计算其key的hash得到的
index=0。记做:Entry[0] = A。一会后又进来一个键值对B，通过计算其index也等于0，如今怎么办？HashMap会这样做:B.next =
A,Entry[0] = B,假设又进来C,index也等于0,那么C.next = B,Entry[0] = C；这样我们发现index=0的地方事实上存取了A,B,C三个键值对,他
们通过next这个属性链接在一起。
所以疑问不用操心。

取值:
获取key的hashcode值，通过hash值去hash%Entry[].length 获取Entry[hash%Entry[].length]，定位到该数组元素之后，再遍历该元
素处的链表。
//取值时候：
当哈希表的容量超过默认容量时，必需要调整table的大小。
当容量达到最大值时，该方法Integer.MAX_VALUE返回。这时。就需要创建
一张表，将原来的表映射到新表中。

4、HashMap、HashTable和ConcurrentHashMap的线程安全问题

HashMap不是线程安全的，
HashTable通过synchronized关键字锁住整张hash表，让线程独占，保证了线程安全，但是也造成了资源浪费，效率低下。
ConcurrentHashMap通过synchronized关键字锁住当前用到的代码段，仅仅在有求size的情况下才锁住整张hash表，所以线程安全的同时，也能保证较好的效率。

5、ArrayList，Vector，LinkedList

ArrayList和Vector都是基于数组实现，支持随机访问，查询元素较快，但是插入和删除数据较慢（因为要重新计算下标），除此之外，vector通过synchronized关键字保证了线程安全，但是效率比较低。
LinkedList是由一个双向链表实现的，不支持随机访问，插入和删除数据较快，查询较慢。同时LinkedList也不是线程安全的。

6、Set，TreeSet

Set是无序不重复集合，存储数据时，首先比较hashCode，如果hashCode不一样则直接存，如果一样则通过equals方法进行比较，不一样则存。
TreeSet是有序不重复集合，本质通过TreeMap来组织数据，可以自然排序也可以通过compartor实现排序。

7、多线程

1>创建线程有三种方式：
继承Thread类，实现Runnable接口或者实现Callable接口，其中实现Callable接口可以有返回值而且可以抛出异常；

2>如何让多个线程顺序执行？
可以通过join()方法来实现线程的顺序执行，例如：

	public static void main(String[] args) {
        Thread A = new Thread(()-> System.out.println("1"));

        Thread B = new Thread(()-> {
            try {
                A.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("2");
        });

        Thread C = new Thread(()-> {
            try {
                B.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("3");
        });
        
        A.start();
        B.start();
        C.start();
    }
}

8、虚拟机

1> 内存模型
程序计数器（线程私有）：
用于记录虚拟机字节码指令地址（当前指令的地址），如果是本地Native方法，则为空。
唯一一个没有规定任何OutOfMemoryError情况的区域。
虚拟机栈（线程私有）:
是描述java方法执行的内存模型，每个方法在执行的同时都会创建一个栈帧，用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。
本地方法栈（线程私有）：
跟虚拟机栈类似，但本地方法栈服务于本地方法（native method）
堆（线程共享）-运行时数据区
创建的对象和数组都保存在堆中，也是垃圾回收器进行垃圾收集的最主要区域。由于现代VM采用分代收集算法，因此从GC的角度还可以将堆分为：新生代和老年代。
方法区（线程共享）-永久代：
即我们常说的永久代，用户存储被JVM加载的类信息、常量、静态变量、即使编译器编译后的代码等数据。HotSpot JVM使用堆的永久代来实现方法区，即可以像管理JAVA堆一样管理这部分内存，而不必开发专门的内存管理器（永久代的内存回收的主要目标是针对常量池的回收和类型的卸载，因此收益一般很小）。运行时常量池也是方法区的一部分。

2> 堆：从GC角度，堆可以分为新生代和老年代，新生代又分为Eden区，From Survivor区和To Survivor区。
新生代用来存放新生的对象，一般占堆内存的1/3空间，由于频繁创建对象，所以新生代会频繁触发MinorGC进行垃圾回收，新生代又分为Eden区，From Survivor区和To Survivor区。
Eden区：一般占新生代的8/10空间，Java对象的出生地，如果新创建的对象占用内存很大，则直接分配到老年代。当Eden区内存不够的时候，就会触发MinorGC。对新生代区进行一次垃圾回收。
From Survivor区：一般占新生代的1/10空间，上一次GC的幸存者，作为这一次GC的被扫描者。
To Survivor区：一般占新生代的1/10空间，保留了一次MinorGC过程的幸存者。
注⚠️：MinorGC采用复制算法：首先把Eden和SurvivorFrom区中存活的对象复制到SurvivorTo区，如果有对象的年龄已经达到了老年的标准，则复制到老年代区，同时把这些对象的年龄+1，如果SurvivorTo内存不够了，则放到老年区，然后清空Eden和SurvivorFrom区中的对象，最后将SurvivorFrom和SurvivorTo互换，原本的SurvivorTo成为下一次GC是的SurvivorFrom区。
老年代主要存放应用程序中生命周期长的内存对象，一般占堆内存的2/3空间。老年代的对象比较稳定，所以MajorGC不会频繁执行，且在进行MajorGC前一般都先进行了一次MinorGC，使得有新生代的对象晋升入老年代，导致空间不够用时才触发MajorGC。当无法找到足够大的连续空间分配给新创建的较大对象时也会提前触发一次MajorGC进行垃圾回收，腾出空间。
注⚠️：MajorGC采用标记清除算法，首先要扫描一次所有老年代，标记出存活的对象，然后回收没有标记的对象。MajorGC耗时较长，因为要扫描再回收。MajorGC会产生内存碎片，为了减少内存损耗，一般需要进行合并或者标记出来方便下次直接分配，当老年代也满了装不下的时候，就会抛出OOM异常。
永久代指内存的永久保存区域，主要存放Class和Meta（元数据）的信息，Class在被加载的时候被放入永久区域，它和存放实例的区域不同，GC不会在主程序运行时期对永久区域进行清理，所以这也导致了永久代的区域会随着加载的Class的增多而胀满，最终抛出OOM异常。在JAVA8中，永久代已经被移除，被一个成为“元数据区”（元空间）的区域所取代，元空间的本质和永久代类似，最大的区别在于：元空间并不在虚拟机中，而是使用本地内存，因此，默认情况下，元空间的大小仅受本地内存的限制，类的元数据放入native memory，字符串池和类的静态变量放入java堆中，这样可以加载多少类的元数据就不再由MaxPermSize控制，而由系统的实际可用空间来控制。

3> 垃圾回收与算法

3.1>如何确定垃圾？

引用计数法：在JAVA中，如果要操作一个对象，则必须通过引用来进行，因此，一个简单的办法就是通过引用计数来判断一个对象是否可以被回收。即一个对象如果没有任何与之关联的引用，则说明对象不太可能再被用到，那么这个对象就是可回收对象。

可达性分析：为了解决引用计数法的循环引用的问题，JAVA使用了可达性分析的方法，通过一系列的“GC roots”对象作为起点搜索，如果在“GC roots”和一个对象之间没有可达路径，则称该对象时不可达的，要注意的是：不可达对象不等价于可回收对象，不可达对象变为可回收对象至少需要经过两次标记过程，两次标记后仍然是不可达对象，则将面临回收。

3.2>标记清除算法（Mark-Sweep）

最基础的垃圾回收算法，分为两个阶段，标注和清除。标记阶段标记出所有需要回收的对象，清除阶段回收被标记的对象所占用的空间，其最大的问题是内存碎片化严重，后续可能发生大对象不能找到可利用空间的问题。如下图所示：

3.3>复制算法（Copying）

为了解决Mark-Sweep算法内存碎片化的缺陷而被提出的算法，按内存容量将内存划分为等大小的两块，每次只使用其中一块。当这一块内存满后，将尚存活的对象复制到另一块上去，把已使用的内存清掉，这种算法实现简单，内存效率高，但最大的问题是把可用内存压缩到了原本的一半，且存活对象增多的话，复制算法的效率会大大降低。如下图：

3.4>标记整理算法（Mark-Compact）

结合了以上两个算法，为了避免缺陷而提出，标记阶段和Mark-Sweep算法相同，标记后不是清理对象，而是将存活对象移向内存的一端，然后清除边界外的对象，如下图：

3.5>分代收集算法（新生代->复制算法；老年代->标记整理或标记清理）

分代收集算法的核心思想是根据对象存活的不同生命周期将内存划分为不同区域，一般情况下将GC堆划分为老年代和新生代，老年代特点是每次垃圾回收时只有少量的对象需要被回收，而新生代的特点是每次垃圾回收时都有大量的垃圾需要被回收，因此可以根据不同的区域选择不同的算法。
新生代中每次垃圾回收都要回收大部分对象，即要复制的操作比较少，所以可以采用复制算法（Copying），但通常情况下并不是按照1:1来划分新生代，一般将新生代划分为一块较大的Eden区和两个较小的Survivor空间。每次使用Eden空间和其中一块Survivor空间，当进行回收时，将该两块空间中还存活的对象复制到另一块Survivor空间中。
老年代每次只回收少量对象，因而采用Mark-Compact算法。
1.JAVA虚拟机提到过的处于方法区的永生代，它用来存储class类，常量，方法描述等，对永生代的回收主要包括废弃常量和无用的类。
2.对象的内存分配主要在新生代的Eden区和Survivor区。少数情况会直接分配给老年代。
3.当新生代的Eden区和Survivor From空间不足时，就会发生一次GC，进行GC后Eden区和Survivor From区存活的对象会被挪到Survivor To区，然后将Eden区和Survivor From区清理。
4.如果Survivor To区无法足够存储某个对象，则将这个对象存储到老年代。
5.在进行GC后，使用的便是Eden 区和Survivor To区了，如此反复循环。
6.当对象在Survivor区躲过一次GC后，其年龄就会+1.默认情况下，年龄达到15的对象会被移到老年代中去。

3.6>分区收集算法

分区收集算法将整个堆空间划分为连续不同的小区间，每个小区间独立使用，独立回收，这样做的好处是可以控制一次回收多少个小区间，根据目标停顿时间，每次合理的回收若干个小区间，而不是整个堆，从而减少一次GC所产生的停顿。

9、JAVA的四种引用类型

强引用：把一个对象赋给一个引用变量，这个引用变量就是一个强引用，当一个对象被强引用变量引用时，它处于可达状态，是不会被GC回收的。因此强引用是造成JAVA内存泄漏的主要原因之一。

软引用：通过SoftReference类来实现，例如
// 注意：wrf这个引用也是强引用，它是指向SoftReference这个对象的，
// 这里的软引用指的是指向new String(“str”)的引用，也就是SoftReference类中T
SoftReference wrf = new SoftReference(new String(“str”));
软引用主要用户缓存，创建缓存的时候，创建的对象放进缓存中，当内存不足时，JVM就会回收早先创建的对象。PS：图片编辑器，视频编辑器之类的软件可以使用这种思路

弱引用：通过WeakReference类来实现，比软引用生命周期更短，只要GC就会被回收，无论内存空间是否足够。例如
WeakReference wrf = new WeakReference(str);

虚引用：虚引用的回收机制跟弱引用差不多，但是它被回收之前，会被放入ReferenceQueue中。注意哦，其它引用是被JVM回收后才被传入ReferenceQueue中的。由于这个机制，所以虚引用大多被用于引用销毁前的处理工作。还有就是，虚引用创建的时候，必须带有ReferenceQueue，使用例子：
PhantomReference prf = new PhantomReference(new String(“str”), new ReferenceQueue<>());

9、JAVA IO/NIO

阻塞IO模型：
最传统的一种 IO 模型，即在读写数据过程中会发生阻塞现象。当用户线程发出 IO 请求之后，内 核会去查看数据是否就绪，如果没有就绪就会等待数据就绪，而用户线程就会处于阻塞状态，用 户线程交出 CPU。当数据就绪之后，内核会将数据拷贝到用户线程，并返回结果给用户线程，用户线程才解除 block 状态。典型的阻塞 IO 模型的例子为:data = socket.read();如果数据没有就 绪，就会一直阻塞在 read 方法。
非阻塞 IO 模型 ：
当用户线程发起一个 read 操作后，并不需要等待，而是马上就得到了一个结果。如果结果是一个 error 时，它就知道数据还没有准备好，于是它可以再次发送 read 操作。一旦内核中的数据准备 好了，并且又再次收到了用户线程的请求，那么它马上就将数据拷贝到了用户线程，然后返回。 所以事实上，在非阻塞 IO 模型中，用户线程需要不断地询问内核数据是否就绪，也就说非阻塞 IO 不会交出 CPU，而会一直占用 CPU。典型的非阻塞 IO 模型一般如下:
while(true){
data = socket.read();
if(data!= error){
处理数据
break;
}
}
但是对于非阻塞 IO 就有一个非常严重的问题，在 while 循环中需要不断地去询问内核数据是否就 绪，这样会导致 CPU 占用率非常高，因此一般情况下很少使用 while 循环这种方式来读取数据

多路复用 IO 模型 ：
在多路复用 IO 模型中，会有一个线程不断去轮询多个 socket 的状态，只有当 socket 真正有读写事件时，才真 正调用实际的 IO 读写操作。因为在多路复用 IO 模型中，只需要使用一个线程就可以管理多个 socket，系统不需要建立新的进程或者线程，也不必维护这些线程和进程，并且只有在真正有 socket 读写事件进行时，才会使用 IO 资源，所以它大大减少了资源占用。在 Java NIO 中，是通 过 selector.select()去查询每个通道是否有到达事件，如果没有事件，则一直阻塞在那里，因此这 种方式会导致用户线程的阻塞。多路复用 IO 模式，通过一个线程就可以管理多个 socket，只有当 socket 真正有读写事件发生才会占用资源来进行实际的读写操作。因此，多路复用 IO 比较适合连 接数比较多的情况。

有待完善…