Java基础

数据类型

==和equals的区别

hashcode（）和equals（）方法

String、StringBuilder、StringBuffer区别

访问权限修饰符

final修饰属性、方法和类的特点

父类和子类静态代码块、非静态代码块、构造函数（方法）执行的先后顺序

多态

override、overload区别

接口和抽象类区别

try catch finally语句中有return 的各类情况

异常

Error和Exception的区别

常见的Error和Exception

Java的异常处理机制

Java集合框架

List、Set

Map

HashMap

Hashtable

ConcurrentHashMap

Hashtable、HashMap、ConcurrentHashMap的区别

JUC

JUC包的分类

JUC包的并发工具类

BlockingQueue阻塞队列

IO机制

BIO

NIO

select、poll、epoll三者的区别　

AIO

IO中的设计模式

推荐资料

计算机网络

数据库

Linux

Java底层

Java多线程与并发

Java框架

设计模式

数据结构和算法

Java基础

数据类型

Java中有两类数据类型：基本数据类型和引用数据类型。

int取值范围-2^31 ~ 2^31-1，long取值范围-2^63 ~ 2^63-1。

占的位数：Java中八种基本数据类型和每种数据类型所占的位数

基本类型和包装类型的区别：基本数据类型和包装类的区别

包装类解决的问题？1）实现类型之间的转换，Integer<->Sting；2）便于函数传值，在一些地方要用到Object的时候方便将基本数据类型转换。

Integer、new Integer() 和 int 比较的面试题

关于String str =new String("abc")和 String str = "abc"的比较

==和equals的区别

==是操作符。对于基本数据类型，比较值是否相同。对于引用类型，比较内存地址是否相同。

equals()是超类Object中的方法。equals方法不能作用于基本数据类型的变量。如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；对equals方法进行了重写的话，比较的是所指向的对象的内容，如String。

equals的源码定义：

public boolean equals(Object obj) {return (this == obj);}

hashcode（）和equals（）方法

equals()和HashCode()深入理解以及Hash算法原理

String、StringBuilder、StringBuffer区别

Java中String、StringBuilder、StringBuffer区别

访问权限修饰符

final修饰属性、方法和类的特点

参考：Java final修饰符：final修饰属性、final修饰方法及final修饰类

父类和子类静态代码块、非静态代码块、构造函数（方法）执行的先后顺序

参考：父类和子类静态代码块、非静态代码块、构造函数（方法）执行的先后顺序问题

多态

面向对象三大特性和介绍：封装、继承、多态

参考：深入理解Java封装、继承、多态

面向对象五大原则：单一职责原则、开放封闭原则、里氏替换原则、依赖倒置原则、接口隔离原则

参考：java多态、Java多态|菜鸟教程

override、overload区别

overload 方法重载：一个类中多态性的一种表现。多个方法具有相同的方法名和不同的参数列表（参数个数、参数类型或参数顺序），返回类型可以相同也可以不同。

override 方法重写：父类与子类之间多态性的一种表现。子类中定义的方法与父类中的方法具有相同的名字、参数列表、返回值类型。（@Override 是一个关键字。@Override是告诉使用者这个方法是重写了基类或者接口的方法。不加编译器也知道这个方法重写了基类或者接口的方法。不加理解上默认已经加过，加了子类或者接口没有对应需要重写的方法则一定会报错。）

参考：Java 重写(Override)与重载(Overload)

接口和抽象类区别

1、抽象方法：抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。必须用 abstract 关键字进行修饰。

abstract void fun();

抽象类：如果一个类含有抽象方法，则称这个类为抽象类，抽象类必须在类前用 abstract 关键字修饰。

[public] abstract class ClassName {abstract void fun();
}

抽象类和普通类的区别：

1）抽象方法必须为 public 或者 protected（因为如果为 private，则不能被子类继承，子类便无法实现该方法），默认情况下默认为 public。

2）抽象类不能用来创建对象；

3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为 abstract 类。

2、接口：接口中可以含有变量和方法，一般情况下不在接口中定义变量。接口中的变量会被隐式地指定为 public static final 变量，而方法会被隐式地指定为 public abstract 方法且只能是 public abstract 方法，并且接口中所有的方法不能有具体的实现。

[public] interface InterfaceName {}

允许一个类遵循多个特定的接口。如果一个非抽象类遵循了某个接口，就必须实现该接口中的所有方法。对于遵循某个接口的抽象类，可以不实现该接口中的抽象方法。

抽象类和接口的区别：

1、语法层面上的区别

1）抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；

2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；

3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；

4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。

2、设计层面上的区别

抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。

抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现（非抽象方法），子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。

try catch finally语句中有return 的各类情况

参考：try、catch、finally语句中有return 的各类情况

异常

异常处理机制主要回答了三个问题

What：异常类型回答了什么被抛出。

Where：异常堆栈跟踪回答了在哪里抛出。

Why：异常信息回答了为什么被抛出。

Error和Exception的区别

Throwable是所有异常体系的顶级父类，包含Error和Exception两个子类，Throwable的父类为Object类。

Error，程序无法处理的系统错误，编译器不做检查。表示系统致命的错误，程序无法处理这些错误。Error类一般是指与JVM相关的问题，如系统奔溃、虚拟机错误、内存空间不足、方法调用栈溢出等等错误。如StackOverFlowError、OutOfMemoryError，遇到这类错误建议让程序终止。

Exception，程序可以处理的异常，捕获后可能恢复。遇到此类异常，尽可能去处理，使程序恢复运行，而不应该随意中止异常。

总结，Error是程序无法处理的错误，Exception是可以处理的异常。

Exception

Exception主要有两个子类，一个是RuntimeException、另一个是非RuntimeException。

RuntimeException（运行时异常）表示不可预知的，程序应当自行避免，例如数组下标越界、访问空指针异常等等。

非RuntimeException（非运行时异常）是可以预知的，编译器校验的异常。从编译器角度来说是必须处理的异常，如果不处理此类异常，编译不能够通过的。例如IOException、SQLException等。

Error属于JVM需要负担的责任。RuntimeException是程序应该负担的责任。Checked Exception可检查异常是Java编译器应该负担的责任。

常见的Error和Exception

RuntimeException

1、NullPointerException空指针引用异常：当应用试图在要求使用对象的地方使用了null时，抛出该异常。比如调用空对象的实例方法、访问空对象的属性、计算空对象的长度等等都会引发该异常。

2、ClassCastException类型强转转换异常。

3、IllegalArgumentException传递非法参数异常：给方法传入了不满足要求的参数，不管是参数的类型还是参数的个数。

4、IndexOutOfBoundsException下标越界异常：数组的索引值为负数或者超过数组长度时就会抛出该异常。

5、NumberFormatException数字格式异常：将String转换为指定的数字类型，而该字符串确实不满足数字类型要求的格式时就会抛出该异常。

非RuntimeException

ClassNotFoundException找不到指定的class的异常。

IOExceptionIO操作异常。

Error错误异常

NoClassDefFoundError找不到class定义的异常。造成的原因包含1)类依赖的class或者jar包不存在。2)类文件存在，但是存在不同的域中。3)大小写问题，javac编译的时候无视大小写的，很有可能编译出来的class文件就与想要的不一样。

StackOverflowError深递归导致栈被耗尽而抛出的异常。

OutOfMemoryError内存溢出异常。

Java的异常处理机制

抛出异常，创建异常对象，交由运行时系统处理。当一个方法出现错误引发异常的时候，方法创建异常对象，并交付给运行时系统，系统对象中包含了异常类型，异常出现时的程序状态等异常信息，运行时系统负责寻找处置异常的代码并执行。　　

捕获异常，寻找合适的异常处理器处理异常，否则终止运行。方法抛出异常以后，运行时系统将转为寻找合适的异常处理器，即ExceptionHandle。潜在的异常处理是异常发生时依次存留在调用栈方法的集合，当异常处理器所能处理的异常类型与抛出的异常类型相符的时候，即为合适的异常处理器，运行时系统从发生异常的方法开始依次回查调用栈中的方法直至找到含有异常处理器的方法并执行。当运行时系统遍历了调用栈都没有找到合适的异常处理器，则运行时系统终止，java程序终止。

Java异常的处理规则：

1)具体明确，抛出的异常应能通过异常类名和message准确说明异常的类型和产生异常的原因。

2)提早抛出，应尽可能早的发现并抛出异常，便于精准定位问题。

3)延迟捕获，异常的捕获和处理应该尽可能延迟，让掌握更多信息的作用域来处理异常。

Java异常处理消耗性能的地方：

try-catch块影响JVM的优化。

异常对象实例需要保存栈快照等等信息，开销较大，这是一个相对较重的操作。所以一定要捕获可能出现异常的代码，不要使用一个大的try-catch包起来整段代码，不要使用异常控制代码的流程，因为此效率远远没有if-else、switch的效率高。

Java集合框架

先上图

再来个简单点的吧

List、Set

List

ArrayList和LinkedList没有用到锁和CAS的技术，是线程不安全的；Vector是Java早期提供线程安全的数组，方法加上synchronized同步锁，不适用于高并发且对性能有较高要求的场景。

ArrayList如何扩容？

ArrayList第一次插入元素时分配10（默认）个对象空间。当添加第11个元素的时候，会扩容1.5倍(10*1.5=15)，当添加到16个元素的时候扩容为15*1.5=22，以此类推。 ArrayList每次扩容都是通过Arrays.copyof(elementData, newCapacity)来实现的。

Set

HashSet的底层是HashMap，通过add将元素以键的形式保存在map中，值是final的Object。

TreeSet的底层是NavigableMap，通过add将元素以键的形式保存在map中，值是final的Object。NavigableMap是个接口，由TreeMap实现。核心在于排序，保证元素有序。

1）自然排序，让对象所属的类去实现comparable接口，无参构造。基于元素对象自身实现的comparable接口的自然排序。

2）比较器接口comparator，带参构造。基于更为灵活不与单元绑定的comparator接口客户化排序。

自然排序

/*** 自然排序，实现了Comparable自然排序的接口，实现了该接口就要实现equals和hashcode方法和compareTo方法。* 为了使Customer类在添加了treeSet之后可以正确排序，要求Customer类里面的equals方法和compareTo方法按照相同的规则来比较两个对象是否相等。*/
public class Customer implements Comparable {private String name;private int age;public Customer(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic boolean equals(Object obj) {// 两个对象相等返回trueif (this == obj) {return true;}if (!(obj instanceof Customer)) {return false;}final Customer other = (Customer) obj;if (this.name.equals(other.name) && this.age == other.getAge()) {return true;} else {return false;}}@Overridepublic int hashCode() {// 重新了equals方法，就要重新hashcode方法int result;result = (name == null) ? 0 : name.hashCode();result = 29 * result + age;// 如果两个对象是相等的，那么hashcode返回值必须是相等的return result;}@Overridepublic int compareTo(Object o) {// compareTo返回值大于0，说明Customer1大于Customer2，反之Customer1小于Customer2；如果等于0，Customer1等于Customer2Customer other = (Customer) o;// 先按照name属性排序if (this.name.compareTo(other.getName()) > 0) {return 1;}if (this.name.compareTo(other.getName()) < 0) {return -1;}// 再按照age属性排序if (this.age > other.getAge()) {return 1;}if (this.age < other.getAge()) {return -1;}return 0;}public static void main(String[] args) {Set<Customer> set = new TreeSet<>();Customer customer1 = new Customer("tom", 16);Customer customer2 = new Customer("tom", 19);Customer customer3 = new Customer("tom", 20);set.add(customer1);set.add(customer2);set.add(customer3);// 循环遍历for (Customer c : set) {System.out.println(c.getName() + " , " + c.getAge());}}
}

客户化排序

/*** 客户化排序，实现Comparator，然后实现compare方法*/
public class CustomerComparator implements Comparator<Customer> {@Overridepublic int compare(Customer c1, Customer c2) {// 对姓名进行排序if (c1.getName().compareTo(c2.getName()) > 0) {return -1;}if (c1.getName().compareTo(c2.getName()) < 0) {return 1;}// 对年龄进行排序if (c1.getAge() - c2.getAge() > 0) {return -1;}if (c1.getAge() - c2.getAge() < 0) {return 1;}return 0;}public static void main(String[] args) {// 此时既使用了自然排序，也使用了客户化排序，在客户化排序和自然排序共存的情况下，最终结果以客户化排序优先。// 查看TreeMap源码的getEntry(key)方法。可以看到先使用客户化排序得到的结果。Set<Customer> set = new TreeSet<>(new CustomerComparator());Customer customer1 = new Customer("张三三", 16);Customer customer2 = new Customer("李四四", 19);Customer customer3 = new Customer("王五五", 20);set.add(customer1);set.add(customer2);set.add(customer3);Iterator<Customer> iterator = set.iterator();while (iterator.hasNext()) {Customer next = iterator.next();System.out.println(next.getName() + " " + next.getAge());}}
}

set怎么保证元素唯一性？

set保证里面元素的唯一性靠两个方法，equals()和hashCode()方法。

往set里面添加数据的时候一般会有隐式的操作。

先是判断set集合中是否有与新添加数据的hashcode值一致的数据，

如果有，那么将再进行第二步调用equals方法再进行一次判断；

假如集合中没有与新添加数据hashcode值一致的数据，那么将不调用eqauls方法。

Map集合用于保存具有映射关系的数据，Map保存的数据都是key-value对的，也就是key-value组成的键值对的。Map里面的key是不可以重复的，用于标示集合里面的每项数据的，Map里面的value则是可以重复的。key是通过set组织起来的，value是通过Collection组织起来的。

HashMap

存储内容是键值对映射。在Java8以前，是数组+链表的组成。数组的特点是查询快，增删慢；而链表的特点是查询慢，增删快，HashMap结合了两者的优势。HashMap是非Synchronized，所以是线程不安全的，但是效率高。

HashMap的数组长度在未赋初始值的时候，默认长度是16的，一个长度为16的数组中，每个元素存储的就是链表的头节点。通过类似于hash(key.hashCode) % len，哈希函数取模的操作获得要添加的元素所要存放的数组的位置。实际上，HashMap的哈希算法是通过位运算来进行的，相对于取模运算，效率更高。这里面有一个极端的情况，如果添加到哈希表里面的不同的值的键位通过哈希散列运算，总是得出相同的值即分配到同一个桶中，这样会是某个桶中链表的长度变得很长，由于链表查询需要从头部开始逐个遍历，因此，在最坏的情况下HashMap性能恶化，从O(1)变成了O(n)。

在Java8以后，HashMap采用了数组 + 链表 + 红黑树的组成。Java8以后使用常量TREEIFY_THRESHOLD来控制是否将链表转换为红黑树来存储数据。这意味着，即使在最坏的情况下，HashMap的性能从O(n)提高到O（logn）。

HashMap源码中成员变量Node<K,V>[] table可以看作是Node<K,V>这个数组和链表组成的复合结构。数组被分为一个个的bucket桶，通过hash值决定了键值对在这个数组的寻址，hash值相同的键值对则以链表的形式来存储。链表的大小超过TREEIFY_THRESHOLD 默认是8这个值的时候，就会被改造成红黑树。而当某个桶上面的元素总数因为删除变得低于阈值UNTREEIFY_THRESHOLD =6之后，红黑树又被转换为链表以保证更高的性能。

构造函数中table数组并没有在最初就初始化好，而是仅仅给成员变量赋初始值，所以HashMap是layload的原则首次使用时才会被初始化。

put方法的逻辑，如下所示：

1）如果HashMap未被初始化过，则进行初始化操作。

2）对Key求Hash值，然后再计算table数组的下标。

3）如果没有碰撞，table数组里面对应的位置还没有键值对，则将键值对直接放入对应的table数组位置（桶）中。

4）如果碰撞了，table数组这个位置有元素了，以链表的方式链接到后面。

5）如果链表长度超过阈值，就把链表转成红黑树。

6）如果链表长度低于6，就把红黑树转回链表。

7）如果节点已经存在就键位对应的旧值进行替换。所谓的节点存在即key值已经存在于HashMap中了，我们找到这个key值将key对应的新值替换掉它对应的旧值。

8）如果桶满了（容量16*加载因子0.75），需要扩容了，就需要resize（扩容2倍后重排）。

get方法的逻辑：使用键对象的hashcode，通过hash算法找到bucket的位置，找到bucket的位置后调用key的equals方法找到链表中正确的节点，最终找到要找的值并返回。

HashMap如何有效减少碰撞？

树化这种被动的方式可以提升性能，哈希运算也是提升性能的关键。

1）扰动函数，促使元素位置分布均匀，减少碰撞的机率。原理就是如果两个不相等的对象返回不同的hashcode，或者元素位置尽量的分布均匀些，那么碰撞的机率就会小些，意味着很多元素就可以通过数组来直接去获取了，这样可以提升hashMap的性能。哈希算法的内部实现，是让不同对象返回不同的hashcode值。

2）其次，如果使用final对象，并采用合适的equals()和hashCode()方法，将会减少碰撞的发生。不可变性使得能够缓存不同键的hashcode，这将提高获取对象的速度，而使用String、Integer这样的wrapper类作为键是非常好的选择。因为它们是final，并且重写了hashcode方法和equals方法。不可变性final是必要的，因为为了要计算hashcode，就要防止键值改变，如果键值在放入时和获取时返回不同的hashcode，就不能从hashMap中找到想要的对象了。

HashMap从获取hash到散列的过程

不使用hashcode()方法获取的值，是因为key.hashCode()方法返回的是int类型的散列值，如果直接使用这个散列值作为下标去访问hashMap数组，考虑到二进制的32位带符号的int值的范围呢-2147483648——2147483647，前后区间大概有40亿的映射空间，只要哈希函数映射的均匀松散，一般应用是很难出现碰撞的，但是40亿长度的数组在内存中是放不下的，况且HashMap在扩容之前数组默认大小是16，所以直接拿这个散列值使用不现实的。

h >>> 16右移16位（高位数移动到低位），再和自己做异或操作。这样做是为了混合原始哈希码的高位与低位，以此来加大低位的随机性，而且混合后的低位参杂了高位部分的特征，这样高位的信息也变相保存了下来。这样做主要从速度、功效、质量进行考虑的，可以在数组table的length在比较小的时候，也能保证考虑到高低bit都参与到哈希的运算中，同时也不会有太大的开销。

hashMap含参的构造器，可以传入初始化的hashMap的初始化大小的，根据传入的初始化值，换算成2的n次方，转换成最接近的2的倍数的值，这样做是为了通过哈希运算定位桶的时候，能实现用与操作来代替取模进而获得更好的效果。

hashMap的扩容resize

1）hashMap的扩容，就是重新计算容量，向hashMap对象中不停的添加元素，而hashMap对象内部的数组无法装载更多的元素时，对象就需要扩大数组的长度了，才能装入更多的元素。java中的数组是无法进行自动扩容的，hashMap的扩容，是使用新的大的数组替换小的数组。

2）hashMap的默认负载因子是0.75f，当hashMap填满了75%的bucket的时候呢，就会创建原来hashMap大小2倍的bucket数组，来重新调整map的大小，并将原来的对象放入的新的bucket数组中。

HashMap扩容的问题，多线程环境下，调整大小会存在条件竞争，容易造成死锁。rehashing是一个比较耗时的过程，由于需要将原先的hashMap中的键值对重新移动的新的hashMap中去，是一个比较耗时的过程。

为什么是两倍扩容？

参考：hashmap为什么是二倍扩容？

负载因子为什么是0.75？

提高空间利用率和减少查询成本的折中，泊松分布0.75的话碰撞最小。

参考：hashmap默认加载因子为什么选择0.75

为什么节点数为8时转换为红黑树？

参考：hashmap为什么在链表长度为8的时候变为红黑树

Hashtable

线程安全的，因为在方法都加了synchronized关键字，和Collections.synchronizedMap(map)效果一样，唯一的区别就是锁定的对象不同而已，都是串行执行的，效率比较低。为了提升多线程下的执行性能，引入了ConcurrentHashMap。

ConcurrentHashMap

无论是Hashtable还是使用synchronizedMap包装了的hashMap，当多线程并发的情况下，都要竞争同一把锁，导致效率极其低下，而在jdk1.5以后，为了改进HashTable的缺点，ConcurrentHashMap应运而生。

如何优化Hashtable？

1）通过锁细粒度化，将整锁拆解成多个锁进行优化。对象锁之间是不相互制约的，因此，我们可以将原本一个锁的行为拆分成多个锁，早期的ConcurrentHashMap也是这样做的。ConcurrentHashMap早期使用的是分段锁技术（由数组和链表组成），将锁一段一段的进行存储，然后给每一段数据配一把锁即Segment，当一个线程占用一把锁即Segment时，然后访问其中一段数据的时候，位于其他Segment的数据也能被其他线程同时访问，默认是分配16个Segment，理论上比Hashtable效率提升了16倍。相比于早期的HashMap，就是将hashMap的table数组逻辑上拆分成多个子数组，每个子数组配置一把锁，线程在获取到某把分段锁的时候，比如下图获取到编号为7的Segment之后，才能操作这个子数组，而其他线程想要操作该子数组，只能被阻塞。但是如果其他线程操作的是其他未被占用的Segment所管辖的子数组，是不会被阻塞的。

可以将分段锁拆分的更细，或者不使用分段锁，而是table里面的每个bucket都用一把不同的锁进行管理，ConcurrentHashMap的效率就得到了更好的提高。

2）jdk1.8以后，ConcurrentHashMap使用的CAS + synchronized保证并发安全。同时，也做了进一步的优化，使用了数组 + 链表 + 红黑树的组合。synchronized只锁定当前链表或者红黑树的首节点，这样，只要哈希不冲突，就不会产生并发，效率得到了进一步的提高。ConcurrentHashMap的结构参考了jdk1.8以后的hashMap来设计的。

ConcurrentHashMap是出自于JUC包的，ConcurrentHashMap有很多地方和hashMap类似的，包含属性参数之类的。

put方法的逻辑

1）判断Node[]数组是否初始化，没有则进行初始化操作。

2）通过hash定位数组的索引坐标，是否有Node节点，如果没有则使用CAS进行添加（链表的头节点），添加失败则进入下次循环，继续尝试添加。

3）检查内部是否正在扩容，如果正在扩容，就调用helpTransfer方法，就帮助它一块扩容。

4）如果f!=null，头节点不为空，则使用synchronized锁住头节点的元素对象（链表、红黑二叉树的头元素）。如果是Node链表结构，则执行链表的添加操作。如果是TreeNode（树形结构）则执行树添加操作。

5）判断链表长度已经到达临界值默认8，当节点数超过这个值就需要把链表转换成树结构了。

ConcurrentHashMap总结

jdk1.8的实现，也是锁分离的思想，比Segment锁拆的更细，只要哈希不冲突，就不会出现并发或者锁的情况。

1）首先使用无锁操作CAS插入头节点，失败则循环重试。如果插入失败，则说明有别的线程插入头节点了，需要再次循环进行操作。

2）若头节点已经存在，则通过synchronized尝试获取头节点的同步锁，再进行操作。性能比Segment分段锁又提高了很多。

Hashtable、HashMap、ConcurrentHashMap的区别

1）HashMap线程不安全的，底层是通过数组 + 链表 + 红黑树来实现。

2）Hashtable是线程安全的，底层是数组 + 链表来实现。实现线程安全的方式，是在修改数组的时候锁住整个hashtable，效率很低下的。

3）ConcurrentHashMap是线程安全的，CAS + 同步锁，底层是数组 + 链表 + 红黑树来实现。是对hashtable进行了优化，通过将锁细粒度化到table的每个元素来提升并发性能。

4）HashMap的key、value均可以为null，而其它的两个类Hashtable、ConcurrentHashMap不支持的。

参考：Java：CAS(乐观锁)、红黑树

java.util.concurrent，简称为JUC，提供了并发编程的解决方案。

JUC包里有两大核心：

1）CAS是java.util.concurrent.atomic包的基础。

2）AQS是java.util.concurrent.locks包以及一些常用类比如Semophore，ReentrantLock等类的基础。

参考：AQS详解

JUC包的分类

1）线程执行器executor：任务的执行和调度的框架，此外，在tools包可以看到和executor相关的Executors类，用来创建ExecutorService、ScheduledExecutorService、ThreadFactory、Callable对象。

2）锁locks：在jdk1.5之前协调共享对象的访问时，可以使用的机制只有synchronized和volatile，之后便出现了锁locks，locks里引入了显式锁，方便线程间的共享资源做更细粒度的锁控制。Condition对象是由Lock对象创建的，一个Lock对象可创建多个Condition对象，主要用于线程的等待和唤醒，即将wait、notify、notifyAll对象化。不管是Condition对象、还是Lock对象都是基于AQS来实现的。AQS得底层是通过调用LockSupport.unpark和LockSupport.park去实现线程的阻塞和唤醒的。ReentrantReadWriteLock是可重入读写锁，没有线程进行写操作时，多个线程可同时进行读操作，当有线程进行写操作时，其它读写操作只能等待，即读读共存，读写不能共存，写写也不能共存。在读多于写的情况下，可重入读写锁能够提供比排它锁ReentrantLock更好的并发性和吞吐量。

3）原子变量类atomic：atomic指一个操作是不可中断的。在多个线程一起执行的时候，一个操作一旦开始就不会被其它线程所干扰，所以原子类就是具有原子操作特征的类，atomic包方便程序员在多线程环境下无锁的进行原子操作。atomic包中一共有12个类，四种原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用、原子更新字段。atomic使用CAS的更新方式，当某个线程在执行atomic方法时不会被其它线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成才由JVM从等待队列中选择一个线程来执行，在软件层面上是非阻塞的，是在底层硬件上借助处理器的原子指令来保证的。在面对多线程的累加操作可以适当运用atomic包里面的类来解决。

4）并发工具类tools。

5）并发集合collections。

JUC包的并发工具类

四个同步器，同步器的作用主要是用于协助线程的同步。

1）闭锁CountDownLatch：让主线程等待一组事件发生后继续执行，这里面的事件指的是CountDownLatch里的countDown()方法。值的注意的是其它线程调用完countDown()方法之后还是会继续执行的。也就是说，countDown()方法调用之后并不代表该子线程已经执行完毕，而是告诉主线程说你可以继续执行，至少我这边不托你后腿了，具体还需要看其它线程给不给力。如图，引入了CountDownLatch之后了，主线程就进入了等待状态，此时CountDownLatch里面有一个cnt变量开始的时候初始化为一个整数，这里就是事件的个数，我们的变量初始化为3。每当其中一个子线程调用countDown()方法之后，这个计数器便会减一，直到所有的子线程都调用了countDown()方法，即cnt变为零之后，主线程才得以重新恢复到执行的状态。

2）栅栏CyclicBarrier：阻塞当前线程，等待其它线程。所有线程必须同时到达栅栏位置后，才能继续执行。所有线程到达栅栏处，可以触发执行另外一个预先设置的线程。

CyclicBarrier和CountDownLatch一样，内部也有一个计数器，如图中的T1，T2，T3每调用一次await()方法，计数器就会减一，且在它们调用await方法的时候，如果计数器不为零，这些线程也会被阻塞。另外TA线程j即当前线程会在所有线程到达栅栏处即计数器为0的时候才会跟着T1，T2，T3一起去执行，同样都是阻塞当前线程来等待其它线程，计数的时候CountDownLatch的其它子线程是可以继续执行的，而CyclicBarrier的所有线程会被阻塞直到计数器变为零，这是两者作用上的区别。

3）信号量Semaphore：控制某个资源可被同时访问的线程个数。通过acquire()方法获取一个许可，如果没有就去等待，而一旦利用资源执行完业务逻辑之后，线程就会调用release方法去释放出一个许可出来。

4）交换器Exchanger：两个线程到达同步点后，相互交换数据。Exchanger提供一个同步点，在这个同步点，两个线程可以交换彼此的数据。Exchanger会产生一个同步点，一个线程先执行到达同步点，就会被阻塞，直到另外一个线程也进入到同步点为止。当两个都到达了同步点之后就开始交换数据，线程中调用Exchanger.Exchange()的地方就是同步点了，Exchanger只能用于两个线程互相交换数据。

BlockingQueue阻塞队列

并发集合collections比较重点的除了concurrentHashMap外，就是BlockingQueue，提供了可阻塞的入队和出队操作。

1）如果队列满了，入队操作将阻塞，直到有空间可用；如果队列空了，出队操作将阻塞，直到有元素可用。根据出入队的规则和底层数据结构的实现，可以划分出多个BlockingQueue的实现子类。

2）主要用于生产者-消费者模式，在多线程场景的时候生产者线程在队列尾部添加元素，而消费者线程在队列头部消费元素，通过这种方式能够达到将任务的生产和消费进行隔离的目的。

BlockingQueue主要有以下的七个队列实现，它们都是线程安全的，重点看前三个。

1）ArrayBlockingQueue，一个有边界的阻塞队列，内部实现是一个数组。有边界的意思是容量是有限的，必须在其初始化的时候指定它的容量大小，容量大小一旦指定就不可改变了。以先进先出的方式存储数据，最新插入的对象是在尾部，最先移除的对象是在头部。

2）LinkedBlockingQueue，一个由链表结构组成的有界或者无界阻塞队列。阻塞队列大小配置是可选的，如果初始化的时候指定大小，那么它就是有边界的；如果不指定大小，它就是无边界的。无边界是采用了默认大小的容量，内部实现是一个链表，和ArrayBlockingQueue一样是采用先进先出的方式存储数据。

3）PriorityBlockingQueue，一个支持优先级排序的无界阻塞队列，不是先进先出的队列。元素按照优先级顺序被移除的，该队列没有上限，但是如果队列为空，那么取元素的操作take就会被阻塞，所以它的检索操作task是受阻的，另外该队列的元素是要具备可比性的，这样才可以按照优先级来进行操作。

4）DealyQueue，一个使用优先级队列实现的无界阻塞队列。支持延迟获取元素的无边界阻塞队列，队列中的元素必须实现Delay接口，在创建元素的时候，可以指定多久才能从队列中获取当前元素，只有在延迟期满的时候，才能从队列中获取元素

5）SynchronousQueue，一个不存储元素的阻塞队列。队列内部仅允许容纳一个元素，当一个线程插入一个元素后，会被阻塞，直到这个元素被另外一个线程给消费掉。

6）LinkedTransferQueue，一个由链表结构组成的无界阻塞队列。是SynchronousQueue和LinkedBlockingQueue合体，性能比LinkedBlockingQueue更高，因为它是无锁操作，比SynchronousQueue存储更多的元素。

7）LinkedBlockingDeque，一个由链表结构组成的双向阻塞队列，是一个双端队列。

IO机制

即Block-IO，是传统的java.io以及部分java.net包下的接口或者类。java.net里比如socket、server socket、http、UrlConnection等，因为网络通信同样是IO行为，因此都可以说是属于BIO的范畴。传统IO基于字节流和字符流进行操作，提供了基于字节流的InputStream和OutputStream，基于字符流的Reader和Writer。

BIO是基于流模型实现的，这意味着其交互方式是同步阻塞的方式。在读取输入流或写入输出流的时候，在读写操作完成之前，线程会一直阻塞在那里。它们之间的调用是可靠的线性顺序，程序发送请求给内核，然后由内核去进行通信，在内核准备好数据之前，这个线程是被挂起的，所以在两个阶段程序都处于挂起状态，类比成Client/Server模式，则其实现模式为一个连接，一个线程即客户端要连接请求的时候服务端就需要启动一个线程进行处理，待操作系统返回结果，如果这个连接不做任何事情，会造成不必要的线程开销，可以通过线程池机制来改善。

BIO的特点就是在IO执行的两个阶段都被阻塞住了，好处就是代码比较简单、直观；缺点就是IO效率和扩展性存在瓶颈。

NonBlock-IO即非阻塞IO，在jdk1.4以后引入了NIO框架，提供了channel、selector、buffer等新的抽象，构建多路复用同步非阻塞的IO操作，同时提供了更接近操作系统底层高性能数据操作方式。

NIO与BIO明显区别就是，在发起第一次请求之后，线程并没有被阻塞，它是反复去检查数据是否已经准备好，把原来大块不能用的阻塞的时间分成了许多小阻塞，检查的会有一些阻塞，线程不断有机会去被执行，检查这个数据有没有准备好，有点类似于轮询。类比成client/server模式，其实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮循到有IO请求时，才启动一个线程进行处理。

NIO的特点就是程序不断去主动询问内核是否已经准备好，第一个阶段是非阻塞的，第二个阶段是阻塞的。

NIO的核心部分组成，Channels、Buffers、Selectors。

基本上所有的IO在NIO中都是从一个Channel开始，Channel有点像流，数据可以从Channel读到Buffer中，也可以从Buffer中写到Channel中。NIO-Channels的类型，涵盖了TCP和UDP网络IO以及文件IO。

a）FileChannel，拥有transferTo方法和transferFron方法。transferTo方法把FileChannel中的数据拷贝到另外一个Channel。transferFron方法把另外一个Channel中的数据拷贝到FileChannel中。该接口常被用于高效的网络文件的数据传输和大文件拷贝，在操作系统支持的情况下，通过该方法传输数据，并不需要将源数据从内核态拷贝到用户态，再从用户态拷贝到目标通道的内核态。同时也避免了两次用户态和内核态间的上下文切换，即零拷贝，效率较高，其性能高于BIO中提供的方法。

b）DatagramChannel

c）SocketChannel

d）ServerSocketChannel

NIO-Buffers的类型，这些Buffer覆盖了我们能通过IO发送的基本数据类型。

a）ByteBuffer

b）CharBuffer

c）DoubleBuffer

d）FloatBuffer

e）IntBuffer

f）LongBuffer

g）ShortBuffer

h）MappedByteBuffer，主要用于表示内存映射文件。

NIO-Selector允许单线程处理多个Channel，如果你的应用打开了多个连接即通道，但每个连接的流量都比较低，使用Selector就会很方便了。例如开发一个聊天服务器就排上用场了。如图所示的是使用一个Selector处理三个Channel的情形，使用Selector得向Selector注册Channel，然后调用它的select方法，这个方法会一直阻塞，直到某个注册的通道有事件就绪，一旦这个方法返回，线程就可以处理这些事件了。事件可以是，比如说是有新的连接进来，或者说Buffer已经有内容可以读取到了等等。

NIO的底层使用了操作系统底层的IO多路复用，多路复用有select、poll、epoll等不同方式，优点在于单线程可以同时处理多个网络IO。IO多路复用调用系统级别的select、poll、epoll模型，由系统监控IO状态，select轮询可以监控许多的IO请求，当有一个socket的数据被准备好的时候就可以返回了。

select、poll、epoll三者的区别　

1）支持一个进程所能打开的最大连接数

select，单个进程所能打开的最大连接数由FD_SETSIZE宏定义，其大小是32个整数的大小（在32位的机器上，大小是32*32，64的机器上FD_SETSIZE为32*64）。我们可以对其进行修改，然后重新编译内核，但是性能无法保证，需要做进一步测试。底层是数组；poll本质上与select没有区别，但是它没有最大连接数的限制，原因是它是基于链表来存储的；epoll虽然连接数有上限，但是数量很大，1G内存的机器上可以打开10万左右的连接。

2）FD剧增后带来的IO效率问题

select和poll因为每次调用时候都会对连接进行线性遍历，所以随着FD的增加会造成遍历速度的线性下降的性能问题；epoll由于epoll是根据每个fd上的callback函数来实现的，只有活跃的socket才会主动调用callback，所以在活跃socket较少的情况下，使用epoll不会有线性下降的性能问题，但是所有的socket都很活跃的情况下，可能会有性能问题。

3）消息传递方式

select和poll内核需要将消息传递到用户空间，需要内核的拷贝动作；epoll通过内核和用户空间共享一块内存来实现，性能较高。

参考：select、poll、epoll的原理与区别、Linux IO模式及 select、poll、epoll详解

JDK７以后开始支持，NIO2.0，Asynchronous IO，异步非阻塞的方式，基于事件和回调机制，可以理解为应用操作直接返回，而不会阻塞在那里，当后台处理完成，操作系统就会通知相应线程进行后续工作。

AIO属于异步模型，用户线程可以同时处理别的事情。AIO如何进一步加工处理结果，Java提供了两种方法。

1）基于回调，实现CompletionHandler接口，调用的时候触发回调函数，在调用的时候，把回调函数传递给对应的API即可

2）返回Future，通过isDone查看是否准备好，通过get方法等待返回数据。

BIO、NIO、AIO对比

属性\模型	阻塞BIO	非阻塞NIO	异步AIO
blocking	阻塞并同步	非阻塞但同步	非阻塞并异步
线程数(server:client)	1:1	1:N	0:N
复杂度	简单	较复杂	复杂
吞吐量	低	高	高

BIO适用于连接数少且固定的架构，对服务器资源要求比较高，是1.4以前的唯一选择，程序直观简单容易理解；NIO适用于连接数多且连接比较短的架构，比如聊天服务器；AIO适用于连接数多且连接长的架构中，比如相册服务器，能充分调用OS来参与并发操作，编程比较复杂，是JDK7以后才支持的。更高一层的应用Netty。

参考：JAVA 中BIO,NIO,AIO的理解

IO中的设计模式

适配器模式、装饰者模式

参考：IO流中的设计模式

计算机网络

计算机网络面试知识点

数据库

数据库面试知识点

Redis面试知识点

Linux

Linux指令面试知识点

Java底层

Java底层知识JVM

Java底层知识GC

Java多线程与并发

Java框架

Java框架Spring

设计模式

参考：设计模式 | 菜鸟教程、尚硅谷-Java设计模式

推荐资料：《Head First设计模式》

数据结构和算法

数据结构

常见的数据结构

hash（怎么解决hash冲突）

数组和链表的区别

链表的操作，如反转、链表环路检测、双向链表、循环链表相关操作

队列，栈的应用（两个栈实现一个队列）

二叉树的遍历方式及其递归和非递归实现

算法

内部排序，如归并排序、交换排序(冒泡、快排)、选择排序、插入排序

外部排序，如何利用有限的内存配合海量的外部存储来处理超大的数据集(fork and join的思想，先将数据集分化处理再合并)

扩展

哪些排序是不稳定的，稳定意味着什么(快排、堆排序是不稳定的)

不同数据集各种排序最好或最坏情况

如何优化算法(空间换时间)

剑指Offer和Leetcode刷题经验

推荐资料：《大话数据结构》、左程云算法课视频

Java开发基础面试知识点相关推荐

Java 开发岗面试知识点大全解析
本人简介:北京邮电大学土著硕士研究生,CSDN博客专家,熟悉的技术为Java后台开发.在2017年暑期实习校招中拿到了百度.搜狐.京东和去哪儿网的实习Offer:在2018届校园招聘中,拿到了百度.小 ...
[ Java面试题 ]Java 开发岗面试知识点解析
在不断的面试中,分类总结了 Java 开发岗位面试中的一些知识点. 主要包括以下几个部分: Java 基础知识点 Java 常见集合高并发编程(JUC 包) JVM 内存管理 Java 8 知识点 ...
知名互联网公司 Java 开发岗面试知识点解析
GitBook.cn 天之道, 损有余而补不足, 是故虚胜实, 不足胜有余. 如背景中介绍,作者在一年之内参加过多场面试,应聘岗位均为 Java 开发方向. 在不断的面试中,分类总结了 Java 开发 ...
这些Java基础面试知识点，你都掌握了吗？
想了解一下学Java的小伙伴们,在学习Java的时候有没有去总结知识点,哪些知识点我们没有掌握,哪些知识点是我们还没有掌握的,今天小编来发掘一些Java基础面试知识点,不知道大家掌握没有. 小编分享的 ...
高级JAVA开发技术栈知识点总结
高级JAVA开发技术栈知识点总结写在前面 MQ Redis Dubbo 分布式系统 JVM Java基础写在前面 "金三银四"对于今年(2019)的互联网行业行情并不适用,面 ...
Java开发实习生面试经历与总结
Java开发实习生面试经历与总结更新日期:2020年1月1日一.引言--初生牛犊不怕虎 2019年我是从大二暑假开始,正式进入Java的学习.大二上学期的时候,学校开设了只有11周的Java程序 ...
Java开发岗面试攻略（应届）
开发岗面试系列文章目录第一章 Java开发岗面试攻略(应届) 文章目录开发岗面试系列文章目录前言一.Java技术栈 1.Java速成学习路线二.Java面试题 1.博主自己总结的面试题(应届 ...
2020春招 / 2021秋招阿里、腾讯、字节、快手、美团 JAVA 开发岗面试高频问题总结
2020春招 / 2021秋招阿里.腾讯.字节.快手.美团 JAVA 开发岗面试高频问题总结 2.1 进程和线程的区别? 2.2 进程的调度算法有哪些?(主要) 2.3 常用 IO 模型? 2.4 s ...
网易Java开发岗面试分享
应对互联网技术面试绝不仅仅是刷题就可以达到的.首先选择技术岗位,其次每个岗位开始都是先着手面经,多看到了解,提炼出必考的技术点合集,最后针对这些必考技术,系统学习,融会贯通. 对这个岗位的必备技能,一 ...

Java开发基础面试知识点

Java基础

数据类型

==和equals的区别

hashcode（）和equals（）方法

String、StringBuilder、StringBuffer区别

访问权限修饰符

final修饰属性、方法和类的特点

父类和子类静态代码块、非静态代码块、构造函数（方法）执行的先后顺序

多态

override、overload区别

接口和抽象类区别

try catch finally语句中有return 的各类情况

异常

Error和Exception的区别

常见的Error和Exception

Java的异常处理机制

Java集合框架

List、Set

Map

HashMap

Hashtable

ConcurrentHashMap

Hashtable、HashMap、ConcurrentHashMap的区别

JUC

JUC包的分类

JUC包的并发工具类

BlockingQueue阻塞队列

IO机制

BIO

NIO

select、poll、epoll三者的区别

AIO

IO中的设计模式

推荐资料

计算机网络

数据库

Linux

Java底层

Java多线程与并发

Java框架

设计模式

数据结构和算法

Java开发基础面试知识点相关推荐

最新文章

热门文章

select、poll、epoll三者的区别　