面试之java知识

骑猪看日落 2021-11-24 02:06 528阅读 0赞

**目录**

一、基础

二、NIO

三、jvm

四、多线程

五、容器

六、并发容器

--------------------

## 一、基础 ##

1、与kotlin的区别

语法简洁、非空安全性调用、支持协程、原型扩展函数等

[http://157.7.135.42/kotlin/docs/reference/server-overview.html][http_157.7.135.42_kotlin_docs_reference_server-overview.html]

2、serialVersionuUid  
[https://www.cnblogs.com/duanxz/p/3511695.html][https_www.cnblogs.com_duanxz_p_3511695.html]

如果序列化和反序列化的serialVersionUid不同，则会反序列化会失败；

static变量不会序列化，

transient变量不参与序列化，

父类需要显示说明是否序列化；

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70][]

3、ArrayList的subList

返回的是ArrayList的视图，最终的操作会反馈到原ArrayList上

4、Arrays.asList

体现的是适配器模式，只是转换接口，不支持add/remove/clear方法，并且最终的修改也会反馈到原数组，因为内部的操作针对的都是原始数组

5、不在foreach循环中对元素进行remove/add

6、comparator要遵循自反性、传递性、对称性

在 JDK7/JDK8（当前JDK8），Comparator 要满足自反性、传递性、对称性，不然 Arrays.sort，Collections.sort 会报 IllegalArgumentException 异常。(JDK7 Comparator,JDK8 Comparator)

说明：

1） 自反性：x，y 的比较结果和 y，x 的比较结果相反。

2） 传递性：x>y,y>z,则 x>z。

3） 对称性：x=y,则 x,z 比较结果和 y，z 比较结果相同。

7、SimpleDateFormat是线程不安全的类，不能定义为static。jdk8之后可以换新的时间日期API

8、finally块不能包含return块，finally块中的return返回后方法结束执行，不会再执行try或catch中的return语句

9、异常体系

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 1][]

## 二、NIO ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 2][]

[https://www.cnblogs.com/wangcq/p/3520400.html][https_www.cnblogs.com_wangcq_p_3520400.html]

[http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf][http_gee.cs.oswego.edu_dl_cpjslides_nio.pdf]

基于上面的交互，将其细分：read、decode、process、encode、send，然后细分几个事件，每个handler只负责处理相应的事件，各司其职，也就不用一直等待其他的事件结束，将一个串行处理变成了并行处理，类似CPU的指令执行

（这是我自己的一种理解，如错误，望指正）

## 三、jvm ##

1、类加载初始化

1.父类静态成员和静态初始化快，按在代码中出现的顺序依次执行。

2.子类静态成员和静态初始化块，按在代码中出现的顺序依次执行。

3. 父类的实例成员和实例初始化块，按在代码中出现的顺序依次执行。

4.执行父类的构造方法。

5.子类实例成员和实例初始化块，按在代码中出现的顺序依次执行。

6.执行子类的构造方法。

2、classload双亲委派

加载时，都先由父加载器加载，如果加载不到，则由子加载器加载，这样的优点是：保证了java类型的的最基础的行为，各个加载器的基础类的统一，比如java.lang.Object不论在哪都是唯一的，因为其他的类加载器都加载不到自定义的java.lang.Object

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 3][]

3、内存区域

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 4][]

4、内存模型

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 5][]

原子性、

可见性：一个线程修改了共享变量的值，其他线程可以看到，volatile，synchronize

有序性：单一线程里有序，不同线程间无序

5、垃圾收集算法

标记-清除算法：效率不高；碎片问题

复制算法：内存缩小为原来的一半，需要有担保策略

标记-整理：基于标记-清除，但是会将所有存活对象整理到一端

分代回收

6、垃圾收集器

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 6][]

[https://blog.csdn.net/havedream\_one/article/details/88381530][https_blog.csdn.net_havedream_one_article_details_88381530]

## 四、多线程 ##

1、线程状态转换

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 7][]

blocked：等待锁

waiting：等待其他事件

（没太清楚有什么区别，?）

线程池

[https://blog.csdn.net/havedream\_one/article/details/87783594][https_blog.csdn.net_havedream_one_article_details_87783594]

2、转换相关的基础函数

> 1. Object wait、notify、notifyAll
> 
> 2. LuckSupport park、unpark
> 
> 3. synchronize
> 
> 4. Thread sleep、join、yield

3、Unsafe

直接原子操作内存地址

4、LockSupport

提供了阻塞线程和唤醒线程的功能

和wait和notify的区别是，无需同步块

5、AQS

当我们自定义一个同步器时，首先需要一个代表资源的变量，其是线程可见的（private volatile int state），接着需要一个队列，保存着所以等待资源的线程（CLH队列），然后需要原子的操作资源（Unsafe）；

基本上AQS也是这样的一个原理，但是它是一个抽象的同步器，具体的资源请求和释放是由子类来实现。

AQS相当于一个同步器模板，其他的基于这个模板实现即可

故有几个抽象方法

protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }
    protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }
    protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }
    protected boolean tryReleaseShared(int arg) {
        throw new UnsupportedOperationException();
    }
    protected boolean isHeldExclusively() {
        throw new UnsupportedOperationException();
    }

子类不需要每个方法都实现，只需要选择适合自己的就行

[https://www.cnblogs.com/200911/p/6031350.html][https_www.cnblogs.com_200911_p_6031350.html]

[https://juejin.im/post/5d37019a51882564c966add6][https_juejin.im_post_5d37019a51882564c966add6]

6、可重入锁ReentrantLock

如果获取到锁，则可一直重新进入，实现原理：判断是自身，则直接获取到资源

state：0表示可以获取到锁，如果大于0，表示已经有线程获取到锁。

7、CyclicBarrier

作用：实现某些线程一起执行的作用

维护几个变量：count，reentrantLock，Condition

count用来记录当前阻塞的线程，当线程调用CyclicBarrier.await时，count--，如果count不为0，则当前线程阻塞Condition.await；如果count为0，则调用Condition.signalAll唤醒所有等待线程继续执行；reentrantLock在此处的作用是count--的线程安全。

8、CountDownLatch

作用：await等待多个线程执行完毕，再继续执行

内部实现了AQS的两种方法：

class CountDownLatch{
        ...
        class Sync extends AbstractQueuedSynchronizer{
    
            //这个count就是我们设置的count
            Sync(int count) {
                setState(count);
            }
            
            //直到state == 0，才说明可以获取到锁，否则就阻塞
            protected int tryAcquireShared(int acquires) {
                return (getState() == 0) ? 1 : -1;
            }
            
            //每次执行countDown，state--，直到0
            //只有最后一个才会去唤醒阻塞的线程，唤醒一个还是唤醒所有呢？
            protected boolean tryReleaseShared(int releases) {
                // Decrement count; signal when transition to zero
                for (;;) {
                    int c = getState();
                    if (c == 0)
                        return false;
                    int nextc = c-1;
                    if (compareAndSetState(c, nextc))
                        return nextc == 0;
                }
            }
        }
        ...
        //最终会调用tryAcquireShared
        public void await() throws InterruptedException {
            sync.acquireSharedInterruptibly(1);
        }
        
        //最终调用tryReleaseShared
        public void countDown() {
            sync.releaseShared(1); 
        }
        ...
    }

问题：如果有多个线程调用了await，则会唤醒几个？会唤醒所有，

![aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvMTY3MjEzLzIwMTYxMS8xNjcyMTMtMjAxNjExMDYwMDQyNDk1NDktMjk5Mzc0Mi5wbmc][]

## 五、容器 ##

1、快速失败ConcurrentModificationException

快速失败，在迭代过程中，如果expectedModCount != count，则立即抛出异常,如java.util下的集合类

安全失败，将元数据复制一个副本，然后对副本进行迭代， 如java.util.concurrent下的集合类

2、HashMap扩容原理

红黑树与AVL树

红黑树的查询性能略微逊色于AVL树，因为他比avl树会稍微不平衡最多一层，也就是说红黑树的查询性能只比相同内容的avl树最多多一次比较，但是，红黑树在插入和删除上完爆avl树，avl树每次插入删除会进行大量的平衡度计算，而红黑树为了维持红黑性质所做的红黑变换和旋转的开销，相较于avl树为了维持平衡的开销要小得多

1.重新计算新的capacity和threshold，

2.初始化新的hash表

3.重新hash

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 8][]

3、map的K/V是否为null

<table style="width:624px;"> 
 <tbody> 
  <tr> 
   <td>集合类</td> 
   <td style="width:101px;">key</td> 
   <td style="width:114px;">value</td> 
   <td style="width:47px;">super</td> 
   <td style="width:178px;">说明</td> 
  </tr> 
  <tr> 
   <td>Hashtable</td> 
   <td style="width:101px;">不允许为null</td> 
   <td style="width:114px;">不允许为null</td> 
   <td style="width:47px;">Dictionary</td> 
   <td style="width:178px;">线程安全</td> 
  </tr> 
  <tr> 
   <td>ConcurrentHashMap</td> 
   <td style="width:101px;">不允许为null</td> 
   <td style="width:114px;">不允许为null</td> 
   <td style="width:47px;">AbstractMap</td> 
   <td style="width:178px;">线程安全</td> 
  </tr> 
  <tr> 
   <td>TreeMap</td> 
   <td style="width:101px;">不允许为null</td> 
   <td style="width:114px;"><span style="color:#f33b45;">允许为null</span></td> 
   <td style="width:47px;">AbstractMap</td> 
   <td style="width:178px;">线程非安全</td> 
  </tr> 
  <tr> 
   <td>HashMap</td> 
   <td style="width:101px;"><span style="color:#f33b45;">允许为null</span></td> 
   <td style="width:114px;"><span style="color:#f33b45;">允许为null</span></td> 
   <td style="width:47px;">AbstractMap</td> 
   <td style="width:178px;">线程非安全</td> 
  </tr> 
 </tbody> 
</table>

4、LinkedHashMap实现LRU

class LRUMap extends LinkedHashMap<KeyType, CacheEntry<KeyType, ValueType>> {
      private int maximumSize;
      LRUMap(int maximumSize) {
        this.maximumSize = maximumSize;
      }
      @Override
      protected boolean removeEldestEntry(Map.Entry<KeyType, CacheEntry<KeyType, ValueType>> eldest) {
        return size() > maximumSize;
      }
      
    }

5、容器框架

[https://blog.csdn.net/havedream\_one/article/details/88597231][https_blog.csdn.net_havedream_one_article_details_88597231]

[https://blog.csdn.net/havedream\_one/article/details/88370123][https_blog.csdn.net_havedream_one_article_details_88370123]

## 六、并发容器 ##

1、ConcurrentHashMap

对应的并发容器：HashMap

2、CopyOnWriteList

对应的非并发容器：ArrayList

读不加锁，写加锁；

在写操作时，先申请lock，然后复制一个副本，对副本进行写操作，写完之后，更新原数组至副本，然后释放锁即实现了写的多线程安全

增加副本的优点，对读操作无影响，写操作实现多线程安全

3、CopyOnWriteSet

对应的非并发容器：HashSet

基于CopyOnWriteList实现，内部的操作都转向了内部的CopyOnWriteList变量，跟hash没有了任何关系

4、ConcurrentSkipListSet

对应的非并发容器：TreeSet

5、ConcurrentSkipListMap

对应的非并发容器：TreeMap

6、ConcurrentLinkedQueue

非阻塞式并发队列

7、LinkedBlockingQueue

对应的非并发容器：LinkedList

阻塞式并发队列

8、PriorityBlockingQueue

阻塞式并发队列

9、ArrayBlockingQueue

阻塞式并发队列

[http_157.7.135.42_kotlin_docs_reference_server-overview.html]: http://157.7.135.42/kotlin/docs/reference/server-overview.html
[https_www.cnblogs.com_duanxz_p_3511695.html]: https://www.cnblogs.com/duanxz/p/3511695.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70]: /images/20211122/d0ef23bc8f974dba85ae0698721f0e4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 1]: /images/20211122/7b6bbeb74ccd4094b3ec449fab6a5c87.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 2]: /images/20211122/f0f7a6a8f48845f195f4da92cfa53ad0.png
[https_www.cnblogs.com_wangcq_p_3520400.html]: https://www.cnblogs.com/wangcq/p/3520400.html
[http_gee.cs.oswego.edu_dl_cpjslides_nio.pdf]: http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 3]: /images/20211122/1de5f90296f249b38400f8c0606adee2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 4]: /images/20211122/c8ea7424272b44f3b6536767ff73e80d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 5]: /images/20211122/1fcceaead6fd4bd3897054f5c52c25e4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 6]: /images/20211122/9df2fa541a594c6785b191054afc3ede.png
[https_blog.csdn.net_havedream_one_article_details_88381530]: https://blog.csdn.net/havedream_one/article/details/88381530
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 7]: /images/20211122/a3c4540d938e458b9056a2ba5f78f3ec.png
[https_blog.csdn.net_havedream_one_article_details_87783594]: https://blog.csdn.net/havedream_one/article/details/87783594
[https_www.cnblogs.com_200911_p_6031350.html]: https://www.cnblogs.com/200911/p/6031350.html
[https_juejin.im_post_5d37019a51882564c966add6]: https://juejin.im/post/5d37019a51882564c966add6
[aHR0cHM6Ly9pbWFnZXMyMDE1LmNuYmxvZ3MuY29tL2Jsb2cvMTY3MjEzLzIwMTYxMS8xNjcyMTMtMjAxNjExMDYwMDQyNDk1NDktMjk5Mzc0Mi5wbmc]: /images/20211122/b5b0876b8fd144fab273deba792304e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhdmVkcmVhbV9vbmU_size_16_color_FFFFFF_t_70 8]: /images/20211122/62b2a7d6db304bfc9c891c5540dc9963.png
[https_blog.csdn.net_havedream_one_article_details_88597231]: https://blog.csdn.net/havedream_one/article/details/88597231
[https_blog.csdn.net_havedream_one_article_details_88370123]: https://blog.csdn.net/havedream_one/article/details/88370123