前言

个人珍藏的80道Java多线程/并发经典面试题，因为篇幅太长，现在先给出1-10的答案解析哈，后面一起完善，并且上传github哈~

❝ +
https://github.com/whx123/JavaHome
+❞

「公众号：捡田螺的小男孩」

1. synchronized的实现原理以及锁优化？

synchronized的实现原理

synchronized作用于「方法」或者「代码块」，保证被修饰的代码在同一时间只能被一个线程访问。
synchronized修饰代码块时，JVM采用「monitorenter、monitorexit」两个指令来实现同步
synchronized修饰同步方法时，JVM采用「ACC_SYNCHRONIZED」标记符来实现同步
monitorenter、monitorexit或者ACC_SYNCHRONIZED都是「基于Monitor实现」的
实例对象里有对象头，对象头里面有Mark Word，Mark Word指针指向了「monitor」
Monitor其实是一种「同步工具」，也可以说是一种「同步机制」。
在Java虚拟机（HotSpot）中，Monitor是由「ObjectMonitor实现」的。ObjectMonitor体现出Monitor的工作原理~

ObjectMonitor() {
+    _header       = NULL;
+    _count        = 0; // 记录线程获取锁的次数
+    _waiters      = 0,
+    _recursions   = 0;  //锁的重入次数
+    _object       = NULL;
+    _owner        = NULL;  // 指向持有ObjectMonitor对象的线程
+    _WaitSet      = NULL;  // 处于wait状态的线程，会被加入到_WaitSet
+    _WaitSetLock  = 0 ;
+    _Responsible  = NULL ;
+    _succ         = NULL ;
+    _cxq          = NULL ;
+    FreeNext      = NULL ;
+    _EntryList    = NULL ;  // 处于等待锁block状态的线程，会被加入到该列表
+    _SpinFreq     = 0 ;
+    _SpinClock    = 0 ;
+    OwnerIsThread = 0 ;
+  }
+

ObjectMonitor的几个关键属性 _count、_recursions、_owner、_WaitSet、 _EntryList 体现了monitor的工作原理 +

锁优化

在讨论锁优化前，先看看JAVA对象头(32位JVM)中Mark Word的结构图吧~

Mark Word存储对象自身的运行数据，如「哈希码、GC分代年龄、锁状态标志、偏向时间戳（Epoch）」 等，为什么区分「偏向锁、轻量级锁、重量级锁」等几种锁状态呢？

❝ +
在JDK1.6之前，synchronized的实现直接调用ObjectMonitor的enter和exit，这种锁被称之为「重量级锁」。从JDK6开始，HotSpot虚拟机开发团队对Java中的锁进行优化，如增加了适应性自旋、锁消除、锁粗化、轻量级锁和偏向锁等优化策略。
+❞

偏向锁：在无竞争的情况下，把整个同步都消除掉，CAS操作都不做。
轻量级锁：在没有多线程竞争时，相对重量级锁，减少操作系统互斥量带来的性能消耗。但是，如果存在锁竞争，除了互斥量本身开销，还额外有CAS操作的开销。
自旋锁：减少不必要的CPU上下文切换。在轻量级锁升级为重量级锁时，就使用了自旋加锁的方式
锁粗化：将多个连续的加锁、解锁操作连接在一起，扩展成一个范围更大的锁。

❝ +
举个例子，买门票进动物园。老师带一群小朋友去参观，验票员如果知道他们是个集体，就可以把他们看成一个整体（锁租化），一次性验票过，而不需要一个个找他们验票。
+❞

锁消除:虚拟机即时编译器在运行时，对一些代码上要求同步，但是被检测到不可能存在共享数据竞争的锁进行削除。

有兴趣的朋友们可以看看我这篇文章： +Synchronized解析——如果你愿意一层一层剥开我的心^[1]

2. ThreadLocal原理，使用注意点，应用场景有哪些？

回答四个主要点：

ThreadLocal是什么?
ThreadLocal原理
ThreadLocal使用注意点
ThreadLocal的应用场景

ThreadLocal是什么?

ThreadLocal，即线程本地变量。如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个本地拷贝，多个线程操作这个变量的时候，实际是操作自己本地内存里面的变量，从而起到线程隔离的作用，避免了线程安全问题。

//创建一个ThreadLocal变量
+static ThreadLocal<String> localVariable = new ThreadLocal<>();
+

ThreadLocal原理

ThreadLocal内存结构图：

+由结构图是可以看出：

Thread对象中持有一个ThreadLocal.ThreadLocalMap的成员变量。
ThreadLocalMap内部维护了Entry数组，每个Entry代表一个完整的对象，key是ThreadLocal本身，value是ThreadLocal的泛型值。

对照着几段关键源码来看，更容易理解一点哈~

public class Thread implements Runnable {
+   //ThreadLocal.ThreadLocalMap是Thread的属性
+   ThreadLocal.ThreadLocalMap threadLocals = null;
+}
+

ThreadLocal中的关键方法set()和get()

    public void set(T value) {
+        Thread t = Thread.currentThread(); //获取当前线程t
+        ThreadLocalMap map = getMap(t);  //根据当前线程获取到ThreadLocalMap
+        if (map != null)
+            map.set(this, value); //K，V设置到ThreadLocalMap中
+        else
+            createMap(t, value); //创建一个新的ThreadLocalMap
+    }
+
+    public T get() {
+        Thread t = Thread.currentThread();//获取当前线程t
+        ThreadLocalMap map = getMap(t);//根据当前线程获取到ThreadLocalMap
+        if (map != null) {
+            //由this（即ThreadLoca对象）得到对应的Value，即ThreadLocal的泛型值
+            ThreadLocalMap.Entry e = map.getEntry(this);
+            if (e != null) {
+                @SuppressWarnings("unchecked")
+                T result = (T)e.value; 
+                return result;
+            }
+        }
+        return setInitialValue();
+    }
+

ThreadLocalMap的Entry数组

static class ThreadLocalMap {
+    static class Entry extends WeakReference<ThreadLocal<?>> {
+        /** The value associated with this ThreadLocal. */
+        Object value;
+
+        Entry(ThreadLocal<?> k, Object v) {
+            super(k);
+            value = v;
+        }
+    }
+}
+

所以怎么回答「ThreadLocal的实现原理」？如下，最好是能结合以上结构图一起说明哈~

❝ +
+
Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，即每个线程都有一个属于自己的ThreadLocalMap。
ThreadLocalMap内部维护着Entry数组，每个Entry代表一个完整的对象，key是ThreadLocal本身，value是ThreadLocal的泛型值。
每个线程在往ThreadLocal里设置值的时候，都是往自己的ThreadLocalMap里存，读也是以某个ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。
+❞

ThreadLocal 内存泄露问题

先看看一下的TreadLocal的引用示意图哈，

ThreadLocalMap中使用的 key 为 ThreadLocal 的弱引用，如下 +

❝ +
弱引用：只要垃圾回收机制一运行，不管JVM的内存空间是否充足，都会回收该对象占用的内存。
+❞

弱引用比较容易被回收。因此，如果ThreadLocal（ThreadLocalMap的Key）被垃圾回收器回收了，但是因为ThreadLocalMap生命周期和Thread是一样的，它这时候如果不被回收，就会出现这种情况：ThreadLocalMap的key没了，value还在，这就会「造成了内存泄漏问题」。

如何「解决内存泄漏问题」？使用完ThreadLocal后，及时调用remove()方法释放内存空间。

ThreadLocal的应用场景

数据库连接池
会话管理中使用

3. synchronized和ReentrantLock的区别？

我记得校招的时候，这道面试题出现的频率还是挺高的~可以从锁的实现、功能特点、性能等几个维度去回答这个问题，

「锁的实现：」 synchronized是Java语言的关键字，基于JVM实现。而ReentrantLock是基于JDK的API层面实现的（一般是lock()和unlock()方法配合try/finally 语句块来完成。）
「性能：」 在JDK1.6锁优化以前，synchronized的性能比ReenTrantLock差很多。但是JDK6开始，增加了适应性自旋、锁消除等，两者性能就差不多了。
「功能特点：」 ReentrantLock 比 synchronized 增加了一些高级功能，如等待可中断、可实现公平锁、可实现选择性通知。

❝ +
+
ReentrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。
ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。
synchronized与wait()和notify()/notifyAll()方法结合实现等待/通知机制，ReentrantLock类借助Condition接口与newCondition()方法实现。
ReentrantLock需要手工声明来加锁和释放锁，一般跟finally配合释放锁。而synchronized不用手动释放锁。
+❞

4. 说说CountDownLatch与CyclicBarrier区别

CountDownLatch：一个或者多个线程，等待其他多个线程完成某件事情之后才能执行;
CyclicBarrier：多个线程互相等待，直到到达同一个同步点，再继续一起执行。 +

举个例子吧：

❝ +
+
CountDownLatch：假设老师跟同学约定周末在公园门口集合，等人齐了再发门票。那么，发门票（这个主线程），需要等各位同学都到齐（多个其他线程都完成），才能执行。
CyclicBarrier:多名短跑运动员要开始田径比赛，只有等所有运动员准备好，裁判才会鸣枪开始，这时候所有的运动员才会疾步如飞。
+❞

5. Fork/Join框架的理解

❝ +
Fork/Join框架是Java7提供的一个用于并行执行任务的框架，是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。
+❞

Fork/Join框架需要理解两个点，「分而治之」和「工作窃取算法」。

「分而治之」

以上Fork/Join框架的定义，就是分而治之思想的体现啦 +

「工作窃取算法」

把大任务拆分成小任务，放到不同队列执行，交由不同的线程分别执行时。有的线程优先把自己负责的任务执行完了，其他线程还在慢慢悠悠处理自己的任务，这时候为了充分提高效率，就需要工作盗窃算法啦~

工作盗窃算法就是，「某个线程从其他队列中窃取任务进行执行的过程」。一般就是指做得快的线程（盗窃线程）抢慢的线程的任务来做，同时为了减少锁竞争，通常使用双端队列，即快线程和慢线程各在一端。

6. 为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run()方法？

看看Thread的start方法说明哈~

    /**
+     * Causes this thread to begin execution; the Java Virtual Machine
+     * calls the <code>run</code> method of this thread.
+     * <p>
+     * The result is that two threads are running concurrently: the
+     * current thread (which returns from the call to the
+     * <code>start</code> method) and the other thread (which executes its
+     * <code>run</code> method).
+     * <p>
+     * It is never legal to start a thread more than once.
+     * In particular, a thread may not be restarted once it has completed
+     * execution.
+     *
+     * @exception  IllegalThreadStateException  if the thread was already
+     *               started.
+     * @see        #run()
+     * @see        #stop()
+     */
+    public synchronized void start() {
+     ......
+    }
+

JVM执行start方法，会另起一条线程执行thread的run方法，这才起到多线程的效果~ 「为什么我们不能直接调用run()方法？」 +如果直接调用Thread的run()方法，其方法还是运行在主线程中，没有起到多线程效果。

7. CAS？CAS 有什么缺陷，如何解决？

CAS,Compare and Swap，比较并交换；

❝ +
CAS 涉及3个操作数，内存地址值V，预期原值A，新值B； +如果内存位置的值V与预期原A值相匹配，就更新为新值B，否则不更新
+❞

CAS有什么缺陷？

「ABA 问题」

❝ +
并发环境下，假设初始条件是A，去修改数据时，发现是A就会执行修改。但是看到的虽然是A，中间可能发生了A变B，B又变回A的情况。此时A已经非彼A，数据即使成功修改，也可能有问题。
+❞

可以通过AtomicStampedReference「解决ABA问题」，它，一个带有标记的原子引用类，通过控制变量值的版本来保证CAS的正确性。

「循环时间长开销」

❝ +
自旋CAS，如果一直循环执行，一直不成功，会给CPU带来非常大的执行开销。
+❞

很多时候，CAS思想体现，是有个自旋次数的，就是为了避开这个耗时问题~

「只能保证一个变量的原子操作。」

❝ +
CAS 保证的是对一个变量执行操作的原子性，如果对多个变量操作时，CAS 目前无法直接保证操作的原子性的。
+❞

可以通过这两个方式解决这个问题：

❝ +
+
使用互斥锁来保证原子性；
将多个变量封装成对象，通过AtomicReference来保证原子性。
+❞

有兴趣的朋友可以看看我之前的这篇实战文章哈~ +CAS乐观锁解决并发问题的一次实践^[2]

9. 如何保证多线程下i++ 结果正确？

使用循环CAS，实现i++原子操作
使用锁机制，实现i++原子操作
使用synchronized，实现i++原子操作

没有代码demo，感觉是没有灵魂的~ 如下：

/**
+ *  @Author 捡田螺的小男孩
+ */
+public class AtomicIntegerTest {
+
+    private static AtomicInteger atomicInteger = new AtomicInteger(0);
+
+    public static void main(String[] args) throws InterruptedException {
+        testIAdd();
+    }
+
+    private static void testIAdd() throws InterruptedException {
+        //创建线程池
+        ExecutorService executorService = Executors.newFixedThreadPool(2);
+        for (int i = 0; i < 1000; i++) {
+            executorService.execute(() -> {
+                for (int j = 0; j < 2; j++) {
+                    //自增并返回当前值
+                    int andIncrement = atomicInteger.incrementAndGet();
+                    System.out.println("线程:" + Thread.currentThread().getName() + " count=" + andIncrement);
+                }
+            });
+        }
+        executorService.shutdown();
+        Thread.sleep(100);
+        System.out.println("最终结果是 ：" + atomicInteger.get());
+    }
+    
+}
+

运行结果：

...
+线程:pool-1-thread-1 count=1997
+线程:pool-1-thread-1 count=1998
+线程:pool-1-thread-1 count=1999
+线程:pool-1-thread-2 count=315
+线程:pool-1-thread-2 count=2000
+最终结果是 ：2000
+

10. 如何检测死锁？怎么预防死锁？死锁四个必要条件

死锁是指多个线程因竞争资源而造成的一种互相等待的僵局。如图感受一下： + +「死锁的四个必要条件：」

互斥：一次只有一个进程可以使用一个资源。其他进程不能访问已分配给其他进程的资源。
占有且等待：当一个进程在等待分配得到其他资源时，其继续占有已分配得到的资源。
非抢占：不能强行抢占进程中已占有的资源。
循环等待：存在一个封闭的进程链，使得每个资源至少占有此链中下一个进程所需要的一个资源。

「如何预防死锁？」

加锁顺序（线程按顺序办事）
加锁时限（线程请求所加上权限，超时就放弃，同时释放自己占有的锁）
死锁检测

参考与感谢

牛顿说，我之所以看得远，是因为我站在巨人的肩膀上~ 谢谢以下各位前辈哈~

面试必问的CAS，你懂了吗？^[3]
Java多线程：死锁^[4]
ReenTrantLock可重入锁（和synchronized的区别）总结^[5]
聊聊并发（八）——Fork/Join 框架介绍^[6]

个人公众号

觉得写得好的小伙伴给个点赞+关注啦，谢谢~
如果有写得不正确的地方，麻烦指出，感激不尽。
同时非常期待小伙伴们能够关注我公众号，后面慢慢推出更好的干货~嘻嘻
github地址：https://github.com/whx123/JavaHome

Reference

+[1]

Synchronized解析——如果你愿意一层一层剥开我的心: https://juejin.im/post/5d5374076fb9a06ac76da894#comment

+ +[2]

CAS乐观锁解决并发问题的一次实践: https://juejin.im/post/5d0616ade51d457756536791

+ +[3]

面试必问的CAS，你懂了吗？: https://blog.csdn.net/v123411739/article/details/79561458

+ +[4]

Java多线程：死锁: https://www.cnblogs.com/xiaoxi/p/8311034.html

+ +[5]

ReenTrantLock可重入锁（和synchronized的区别）总结: https://blog.csdn.net/qq838642798/article/details/65441415

+ +[6]

聊聊并发（八）——Fork/Join 框架介绍: https://www.infoq.cn/article/fork-join-introduction

+ +

From 2c8ba3d0ead6d5b4a890a825de6f02fdbf2d1476 Mon Sep 17 00:00:00 2001 From: whx123 <327658337@qq.com> Date: Tue, 11 Aug 2020 23:05:04 +0800 Subject: [PATCH 15/77] volatile --- ...71\344\275\215\350\247\243\346\236\220.md" | 487 ++++++++++++++++++ 1 file changed, 487 insertions(+) create mode 100644 "Java\345\237\272\347\241\200\345\255\246\344\271\240/Java\347\250\213\345\272\217\345\221\230\351\235\242\350\257\225\345\277\205\345\244\207\357\274\232Volatile\345\205\250\346\226\271\344\275\215\350\247\243\346\236\220.md" diff --git "a/Java\345\237\272\347\241\200\345\255\246\344\271\240/Java\347\250\213\345\272\217\345\221\230\351\235\242\350\257\225\345\277\205\345\244\207\357\274\232Volatile\345\205\250\346\226\271\344\275\215\350\247\243\346\236\220.md" "b/Java\345\237\272\347\241\200\345\255\246\344\271\240/Java\347\250\213\345\272\217\345\221\230\351\235\242\350\257\225\345\277\205\345\244\207\357\274\232Volatile\345\205\250\346\226\271\344\275\215\350\247\243\346\236\220.md" new file mode 100644 index 0000000..35fff3c --- /dev/null +++ "b/Java\345\237\272\347\241\200\345\255\246\344\271\240/Java\347\250\213\345\272\217\345\221\230\351\235\242\350\257\225\345\277\205\345\244\207\357\274\232Volatile\345\205\250\346\226\271\344\275\215\350\247\243\346\236\220.md" @@ -0,0 +1,487 @@ +### 前言 +volatile是Java程序员必备的基础，也是面试官非常喜欢问的一个话题，本文跟大家一起开启volatile学习之旅，如果有不正确的地方，也麻烦大家指出哈，一起相互学习~ + +- 1.volatile的用法 +- 2.volatile变量的作用 +- 3.现代计算机的内存模型（计算机模型，总线，MESI协议，嗅探技术） +- 4.Java内存模型（JMM） +- 5.并发编程的3个特性（原子性、可见性、有序性、happen-before、as-if-serial、指令重排） +- 6.volatile的底层原理（如何保证可见性，如何保证指令重排，内存屏障） +- 7.volatile的典型场景（状态标志，DCL单例模式） +- 8.volatile常见面试题&&答案解析 +- 公众号：捡田螺的小男孩 + +**github 地址** +> https://github.com/whx123/JavaHome + +### 1.volatile的用法 +volatile关键字是Java虚拟机提供的的**最轻量级的同步机制**，它作为一个修饰符出现，用来**修饰变量**，但是这里不包括局部变量哦。我们来看个demo吧，代码如下: +``` +/** + * @Author 捡田螺的小男孩 + * @Date 2020/08/02 + * @Desc volatile的可见性探索 + */ +public class VolatileTest { + + public static void main(String[] args) throws InterruptedException { + Task task = new Task(); + + Thread t1 = new Thread(task, "线程t1"); + Thread t2 = new Thread(new Runnable() { + @Override + public void run() { + try { + Thread.sleep(1000); + System.out.println("开始通知线程停止"); + task.stop = true; //修改stop变量值。 + } catch (InterruptedException e) { + e.printStackTrace(); + } + + } + }, "线程t2"); + t1.start(); //开启线程t1 + t2.start(); //开启线程t2 + Thread.sleep(1000); + } +} + +class Task implements Runnable { + boolean stop = false; + int i = 0; + + @Override + public void run() { + long s = System.currentTimeMillis(); + while (!stop) { + i++; + } + System.out.println("线程退出" + (System.currentTimeMillis() - s)); + } +} +``` +**运行结果：** +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/057e2eec568a40fe9f47e05f3b47bdb7~tplv-k3u1fbpfcp-zoom-1.image) +可以发现线程t2，虽然把stop设置为true了，但是线程t1对t2的**stop变量视而不可见**，因此，它一直在死循环running中。如果给变量stop加上volatile修饰，线程t1是可以停下来的,运行结果如下： +``` +volatile boolean stop = false; +``` +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/81326a66e9cc4350af71b0e9ff4dc304~tplv-k3u1fbpfcp-zoom-1.image) + + +### 2. vlatile修饰变量的作用 + +从以上例子，我们可以发现变量stop，加了vlatile修饰之后，线程t1对stop就可见了。其实，vlatile的作用就是：**保证变量对所有线程可见性**。当然，vlatile还有个作用就是，**禁止指令重排**，但是它**不保证原子性**。 +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b5177218cf2b491da99d43392c7bd271~tplv-k3u1fbpfcp-zoom-1.image) + +所以当面试官问你**volatile的作用或者特性**，都可以这么回答： +- 保证变量对所有线程可见性; +- 禁止指令重排序 +- 不保证原子性 + +### 3. 现代计算机的内存模型（计算机模型，MESI协议，嗅探技术，总线） +为了更好理解volatile，先回顾一下计算机的内存模型与JMM（Java内存模型）吧~ + +#### 计算机模型 +计算机执行程序时，指令是由CPU处理器执行的，而打交道的数据是在主内存当中的。 + +由于计算机的存储设备与处理器的运算速度有几个数量级的差距，总不能每次CPU执行完指令，然后等主内存慢悠悠存取数据吧， +所以现代计算机系统加入一层读写速度接近处理器运算速度的高速缓存（Cache），以作为来作为内存与处理器之间的缓冲。 + +在多路处理器系统中，每个处理器都有自己的高速缓存，而它们共享同一主内存。**计算机抽象内存模型**如下： + +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f995fb284a7241b9b95431e79a1c37b0~tplv-k3u1fbpfcp-zoom-1.image) + +- 程序执行时，把需要用到的数据，从主内存拷贝一份到高速缓存。 +- CPU处理器计算时，从它的高速缓存中读取，把计算完的数据写入高速缓存。 +- 当程序运算结束，把高速缓存的数据刷新会主内存。 + +随着科学技术的发展，为了效率，高速缓存又衍生出一级缓存（L1），二级缓存（L2），甚至三级缓存(L3); +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/05fa9ff22d7f42ae82122bfc6c233bd9~tplv-k3u1fbpfcp-zoom-1.image) + +当多个处理器的运算任务都涉及同一块主内存区域，可能导致**缓存数据不一致**问题。如何解决这个问题呢？有两种方案 + +> - 1、通过在总线加LOCK#锁的方式。 +> - 2、通过缓存一致性协议（Cache Coherence Protocol） + +#### 总线 + +> 总线（Bus）是计算机各种功能部件之间传送信息的公共通信干线，它是由导线组成的传输线束，按照计算机所传输的信息种类，计算机的总线可以划分为数据总线、地址总线和控制总线，分别用来传输数据、数据地址和控制信号。 + +CPU和其他功能部件是通过总线通信的，如果在总线加LOCK#锁，那么在锁住总线期间，其他CPU是无法访问内存，这样一来，**效率就比较低了**。 + +#### MESI协议 +为了解决一致性问题，还可以通过缓存一致性协议。即各个处理器访问缓存时都遵循一些协议，在读写时要根据协议来进行操作，这类协议有MSI、MESI（IllinoisProtocol）、MOSI、Synapse、Firefly及DragonProtocol等。比较著名的就是Intel的MESI（Modified Exclusive Shared Or Invalid）协议，它的核心思想是： + + > 当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。 + +CPU中每个缓存行标记的4种状态（M、E、S、I）,也了解一下吧: + +| 缓存状态 | 描述 | +|-----|-----| +| M，被修改（Modified) | 该缓存行只被该CPU缓存，与主存的值不同，会在它被其他CPU读取之前写入内存，并设置为Shared | +| E，独享的（Exclusive) | 该缓存行只被该CPU缓存，与主存的值相同，被其他CPU读取时置为Shared，被其他CPU写时置为Modified | +| S，共享的（Shared) | 该缓存行可能被多个CPU缓存，各个缓存中的数据与主存数据相同| +| I，无效的（Invalid） | 该缓存行数据是无效，需要时需重新从主存载入 | + + +MESI协议是如何实现的？如何保证当前处理器的内部缓存、主内存和其他处理器的缓存数据在总线上保持一致的？**多处理器总线嗅探** + +#### 嗅探技术 +> 在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己的缓存值是不是过期了，如果处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据库读到处理器缓存中。 + +### 4. Java内存模型（JMM） + +- Java虚拟机规范试图定义一种Java内存模型,来**屏蔽掉各种硬件和操作系统的内存访问差异**，以实现让Java程序在各种平台上都能达到一致的内存访问效果。 +- Java内存模型**类比**于计算机内存模型。 +- 为了更好的执行性能，java内存模型并没有限制执行引擎使用处理器的特定寄存器或缓存来和主内存打交道，也没有限制编译器进行调整代码顺序优化。所以Java内存模型**会存在缓存一致性问题和指令重排序问题的**。 +- Java内存模型规定所有的变量都是存在主内存当中（类似于计算机模型中的物理内存），每个线程都有自己的工作内存（类似于计算机模型的高速缓存）。这里的**变量**包括实例变量和静态变量，但是**不包括局部变量**，因为局部变量是线程私有的。 +- 线程的工作内存保存了被该线程使用的变量的主内存副本，**线程对变量的所有操作都必须在工作内存中进行**，而不能直接操作操作主内存。并且每个线程不能访问其他线程的工作内存。 + +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a6ca8c98a8cc42c998dd4fe3324ded79~tplv-k3u1fbpfcp-zoom-1.image) + +举个例子吧，假设i的初始值是0，执行以下语句： +``` +i = i+1; +``` +首先，执行线程t1从主内存中读取到i=0，到工作内存。然后在工作内存中，赋值i+1,工作内存就得到i=1，最后把结果写回主内存。因此，如果是单线程的话，该语句执行是没问题的。但是呢，线程t2的本地工作内存还没过期，那么它读到的数据就是脏数据了。如图： +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c0abe171336e4f89a58722a1569d64ce~tplv-k3u1fbpfcp-zoom-1.image) + +Java内存模型是围绕着如何在并发过程中如何处理**原子性、可见性和有序性**这3个特征来建立的，我们再来一起回顾一下~ + +### 5.并发编程的3个特性（原子性、可见性、有序性） + +#### 原子性 + +原子性，指操作是不可中断的，要么执行完成，要么不执行，基本数据类型的访问和读写都是具有原子性，当然（long和double的非原子性协定除外）。我们来看几个小例子： +``` +i =666； // 语句1 +i = j; // 语句2 +i = i+1; //语句 3 +i++; // 语句4 +``` +- 语句1操作显然是原子性的，将数值666赋值给i，即线程执行这个语句时，直接将数值666写入到工作内存中。 +- 语句2操作看起来也是原子性的，但是它实际上涉及两个操作，先去读j的值，再把j的值写入工作内存，两个操作分开都是原子操作，但是合起来就不满足原子性了。 +- 语句3读取i的值，加1，再写回主存，这个就不是原子性操作了。 +- 语句4 等同于语句3，也是非原子性操作。 + +#### 可见性 + +- 可见性就是指当一个线程修改了共享变量的值时，其他线程能够立即得知这个修改。 +- Java内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存作为传递媒介的方式来实现可见性的，无论是普通变量还是volatile变量都是如此。 +- volatile变量，保证新值能立即同步回主内存，以及每次使用前立即从主内存刷新，所以我们说volatile保证了多线程操作变量的可见性。 +- synchronized和Lock也能够保证可见性，线程在释放锁之前，会把共享变量值都刷回主存。final也可以实现可见性。 + + +#### 有序性 + +Java虚拟机这样描述Java程序的有序性的：如果在本线程内观察，所有的操作都是有序的；如果在一个线程中，观察另一个线程，所有的操作都是无序的。 + +后半句意思就是，在Java内存模型中，**允许编译器和处理器对指令进行重排序**，会影响到多线程并发执行的正确性；前半句意思就是**as-if-serial**的语义，即不管怎么重排序（编译器和处理器为了提高并行度），（单线程）程序的执行结果不会被改变。 + +比如以下程序代码： +``` +double pi = 3.14; //A +double r = 1.0; //B +double area = pi * r * r; //C +``` +步骤C依赖于步骤A和B，因为指令重排的存在，程序执行顺讯可能是A->B->C,也可能是B->A->C,但是C不能在A或者B前面执行，这将违反as-if-serial语义。 +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/87387195b86749ddbe1f36582a562988~tplv-k3u1fbpfcp-zoom-1.image) + +看段代码吧，假设程序先执行read方法，再执行add方法，结果一定是输出sum=2嘛？ +``` +bool flag = false; +int b = 0; + +public void read() { + b = 1; //1 + flag = true; //2 +} + +public void add() { + if (flag) { //3 + int sum =b+b; //4 + System.out.println("bb sum is"+sum); + } +} + +``` + +如果是单线程，结果应该没问题，如果是多线程，线程t1对步骤1和2进行了**指令重排序**呢？结果sum就不是2了，而是0，如下图所示： +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/093c6e37453c462985bed78c4d239979~tplv-k3u1fbpfcp-zoom-1.image) + +这是为啥呢？**指令重排序**了解一下，指令重排是指在程序执行过程中,**为了提高性能**, **编译器和CPU可能会对指令进行重新排序**。CPU重排序包括指令并行重排序和内存系统重排序，重排序类型和重排序执行过程如下： + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/d8a24934eab24bf9b80c402039371aa2~tplv-k3u1fbpfcp-zoom-1.image) + +实际上，可以给flag加上volatile关键字，来保证有序性。当然，也可以通过synchronized和Lock来保证有序性。synchronized和Lock保证某一时刻是只有一个线程执行同步代码，相当于是让线程顺序执行程序代码了，自然就保证了有序性。 + +实际上Java内存模型的有序性并不是仅靠volatile、synchronized和Lock来保证有序性的。这是因为Java语言中，有一个先行发生原则（happens-before）： +- **程序次序规则**：在一个线程内，按照控制流顺序，书写在前面的操作先行发生于书写在后面的操作。 +- **管程锁定规则**：一个unLock操作先行发生于后面对同一个锁额lock操作 +- **volatile变量规则**：对一个变量的写操作先行发生于后面对这个变量的读操作 +- **线程启动规则**：Thread对象的start()方法先行发生于此线程的每个一个动作 +- **线程终止规则**：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行 +- **线程中断规则**：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生 +- **对象终结规则**：一个对象的初始化完成先行发生于他的finalize()方法的开始 +- **传递性**：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C + +根据happens-before的八大规则，我们回到刚的例子，一起分析一下。给flag加上volatile关键字，look look它是如何保证有序性的， +``` +volatile bool flag = false; +int b = 0; + +public void read() { + b = 1; //1 + flag = true; //2 +} + +public void add() { + if (flag) { //3 + int sum =b+b; //4 + System.out.println("bb sum is"+sum); + } +} +``` +- 首先呢，flag加上volatile关键字，那就禁止了指令重排，也就是1 happens-before 2了 +- 根据**volatile变量规则**，2 happens-before 3 +- 由**程序次序规则**，得出 3 happens-before 4 +- 最后由**传递性**，得出1 happens-before 4，因此妥妥的输出sum=2啦~ + +### 6.volatile底层原理 + +以上讨论学习，我们知道volatile的语义就是保证变量对所有线程可见性以及禁止指令重排优化。那么，它的底层是如何保证可见性和禁止指令重排的呢？ + +#### 图解volatile是如何保证可见性的？ +在这里，先看几个图吧，哈哈~ + +假设flag变量的初始值false，现在有两条线程t1和t2要访问它，就可以简化为以下图： +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7ddbe230c8dc4501a77ffbe0587b5ba6~tplv-k3u1fbpfcp-zoom-1.image) + +如果线程t1执行以下代码语句，并且flag没有volatile修饰的话；t1刚修改完flag的值，还没来得及刷新到主内存，t2又跑过来读取了，很容易就数据flag不一致了，如下： + +``` +flag=true; +``` +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/cc065cf75803496aa1efafd6d68ba968~tplv-k3u1fbpfcp-zoom-1.image) + +如果flag变量是由volatile修饰的话，就不一样了，如果线程t1修改了flag值，volatile能保证修饰的flag变量后，可以**立即同步回主内存**。如图： + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/27e9e195810a4a71bdeb38dd128b27e4~tplv-k3u1fbpfcp-zoom-1.image) + +细心的朋友会发现，线程t2不还是flag旧的值吗，这不还有问题嘛？其实volatile还有一个保证，就是**每次使用前立即先从主内存刷新最新的值**，线程t1修改完后，线程t2的变量副本会过期了，如图： +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7e67dcdfe9d9412dab89961bf92b5b53~tplv-k3u1fbpfcp-zoom-1.image) + +显然，这里还不是底层，实际上volatile保证可见性和禁止指令重排都跟**内存屏障**有关，我们编译volatile相关代码看看~ + +#### DCL单例模式（volatile）&编译对比 +DCL单例模式（Double Check Lock，双重检查锁）比较常用，它是需要volatile修饰的，所以就拿这段代码编译吧 +``` +public class Singleton { + private volatile static Singleton instance; + private Singleton (){} + public static Singleton getInstance() { + if (instance == null) { + synchronized (Singleton.class) { + if (instance == null) { + instance = new Singleton(); + } + } + } + return instance; + } +} +``` +编译这段代码后，观察有volatile关键字和没有volatile关键字时的instance所生成的汇编代码发现，有volatile关键字修饰时，会多出一个lock addl $0x0,(%esp)，即多出一个lock前缀指令 +``` +0x01a3de0f: mov $0x3375cdb0,%esi ;...beb0cd75 33 + ; {oop('Singleton')} +0x01a3de14: mov %eax,0x150(%esi) ;...89865001 0000 +0x01a3de1a: shr $0x9,%esi ;...c1ee09 +0x01a3de1d: movb $0x0,0x1104800(%esi) ;...c6860048 100100 +0x01a3de24: lock addl $0x0,(%esp) ;...f0830424 00 + ;*putstatic instance + ; - Singleton::getInstance@24 +``` + lock指令相当于一个**内存屏障**，它保证以下这几点： + > - 1.重排序时不能把后面的指令重排序到内存屏障之前的位置 + > - 2.将本处理器的缓存写入内存 + > - 3.如果是写入动作，会导致其他处理器中对应的缓存无效。 + +显然，第2、3点不就是volatile保证可见性的体现嘛，第1点就是禁止指令重排列的体现。 + +#### 内存屏障 + +内存屏障四大分类：（Load 代表读取指令，Store代表写入指令） + +| 内存屏障类型 | 抽象场景| 描述| +|-----|-----|-----| +|LoadLoad屏障| Load1; LoadLoad; Load2|在Load2要读取的数据被访问前，保证Load1要读取的数据被读取完毕。| +|StoreStore屏障|Store1; StoreStore; Store2|在Store2写入执行前，保证Store1的写入操作对其它处理器可见| +|LoadStore屏障|Load1; LoadStore; Store2| 在Store2被写入前，保证Load1要读取的数据被读取完毕。| +|StoreLoad屏障|Store1; StoreLoad; Load2|在Load2读取操作执行前，保证Store1的写入对所有处理器可见。| + +为了实现volatile的内存语义，Java内存模型采取以下的保守策略 +- 在每个volatile写操作的前面插入一个StoreStore屏障。 +- 在每个volatile写操作的后面插入一个StoreLoad屏障。 +- 在每个volatile读操作的前面插入一个LoadLoad屏障。 +- 在每个volatile读操作的后面插入一个LoadStore屏障。 + +有些小伙伴，可能对这个还是有点疑惑，内存屏障这玩意太抽象了。我们照着代码看下吧： + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a3097b7467304540b6a552d897d46997~tplv-k3u1fbpfcp-zoom-1.image) +内存屏障保证前面的指令先执行，所以这就保证了禁止了指令重排啦，同时内存屏障保证缓存写入内存和其他处理器缓存失效，这也就保证了可见性，哈哈~ + +### 7.volatile的典型场景 +通常来说，使用volatile必须具备以下2个条件： +- 1）对变量的写操作不依赖于当前值 +- 2）该变量没有包含在具有其他变量的不变式中 + +实际上，volatile场景一般就是**状态标志**，以及**DCL单例模式**。 + +#### 7.1 状态标志 +深入理解Java虚拟机，书中的例子： +``` +Map configOptions; +char[] configText; +// 此变量必须定义为 volatile +volatile boolean initialized = false; + +// 假设以下代码在线程 A 中运行 +// 模拟读取配置信息, 当读取完成后将 initialized 设置为 true 以告知其他线程配置可用 +configOptions = new HashMap(); +configText = readConfigFile(fileName); +processConfigOptions(configText, configOptions); +initialized = true; + +// 假设以下代码在线程 B 中运行 +// 等待 initialized 为 true, 代表线程 A 已经把配置信息初始化完成 +while(!initialized) { + sleep(); +} +// 使用线程 A 中初始化好的配置信息 +doSomethingWithConfig(); +``` +#### 7.2 DCL单例模式 +``` +class Singleton{ + private volatile static Singleton instance = null; + + private Singleton() { + } + + public static Singleton getInstance() { + if(instance==null) { + synchronized (Singleton.class) { + if(instance==null) + instance = new Singleton(); + } + } + return instance; + } +} + +``` + +### 8. volatile相关经典面试题 +- 谈谈volatile的特性 +- volatile的内存语义 +- 说说并发编程的3大特性 +- 什么是内存可见性，什么是指令重排序？ +- volatile是如何解决java并发中可见性的问题 +- volatile如何防止指令重排 +- volatile可以解决原子性嘛？为什么？ +- volatile底层的实现机制 +- volatile和synchronized的区别？ + +#### 8.1 谈谈volatile的特性 + +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8e624231e978455ebec33c7380ffba0d~tplv-k3u1fbpfcp-zoom-1.image) + +#### 8.2 volatile的内存语义 + +- 当写一个 volatile 变量时，JMM 会把该线程对应的本地内存中的共享变量值刷新到主内存。 +- 当读一个 volatile 变量时，JMM 会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。 + +#### 8.3 说说并发编程的3大特性 +- 原子性 +- 可见性 +- 有序性 + +#### 8.4 什么是内存可见性，什么是指令重排序？ +- 可见性就是指当一个线程修改了共享变量的值时，其他线程能够立即得知这个修改。 +- 指令重排是指JVM在编译Java代码的时候，或者CPU在执行JVM字节码的时候，对现有的指令顺序进行重新排序。 + +#### 8.5 volatile是如何解决java并发中可见性的问题 + +底层是通过内存屏障实现的哦，volatile能保证修饰的变量后，可以立即同步回主内存，每次使用前立即先从主内存刷新最新的值。 + +#### 8.6 volatile如何防止指令重排 + +也是内存屏障哦，跟面试官讲下Java内存的保守策略： +- 在每个volatile写操作的前面插入一个StoreStore屏障。 +- 在每个volatile写操作的后面插入一个StoreLoad屏障。 +- 在每个volatile读操作的前面插入一个LoadLoad屏障。 +- 在每个volatile读操作的后面插入一个LoadStore屏障。 + +再讲下volatile的语义哦，重排序时不能把内存屏障后面的指令重排序到内存屏障之前的位置 + +#### 8.7 volatile可以解决原子性嘛？为什么？ + +不可以，可以直接举i++那个例子，原子性需要synchronzied或者lock保证 + +``` +public class Test { + public volatile int race = 0; + + public void increase() { + race++; + } + + public static void main(String[] args) { + final Test test = new Test(); + for(int i=0;i<10;i++){ + new Thread(){ + public void run() { + for(int j=0;j<100;j++) + test.increase(); + }; + }.start(); + } + + //等待所有累加线程结束 + while(Thread.activeCount()>1) + Thread.yield(); + System.out.println(test.race); + } +} +``` + + #### 8.8 volatile底层的实现机制 + + 可以看本文的第六小节，volatile底层原理哈，主要你要跟面试官讲述，volatile如何保证可见性和禁止指令重排，需要讲到内存屏障~ + + #### 8.9 volatile和synchronized的区别？ + - volatile修饰的是变量，synchronized一般修饰代码块或者方法 + - volatile保证可见性、禁止指令重排，但是不保证原子性；synchronized可以保证原子性 + - volatile不会造成线程阻塞，synchronized可能会造成线程的阻塞，所以后面才有锁优化那么多故事~ + - 哈哈，你还有补充嘛~ + +推荐之前写的一篇文章： +[Synchronized解析——如果你愿意一层一层剥开我的心](https://juejin.im/post/6844903918653145102) + + +### 公众号 +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/07e9fd0521c244adab8556fee99a2011~tplv-k3u1fbpfcp-zoom-1.image) + +### 参考与感谢 +- <<深入理解Java虚拟机>> +- [Java并发编程：volatile关键字解析](https://www.cnblogs.com/dolphin0520/p/3920373.html) +- [面试官最爱的volatile关键字](https://juejin.im/post/6844903520760496141) +- [ 面试官没想到一个Volatile，我都能跟他扯半小时](https://juejin.im/post/6844904149536997384) +- [再有人问你Java内存模型是什么，就把这篇文章发给他。](http://47.103.216.138/archives/2550) +- [【并发编程】MESI--CPU缓存一致性协议](https://www.cnblogs.com/z00377750/p/9180644.html) +- [漫画：volatile对指令重排的影响 ](https://www.sohu.com/a/211287207_684445) +- [volatile三大特性详解](https://www.jianshu.com/p/765e3abbe89a) + From c7c32e05c9e8f3db093a5c21c567d68b6ba66738 Mon Sep 17 00:00:00 2001 From: whx123 <327658337@qq.com> Date: Sun, 23 Aug 2020 10:15:43 +0800 Subject: [PATCH 16/77] =?UTF-8?q?volatile=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...0\346\226\271\344\275\215\350\247\243\346\236\220.md" | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git "a/Java\345\237\272\347\241\200\345\255\246\344\271\240/Java\347\250\213\345\272\217\345\221\230\351\235\242\350\257\225\345\277\205\345\244\207\357\274\232Volatile\345\205\250\346\226\271\344\275\215\350\247\243\346\236\220.md" "b/Java\345\237\272\347\241\200\345\255\246\344\271\240/Java\347\250\213\345\272\217\345\221\230\351\235\242\350\257\225\345\277\205\345\244\207\357\274\232Volatile\345\205\250\346\226\271\344\275\215\350\247\243\346\236\220.md" index 35fff3c..05c9e70 100644 --- "a/Java\345\237\272\347\241\200\345\255\246\344\271\240/Java\347\250\213\345\272\217\345\221\230\351\235\242\350\257\225\345\277\205\345\244\207\357\274\232Volatile\345\205\250\346\226\271\344\275\215\350\247\243\346\236\220.md" +++ "b/Java\345\237\272\347\241\200\345\255\246\344\271\240/Java\347\250\213\345\272\217\345\221\230\351\235\242\350\257\225\345\277\205\345\244\207\357\274\232Volatile\345\205\250\346\226\271\344\275\215\350\247\243\346\236\220.md" @@ -325,12 +325,13 @@ public class Singleton { 为了实现volatile的内存语义，Java内存模型采取以下的保守策略 - 在每个volatile写操作的前面插入一个StoreStore屏障。 - 在每个volatile写操作的后面插入一个StoreLoad屏障。 -- 在每个volatile读操作的前面插入一个LoadLoad屏障。 +- 在每个volatile读操作的后面插入一个LoadLoad屏障。 - 在每个volatile读操作的后面插入一个LoadStore屏障。 -有些小伙伴，可能对这个还是有点疑惑，内存屏障这玩意太抽象了。我们照着代码看下吧： +有些小伙伴，可能对这个还是有点疑惑，内存屏障这玩意太抽象了。我们照着代码看下吧（LoadLoad内存屏障也是在flag后面哈，图片有误）： + +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a85eff53f99f420c8139bb69b2d4f6ae~tplv-k3u1fbpfcp-zoom-1.image) -![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a3097b7467304540b6a552d897d46997~tplv-k3u1fbpfcp-zoom-1.image) 内存屏障保证前面的指令先执行，所以这就保证了禁止了指令重排啦，同时内存屏障保证缓存写入内存和其他处理器缓存失效，这也就保证了可见性，哈哈~ ### 7.volatile的典型场景 @@ -422,7 +423,7 @@ class Singleton{ 也是内存屏障哦，跟面试官讲下Java内存的保守策略： - 在每个volatile写操作的前面插入一个StoreStore屏障。 - 在每个volatile写操作的后面插入一个StoreLoad屏障。 -- 在每个volatile读操作的前面插入一个LoadLoad屏障。 +- 在每个volatile读操作的后面插入一个LoadLoad屏障。 - 在每个volatile读操作的后面插入一个LoadStore屏障。再讲下volatile的语义哦，重排序时不能把内存屏障后面的指令重排序到内存屏障之前的位置 From f64e44e8402e489ac2135381b186aa401916f57e Mon Sep 17 00:00:00 2001 From: whx123 <327658337@qq.com> Date: Sun, 23 Aug 2020 10:21:46 +0800 Subject: [PATCH 17/77] =?UTF-8?q?=E9=9D=A2=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...10\350\247\243\346\236\220\357\274\211.md" | 694 ++++++++++++++++++ 1 file changed, 694 insertions(+) create mode 100644 "Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/Java \345\271\266\345\217\221 && \345\244\232\347\272\277\347\250\213/\344\270\252\344\272\272\347\217\215\350\227\217\347\232\20480\351\201\223\345\244\232\347\272\277\347\250\213\345\271\266\345\217\221\351\235\242\350\257\225\351\242\230\357\274\21011-20\347\255\224\346\241\210\350\247\243\346\236\220\357\274\211.md" diff --git "a/Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/Java \345\271\266\345\217\221 && \345\244\232\347\272\277\347\250\213/\344\270\252\344\272\272\347\217\215\350\227\217\347\232\20480\351\201\223\345\244\232\347\272\277\347\250\213\345\271\266\345\217\221\351\235\242\350\257\225\351\242\230\357\274\21011-20\347\255\224\346\241\210\350\247\243\346\236\220\357\274\211.md" "b/Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/Java \345\271\266\345\217\221 && \345\244\232\347\272\277\347\250\213/\344\270\252\344\272\272\347\217\215\350\227\217\347\232\20480\351\201\223\345\244\232\347\272\277\347\250\213\345\271\266\345\217\221\351\235\242\350\257\225\351\242\230\357\274\21011-20\347\255\224\346\241\210\350\247\243\346\236\220\357\274\211.md" new file mode 100644 index 0000000..2a71671 --- /dev/null +++ "b/Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/Java \345\271\266\345\217\221 && \345\244\232\347\272\277\347\250\213/\344\270\252\344\272\272\347\217\215\350\227\217\347\232\20480\351\201\223\345\244\232\347\272\277\347\250\213\345\271\266\345\217\221\351\235\242\350\257\225\351\242\230\357\274\21011-20\347\255\224\346\241\210\350\247\243\346\236\220\357\274\211.md" @@ -0,0 +1,694 @@ +## 前言 +个人珍藏的80道Java多线程/并发经典面试题，现在给出11-20的答案解析哈，并且上传github哈~ + +> https://github.com/whx123/JavaHome + +[个人珍藏的80道多线程并发面试题（1-10答案解析）](https://juejin.im/post/6854573221258199048) + +### 11、为什么要用线程池？Java的线程池内部机制，参数作用，几种工作阻塞队列，线程池类型以及使用场景 +回答这些点： +- 为什么要用线程池？ +- Java的线程池原理 +- 线程池核心参数 +- 几种工作阻塞队列 +- 线程池使用不当的问题 +- 线程池类型以及使用场景 + +#### 为什么要用线程池？ +线程池：一个管理线程的池子。 +- 管理线程，避免增加创建线程和销毁线程的资源损耗。 +- 提高响应速度。 +- 重复利用。 + +#### Java的线程池执行原理 +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/efe9ed82093e4c8bab768eac79dffed3~tplv-k3u1fbpfcp-zoom-1.image) +为了形象描述线程池执行，打个比喻： +- 核心线程比作公司正式员工 +- 非核心线程比作外包员工 +- 阻塞队列比作需求池 +- 提交任务比作提需求 +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/6ed3df3db91941e9b8d3e1078fdd02b5~tplv-k3u1fbpfcp-zoom-1.image) + +#### 线程池核心参数 +``` +public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, + long keepAliveTime, + TimeUnit unit, + BlockingQueue workQueue, + ThreadFactory threadFactory, + RejectedExecutionHandler handler) +``` +- corePoolSize：线程池核心线程数最大值 +- maximumPoolSize：线程池最大线程数大小 +- keepAliveTime：线程池中非核心线程空闲的存活时间大小 +- unit：线程空闲存活时间单位 +- workQueue：存放任务的阻塞队列 +- threadFactory：用于设置创建线程的工厂，可以给创建的线程设置有意义的名字，可方便排查问题。 +- handler：线城池的饱和策略事件，主要有四种类型拒绝策略。 + +**四种拒绝策略** +- AbortPolicy(抛出一个异常，默认的) +- DiscardPolicy(直接丢弃任务) +- DiscardOldestPolicy（丢弃队列里最老的任务，将当前这个任务继续提交给线程池） +- CallerRunsPolicy（交给线程池调用所在的线程进行处理) + +#### 几种工作阻塞队列 + +- ArrayBlockingQueue（用数组实现的有界阻塞队列，按FIFO排序量） +- LinkedBlockingQueue（基于链表结构的阻塞队列，按FIFO排序任务，容量可以选择进行设置，不设置的话，将是一个无边界的阻塞队列） +- DelayQueue（一个任务定时周期的延迟执行的队列） +- PriorityBlockingQueue（具有优先级的无界阻塞队列） +- SynchronousQueue（一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态） + + +#### 线程池使用不当的问题 +线程池适用不当可能导致内存飙升问题哦 + +有兴趣可以看我这篇文章哈:[源码角度分析-newFixedThreadPool线程池导致的内存飙升问题](https://juejin.im/post/6844903930502070285) + +#### 线程池类型以及使用场景 +- newFixedThreadPool +> 适用于处理CPU密集型的任务，确保CPU在长期被工作线程使用的情况下，尽可能的少的分配线程，即适用执行长期的任务。 +- newCachedThreadPool +> 用于并发执行大量短期的小任务。 +- newSingleThreadExecutor +> 适用于串行执行任务的场景，一个任务一个任务地执行。 +- newScheduledThreadPool +> 周期性执行任务的场景，需要限制线程数量的场景 +- newWorkStealingPool +> 建一个含有足够多线程的线程池，来维持相应的并行级别，它会通过工作窃取的方式，使得多核的 CPU 不会闲置，总会有活着的线程让 CPU 去运行,本质上就是一个 ForkJoinPool。) + + +有兴趣可以看我这篇文章哈:[面试必备：Java线程池解析](https://juejin.im/post/6844903889678893063) + +### 12、谈谈volatile关键字的理解 +volatile是面试官非常喜欢问的一个问题，可以回答以下这几点： +- vlatile变量的作用 +- 现代计算机的内存模型（嗅探技术，MESI协议，总线） +- Java内存模型（JMM） +- 什么是可见性？ +- 指令重排序 +- volatile的内存语义 +- as-if-serial +- Happens-before +- volatile可以解决原子性嘛？为什么？ +- volatile底层原理，如何保证可见性和禁止指令重排（内存屏障） + +#### vlatile变量的作用？ +- 保证变量对所有线程可见性 +- 禁止指令重排 +#### 现代计算机的内存模型 +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b4bb647387f34af09ce1096ef916be9a~tplv-k3u1fbpfcp-zoom-1.image) +- 其中高速缓存包括L1，L2，L3缓存~ +- 缓存一致性协议，可以了解MESI协议 +- 总线（Bus）是计算机各种功能部件之间传送信息的公共通信干线，CPU和其他功能部件是通过总线通信的。 +- 处理器使用嗅探技术保证它的内部缓存、系统内存和其他处理器的缓存数据在总线上保持一致。 +#### Java内存模型（JMM） +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/275f5b038d1d4e9ba308ab129df4aef3~tplv-k3u1fbpfcp-zoom-1.image) + +#### 什么是可见性？ +可见性就是当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。 + +#### 指令重排序 +指令重排是指在程序执行过程中,为了提高性能, 编译器和CPU可能会对指令进行重新排序。 +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/063d5ff09b604add8bbb25b3d9346169~tplv-k3u1fbpfcp-zoom-1.image) + +#### volatile的内存语义 +- 当写一个 volatile 变量时，JMM 会把该线程对应的本地内存中的共享变量值刷新到主内存。 +- 当读一个 volatile 变量时，JMM 会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。 + +#### as-if-serial +如果在本线程内观察，所有的操作都是有序的；即不管怎么重排序（编译器和处理器为了提高并行度），（单线程）程序的执行结果不会被改变。 +``` +double pi = 3.14; //A +double r = 1.0; //B +double area = pi * r * r; //C +``` +步骤C依赖于步骤A和B，因为指令重排的存在，程序执行顺讯可能是A->B->C,也可能是B->A->C,但是C不能在A或者B前面执行，这将违反as-if-serial语义。 +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/50dd857cc9d94ec8853531fdeae52497~tplv-k3u1fbpfcp-zoom-1.image) + +#### Happens-before +Java语言中，有一个先行发生原则（happens-before）： +- **程序次序规则**：在一个线程内，按照控制流顺序，书写在前面的操作先行发生于书写在后面的操作。 +- **管程锁定规则**：一个unLock操作先行发生于后面对同一个锁额lock操作 +- **volatile变量规则**：对一个变量的写操作先行发生于后面对这个变量的读操作 +- **线程启动规则**：Thread对象的start()方法先行发生于此线程的每个一个动作 +- **线程终止规则**：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行 +- **线程中断规则**：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生 +- **对象终结规则**：一个对象的初始化完成先行发生于他的finalize()方法的开始 +- **传递性**：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C + +#### volatile可以解决原子性嘛？为什么？ +不可以，可以直接举i++那个例子，原子性需要synchronzied或者lock保证 +``` +public class Test { + public volatile int race = 0; + + public void increase() { + race++; + } + + public static void main(String[] args) { + final Test test = new Test(); + for(int i=0;i<10;i++){ + new Thread(){ + public void run() { + for(int j=0;j<100;j++) + test.increase(); + }; + }.start(); + } + + //等待所有累加线程结束 + while(Thread.activeCount()>1) + Thread.yield(); + System.out.println(test.race); + } +} + +``` + +#### volatile底层原理，如何保证可见性和禁止指令重排（内存屏障） + +volatile 修饰的变量，转成汇编代码，会发现多出一个lock前缀指令。lock指令相当于一个内存屏障，它保证以下这几点： +- 1.重排序时不能把后面的指令重排序到内存屏障之前的位置 +- 2.将本处理器的缓存写入内存 +- 3.如果是写入动作，会导致其他处理器中对应的缓存无效。 + +2、3点保证可见性，第1点禁止指令重排~ + +有兴趣的朋友可以看我这篇文章哈:[Java程序员面试必备：Volatile全方位解析](https://juejin.im/post/6859390417314512909) + + +### 13、AQS组件，实现原理 +AQS，即AbstractQueuedSynchronizer，是构建锁或者其他同步组件的基础框架，它使用了一个int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。可以回答以下这几个关键点哈： +- state 状态的维护。 +- CLH队列 +- ConditionObject通知 +- 模板方法设计模式 +- 独占与共享模式。 +- 自定义同步器。 +- AQS全家桶的一些延伸，如：ReentrantLock等。 + +#### state 状态的维护 + +- state，int变量，锁的状态，用volatile修饰，保证多线程中的可见性。 +- getState()和setState()方法采用final修饰，限制AQS的子类重写它们两。 +- compareAndSetState（）方法采用乐观锁思想的CAS算法操作确保线程安全,保证状态 +设置的原子性。 + +对CAS有兴趣的朋友，可以看下我这篇文章哈~ +[CAS乐观锁解决并发问题的一次实践](https://juejin.im/post/6844903869340712967#comment) + + +#### CLH队列 +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/3f37b908ad9b482fb60de6478817a7dc~tplv-k3u1fbpfcp-zoom-1.image) + +> **CLH(Craig, Landin, and Hagersten locks) 同步队列** 是一个FIFO双向队列，其内部通过节点head和tail记录队首和队尾元素，队列元素的类型为Node。AQS依赖它来完成同步状态state的管理，当前线程如果获取同步状态失败时，AQS则会将当前线程已经等待状态等信息构造成一个节点（Node）并将其加入到CLH同步队列，同时会阻塞当前线程，当同步状态释放时，会把首节点唤醒（公平锁），使其再次尝试获取同步状态。 + + +#### ConditionObject通知 + +我们都知道，synchronized控制同步的时候，可以配合Object的wait()、notify()，notifyAll() 系列方法可以实现等待/通知模式。而Lock呢？它提供了条件Condition接口，配合await(),signal(),signalAll() 等方法也可以实现等待/通知机制。ConditionObject实现了Condition接口，给AQS提供条件变量的支持。 + +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/385e31246e8c4e1e8e8a9dacb183da74~tplv-k3u1fbpfcp-zoom-1.image) + +ConditionObject队列与CLH队列的爱恨情仇： + +- 调用了await()方法的线程，会被加入到conditionObject等待队列中，并且唤醒CLH队列中head节点的下一个节点。 +- 线程在某个ConditionObject对象上调用了singnal()方法后，等待队列中的firstWaiter会被加入到AQS的CLH队列中，等待被唤醒。 +- 当线程调用unLock()方法释放锁时，CLH队列中的head节点的下一个节点(在本例中是firtWaiter)，会被唤醒。 + + +#### 模板方法设计模式 +什么是模板设计模式？ +> 在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。 + +AQS的典型设计模式就是模板方法设计模式啦。AQS全家桶（ReentrantLock，Semaphore）的衍生实现，就体现出这个设计模式。如AQS提供tryAcquire，tryAcquireShared等模板方法，给子类实现自定义的同步器。 + +#### 独占与共享模式 +- 独占式: 同一时刻仅有一个线程持有同步状态，如ReentrantLock。又可分为公平锁和非公平锁。 +- 共享模式:多个线程可同时执行，如Semaphore/CountDownLatch等都是共享式的产物。 + +#### 自定义同步器 + +你要实现自定义锁的话，首先需要确定你要实现的是独占锁还是共享锁，定义原子变量state的含义，再定义一个内部类去继承AQS，重写对应的模板方法即可啦 + +#### AQS全家桶的一些延伸。 +Semaphore，CountDownLatch，ReentrantLock + +可以看下之前我这篇文章哈，[AQS解析与实战](https://juejin.im/post/6844903903188746247) + +### 14、什么是多线程环境下的伪共享 +- 什么是伪共享 +- 如何解决伪共享问题 + +#### 什么是伪共享 +伪共享定义？ +> CPU的缓存是以缓存行(cache line)为单位进行缓存的，当多个线程修改相互独立的变量，而这些变量又处于同一个缓存行时就会影响彼此的性能。这就是伪共享 + +现代计算机计算模型，大家都有印象吧？我之前这篇文章也有讲过，有兴趣可以看一下哈，[Java程序员面试必备：Volatile全方位解析](https://juejin.im/post/6859390417314512909) + +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a3bcae0d0fb44b1b9fb2db5093e6dd5d~tplv-k3u1fbpfcp-zoom-1.image) +- CPU执行速度比内存速度快好几个数量级，为了提高执行效率，现代计算机模型演变出CPU、缓存（L1，L2，L3），内存的模型。 +- CPU执行运算时，如先从L1缓存查询数据，找不到再去L2缓存找，依次类推，直到在内存获取到数据。 +- 为了避免频繁从内存获取数据，聪明的科学家设计出缓存行，缓存行大小为64字节。 + +也正是因为缓存行，就导致伪共享问题的存在，如图所示： +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/886ab0227a174842a2976581472eec06~tplv-k3u1fbpfcp-zoom-1.image) + +假设数据a、b被加载到同一个缓存行。 +- 当线程1修改了a的值，这时候CPU1就会通知其他CPU核，当前缓存行（Cache line）已经失效。 +- 这时候，如果线程2发起修改b，因为缓存行已经失效了，所以**core2 这时会重新从主内存中读取该 Cache line 数据**。读完后，因为它要修改b的值，那么CPU2就通知其他CPU核，当前缓存行（Cache line）又已经失效。 +- 酱紫，如果同一个Cache line的内容被多个线程读写，就很容易产生相互竞争，频繁回写主内存，会大大降低性能。 + + +#### 如何解决伪共享问题 +既然伪共享是因为相互独立的变量存储到相同的Cache line导致的，一个缓存行大小是64字节。那么，我们就可以**使用空间换时间**，即数据填充的方式，把独立的变量分散到不同的Cache line~ + +共享内存demo例子: +``` +public class FalseShareTest { + + public static void main(String[] args) throws InterruptedException { + Rectangle rectangle = new Rectangle(); + long beginTime = System.currentTimeMillis(); + Thread thread1 = new Thread(() -> { + for (int i = 0; i < 100000000; i++) { + rectangle.a = rectangle.a + 1; + } + }); + + Thread thread2 = new Thread(() -> { + for (int i = 0; i < 100000000; i++) { + rectangle.b = rectangle.b + 1; + } + }); + + thread1.start(); + thread2.start(); + thread1.join(); + thread2.join(); + + System.out.println("执行时间" + (System.currentTimeMillis() - beginTime)); + } + +} + +class Rectangle { + volatile long a; + volatile long b; +} +``` + +运行结果： +``` +执行时间2815 +``` +一个long类型是8字节，我们在变量a和b之间不上7个long类型变量呢，输出结果是啥呢？如下： +``` +class Rectangle { + volatile long a; + long a1,a2,a3,a4,a5,a6,a7; + volatile long b; +} +``` +运行结果： +``` +执行时间1113 +``` +可以发现利用填充数据的方式，让读写的变量分割到不同缓存行，可以很好挺高性能~ + + +### 15、说一下 Runnable和 Callable有什么区别？ +- Callable接口方法是call()，Runnable的方法是run()； +- Callable接口call方法有返回值，支持泛型，Runnable接口run方法无返回值。 +- Callable接口call()方法允许抛出异常；而Runnable接口run()方法不能继续上抛异常； + +``` +@FunctionalInterface +public interface Callable { + /** + * 支持泛型V，有返回值，允许抛出异常 + */ + V call() throws Exception; +} + +@FunctionalInterface +public interface Runnable { + /** + * 没有返回值，不能继续上抛异常 + */ + public abstract void run(); +} + +``` + +看下demo代码吧，这样应该好理解一点哈~ +``` +/* + * @Author 捡田螺的小男孩 + * @date 2020-08-18 + */ +public class CallableRunnableTest { + + public static void main(String[] args) { + ExecutorService executorService = Executors.newFixedThreadPool(5); + + Callable callable =new Callable() { + @Override + public String call() throws Exception { + return "你好，callable"; + } + }; + + //支持泛型 + Future futureCallable = executorService.submit(callable); + + try { + System.out.println(futureCallable.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + + Runnable runnable = new Runnable() { + @Override + public void run() { + System.out.println("你好呀,runnable"); + } + }; + + Future futureRunnable = executorService.submit(runnable); + try { + System.out.println(futureRunnable.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + executorService.shutdown(); + + } +} +``` +运行结果： +``` +你好，callable +你好呀,runnable +null +``` + + +### 16、wait(),notify()和suspend(),resume()之间的区别 + +- wait() 使得线程进入阻塞等待状态，并且释放锁 +- notify()唤醒一个处于等待状态的线程，它一般跟wait（）方法配套使用。 +- suspend()使得线程进入阻塞状态，并且不会自动恢复，必须对应的resume() 被调用，才能使得线程重新进入可执行状态。suspend()方法很容易引起死锁问题。 +- resume()方法跟suspend()方法配套使用。 + +**suspend()不建议使用**,suspend()方法在调用后，线程不会释放已经占有的资源（比如锁），而是占有着资源进入睡眠状态，这样容易引发死锁问题。 + + +### 17.Condition接口及其实现原理 +- Condition接口与Object监视器方法对比 +- Condition接口使用demo +- Condition实现原理 + +#### Condition接口与Object监视器方法对比 +Java对象（Object），提供wait()、notify()，notifyAll() 系列方法，配合synchronized，可以实现等待/通知模式。而Condition接口配合Lock，通过await(),signal(),signalAll() 等方法，也可以实现类似的等待/通知机制。 + +| 对比项 | 对象监视方法| Condition | +|-----|-----|------| +| 前置条件 | 获得对象的锁 | 调用Lock.lock()获取锁,调用Lock.newCondition()获得Condition对象| +| 调用方式 | 直接调用，object.wait() | 直接调用，condition.await() | +| 等待队列数 | 1个 | 多个 | +| 当前线程释放锁并进入等待状态 | 支持 | 支持 | +| 在等待状态中不响应中断 | 不支持 | 支持 | +| 当前线程释放锁并进入超时等待状态| 支持 | 支持 | +| 当前线程释放锁并进入等待状态到将来的某个时间| 不支持 | 支持 | +| 唤醒等待队列中的一个线程| 支持 | 支持 | +| 唤醒等待队列中的全部线程| 支持 | 支持 | + + +#### Condition接口使用demo +``` +public class ConditionTest { + Lock lock = new ReentrantLock(); + Condition condition = lock.newCondition(); + + public void conditionWait() throws InterruptedException { + lock.lock(); + try { + condition.await(); + } finally { + lock.unlock(); + } + } + + public void conditionSignal() throws InterruptedException { + lock.lock(); + try { + condition.signal(); + } finally { + lock.unlock(); + } + } +} + +``` +#### Condition实现原理 +其实，同步队列和等待队列中节点类型都是同步器的静态内部类 AbstractQueuedSynchronizer.Node，接下来我们图解一下Condition的实现原理~ + +**等待队列的基本结构图** +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a6f62d7c11ea4907b84924c4a02cee7f~tplv-k3u1fbpfcp-zoom-1.image) +> 一个Condition包含一个等待队列，Condition拥有首节点（firstWaiter）和尾节点（lastWaiter）。当前线程调用Condition.await()方法，将会以当前线程构造节点，并将节点从尾部加入等待队 + +**AQS 结构图** + +ConditionI是跟Lock一起结合使用的，底层跟同步器（AQS）相关。同步器拥有一个同步队列和多个等待队列~ +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f342c548da8c42d6a60a0c19aeee8489~tplv-k3u1fbpfcp-zoom-1.image) + + +**等待** + +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/677bf2a7edd8447b9f21e626e6667aa3~tplv-k3u1fbpfcp-zoom-1.image) +> 当调用await()方法时，相当于同步队列的首节点（获取了锁的节点）移动到Condition的等待队列中。 + + +**通知** + +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/bac0705fa308413b97eed7a9d8b938c6~tplv-k3u1fbpfcp-zoom-1.image) +> 调用Condition的signal()方法，将会唤醒在等待队列中等待时间最长的节点（首节点），在 +唤醒节点之前，会将节点移到同步队列中。 + + +### 18、线程池如何调优，最大数目如何确认？ + +在《Java Concurrency in Practice》一书中，有一个评估线程池线程大小的公式 +> **Nthreads=Ncpu*Ucpu*(1+w/c)** +> +> - Ncpu = CPU总核数 +- Ucpu =cpu使用率，0~1 +- W/C=等待时间与计算时间的比率 + +假设cpu 100%运转，则公式为 +``` +Nthreads=Ncpu*(1+w/c) +``` + +**估算的话，酱紫：** +- 如果是**IO密集型应用**（如数据库数据交互、文件上传下载、网络数据传输等等），IO操作一般比较耗时，等待时间与计算时间的比率（w/c）会大于1，所以最佳线程数估计就是 Nthreads=Ncpu*（1+1）= 2Ncpu 。 +- 如果是**CPU密集型应用**（如算法比较复杂的程序），最理想的情况，没有等待，w=0，Nthreads=Ncpu。又对于计算密集型的任务，在拥有N个处理器的系统上，当线程池的大小为N+1时，通常能实现最优的效率。所以 Nthreads = Ncpu+1 + +有具体指参考呢？举个例子 +> 比如平均每个线程CPU运行时间为0.5s，而线程等待时间（非CPU运行时间，比如IO）为1.5s，CPU核心数为8，那么根据上面这个公式估算得到：线程池大小=(1+1.5/05)*8 =32。 + +参考了网上这篇文章，写得很棒，有兴趣的朋友可以去看一下哈： +- [根据CPU核心数确定线程池并发线程数](https://www.cnblogs.com/dennyzhangdd/p/6909771.html) + +### 19、假设有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？ + +可以使用**join方法**解决这个问题。比如在线程A中，调用线程B的join方法表示的意思就是**：A等待B线程执行完毕后（释放CPU执行权），在继续执行。** + +代码如下： +``` +public class ThreadTest { + + public static void main(String[] args) { + + Thread spring = new Thread(new SeasonThreadTask("春天")); + Thread summer = new Thread(new SeasonThreadTask("夏天")); + Thread autumn = new Thread(new SeasonThreadTask("秋天")); + + try + { + //春天线程先启动 + spring.start(); + //主线程等待线程spring执行完，再往下执行 + spring.join(); + //夏天线程再启动 + summer.start(); + //主线程等待线程summer执行完，再往下执行 + summer.join(); + //秋天线程最后启动 + autumn.start(); + //主线程等待线程autumn执行完，再往下执行 + autumn.join(); + } catch (InterruptedException e) + { + e.printStackTrace(); + } + } +} + +class SeasonThreadTask implements Runnable{ + + private String name; + + public SeasonThreadTask(String name){ + this.name = name; + } + + @Override + public void run() { + for (int i = 1; i <4; i++) { + System.out.println(this.name + "来了: " + i + "次"); + try { + Thread.sleep(100); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } +} + +``` + +运行结果： +``` +春天来了: 1次 +春天来了: 2次 +春天来了: 3次 +夏天来了: 1次 +夏天来了: 2次 +夏天来了: 3次 +秋天来了: 1次 +秋天来了: 2次 +秋天来了: 3次 +``` +### 20. LockSupport作用是？ + +- LockSupport作用 +- park和unpark，与wait，notify的区别 +- Object blocker作用？ + +LockSupport是个工具类，它的主要作用是挂起和唤醒线程，该工具类是创建锁和其他同步类的基础。 + +``` +public static void park(); //挂起当前线程，调用unpark(Thread thread)或者当前线程被中断，才能从park方法返回 +public static void parkNanos(Object blocker, long nanos); // 挂起当前线程，有超时时间的限制 +public static void parkUntil(Object blocker, long deadline); // 挂起当前线程，直到某个时间 +public static void park(Object blocker); //挂起当前线程 +public static void unpark(Thread thread); // 唤醒当前thread线程 +``` + +看个例子吧： +``` +public class LockSupportTest { + + public static void main(String[] args) { + + CarThread carThread = new CarThread(); + carThread.setName("劳斯劳斯"); + carThread.start(); + + try { + Thread.currentThread().sleep(2000); + carThread.park(); + Thread.currentThread().sleep(2000); + carThread.unPark(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + static class CarThread extends Thread{ + + private boolean isStop = false; + + @Override + public void run() { + + System.out.println(this.getName() + "正在行驶中"); + + while (true) { + + if (isStop) { + System.out.println(this.getName() + "车停下来了"); + LockSupport.park(); //挂起当前线程 + } + System.out.println(this.getName() + "车还在正常跑"); + + try { + Thread.sleep(1000L); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + } + } + + public void park() { + isStop = true; + System.out.println("停车啦，检查酒驾"); + + } + + public void unPark(){ + isStop = false; + LockSupport.unpark(this); //唤醒当前线程 + System.out.println("老哥你没酒驾，继续开吧"); + } + + } +} + +``` +运行结果： +``` +劳斯劳斯正在行驶中 +劳斯劳斯车还在正常跑 +劳斯劳斯车还在正常跑 +停车啦，检查酒驾 +劳斯劳斯车停下来了 +老哥你没酒驾，继续开吧 +劳斯劳斯车还在正常跑 +劳斯劳斯车还在正常跑 +劳斯劳斯车还在正常跑 +劳斯劳斯车还在正常跑 +劳斯劳斯车还在正常跑 +劳斯劳斯车还在正常跑 +``` + +LockSupport的park和unpark的实现，有点类似wait和notify的功能。但是 +> - park不需要获取对象锁 +> - 中断的时候park不会抛出InterruptedException异常，需要在park之后自行判断中断状态 +> - 使用park和unpark的时候，可以不用担心park的时序问题造成死锁 +> - LockSupport不需要在同步代码块里 +> - unpark却可以唤醒一个指定的线程，notify只能随机选择一个线程唤醒 + +Object blocker作用？ +> 方便在线程dump的时候看到具体的阻塞对象的信息。 + +### 公众号 +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/07e9fd0521c244adab8556fee99a2011~tplv-k3u1fbpfcp-zoom-1.image) + + +### 参考与感谢 +- 《java并发编程的艺术》 +- [杂谈什么是伪共享（false sharing）？](https://juejin.im/post/6844903841964507150) +- [根据CPU核心数确定线程池并发线程数](https://www.cnblogs.com/dennyzhangdd/p/6909771.html) +- [LockSupport的用法及原理](https://www.jianshu.com/p/f1f2cd289205) +- [探讨缓存行与伪共享](https://mp.weixin.qq.com/s/f9CTFc4H9Q0x4K-02beUoQ) From 75ddfe38df8837c482e54d6da4ab24f4bc59f1ee Mon Sep 17 00:00:00 2001 From: whx123 <327658337@qq.com> Date: Tue, 1 Sep 2020 08:54:52 +0800 Subject: [PATCH 18/77] =?UTF-8?q?zookeeper=E5=8D=81=E4=BA=8C=E8=BF=9E?= =?UTF-8?q?=E9=97=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...27\344\272\206\345\230\233\357\274\237.md" | 298 ++++++++++++++++++ 1 file changed, 298 insertions(+) create mode 100644 "Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/zookeeper/ZooKeeper\347\232\204\345\215\201\344\272\214\350\277\236\351\227\256\357\274\214\344\275\240\351\241\266\345\276\227\344\272\206\345\230\233\357\274\237.md" diff --git "a/Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/zookeeper/ZooKeeper\347\232\204\345\215\201\344\272\214\350\277\236\351\227\256\357\274\214\344\275\240\351\241\266\345\276\227\344\272\206\345\230\233\357\274\237.md" "b/Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/zookeeper/ZooKeeper\347\232\204\345\215\201\344\272\214\350\277\236\351\227\256\357\274\214\344\275\240\351\241\266\345\276\227\344\272\206\345\230\233\357\274\237.md" new file mode 100644 index 0000000..4504b5e --- /dev/null +++ "b/Java\351\235\242\350\257\225\351\242\230\351\233\206\347\273\223\345\217\267/zookeeper/ZooKeeper\347\232\204\345\215\201\344\272\214\350\277\236\351\227\256\357\274\214\344\275\240\351\241\266\345\276\227\344\272\206\345\230\233\357\274\237.md" @@ -0,0 +1,298 @@ +## 前言 +一线大厂ZooKeeper的十二连问，你顶得了嘛？ + +本文已经收录到github +> https://github.com/whx123/JavaHome + +### 1. 面试官：工作中使用过Zookeeper嘛？你知道它是什么，有什么用途呢？ + +**小菜鸡的我：** + +- 有使用过的，使用ZooKeeper作为**dubbo的注册中心**，使用ZooKeeper实现**分布式锁**。 +- ZooKeeper，它是一个开放源码的**分布式协调服务**，它是一个集群的管理者，它将简单易用的接口提供给用户。 +- 可以基于Zookeeper 实现诸如数据发布/订阅、负载均衡、命名服务、分布式协调/通知、集群管理、Master 选举、分布式锁和分布式队列**等功能**。 +- Zookeeper的**用途**：命名服务、配置管理、集群管理、分布式锁、队列管理 + +用途跟功能不是一个意思咩？给我一个眼神，让我自己体会 +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/fa22060efba341a391c1ef9ead212e95~tplv-k3u1fbpfcp-zoom-1.image) + +### 2. 面试官：说下什么是命名服务，什么是配置管理，又什么是集群管理吧 + +**小菜鸡的我(幸好我刷过面试题)，无所畏惧** +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/49f59ab796684aed93b0c6f1b6cade91~tplv-k3u1fbpfcp-zoom-1.image) + - **命名服务就是**： + > 命名服务是指通过**指定的名字**来获取资源或者服务地址。Zookeeper可以创建一个**全局唯一的路径**，这个路径就可以作为一个名字。被命名的实体可以是**集群中的机器，服务的地址，或者是远程的对象**等。一些分布式服务框架（RPC、RMI）中的服务地址列表，通过使用命名服务，客户端应用能够根据特定的名字来获取资源的实体、服务地址和提供者信息等。 + + - **配置管理：** ： + > 实际项目开发中，我们经常使用.properties或者xml需要配置很多信息，如数据库连接信息、fps地址端口等等。因为你的程序一般是分布式部署在不同的机器上（如果你是单机应用当我没说），如果把程序的这些配置信息**保存在zk的znode节点**下，当你要修改配置，即znode会发生变化时，可以通过改变zk中某个目录节点的内容，利用**watcher通知给各个客户端**，从而更改配置。 + +- **集群管理** +> 集群管理包括集群监控和集群控制，其实就是监控集群机器状态，剔除机器和加入机器。zookeeper可以方便集群机器的管理，它可以实时监控znode节点的变化，一旦发现有机器挂了，该机器就会与zk断开连接，对用的临时目录节点会被删除，其他所有机器都收到通知。新机器加入也是类似酱紫，所有机器收到通知：有新兄弟目录加入啦。 + + +### 3. 面试官：你提到了znode节点，那你知道znode有几种类型呢？zookeeper的数据模型是怎样的呢？ + +**小菜鸡的我（我先想想）：** + +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/fc8d387fe5764ecca82917190801bf66~tplv-k3u1fbpfcp-zoom-1.image) + +#### zookeeper的数据模型 +ZooKeeper的视图数据结构，很像Unix文件系统，也是树状的，这样可以确定每个路径都是唯一的。zookeeper的节点统一叫做**znode**，它是可以通过**路径来标识**，结构图如下： +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8d7058978e614f7f8ee4832cb3b9c7cb~tplv-k3u1fbpfcp-zoom-1.image) + +#### znode的4种类型 +根据节点的生命周期，znode可以分为4种类型，分别是持久节点（PERSISTENT）、持久顺序节点（PERSISTENT_SEQUENTIAL）、临时节点（EPHEMERAL）、临时顺序节点（EPHEMERAL_SEQUENTIAL） + +- 持久节点（PERSISTENT） +> 这类节点被创建后，就会一直存在于Zk服务器上。直到手动删除。 + +- 持久顺序节点（PERSISTENT_SEQUENTIAL） +> 它的基本特性同持久节点，不同在于增加了顺序性。父节点会维护一个自增整性数字，用于子节点的创建的先后顺序。 + +- 临时节点（EPHEMERAL） +> 临时节点的生命周期与客户端的会话绑定，一旦客户端会话失效（非TCP连接断开），那么这个节点就会被自动清理掉。zk规定临时节点只能作为叶子节点。 + +- 临时顺序节点（EPHEMERAL_SEQUENTIAL） +> 基本特性同临时节点，添加了顺序的特性。 + +### 4、面试官：你知道znode节点里面存储的是什么吗？每个节点的数据最大不能超过多少呢？ +**小菜鸡的我：** +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/92a4f38edb734cd195a2cae0e00a1d7a~tplv-k3u1fbpfcp-zoom-1.image) +#### znode节点里面存储的是什么？ + +Znode数据节点的代码如下 +``` +public class DataNode implements Record { + byte data[]; + Long acl; + public StatPersisted stat; + private Set children = null; +} +``` +哈哈，Znode包含了**存储数据、访问权限、子节点引用、节点状态信息**，如图： +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/91b23e62a6424ae2848a050556ed34df~tplv-k3u1fbpfcp-zoom-1.image) + +- **data:** znode存储的业务数据信息 +- **ACL:** 记录客户端对znode节点的访问权限，如IP等。 +- **child:** 当前节点的子节点引用 +- **stat:** 包含Znode节点的状态信息，比如**事务id、版本号、时间戳**等等。 + + +#### 每个节点的数据最大不能超过多少呢 + +为了保证高吞吐和低延迟，以及数据的一致性，znode只适合存储非常小的数据，不能超过1M，最好都小于1K。 + + +### 5、面试官：你知道znode节点上的监听机制嘛？讲下Zookeeper watch机制吧。 +**小菜鸡的我：** + +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/fd8dc23431b24ec38fcd5b142d4ff453~tplv-k3u1fbpfcp-zoom-1.image) +- Watcher机制 +- 监听机制的工作原理 +- Watcher特性总结 + +#### Watcher监听机制 +Zookeeper 允许客户端向服务端的某个Znode注册一个Watcher监听，当服务端的一些指定事件触发了这个Watcher，服务端会向指定客户端发送一个事件通知来实现分布式的通知功能，然后客户端根据 Watcher通知状态和事件类型做出业务上的改变。 +> 可以把Watcher理解成客户端注册在某个Znode上的触发器，当这个Znode节点发生变化时（增删改查），就会触发Znode对应的注册事件，注册的客户端就会收到异步通知，然后做出业务的改变。 + +#### Watcher监听机制的工作原理 +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/9477e0dada834eee9a997313a14a963b~tplv-k3u1fbpfcp-zoom-1.image) + +- ZooKeeper的Watcher机制主要包括客户端线程、客户端 WatcherManager、Zookeeper服务器三部分。 +- 客户端向ZooKeeper服务器注册Watcher的同时，会将Watcher对象存储在客户端的WatchManager中。 +- 当zookeeper服务器触发watcher事件后，会向客户端发送通知，客户端线程从 WatcherManager 中取出对应的 Watcher 对象来执行回调逻辑。 + +#### Watcher特性总结 +- **一次性：**一个Watch事件是一个一次性的触发器。一次性触发，客户端只会收到一次这样的信息。 +- **异步的: ** Zookeeper服务器发送watcher的通知事件到客户端是异步的，不能期望能够监控到节点每次的变化，Zookeeper只能保证最终的一致性，而无法保证强一致性。 +- **轻量级：** Watcher 通知非常简单，它只是通知发生了事件，而不会传递事件对象内容。 +- **客户端串行：** 执行客户端 Watcher 回调的过程是一个串行同步的过程。 +- 注册 watcher用getData、exists、getChildren方法 +- 触发 watcher用create、delete、setData方法 + + +### 6、面试官：你对Zookeeper的数据结构都有一定了解，那你讲下Zookeeper的特性吧 +**小菜鸡的我：（我背过书，啊哈哈）** +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/975294fd4807485e87adcb50f37fdc26~tplv-k3u1fbpfcp-zoom-1.image) +Zookeeper 保证了如下分布式一致性特性： +- **顺序一致性**：从同一客户端发起的事务请求，最终将会严格地按照顺序被应用到 ZooKeeper 中去。 +- **原子性**：所有事务请求的处理结果在整个集群中所有机器上的应用情况是一致的，也就是说，要么整个集群中所有的机器都成功应用了某一个事务，要么都没有应用。 +- **单一视图**：无论客户端连到哪一个 ZooKeeper 服务器上，其看到的服务端数据模型都是一致的。 +- **可靠性：** 一旦服务端成功地应用了一个事务，并完成对客户端的响应，那么该事务所引起的服务端状态变更将会被一直保留下来。 +- **实时性（最终一致性）：** Zookeeper 仅仅能保证在一定的时间段内，客户端最终一定能够从服务端上读取到最新的数据状态。 + +### 7、面试官：你刚提到顺序一致性，那zookeeper是如何保证事务的顺序一致性的呢？ +**小菜鸡的我：（完蛋了这题不会）** +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/cb1eac96fd474f8e8e2317b6bf8b0641~tplv-k3u1fbpfcp-zoom-1.image) + +这道题可以看下这篇文章（本题答案来自该文章）：[聊一聊ZooKeeper的顺序一致性](https://time.geekbang.org/column/article/239261) +> 需要了解事务ID，即zxid。ZooKeeper的在选举时通过比较各结点的zxid和机器ID选出新的主结点的。zxid由Leader节点生成，有新写入事件时，Leader生成新zxid并随提案一起广播，每个结点本地都保存了当前最近一次事务的zxid，zxid是递增的，所以谁的zxid越大，就表示谁的数据是最新的。 + +ZXID的生成规则如下： +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ea46600cd60d462ca982c60fa854419b~tplv-k3u1fbpfcp-zoom-1.image) + +ZXID有两部分组成： + +- 任期：完成本次选举后，直到下次选举前，由同一Leader负责协调写入； +- 事务计数器：单调递增，每生效一次写入，计数器加一。 + +> ZXID的低32位是计数器，所以同一任期内，ZXID是连续的，每个结点又都保存着自身最新生效的ZXID，通过对比新提案的ZXID与自身最新ZXID是否相差“1”，来保证事务严格按照顺序生效的。 + +### 8、面试官：你提到了Leader，你知道Zookeeper的服务器有几种角色嘛？Zookeeper下Server工作状态又有几种呢？ + +**小菜鸡的我：** +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5b965992267c4fcbbaca532089548cad~tplv-k3u1fbpfcp-zoom-1.image) + +#### Zookeeper 服务器角色 +Zookeeper集群中，有Leader、Follower和Observer三种角色 + +**Leader** + +> Leader服务器是整个ZooKeeper集群工作机制中的核心，其主要工作： +- 事务请求的唯一调度和处理者，保证集群事务处理的顺序性 +- 集群内部各服务的调度者 + +**Follower** + +> Follower服务器是ZooKeeper集群状态的跟随者，其主要工作： +- 处理客户端非事务请求，转发事务请求给Leader服务器 +- 参与事务请求Proposal的投票 +- 参与Leader选举投票 + +**Observer** +> Observer是3.3.0 版本开始引入的一个服务器角色，它充当一个观察者角色——观察ZooKeeper集群的最新状态变化并将这些状态变更同步过来。其工作： +- 处理客户端的非事务请求，转发事务请求给 Leader 服务器 +- 不参与任何形式的投票 + + +#### Zookeeper下Server工作状态 +> 服务器具有四种状态，分别是 LOOKING、FOLLOWING、LEADING、OBSERVING。 +- 1.LOOKING：寻找Leader状态。当服务器处于该状态时，它会认为当前集群中没有 Leader，因此需要进入 Leader 选举状态。 +- 2.FOLLOWING：跟随者状态。表明当前服务器角色是Follower。 +- 3.LEADING：领导者状态。表明当前服务器角色是Leader。 +- 4.OBSERVING：观察者状态。表明当前服务器角色是Observer。 + + +### 9、面试官：你说到服务器角色是基于ZooKeeper集群的，那你画一下ZooKeeper集群部署图吧？ZooKeeper是如何保证主从节点数据一致性的呢？ +**小菜鸡的我：** +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/2037f26385ef479281e004084f1cd8da~tplv-k3u1fbpfcp-zoom-1.image) +#### ZooKeeper集群部署图 +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/6cf565bd494b4262baee09cfadfee24d~tplv-k3u1fbpfcp-zoom-1.image) +ZooKeeper集群是一主多从的结构： +- 如果是写入数据，先写入主服务器（主节点），再通知从服务器。 +- 如果是读取数据，既读主服务器的，也可以读从服务器的。 + +#### ZooKeeper如何保证主从节点数据一致性 +我们知道集群是主从部署结构，要保证主从节点一致性问题，无非就是两个主要问题： +- **主服务器挂了，或者重启了** +- **主从服务器之间同步数据**~ + +Zookeeper是采用ZAB协议（Zookeeper Atomic Broadcast，Zookeeper原子广播协议）来保证主从节点数据一致性的，ZAB协议支持**崩溃恢复和消息广播**两种模式，很好解决了这两个问题： +- 崩溃恢复：Leader挂了，进入该模式，选一个新的leader出来 +- 消息广播：把更新的数据，从Leader同步到所有Follower + +> Leader服务器挂了，所有集群中的服务器进入LOOKING状态，首先，它们会选举产生新的Leader服务器；接着，新的Leader服务器与集群中Follower服务进行数据同步，当集群中超过半数机器与该 Leader服务器完成数据同步之后，退出恢复模式进入消息广播模式。Leader 服务器开始接收客户端的事务请求生成事务Proposal进行事务请求处理。 + +### 10、面试官：Leader挂了，进入崩溃恢复，是如何选举Leader的呢？你讲一下ZooKeeper选举机制吧 +**小菜鸡的我：** +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/de58c6ae02c04f008b6abad08178fcb9~tplv-k3u1fbpfcp-zoom-1.image) + +服务器启动或者服务器运行期间（Leader挂了），都会进入Leader选举，我们来看一下~假设现在ZooKeeper集群有五台服务器，它们myid分别是服务器1、2、3、4、5，如图： +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1b578b765d4b4500a83d7ad63bb35e2f~tplv-k3u1fbpfcp-zoom-1.image) +#### 服务器启动的Leader选举 + +zookeeper集群初始化阶段，服务器（myid=1-5）**依次**启动，开始zookeeper选举Leader~ +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5791e745136d4da18aa4254e7c116f23~tplv-k3u1fbpfcp-zoom-1.image) +- 服务器1（myid=1）启动，当前只有一台服务器，无法完成Leader选举 +- 服务器2（myid=2）启动，此时两台服务器能够相互通讯，开始进入Leader选举阶段 +> 1. 每个服务器发出一个投票 +> > 服务器1 和服务器2都将自己作为Leader服务器进行投票，投票的基本元素包括：服务器的myid和ZXID，我们以（myid，ZXID）形式表示。初始阶段，服务器1和服务器2都会投给自己，即服务器1的投票为（1,0），服务器2的投票为（2,0），然后各自将这个投票发给集群中的其他所有机器。 +> 2. 接受来自各个服务器的投票 +> > 每个服务器都会接受来自其他服务器的投票。同时，服务器会校验投票的有效性，是否本轮投票、是否来自LOOKING状态的服务器。 +> 3. 处理投票 +>> 收到其他服务器的投票，会将被人的投票跟自己的投票PK，PK规则如下： +>>> - 优先检查ZXID。ZXID比较大的服务器优先作为leader。 +>>> - 如果ZXID相同的话，就比较myid，myid比较大的服务器作为leader。 +>> 服务器1的投票是（1,0），它收到投票是（2,0），两者zxid都是0，因为收到的myid=2，大于自己的myid=1，所以它更新自己的投票为（2,0），然后重新将投票发出去。对于服务器2呢，即不再需要更新自己的投票，把上一次的投票信息发出即可。 +> 4. 统计投票 +>> 每次投票后，服务器会统计所有投票，判断是否有过半的机器接受到相同的投票信息。服务器2收到两票，少于3（n/2+1,n为总服务器），所以继续保持LOOKING状态 +- 服务器3（myid=3）启动，继续进入Leader选举阶段 +> 跟前面流程一致，服务器1和2先投自己一票，因为服务器3的myid最大，所以大家把票改投给它。此时，服务器为3票（大于等于n/2+1）,所以服务器3当选为Leader。服务器1，2更改状态为FOLLOWING，服务器3更改状态为LEADING； +- 服务器4启动，发起一次选举。 +> 此时服务器1，2，3已经不是LOOKING状态，不会更改选票信息。选票信息结果：服务器3为4票，服务器4为1票。服务器4并更改状态为FOLLOWING； +- 服务器5启动，发起一次选举。 +> 同理，服务器也是把票投给服务器3，服务器5并更改状态为FOLLOWING； +- 投票结束，服务器3当选为Leader + + +#### 服务器运行期间的Leader选举 + +zookeeper集群的五台服务器（myid=1-5）正在运行中，突然某个瞬间，Leader服务器3挂了，这时候便开始Leader选举~ +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c974c58e0d4842cf8c7ef59d9fb28af2~tplv-k3u1fbpfcp-zoom-1.image) + +- 1.变更状态 +> Leader 服务器挂了之后，余下的非Observer服务器都会把自己的服务器状态更改为LOOKING，然后开始进入Leader选举流程。 +- 2.每个服务器发起投票 +> 每个服务器都把票投给自己，因为是运行期间，所以每台服务器的ZXID可能不相同。假设服务1,2,4,5的zxid分别为333,666,999,888，则分别产生投票（1,333），（2，666），（4,999）和（5,888），然后各自将这个投票发给集群中的其他所有机器。 +- 3.接受来自各个服务器的投票 +- 4.处理投票 +> 投票规则是跟Zookeeper集群启动期间一致的，优先检查ZXID，大的优先作为Leader，所以显然服务器zxid=999具有优先权。 +- 5.统计投票 +- 6.改变服务器状态 + +### 11、面试官：你前面提到在项目中使用过Zookeeper的分布式锁，讲一下zk分布式锁的实现原理吧？ +**小菜鸡的我：** +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/84050ae342c040b69f657cabf2359a07~tplv-k3u1fbpfcp-zoom-1.image) +Zookeeper就是使用临时顺序节点特性实现分布式锁的。 +- 获取锁过程（创建临时节点，检查序号最小） +- 释放锁（删除临时节点，监听通知） + +#### 获取锁过程 + +- 当第一个客户端请求过来时，Zookeeper客户端会创建一个持久节点/locks。如果它（Client1）想获得锁，需要在locks节点下创建一个顺序节点lock1.如图 +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/39e5ee84f901453fb894600c331693d6~tplv-k3u1fbpfcp-zoom-1.image) +- 接着，客户端Client1会查找locks下面的所有临时顺序子节点，判断自己的节点lock1是不是排序最小的那一个，如果是，则成功获得锁。 +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e958178a196742b480a20dff85dfef4f~tplv-k3u1fbpfcp-zoom-1.image) +- 这时候如果又来一个客户端client2前来尝试获得锁，它会在locks下再创建一个临时节点lock2 +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/34a3a0f7221b4de79e1ed5595d7c177c~tplv-k3u1fbpfcp-zoom-1.image) +- 客户端client2一样也会查找locks下面的所有临时顺序子节点，判断自己的节点lock2是不是最小的，此时，发现lock1才是最小的，于是获取锁失败。获取锁失败，它是不会甘心的，client2向它排序靠前的节点lock1注册Watcher事件，用来监听lock1是否存在，也就是说client2抢锁失败进入等待状态。 +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a17880856e1546bba4f2571dbf8b3b38~tplv-k3u1fbpfcp-zoom-1.image) +- 此时，如果再来一个客户端Client3来尝试获取锁，它会在locks下再创建一个临时节点lock3 +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/abda17df527b4dbe8faa7e3a3a9e859e~tplv-k3u1fbpfcp-zoom-1.image) +- 同样的，client3一样也会查找locks下面的所有临时顺序子节点，判断自己的节点lock3是不是最小的，发现自己不是最小的，就获取锁失败。它也是不会甘心的，它会向在它前面的节点lock2注册Watcher事件，以监听lock2节点是否存在。 +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5a8725119723434daddca761b0d7be83~tplv-k3u1fbpfcp-zoom-1.image) + +#### 释放锁 + +我们再来看看释放锁的流程，zookeeper的**客户端业务完成或者故障**，都会删除临时节点，释放锁。如果是任务完成，Client1会显式调用删除lock1的指令 +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ecf2bec179f64ef79b180f66a327e634~tplv-k3u1fbpfcp-zoom-1.image) +如果是客户端故障了，根据临时节点得特性，lock1是会自动删除的 +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e87703be60a3407e9e570c86bd4c180d~tplv-k3u1fbpfcp-zoom-1.image) +lock1节点被删除后，Client2可开心了，因为它一直监听着lock1。lock1节点删除，Client2立刻收到通知，也会查找locks下面的所有临时顺序子节点，发下lock2是最小，就获得锁。 +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/be3c7146f2934dd69a598cdf974ab390~tplv-k3u1fbpfcp-zoom-1.image) + +同理，Client2获得锁之后，Client3也对它虎视眈眈，啊哈哈~ + +### 12. 面试官：好的，最后一道题，你说说dubbo和Zookeeper的关系吧，为什么选择Zookeeper作为注册中心？ +小菜鸡的我（答了这么多道题，不会还不给我过吧？）： +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/fd81e6dd9b0a40f9811c98e3c8e3a424~tplv-k3u1fbpfcp-zoom-1.image) + +dubbo的注册中心可以选Zookeeper，memcached，redis等。为什么选择Zookeeper，因为它的功能特性咯~ +- 命名服务，服务提供者向Zookeeper指定节点写入url，完成服务发布。 +- 负载均衡，注册中心的承载能力有限，而Zookeeper集群配合web应用很容易达到负载均衡。 +- zk支持监听事件，特别适合发布/订阅的场景，dubbo的生产者和消费者就类似这场景。 +- 数据模型简单，数据存在内存，可谓高性能 +- Zookeeper其他特点都可以搬出来讲一下~ + + +### 个人公众号 +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e6b23c704fc94ca09207b779f953cce6~tplv-k3u1fbpfcp-zoom-1.image) + +### 参考与感谢 +- [zookeeper面试题](https://segmentfault.com/a/1190000014479433) +- [28道进阶必备ZooKeeper面试真题（建议收藏！）](https://zhuanlan.zhihu.com/p/102168788) +- [漫画：什么是ZooKeeper？](https://juejin.im/post/6844903608685707271) +- [聊一聊ZooKeeper的顺序一致性](https://time.geekbang.org/column/article/239261) +- [Zookeeper——一致性协议:Zab协议](https://www.jianshu.com/p/2bceacd60b8a) +- [Zookeeper的选举机制原理（图文深度讲解）](https://blog.csdn.net/wx1528159409/article/details/84622762) +- [漫画：如何用Zookeeper实现分布式锁？](https://mp.weixin.qq.com/s/u8QDlrDj3Rl1YjY4TyKMCA) From f21ffbce27712a766b15ab69c5416ae117d4d057 Mon Sep 17 00:00:00 2001 From: whx123 <327658337@qq.com> Date: Sat, 19 Sep 2020 13:24:11 +0800 Subject: [PATCH 19/77] =?UTF-8?q?JDK=E6=96=B0=E7=89=B9=E6=80=A7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...70\346\226\260\347\211\271\346\200\247.md" | 1380 +++++++++++++++++ 1 file changed, 1380 insertions(+) create mode 100644 "Java\345\237\272\347\241\200\345\255\246\344\271\240/Java\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\345\237\272\347\241\200\357\274\232JDK 5-15\351\203\275\346\234\211\345\223\252\344\272\233\347\273\217\345\205\270\346\226\260\347\211\271\346\200\247.md" diff --git "a/Java\345\237\272\347\241\200\345\255\246\344\271\240/Java\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\345\237\272\347\241\200\357\274\232JDK 5-15\351\203\275\346\234\211\345\223\252\344\272\233\347\273\217\345\205\270\346\226\260\347\211\271\346\200\247.md" "b/Java\345\237\272\347\241\200\345\255\246\344\271\240/Java\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\345\237\272\347\241\200\357\274\232JDK 5-15\351\203\275\346\234\211\345\223\252\344\272\233\347\273\217\345\205\270\346\226\260\347\211\271\346\200\247.md" new file mode 100644 index 0000000..85cc926 --- /dev/null +++ "b/Java\345\237\272\347\241\200\345\255\246\344\271\240/Java\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\345\237\272\347\241\200\357\274\232JDK 5-15\351\203\275\346\234\211\345\223\252\344\272\233\347\273\217\345\205\270\346\226\260\347\211\271\346\200\247.md" @@ -0,0 +1,1380 @@ +### 前言 +JDK 15发布啦~ 我们一起回顾JDK 5-15 的新特性吧，大家一起学习哈~ + +本文已经收录到github +> https://github.com/whx123/JavaHome + +**公众号：捡田螺的小男孩** + +### Java 5 新特性 +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/03f5d66e89bb4cd49e85fbfd795f204d~tplv-k3u1fbpfcp-zoom-1.image) +#### 1. 泛型 +泛型本质是参数化类型，解决不确定具体对象类型的问题。 +``` + List strList=new ArrayList(); +``` +#### 2. 增强循环（for-each） +for-each循环简化了集合的遍历。 +``` +String [] str = {"关注","公众号","捡田螺的小男孩"}; +for (String temp:str) { + System.out.println(temp); +} +``` +#### 3. 自动封箱拆箱 +- 自动装箱: 就是将基本数据类型自动转换成对应的包装类。 +- 自动拆箱：就是将包装类自动转换成对应的基本数据类型。 + +包装类型有：Integer,Double,Float,Long,Short,Character和Boolean +``` +Integer i =666; //自动装箱 +int a= i; //自动拆箱 +``` + +#### 4. 枚举 +关键字enum可以将一组具名的值的有限集合创建为一种新的类型，而这些具名的值可以作为常规的程序组件使用，这就是枚举类型。 +``` +enum SeasonEnum { + SPRING,SUMMER,FALL,WINTER; +} +``` +#### 5. 可变参数 +我们在定义方法参数的时候不确定定义多少个，就可以定义为**可变参数**，它本质上是一个**数组**。 +``` +public static void main(String[] args) throws Exception { + String [] str = {"关注","公众号","捡田螺的小男孩"}; + testVarargs(str); + String str1 = "关注公众号，捡田螺的小男孩"; + testVarargs(str1); +} +//可变参数String... args +private static void testVarargs(String... args) { + for (String arg : args) { + System.out.println(arg); + } +} +``` +#### 6. 注解 +可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。 +``` +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.SOURCE) +public @interface Override { +} +``` + +#### 7.静态导入 +通过import static类，就可以使用类里的静态变量或方法。看一下例子哈~ +``` +import static java.lang.System.out; //静态导入System类的静态变量out +public class Test { + public static void main(String[] args) throws Exception { + String str1 = "关注公众号，捡田螺的小男孩"; + System.out.println(str1); //常规写法 + out.println(str1); //静态导入，可以直接使用out输出 + } +} +``` +#### 8. 线程并发库（JUC） +JDK5 丰富了线程处理功能，java.util.concurrent包提供了以下的类、接口： + +> - 线程池：ExecutorService接口 +> - 线程护斥：Lock 类 +> - 线程通信：Condition接口 +> - 同步队列：ArrayBlockingQueue类 +> - 同步集合：ConcurrentHashMap类 + + +### Java 6 新特性 +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a91df99e8eb948e7a208d7222eb162cf~tplv-k3u1fbpfcp-zoom-1.image) +#### 1.Desktop类和SystemTray类 +JDK 6在java.awt包下，新增了两个类：Desktop类和SystemTray类 +> - **Desktop类**: 用来打开系统默认浏览器浏览指定的URL,打开系统默认邮件客户端发邮件等 +> - **SystemTray类**:用来在系统托盘区创建一个托盘程序,如果在微软的Windows上，它被称为“任务栏”状态区域。 + +``` +//获取Desktop实例 +Desktop desktop = Desktop.getDesktop(); +desktop.browse(URI.create("https://www.baidu.com")); +``` + +#### 2. 使用JAXB2来实现对象与XML之间的映射 + JAXB,即Java Architecture for XML Binding,可以实现对象与XML之间的映射，常用注解如下: +> - @XmlRootElement：注解在类上面，对应xml的跟元素，使用name属性定义根节点的名称。 +> - @XmlElement：指定一个字段或get/set方法映射到xml的节点，使用name属性定义这个根节点的名称。 +> - @XmlAttribute：将JavaBean对象的属性映射为xml的属性,使用name属性为生成的xml属性指定别名。 +> - @XmlAccessorType:定义映射这个类中的何种类型都需要映射到xml。 +> - @XmlSchema: 将包映射到XML名称空间 + +**看个例子吧~** +``` +public class JAXB2XmlTest { + + public static void main(String[] args) throws JAXBException, IOException { + + List list = new ArrayList<>(); + list.add(new Singer("jay", 8)); + list.add(new Singer("eason", 10)); + + SingerList singerList = new SingerList(); + singerList.setSingers(list); + + String str = JAXB2XmlTest.beanToXml(singerList, SingerList.class); + String path = "C:\\jay.txt"; + BufferedWriter bfw = new BufferedWriter(new FileWriter(new File(path))); + bfw.write(str); + bfw.close(); + + } + + private static String beanToXml(Object obj, Class load) throws JAXBException { + JAXBContext context = JAXBContext.newInstance(load); + Marshaller marshaller = context.createMarshaller(); + marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); + marshaller.setProperty(Marshaller.JAXB_ENCODING, "GBK"); + StringWriter writer = new StringWriter(); + marshaller.marshal(obj,writer); + return writer.toString(); + } +} +public class Singer { + + private String name; + private int age; + public Singer(String name, int age) { + this.name = name; + this.age = age; + } + @XmlAttribute(name="name") + public String getName() { + return name; + } + public void setName(String name) { + this.name = name; + } + @XmlAttribute(name="age") + public int getAge() { + return age; + } + public void setAge(int age) { + this.age = age; + } +} +@XmlRootElement(name="list") +public class SingerList { + + private List singers; + + @XmlElement(name="singer") + public List getSingers() { + return singers; + } + + public void setSingers(List singers) { + this.singers = singers; + } +} +``` + +**运行效果：** +``` + + + + + +``` + +#### 3.轻量级 Http Server API +JDK 6中提供了简单的Http Server API，可以构建嵌入式Http服务器,同时支持Http和Https协议。HttpServer会调用HttpHandler实现类的回调方法来处理客户端请求,这里用户只需实现HttpHandler接口就可以了。 + +``` +/** + * 根据Java提供的API实现Http服务器 + */ +public class MyHttpServer { + + /** + * @param args + * @throws IOException + */ + public static void main(String[] args) throws IOException { + //创建HttpServer服务器 + HttpServer httpServer = HttpServer.create(new InetSocketAddress(8080), 10); + //将 /jay请求交给MyHandler处理器处理 + httpServer.createContext("/", new MyHandler()); + httpServer.start(); + } +} + +public class MyHandler implements HttpHandler { + + public void handle(HttpExchange httpExchange) throws IOException { + //请求头 + Headers headers = httpExchange.getRequestHeaders(); + Set>> entries = headers.entrySet(); + + StringBuffer response = new StringBuffer(); + for (Map.Entry> entry : entries){ + response.append(entry.toString() + "\n"); + } + //设置响应头属性及响应信息的长度 + httpExchange.sendResponseHeaders(200, response.length()); + //获得输出流 + OutputStream os = httpExchange.getResponseBody(); + os.write(response.toString().getBytes()); + os.close(); + } +} +``` +#### 4. 插入式注解处理API + +> JDK 6提供了插入式注解处理API，可以让我们定义的注解在编译期而不是运行期生效，从而可以在编译期修改字节码。lombok框架就是使用该特性来实现的，Lombok通过注解的方式，在编译时自动为属性生成构造器、getter/setter、equals、hashcode、toString等方法，大大简化了代码的开发。 + +#### 5. STAX +STAX，是JDK6中一种处理XML文档的API。 +``` +public class STAXTest { + + public static void main(String[] args) throws Exception { + + XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance(); + XMLEventReader xmlEventReader = xmlInputFactory.createXMLEventReader(new FileInputStream("C:\\jay.xml")); + XMLEvent event = null; + StringBuffer stringBuffer = new StringBuffer(); + while (xmlEventReader.hasNext()) { + event = xmlEventReader.nextEvent(); + stringBuffer.append(event.toString()); + } + System.out.println("xml文档解析结果："); + System.out.println(stringBuffer); + } +} +``` +**运行结果:** +``` +xml文档解析结果： + + + +ENDDOCUMENT +``` + +#### 6. Common Annotations +> Common annotations原本是Java EE 5.0(JSR 244)规范的一部分，现在SUN把它的一部分放到了Java SE 6.0中。随着Annotation元数据功能加入到Java SE 5.0里面，很多Java 技术都会用Annotation部分代替XML文件来配置运行参数。 + + 以下列举Common Annotations 1.0里面的几个Annotations: +- @Generated：用于标注生成的源代码 +- @Resource：用于标注所依赖的资源，容器据此注入外部资源依赖，有基于字段的注入和基于setter方法的注入两种方式。 +- @Resources：同时标注多个外部依赖，容器会把所有这些外部依赖注入 +- @PostConstruct：标注当容器注入所有依赖之后运行的方法，用来进行依赖注入后的初始化工作，只有一个方法可以标注为PostConstruct 。 +- @PreDestroy：当对象实例将要被从容器当中删掉之前，要执行的回调方法要标注为PreDestroy + +#### 7. Compiler API +javac编译器可以把.java的源文件编译为.class文件，JDK 6的新特性Compiler API(JSR 199)也可以动态编译Java源文件。 +``` +public class CompilerApiTest { + public static void main(String[] args) throws Exception { + JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler(); + StandardJavaFileManager standardJavaFileManager = javaCompiler.getStandardFileManager(null,null,null); + Iterable javaFileObjects = standardJavaFileManager.getJavaFileObjects("C:\\Singer.java"); + javaCompiler.getTask(null, standardJavaFileManager, null, null, null, javaFileObjects).call(); + standardJavaFileManager.close(); + } +} + +``` +运行结果：会在C目录生成Singer.class文件 + +#### 8. 对脚本语言的支持（如: ruby, groovy, javascript） +JDK6增加了对脚本语言的支持(JSR 223)，原理是将脚本语言编译成字节码，这样脚本语言也能享用Java平台的诸多优势，包括可移植性，安全等。JDK6实现包含了一个基于Mozilla Rhino的脚本语言引擎,因此可以支持javascript，当然JDK也支持ruby等其他语言 + +``` +public class JavaScriptTest { + + public static void main(String[] args) throws Exception { + ScriptEngineManager factory = new ScriptEngineManager(); + ScriptEngine engine = factory.getEngineByName("JavaScript"); + String script; + try { + script = "print('Hello')"; + engine.eval(script);// 执行脚本 + }catch (Exception e) { + e.printStackTrace(); + } + } +} +//output +Hello +``` +### Java 7 新特性 +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c52833f0793f4c0fadf77f172b016912~tplv-k3u1fbpfcp-zoom-1.image) +#### 1.switch 支持String字符串类型。 +``` +String singer = "jay"; +switch (singer) { + case "jay" : + System.out.println("周杰伦"); + break; + case "eason" : + System.out.println("陈奕迅"); + break ; + default : + System.out.println("其他"); + break ; + } +``` + +#### 2.try-with-resources，资源自动关闭 +JDK 7 之前: +``` +BufferedReader br = new BufferedReader(new FileReader("d:七里香.txt")); +try { + return br.readLine(); +} finally { + br.close(); +} +``` +JDK 7 之后： +``` +/* + * 声明在try括号中的对象称为资源，在方法执行完毕后会被自动关闭 + */ +try (BufferedReader br = new BufferedReader(new FileReader("d:七里香.txt")) { + return br.readLine(); +} +``` + +#### 3. 整数类型如（byte，short，int，long）能够用二进制来表示 +``` +//0b或者0B表示二进制 +int a = 0b010; +int b = 0B010; +``` +#### 4. 数字常量支持下划线 +``` +int a = 11_11;//a的值为1111，下划线不影响实际值，提升可读性 +``` + +#### 5. 泛型实例化类型自动推断,即”<>” +JDK 7 之前： +``` +Map> map = new HashMap>(); +``` +JDK 7之后： +``` +//不须声明类型,自动根据前面<>推断其类型 +Map> map = new HashMap<>(); +``` + +#### 6.一个catch中捕获多个异常类型，用（|）分隔开 +JDK 7之前 +``` +try{ + //do something +} catch (FirstException e) { + logger.error(e); +} catch (SecondException e) { + logger.error(ex); +} +``` +JDk 7之后 +``` +try{ + //do something +} catch (FirstException | SecondException e) { + logger.error(e); +} +``` +#### 7. 增强的文件系统 + +Java7 提供了全新的NIO2.0 API，方便文件管理的编码。如，可以在java.nio.file包下使用Path、Paths、Files、WatchService等常用类型。 + +``` +Path path = Paths.get("C:\\jay\\七里香.txt"); //创建Path对象 +byte[] bytes= Files.readAllBytes(path); //读取文件 +System.out.println(path.getFileName()); //获取当前文件名称 +System.out.println(path.toAbsolutePath()); // 获取文件绝对路径 +System.out.println(new String(bytes, "utf-8")); +``` + +#### 8. Fork/join 框架 +Java7提供的一个用于并行执行任务的框架，是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。 +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/823a548cf6d64cedb1dd507c5234788f~tplv-k3u1fbpfcp-zoom-1.image) + +Fork/join计算1-1000累加值： +``` +public class ForkJoinPoolTest { + + private static final Integer DURATION_VALUE = 100; + + static class ForkJoinSubTask extends RecursiveTask{ + + // 子任务开始计算的值 + private Integer startValue; + // 子任务结束计算的值 + private Integer endValue; + + private ForkJoinSubTask(Integer startValue , Integer endValue) { + this.startValue = startValue; + this.endValue = endValue; + } + + @Override + protected Integer compute() { + //小于一定值DURATION,才开始计算 + if(endValue - startValue < DURATION_VALUE) { + System.out.println("执行子任务计算：开始值 = " + startValue + ";结束值 = " + endValue); + Integer totalValue = 0; + for (int index = this.startValue; index <= this.endValue; index++) { + totalValue += index; + } + return totalValue; + } else { + // 将任务拆分，拆分成两个任务 + ForkJoinSubTask subTask1 = new ForkJoinSubTask(startValue, (startValue + endValue) / 2); + subTask1.fork(); + ForkJoinSubTask subTask2 = new ForkJoinSubTask((startValue + endValue) / 2 + 1 , endValue); + subTask2.fork(); + return subTask1.join() + subTask2.join(); + } + } + } + + public static void main(String[] args) throws ExecutionException, InterruptedException { + // Fork/Join框架的线程池 + ForkJoinPool pool = new ForkJoinPool(); + ForkJoinTask taskFuture = pool.submit(new ForkJoinSubTask(1,1000)); + + Integer result = taskFuture.get(); + System.out.println("累加结果是:" + result); + + } +} +``` +运行结果： +``` +... +执行子任务计算：开始值 = 189;结束值 = 250 +执行子任务计算：开始值 = 251;结束值 = 313 +执行子任务计算：开始值 = 314;结束值 = 375 +执行子任务计算：开始值 = 376;结束值 = 438 +执行子任务计算：开始值 = 439;结束值 = 500 +执行子任务计算：开始值 = 501;结束值 = 563 +执行子任务计算：开始值 = 564;结束值 = 625 +执行子任务计算：开始值 = 626;结束值 = 688 +执行子任务计算：开始值 = 689;结束值 = 750 +执行子任务计算：开始值 = 751;结束值 = 813 +执行子任务计算：开始值 = 814;结束值 = 875 +执行子任务计算：开始值 = 876;结束值 = 938 +执行子任务计算：开始值 = 939;结束值 = 1000 +累加结果是:500500 +``` + +### Java 8 新特性 + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5730671f3ef344bd89163eb4a3f9f710~tplv-k3u1fbpfcp-zoom-1.image) + +#### 1.lambada表达式 +Lambda 允许把函数作为一个方法的参数，传递到方法中 + +语法格式： +``` +(parameters) -> expression 或 (parameters) ->{ statements; } +``` +代码示例： +``` +Arrays.asList("jay", "Eason", "SHE").forEach( + ( String singer ) -> System.out.print( singer + ",") ); +``` + +#### 2. 函数式接口 +Lambda的设计者为了让现有的功能与Lambda表达式很好兼容，设计出函数式接口。 +- 函数式接口是指只有一个函数的接口，可以隐式转换为lambada表达式。 +- Java 8 提供了注解@FunctionalInterface，显示声明一个函数式接口。 +- java.lang.Runnable和java.util.concurrent.Callable是函数式接口的例子~ + +``` +@FunctionalInterface +public interface Runnable { + public abstract void run(); +} +``` + +#### 3. 方法引用 +方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。它与Lambda表达式配合使用，可以减少冗余代码，使代码更加简洁。 +``` +//利用函数式接口Consumer的accept方法实现打印，Lambda表达式如下 +Consumer consumer = x -> System.out.println(x); +consumer.accept("jay"); +//引用PrintStream类（也就是System.out的类型）的println方法，这就是方法引用 +consumer = System.out::println; +consumer.accept("关注公众号捡田螺的小男孩"); +``` + +#### 4. 默认方法 + + 默认方法就是一个在接口里面有了一个实现的方法。它允许将新方法添加到接口，但不强制实现了该接口的类必须实现新的方法。 + +``` +public interface ISingerService { + // 默认方法 + default void sing(){ + System.out.println("唱歌"); + } + void writeSong(); +} + +//JaySingerServiceImpl 不用强制实现ISingerService的默认sing()方法 +public class JaySingerServiceImpl implements ISingerService { + @Override + public void writeSong() { + System.out.println("写了一首七里香"); + } +} +``` + +#### 5.Stream API +Stream API，支持对元素流进行函数式操作，它集成在Collections API 中，可以对集合进行批量操作。常用API： +- filter 筛选 +- map流映射 +- reduce 将流中的元素组合起来 +- collect 返回集合 +- sorted 排序 +- flatMap 流转换 +- limit返回指定流个数 +- distinct去除重复元素 +``` +public class Singer { + + private String name; + private Integer songNum; + private Integer age; + ... +} + +List singerList = new ArrayList(); +singerList.add(new Singer("jay", 11, 36)); +singerList.add(new Singer("eason", 8, 31)); +singerList.add(new Singer("JJ", 6, 29)); + +List singerNameList = singerList.stream() + .filter(singer -> singer.getAge() > 30) //筛选年龄大于30 + .sorted(Comparator.comparing(Singer::getSongNum)) //根据歌曲数量排序 + .map(Singer::getName) //提取歌手名字 + .collect(Collectors.toList()); //转换为List +``` + +#### 6. Optional + Java 8引入Optional类，用来解决NullPointerException。Optional代替if...else解决空指针问题，使代码更加简洁。 + +if...else 判空 +``` +Singer singer = getSingerById("666"); +if (singer != null) { + String name = singer.getName(); + System.out.println(name); +} +``` +Optional的判空 +``` +Optional singer = Optional.ofNullable(getSingerById("666")); +singer.ifPresent(s -> System.out.println(s.getName())); +``` + +#### 7. Date Time API +JDK 8之前的日期API处理存在非线程安全、时区处理麻烦等问题。Java 8 在 java.time包下提供了新的日期API，简化了日期的处理~ + +``` +LocalDate today = LocalDate.now(); +int year = today.getYear(); +System.out.println("今年是" + year); +//是否闰年 +System.out.println("今年是不是闰年:" + today.isLeapYear()); + +LocalDateTime todayTime = LocalDateTime.now(); +System.out.println("当前时间" + todayTime); +//时区指定 +System.out.println("美国时间:" + ZonedDateTime.of(todayTime,ZoneId.of("America/Los_Angeles"))); + +LocalDate specailDate = LocalDate.of(2020, 6, 20); +LocalDate expectDate = specailDate.plus(100, ChronoUnit.DAYS); +System.out.println("比较特别的一天" + specailDate); +System.out.println("特殊日期的100天" + expectDate); +``` + +#### 8. 重复注解 +重复注解，即一个注解可以在一个类、属性或者方法上同时使用多次；用@Repeatable定义重复注解 +``` +@Repeatable(ScheduleTimes.class) +public @interface ScheduleTime { + String value(); +} + +public @interface ScheduleTimes { + ScheduleTime[] value(); +} + +public class ScheduleTimeTask { + @ScheduleTime("10") + @ScheduleTime("12") + public void doSomething() { } +} +``` +#### 9. Base64 +Java 8把Base64编码的支持加入到官方库中~ +``` +String str = "公众号:捡田螺的小男孩"; +String encoded = Base64.getEncoder().encodeToString(str.getBytes( StandardCharsets.UTF_8)); +String decoded = new String(Base64.getDecoder().decode(encoded), StandardCharsets.UTF_8); +``` + +#### 10. JVM的新特性 +使用元空间Metaspace代替持久代（PermGen space），JVM参数使用-XX:MetaSpaceSize和-XX:MaxMetaspaceSize设置大小。 + +### Java 9 新特性 +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8b0457ff711b412094b2900ba4b4e974~tplv-k3u1fbpfcp-zoom-1.image) +#### 1. java模块系统 + +什么是模块化？ +> 一个大型系统，比如一个商城网站，它会包含很多模块的，如：订单模块，用户信息模块，商品信息模块，广告位模块等等。各个模块之间会相互调用。如果每个模块单独运行都会带动其他所有模块，性能非常低效。但是，如果某一模块运行时，只会启动它所依赖的模块，性能大大提升。这就是JDK 9模块化的思想。 + +什么是JDK 9模块化？ +> Java 平台模块系统，即Project Jigsaw，把模块化开发实践引入到了Java平台中。在引入了模块系统之后，JDK 被重新组织成94个模块。Java 应用可以通过新增的jlink 工具，创建出只包含所依赖的JDK模块的自定义运行时镜像。这样可以极大的减少Java运行时环境的大小。 + +Java 9 模块的重要特征： +> - 在其工件（artifact）的根目录中包含了一个描述模块的 module-info.class 文件。 +> - 工件的格式可以是传统的 JAR 文件或是 Java 9 新增的 JMOD 文件。 +> - 这个文件由根目录中的源代码文件 module-info.java 编译而来。 +> - 该模块声明文件可以描述模块的不同特征。 + +在 module-info.java 文件中，我们可以用新的关键词module来声明一个模块，如下所示。下面给出了一个模块com.mycompany.mymodule的最基本的模块声明 + +``` +module com.jay.sample { //关键词module来声明一个模块 + exports com.jay.sample; //使用 exports可以声明模块对其他模块所导出的包。 + requires com.jay.common; //使用requires可以声明模块对其他模块的依赖关系。 +} +``` + +#### 2. 不可变集合工厂方法 + +为了创建不可变集合，JDK9之前酱紫的： +``` +List stringList = new ArrayList<>(); +stringList.add("关注公众号:"); +stringList.add("捡田螺的小男孩"); +List unmodifiableList = Collections.unmodifiableList(stringList); +``` +JDK 9 提供了List.of()、Set.of()、Map.of()和Map.ofEntries()等工厂方法来创建不可变集合： +``` +List unmodifiableList = List.of("关注公众号:","捡田螺的小男孩"); +``` + +#### 3. 接口支持私有方法 +JDK 8支持在接口实现默认方法和静态方法，但是不能在接口中创建私有方法，为了避免了代码冗余和提高阅读性，JDK 9在接口中支持私有方法。 +``` +public interface IPrivateInterfaceTest { + + //JDK 7 之前 + String a = "jay"; + void method7(); + + //JDK 8 + default void methodDefault8(){ + System.out.println("JDK 8新特性默认方法"); + } + static void methodStatic8() { + System.out.println("JDk 8新特性静态方法"); + } + + //Java 9 接口支持私有方法 + private void method9(){} +} +``` + +#### 4. 钻石操作符升级 +- 钻石操作符是在 java 7 中引入的，可以让代码更易读，但它不能用于匿名的内部类。 +- 在 java 9 中，它可以与匿名的内部类一起使用，从而提高代码的可读性。 + +``` +//JDK 5,6 +Map map56 = new HashMap(); +//JDk 7,8 +Map map78 = new HashMap<>(); +//JDK 9 结合匿名内部类的实现 +Map map9 = new HashMap<>(){}; +``` + +#### 5. Optional 类改进 + java 9 中，java.util.Optional 添加了很多新的有用方法，如： +- stream() +- ifPresentOrElse() +- or() + +ifPresentOrElse 方法的改进就是有了 else，接受两个参数 Consumer 和 Runnable。 +``` +import java.util.Optional; + +public class OptionalTest { + public static void main(String[] args) { + Optional optional = Optional.of(1); + + optional.ifPresentOrElse( x -> System.out.println("Value: " + x),() -> + System.out.println("Not Present.")); + + optional = Optional.empty(); + + optional.ifPresentOrElse( x -> System.out.println("Value: " + x),() -> + System.out.println("Not Present.")); + } +} +``` +#### 6. 多版本兼容Jar包 +> 很多公司使用的JDK都是老版本的，JDK6、JDk5 ，甚至JDk4的，不是他们不想升级JDk版本，而是担心兼容性问题。JDK 9的一个新特性，多版本兼容Jar包解决了这个问题。举个例子：假设你一直用的是小米8，已经非常习惯它的运行流程了，突然出来小米9，即使小米9很多新功能引人入胜，但是有些人不会轻易买小米9，因为已经已经习惯小米8的流程。同理，为什么很多公司不升级JDK，就是在此。但是呢，JDK 9的这个功能很强大，它可以让你的版本升级到JDK 9，但是还是老版本的运行流程，即在老的运行流程继承新的功能~ + + + +#### 7. JShell工具 +jShell工具相当于cmd工具，然后呢，你可以像在cmd工具操作一样，直接在上面运行Java方法，Java语句等~ +``` +jshell> System.out.println("关注公众号：捡田螺的小男孩"); +关注公众号：捡田螺的小男孩 +``` + +#### 8. try-with-resources的改进 +JDK 9对try-with-resources异常处理机制进行了升级~ +``` +//JDK 7,8 +try (BufferedReader br = new BufferedReader(new FileReader("d:七里香.txt")) { + br.readLine(); +}catch(IOException e){ + log.error("IO 异常，e:{}",e); +} +//JDk 9 +BufferedReader br = new BufferedReader(new FileReader("d:七里香.txt") +try(br){ + br.readLine(); +}catch(IOException e){ + log.error("IO 异常，e:{}",e); +} +``` + +#### 9. Stream API的改进 +JDK 9 为Stream API引入以下这些方法，丰富了流处理操作： +- takeWhile（） +- dropWhile（） +- iterate +- ofNullable + +**takeWhile** + +使用一个断言（Predicate 接口）作为参数，返回给定Stream的子集直到断言语句第一次返回 false +``` +// 语法格式 +default Stream takeWhile(Predicate predicate) +//代码示例 +Stream.of(1,2,3).takeWhile(s-> x<2) + .forEach(System.out::println); + //输出 + 1 +``` +**dropWhile** + +与 takeWhile（）作用相反，使用一个断言（Predicate 接口）作为参数，直到断言语句第一次返回true，返回给定Stream的子集 +``` +//语法 +default Stream dropWhile(Predicate predicate) +//代码示例 +Stream.of(1,2,3).dropWhile(s-> x<2) + .forEach(System.out::println); +//输出 +2 +3 +``` +**iterate** + +iterate() 方法能够返回以seed（第一个参数）开头，匹配 Predicate（第二个参数）直到返回false，并使用第三个参数生成下一个元素的元素流。 +``` +//语法 +static Stream iterate(T seed, Predicate hasNext, UnaryOperator next) +//代码示例 +IntStream.iterate(2, x -> x < 10, x -> x*x).forEach(System.out::println); +//输出 +2 +4 +``` +**ofNullable** + +如果指定元素为非null，则获取一个元素并生成单个元素流，元素为null则返回一个空Stream。 +``` +//语法 +static Stream ofNullable(T t) +//代码示例 +Stream s1= Stream.ofNullable(100); +s1.forEach(System.out::println) +Stream s2 = Stream.ofNullable(null)； +s2.forEach(System.out::println) +//输出 +100 + +``` + +#### 10.其他 +> - HTTP 2客户端 (支持 WebSocket和 HTTP2 流以及服务器推送) +> - 进程API（控制和管理操作系统进程） +> - String底层存储结构更改(char[]替换为byte[]) +> - 标识符添加限制( String _ ="hello"不能用) +> - 响应式流 API (支持Java 9中的响应式编程) + +### Java 10 新特性 +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1641de35ea274dbb9d7d34c78ea40a0f~tplv-k3u1fbpfcp-zoom-1.image) +#### 1.局部变量类型推断 + +JDK 10增加了局部变量类型推断（Local-Variable Type Inference）功能，让 Java 可以像Js里的var一样可以自动推断数据类型。Java中的var是一个保留类型名称，而不是关键字。 + +JDK 10之前 +``` +List list = new ArrayList(); +Stream stream = Stream.of(1, 2, 3); +``` +JDK 10 之后 +``` +var list = new ArrayList(); // ArrayList +var stream = Stream.of(1, 2, 3); +``` +var 变量类型推断的使用也有局限性，仅**局限**于以下场景： +- 具有初始化器的局部变量 +- 增强型for循环中的索引变量 +- 传统for循环中声明的局部变量 + +而**不能用于** +- 推断方法的参数类型 +- 构造函数参数类型推断 +- 推断方法返回类型 +- 字段类型推断 +- 捕获表达式 + + +#### 2. 不可变集合的改进 +JDK 10中，List，Set，Map 提供了一个新的静态方法copyOf(Collection coll)，它返回Collection集合一个不可修改的副本。 + +JDK 源码： +``` +static List copyOf(Collection coll) { + return ImmutableCollections.listCopy(coll); +} +``` + +使用实例： + +``` +var oldList = new ArrayList(); +oldList.add("欢迎关注公众号："); +oldList.add("捡田螺的小男孩"); + +var copyList = List.copyOf(oldList); +oldList.add("在看、转载、点赞三连"); +copyList.add("双击666"); //UnsupportedOperationException异常 +``` + +#### 3. 并行全垃圾回收器 G1 + +> JDK 9引入 G1 作为默认垃圾收集器，执行GC 时采用的是基于单线程标记扫描压缩算法（mark-sweep-compact）。为了最大限度地减少 Full GC 造成的应用停顿的影响，Java 10 中将为 G1 引入多线程并行 GC，同时会使用与年轻代回收和混合回收相同的并行工作线程数量，从而减少了 Full GC 的发生，以带来更好的性能提升、更大的吞吐量。 + + +#### 4. 线程本地握手 + +Java 10 中线程管控引入JVM安全点的概念，将允许在不运行全局JVM安全点的情况下实现线程回调，由线程本身或者JVM线程来执行，同时保持线程处于阻塞状态，这将会很方便使得停止单个线程或不停止线程成为可能。 + +#### 5. Optional新增orElseThrow()方法 +Optional、OptionalDouble等类新增一个方法orElseThrow()，在没有值时抛出异常 + +#### 6. 其他新特性 +- 基于 Java 的实验性 JIT 编译器 +- 类数据共享 +- Unicode 语言标签扩展 +- 根证书 +- 基于时间（Time-Based）的版本控制模型 + +### Java 11 新特性 + +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4041b93cd08c4865aaceec2bafbd214f~tplv-k3u1fbpfcp-zoom-1.image) + +#### 1.字符串操作 +String类是Java最常用的类，JDK 11增加了一系列好用的字符串处理方法 +- isBlank() 判空。 +- strip() 去除首尾空格 +- stripLeading() 去除字符串首部空格 +- stripTrailing() 去除字符串尾部空格 +- lines() 分割获取字符串流。 +- repeat() 复制字符串 + +``` +// 判断字符串是否为空白 +" ".isBlank(); // true + +// 去除首尾空格 +" jay ".strip(); // "jay" + +// 去除首部空格 +" jay ".stripLeading(); // "jay " + +去除字符串尾部空格 +" jay ".stripLeading(); // " jay" + +// 行数统计 +"a\nb\nc".lines().count(); // 3 + +// 复制字符串 +"jay".repeat(3); // "jayjayjay" + +``` + +#### 2.用于 Lambda 参数的局部变量语法 + +局部变量类型推断是Java 10引入的新特性，但是不能在Lambda 表达式中使用。Java 11再次创新，它允许开发者在 Lambda 表达式中使用 var 进行参数声明。 +``` +var map = new HashMap(); +map.put("公众号", "捡田螺的小男孩"); +map.forEach((var k, var v) -> { + System.out.println(k + ": " + v); +}); +``` + +#### 3.标准化HTTP Client +Java 9 引入Http Client API,Java 10对它更新，Java 11 对它进行标准化。这几个版本后，Http Client几乎被完全重写，支持HTTP/1.1和HTTP/2 ，也支持 websockets。 + +``` +HttpClient client = HttpClient.newHttpClient(); +HttpRequest request = HttpRequest.newBuilder() + .uri(URI.create("https://github.com/whx123/JavaHome")) + .GET() + .build(); + +// 同步 +HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); +System.out.println(response.body()); + +// 异步 +client.sendAsync(request, HttpResponse.BodyHandlers.ofString()) + .thenApply(HttpResponse::body) + .thenAccept(System.out::println); +``` + +#### 4. 单个命令编译运行源代码 +Java 11增强了Java 启动器，使之能够运行单一文件的Java 源代码。 + +- Java 11之前,要运行一个 Java 源代码必须先编译，再运行 +``` +// 编译 +javac Jay.java +// 运行 +java Jay +``` +- Java 11之后,只要一个java命令就搞定 +``` +java Jay.java +``` + +#### 5. ZGC：可伸缩低延迟垃圾收集器 + +ZGC ，即 Z Garbage Collector（垃圾收集器或垃圾回收器）。它是一个可伸缩的、低延迟的垃圾收集器。 +ZGC 主要为了满足如下目标进行设计： +- GC 停顿时间不超过 10ms +- 既能处理几百 MB 的小堆，也能处理几个 TB 的大堆 +- 应用吞吐能力不会下降超过 15%（与 G1 回收算法相比） +- 方便在此基础上引入新的 GC 特性和利用 colord +- 针以及 Load barriers 优化奠定基础 +- 当前只支持 Linux/x64 位平台 + +#### 6.其他一些特性 +- 添加 Epsilon 垃圾收集器。 +- 支持 TLS 1.3 协议 +- 飞行记录器分析工具 +- 动态类文件常量 +- 低开销的 Heap Profiling + +### Java 12 新特性 +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a9700faac24f45508d6f7071e779d1b8~tplv-k3u1fbpfcp-zoom-1.image) +#### 1. Switch 表达式扩展（预览功能） +传统的switch语句，容易漏写break而出错，同时写法并不简洁优雅。 + +Java 12之前 +``` +switch (day) { + case MONDAY: + case FRIDAY: + case SUNDAY: + System.out.println(6); + break; + case TUESDAY: + System.out.println(7); + break; + case THURSDAY: + case SATURDAY: + System.out.println(8); + break; + case WEDNESDAY: + System.out.println(9); + break; +} + +``` +JDk 12 之后，Switch表达式得到增强，能接受语句和表达式。 +``` +switch (day) { + case MONDAY, FRIDAY, SUNDAY -> System.out.println(6); + case TUESDAY -> System.out.println(7); + case THURSDAY, SATURDAY -> System.out.println(8); + case WEDNESDAY -> System.out.println(9); +} +``` + +#### 2. 紧凑的数据格式 +JDK 12 新增了NumberFormat对复杂数字的格式化 +``` +NumberFormat numberFormat = NumberFormat.getCompactNumberInstance(Locale.CHINA, NumberFormat.Style.SHORT); +System.out.println(numberFormat.format(100000)); +//output +10万 +``` + +#### 3. 字符串支持transform、indent操作 +- transform 字符串转换，可以配合函数式接口Function一起使用 +``` +List list1 = List.of("jay", " 捡田螺的小男孩"); +List list2 = new ArrayList<>(); +list1.forEach(element -> + list2.add(element.transform(String::strip) + .transform((e) -> "Hello," + e)) + ); +list2.forEach(System.out::println); +//输出 +Hello,jay +Hello,捡田螺的小男孩 +``` +- indent 缩进，每行开头增加空格space和移除空格 +``` +String result = "Java\n Python\nC".indent(3); +System.out.println(result); +//输出 + Java + Python + C +``` + +#### 4. Files.mismatch(Path, Path) +Java 12 新增了mismatch方法，此方法返回第一个不匹配的位置，如果没有不匹配，则返回 -1L。 +``` +public static long mismatch(Path path, Path path2) throws IOException; +``` +代码示例： +``` +Path file1 = Paths.get("c:\\jay.txt"); +Path file2 = Paths.get("c：\\捡田螺的小男孩.txt"); + +try { + long fileMismatch = Files.mismatch(file1, file2); + System.out.println(fileMismatch); +} catch (IOException e) { + e.printStackTrace(); +} +``` +#### 5. Teeing Collector + +Teeing Collector 是 Streams API 中引入的新的收集器实用程序，它的作用是 merge 两个 collector 的结果,API格式如下： +``` +public static + Collector teeing(Collector downstream1, + Collector downstream2, + BiFunction merger) +``` +直接看代码例子吧，如下为求学生的平均分和总分的例子 +``` + List studentList= Arrays.asList( + new Student("jay", 90), + new Student("捡田螺的小男孩", 100), + new Student("捡表情的小男孩", 80) + ); + String teeingResult=studentList.stream().collect( + Collectors.teeing( + Collectors.averagingInt(Student::getScore), + Collectors.summingInt(Student::getScore), + (s1,s2)-> s1+ ":"+ s2 + ) + ); + System.out.println(teeingResult); //90:270 +``` +#### 6.其他特性 +- 支持unicode 11（684个新字符、11个新blocks、7个新脚本） +- JVM 常量 API （主要在新的java.lang.invoke.constant包中定义了一系列基于值的符号引用类型，能够描述每种可加载常量。） +- Shenandoah GC（低暂停时间垃圾收集器） +- G1 收集器提升（可中止的混合收集集合、及时返回未使用的已分配内存） +- 默认CDS档案 +- JMH 基准测试 + +### Java 13 新特性 +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/404668ad77d248ec97d482622182eb70~tplv-k3u1fbpfcp-zoom-1.image) + +#### Switch 表达式扩展（引入 yield 关键字） +传统的switch： +``` +private static String getText(int number) { + String result = ""; + switch (number) { + case 1, 2: + result = "one or two"; + break; + case 3: + result = "three"; + break; + case 4, 5, 6: + result = "four or five or six"; + break; + default: + result = "unknown"; + break; +``` +Java 13之后，value break 语句不再被编译，而是用 yield 来进行值返回 +``` +private static String getText(int number) { + return switch (number) { + case 1, 2: + yield "one or two"; + case 3: + yield "three"; + case 4, 5, 6: + yield "four or five or six"; + default: + yield "unknown"; + }; +} +``` +#### 2.文本块升级 +Java 13之前，字符串不能够多行使用，需要通过换行转义或者换行连接符等等，反正就是好麻烦、好难维护。 +``` +String html = "\n" + + " \n" + + "

Hello, 捡田螺的小男孩

\n" + + " \n" + + "\n"; +``` +Java 13之后，清爽多了~ +``` +String html = """ + + +

Hello, 捡田螺的小男孩

+ + + """; +``` +#### 3. SocketAPI 重构 +- 传统的Java Socket API（java.net.ServerSocket 和 java.net.Socket）依赖于SocketImpl 的内部实现 +- 在 Java 13之前，通过使用 PlainSocketImpl 作为 SocketImpl 的具体实现。 +- Java 13 中的新底层实现，引入 NioSocketImpl 的实现用以替换 SocketImpl 的 PlainSocketImpl 实现，此实现与 NIO（新 I/O）实现共享相同的内部基础结构，并且与现有的缓冲区高速缓存机制集成在一起。 + +一个Socket简单例子： +``` +import java.io.IOException; +import java.net.ServerSocket; +import java.net.Socket; + +public class SocketAPITest { + public static void main(String[] args) { + try (ServerSocket serverSocket = new ServerSocket(8080)){ + boolean runFlag = true; + while(runFlag){ + Socket clientSocket = serverSocket.accept(); + //搞事情 + } + } catch (IOException e) { + e.printStackTrace(); + } + } +} +``` +运行以上的实例，看下是否有以下关键词输出~ +``` +[class,load] sun.nio.ch.NioSocketImpl +``` + +#### 4.FileSystems.newFileSystem新方法 +FileSystems 类中添加了以下三种新方法，以便更容易地使用将文件内容视为文件系统的文件系统提供程序： +- 1、newFileSystem(Path) +- 2、newFileSystem(Path, Map) +- 3、newFileSystem(Path, Map, ClassLoader) + +#### 5. 增强 ZGC 释放未使用内存 +- ZGC 是Java 11 中引入的最为瞩目的垃圾回收特性，是一种可伸缩、低延迟的垃圾收集器。但是实际使用中，它不能够主动将未使用的内存释放给操作系统。 +- Java 13 中对 ZGC 的改进，包括释放未使用内存给操作系统、支持最大堆大小为 16TB、JVM参数-XX:SoftMaxHeapSize 来软限制堆大小 + +#### 6.其他特性 +- 动态 CDS 存档，扩展了 Java 10 中引入的类数据共享功能，使用CDS 存档变得更容易。 +- 文本块的字符串类新方法，如formatted(Object…args)，stripIndent()等。 + + + +### Java 14 新特性 +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c386249741174a38b6d29f6900829a66~tplv-k3u1fbpfcp-zoom-1.image) +#### 1. instanceof模式匹配 +instanceof 传统使用方式： +``` +if (person instanceof Singer) { + Singer singer = (Singer) person; + singer.sing(); +} else if (person instanceof Writer) { + Writer writer = (Writer) person; + writer.write(); +} +``` +Java 14 对 instanceof 进行模式匹配改进之后 +``` +if (person instanceof Singer singer) { + singer.sing(); +} else if (person instanceof Writer writer) { + writer.write(); +} +``` + + +#### 2.Record 类型（预览功能） +Java 14将Record 类型作为预览特性而引入，有点类似于Lombok 的@Data注解，看个例子吧： +``` +public record Person(String name, int age) { + public static String address; + + public String getName() { + return name; + } +} +``` +反编译结果： +``` +public final class Person extends java.lang.Record { + private final java.lang.String name; + private final java.lang.String age; + + public Person(java.lang.String name, java.lang.String age) { /* compiled code */ } + + public java.lang.String getName() { /* compiled code */ } + + public java.lang.String toString() { /* compiled code */ } + + public final int hashCode() { /* compiled code */ } + + public final boolean equals(java.lang.Object o) { /* compiled code */ } + + public java.lang.String name() { /* compiled code */ } + + public java.lang.String age() { /* compiled code */ } +} +``` +可以发现，当用 Record 来声明一个类时，该类将自动拥有下面特征： +- 构造方法 +- hashCode() 方法 +- euqals() 方法 +- toString() 方法 +- 类对象被final 关键字修饰，不能被继承。 + + +#### 3. Switch 表达式-标准化 +switch 表达式在之前的 Java 12 和 Java 13 中都是处于预览阶段，终于在 Java 14 标准化，成为稳定版本。 +- Java 12 为switch 表达式引入Lambda 语法 +- Java 13 使用yield代替 break 关键字来返回表达式的返回值。 +``` +String result = switch (day) { + case "M", "W", "F" -> "MWF"; + case "T", "TH", "S" -> "TTS"; + default -> { + if (day.isEmpty()) { + yield "Please insert a valid day."; + } else { + yield "Looks like a Sunday."; + } + } +}; +System.out.println(result); +``` + +#### 4. 改进 NullPointerExceptions提示信息 +Java 14 之前： +``` +String name = song.getSinger().getSingerName() + +//堆栈信息 +Exception in thread "main" java.lang.NullPointerException + at NullPointerExample.main(NullPointerTest.java:6) +``` +Java 14，通过引入JVM 参数-XX:+ShowCodeDetailsInExceptionMessages，可以在空指针异常中获取更为详细的调用信息。 +``` +Exception in thread "main" java.lang.NullPointerException: Cannot invoke "Singer.getSingerName()" +because the return value of "rainRow.getSinger()" is null + at NullPointerExample.main(NullPointerTest.java:6) +``` +#### 5. 其他特性 +- G1 的 NUMA 可识别内存分配 +- 删除 CMS 垃圾回收器 +- GC 支持 MacOS 和 Windows 系统 + +### Java 15 新特性 +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/691c5bdd4de64d41bc5f50599b9ba078~tplv-k3u1fbpfcp-zoom-1.image) +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/96a3928212f1483ca669f6cbc7893c21~tplv-k3u1fbpfcp-zoom-1.image) +#### 1.EdDSA 数字签名算法 +- 使用 Edwards-Curve 数字签名算法（EdDSA）实现加密签名。 +- 与其它签名方案相比，EdDSA 具有更高的安全性和性能。 +- 得到许多其它加密库（如 OpenSSL、BoringSSL）的支持。 + +#### 2.Sealed Classes（封闭类，预览） +封闭类，可以是封闭类、封闭接口，防止其他类或接口扩展或实现它们。 +``` +public abstract sealed class Singer + permits Jay, Eason{ + ... +} +``` +类Singer被sealed 修饰，是封闭类，只能被2个指定子类（Jay, Eason）继承。 + +#### 3. Hidden Classes（隐藏类） +- 隐藏类天生为框架设计的。 +- 隐藏类只能通过反射访问，不能直接被其他类的字节码。 + +#### 4. Remove the Nashorn JavaScript Engine +- Nashorn太难维护了，移除 Nashorn JavaScript引擎成为一种必然 +- 其实早在JDK 11 中就已经被标记为 deprecated 了。 + +#### 5.Reimplement the Legacy DatagramSocket API（重新实现DatagramSocket API） +- 重新实现老的DatagramSocket API +- 更改java.net.DatagramSocket 和 java.net.MulticastSocket 为更加简单、现代化的底层实现。 + +#### 6.其他 +- Disable and Deprecate Biased Locking（准备禁用偏向锁） +- instanceof 自动匹配模式（预览） +- ZGC，一个可伸缩、低延迟的垃圾回收器。（转正） +- Text Blocks，文本功能转正（JDK 13和14预览，14终于转正） +- Remove the Solaris and SPARC Ports（删除 Solaris 和 SPARC 端口） +- 外部存储器访问 API（允许Java 应用程序安全有效地访问 Java 堆之外的外部内存。） +- Record类型二次预览（在Java 14就预览过啦） + + +### 参考与感谢 +- [JDK6 新特性](https://blog.csdn.net/weixin_40926603/article/details/84970283) +- [Java 7的新功能](https://stackoverflow.com/questions/213958/new-features-in-java-7) +- [Java 9 新特性概述](https://developer.ibm.com/zh/articles/the-new-features-of-Java-9/) +- [Java 9 新特性](https://www.runoob.com/java/java9-new-features.html) +- [Java 10 新特性介绍](https://developer.ibm.com/zh/technologies/java/articles/the-new-features-of-java-10/) +- [Java 11 新特性介绍](https://developer.ibm.com/zh/technologies/java/articles/the-new-features-of-java-11/) +- [Java 13 新特性概述](https://developer.ibm.com/zh/technologies/java/articles/the-new-features-of-java-13/) +- [Java 14 新特性概述](https://developer.ibm.com/zh/technologies/java/articles/the-new-features-of-java-14/) +- [JDK/Java 15发布](https://mp.weixin.qq.com/s/bNbNzo-Jy_SskRAupUBbNQ) +- [Java 15 正式发布， 14 个新特性，刷新你的认知！！ +](https://www.cnblogs.com/javastack/p/13683220.html) +### 个人公众号 + +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/2845e9f737f14311a119f45751683b3c~tplv-k3u1fbpfcp-zoom-1.image) + + + + + From f39f1a5deeba61da07b15150728456fdc13a8136 Mon Sep 17 00:00:00 2001 From: whx123 <327658337@qq.com> Date: Wed, 30 Sep 2020 20:01:14 +0800 Subject: [PATCH 20/77] =?UTF-8?q?=E4=BB=A3=E7=A0=81=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...13\345\223\252\344\272\233\344\271\246.md" | 535 ++++++++++++++++++ ...43\347\240\201\344\274\230\345\214\226.md" | 204 +++++++ 2 files changed, 739 insertions(+) create mode 100644 "Java\347\250\213\345\272\217\345\221\230\351\234\200\350\246\201\347\234\213\345\223\252\344\272\233\344\271\246/Java\347\250\213\345\272\217\345\221\230\351\234\200\350\246\201\347\234\213\345\223\252\344\272\233\344\271\246.md" create mode 100644 "\345\267\245\344\275\234\346\200\273\347\273\223/\344\270\200\346\254\241\344\273\243\347\240\201\344\274\230\345\214\226.md" diff --git "a/Java\347\250\213\345\272\217\345\221\230\351\234\200\350\246\201\347\234\213\345\223\252\344\272\233\344\271\246/Java\347\250\213\345\272\217\345\221\230\351\234\200\350\246\201\347\234\213\345\223\252\344\272\233\344\271\246.md" "b/Java\347\250\213\345\272\217\345\221\230\351\234\200\350\246\201\347\234\213\345\223\252\344\272\233\344\271\246/Java\347\250\213\345\272\217\345\221\230\351\234\200\350\246\201\347\234\213\345\223\252\344\272\233\344\271\246.md" new file mode 100644 index 0000000..12a0435 --- /dev/null +++ "b/Java\347\250\213\345\272\217\345\221\230\351\234\200\350\246\201\347\234\213\345\223\252\344\272\233\344\271\246/Java\347\250\213\345\272\217\345\221\230\351\234\200\350\246\201\347\234\213\345\223\252\344\272\233\344\271\246.md" @@ -0,0 +1,535 @@ +### 前言 +不要因为迷茫，而停止了脚下的路。给大家推荐一份Java程序员必看的书单，豆瓣评分都挺不错的，每一本都值得去读，都值得去收藏，加油呀 + +本文已经收录到github + httpsgithub.comwhx123JavaHome + +- 专题一：Java 基础篇书单 +- 专题二：代码优化篇书单 +- 专题三：计算机网络篇书单 +- 专题四：操作系统 && 计算机底层书单 +- 专题五：数据结构与算法篇书单 +- 专题六：缓存篇书单 +- 专题七：数据库书单 +- 专题八：微服务 && 分布式篇书单 +- 专题九：消息中间件书单 +- 专题十：容器书单 +- 专题十一：面试相关书单 +- 专题十二：软件开发&&程序人生书单 + +公众号：捡田螺的小男孩 + +### 专题一：Java 基础篇书单 +- 《Java编程思想》 +- 《深入理解Java虚拟机：JVM高级特性与最佳实践》 +- 《Head First 设计模式》 +- 《Effective java》 +- 《Java核心技术》 +- 《Java8 实战》 +- 《Java并发编程实战》 +- 《Spring揭秘》 +- 《MyBatis技术内幕》 + + +#### Java编程思想 +![](httpsp1-juejin.byteimg.comtos-cn-i-k3u1fbpfcpadaee100b9544590bbee4c54a605d6e8~tplv-k3u1fbpfcp-zoom-1.image) + + 本书赢得了全球程序员的广泛赞誉，即使是最晦涩的概念，作者都会用小而直接的编程示例讲解明白。从Java的基础语法到最高级特性（深入的面向对象概念、多线程、自动项目构建、单元测试和调试等），本书都能逐步指导你轻松掌握。 + +- 综合评分：9.1 +- 个人推荐指数：五星 +- 适合对象：初级、中级、高级 +- Java界的神书，如果你是一名Java开发程序员，或者准备进入Java开发领域，都非常推荐你去读一读~ + +#### 深入理解Java虚拟机：JVM高级特性与最佳实践 +![](httpsp6-juejin.byteimg.comtos-cn-i-k3u1fbpfcp524a027174b542db9a4164ae72ae072a~tplv-k3u1fbpfcp-zoom-1.image) + + 这是一本从工作原理和工程实践两个维度深入剖析JVM的著作，是计算机领域公认的经典。 + +- 综合评分：9.6 +- 个人推荐指数：五星 +- 适合对象：初级、中级、高级 +- 不会JVM知识的Java程序员，是没有灵魂的。这本书真的超级适合学习JVM方面的知识。 + +#### Head First 设计模式 +![](httpsp9-juejin.byteimg.comtos-cn-i-k3u1fbpfcpe839c06e8da74f65b4d5ac9fed60a921~tplv-k3u1fbpfcp-zoom-1.image) + + 本书涵盖了23个设计模式，例子简单易懂，抛砖引玉，读起来很有意思的。真的是一本非常赞的设计模式入门书籍 + +- 综合评分：9.2 +- 个人推荐指数：五星 +- 适合对象：初级、中级 +- 对代码有追求的伙伴，想好好学习设计模式的小伙伴，都去看看吧~用设计模式写出优雅代码~ + + +#### Effective java +![](httpsp3-juejin.byteimg.comtos-cn-i-k3u1fbpfcp2a8667e690b24195a0b3e7f2a16b3eed~tplv-k3u1fbpfcp-zoom-1.image) + + 本书一共包含90个条目，每个条目讨论Java程序设计中的一条规则。这些规则反映了最有经验的优秀程序员在实践中常用的一些有益的做法。 + +- 综合评分：9.6 +- 个人推荐指数：五星 +- 适合对象：初级、中级、高级 +- 学习Java必读的一本书籍，我们写代码从来不是图谁写得多，或者比谁写得多，而是应该思考如何编写出清晰、正确、健壮、易维护的程序代码。 + + +#### Java核心技术 +![](httpsp9-juejin.byteimg.comtos-cn-i-k3u1fbpfcp8df7b5aec8774aa48a8117659f5d131e~tplv-k3u1fbpfcp-zoom-1.image) + 这本书是以为拥有20多年教学与研究经验的资深Java技术专家撰写，是程序员的优选Java指南。 + +- 综合评分：9.3 +- 个人推荐指数：四星 +- 适合对象：初级、中级 +- Java入门的工具书，基础知识讲的很细，如果你是入门Java的话，可以去看一看呀~ + +#### Java8 实战 +![](httpsp6-juejin.byteimg.comtos-cn-i-k3u1fbpfcpd9fcf57481d542d081eaae89274f7b25~tplv-k3u1fbpfcp-zoom-1.image) + 本书全面介绍了Java 8 这个里程碑版本的新特性，包括Lambdas、流和函数式编程。函数式编程，让代码更简洁~ + +- 综合评分：9.3 +- 个人推荐指数：五星 +- 适合对象：初级、中级 +- 江湖流传Java版本任你发，我用Java 8，可以知道java 8的地位了。这本书全面系统地讲述了Java8给Java语言带来的改变，例子也很生动，值得一读~ + +#### Java并发编程实战 +![](httpsp6-juejin.byteimg.comtos-cn-i-k3u1fbpfcpb847255548164d05ac402ddcc1188307~tplv-k3u1fbpfcp-zoom-1.image) + 本书深入浅出地介绍了Java线程和并发，是一本完美的Java并发参考手册。 + +- 综合评分：9.0 +- 个人推荐指数：四星 +- 适合对象：初级、中级 +- 讲并发的一本书，个人觉得不能算得上Java神书，但是呢，茶余饭后还是值得去读一读的。 + +#### Spring揭秘 +![](httpsp3-juejin.byteimg.comtos-cn-i-k3u1fbpfcp217e1bf0c9f0479f817b6f9b5a696068~tplv-k3u1fbpfcp-zoom-1.image) + 本书内容全面，论述深刻入理，必将成为每个Java专业开发人员必备的Spring图书。 + +- 综合评分：9.1 +- 个人推荐指数：五星 +- 适合对象：初级、中级 +- 可以当做spring的入门书籍，想用甜而不腻来形容这本书。 + +####MyBatis技术内幕 +![](httpsp6-juejin.byteimg.comtos-cn-i-k3u1fbpfcp176ac64ea5a44d979b9587e33dcb0dfd~tplv-k3u1fbpfcp-zoom-1.image) + 《MyBatis技术内幕》旨在为读者理解MyBatis的设计原理、阅读MyBatis源码、扩展MyBatis功能提供帮助和指导，让读者更加深入地了解MyBatis的运行原理、设计理念。希望《MyBatis技术内幕》能够帮助读者全面提升自身的技术能力，让读者在设计业务系统时，可以参考MyBatis的优秀设计，更好地应用MyBatis。 + +- 综合评分：8.6 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 还不错，讲的还挺清晰。但是呢一上来就开始讲源码，有些读者可能有点抗拒。 + + +### 专题二：代码优化篇书单 +- 《重构：改善既有代码的设计》 +- 《代码整洁之道》 +- 《代码整洁之道程序员的职业素养》 + +#### 重构：改善既有代码的设计 +![](httpsp3-juejin.byteimg.comtos-cn-i-k3u1fbpfcpc3fb1b0c51d64258994ecdace65ae999~tplv-k3u1fbpfcp-zoom-1.image) + 本书凝聚了软件开发社区专家多年摸索而获得的宝贵经验，拥有不因时光流逝而磨灭的价值。代码重构，因为这本书，成为了众多普通程序员日常开发工作中不可或缺的一部分。 + +- 综合评分：9.0 +- 个人推荐指数：五星 +- 适合对象：初级、中级、高级 +- 花了三周，把这本书看了两遍，真得觉得很有帮助。比如代码的坏味道，讲到重复代码、过长的函数、过长的类、过多的参数等等，都是我们司空见惯的不好代码，我们工作中应该注意、积累、思考，写出优雅、健壮的好代码。 + + +#### 代码整洁之道 +![](httpsp9-juejin.byteimg.comtos-cn-i-k3u1fbpfcp6a5f6e0f2b044fe09afe0d236b47f401~tplv-k3u1fbpfcp-zoom-1.image) + + 本书作者给出了一系列行之有效的整洁代码操作实践，些实践在本书中体现为一条条规则，并辅以来自现实项目的正、反两面的范例。只要遵循这些规则，就能编写出干净的代码，从而有效提升代码质量。 + +- 综合评分：9.1 +- 个人推荐指数：五星 +- 适合对象：初级、中级、高级 +- 个人更加推荐的是英文版，虽然我看的也是中文版，哈哈~ + + +#### 代码整洁之道程序员的职业素养 +![](httpsp9-juejin.byteimg.comtos-cn-i-k3u1fbpfcpeccaed0661f24dfe9a8ec41e28633acc~tplv-k3u1fbpfcp-zoom-1.image) + 这本书汇聚编程大师40余年编程生涯的心得体会. 阐释软件工艺中的原理、技术、工具和实践. 助力专业软件开发人员具备令人敬佩的职业素养。 + +- 综合评分：8.7 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 这本书值得多读几遍，坚持以正确的方式做对的事情。生活是这样，写代码也是~ + + +### 专题三：计算机网络篇书单 +- 《计算机网络自顶向下方法》 +- 《TCPIP详解》 +- 《图解 HTTP》 +- 《深入剖析Tomcat》 +- 《深入理解Nginx》 + +#### 计算机网络自顶向下方法 +![](httpsp6-juejin.byteimg.comtos-cn-i-k3u1fbpfcp26eb718b0e8644188c8804115a630992~tplv-k3u1fbpfcp-zoom-1.image) + 本书是经典的计算机网络教材，采用作者独创的自顶向下方法来讲授计算机网络的原理及其协议，自第1版出版以来已经被数百所大学和学院选作教材，被译为14种语言。 + +- 综合评分：9.2 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 大学时候的教材，有空可以回过头复习一下的，挺不错的一本书。 + +#### TCPIP详解 +![](httpsp3-juejin.byteimg.comtos-cn-i-k3u1fbpfcp440d8b0fca5441ae8f2909a5b5838ccd~tplv-k3u1fbpfcp-zoom-1.image) + 《TCPIP详解卷1：协议》是一本完整而详细的TCPIP协议指南。描述了属于每一层的各个协议以及它们如何在不同操作系统中运行。适合作为计算机专业学生学习网络的教材和教师参考书，也适用于研究网络的技术人员。 + +- 综合评分：9.2 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 有些朋友可能觉得读起来会有点枯燥，但是有时间的话，坚持把它看完吧。作为一名程序员，还是需要对计算机网路相关知识了解的多点才好。 + +#### 图解HTTP +![](httpsp3-juejin.byteimg.comtos-cn-i-k3u1fbpfcp64969deabfb648d7becdfd032cec4d9b~tplv-k3u1fbpfcp-zoom-1.image) + 本书对互联网基盘——HTTP协议进行了全面系统的介绍。HTTP协议的发展历史娓娓道来，严谨细致地剖析了HTTP协议的结构，列举诸多常见通信场景及实战案例，最后延伸到Web安全、最新技术动向等方面。 + +- 综合评分：8.1 +- 个人推荐指数：四星 +- 适合对象：初级、中级 +- 这本挺还不错的，涵盖了HTTP的主要知识，并且言简意赅，挺适合入门的。 + +#### 深入剖析Tomcat +![](httpsp9-juejin.byteimg.comtos-cn-i-k3u1fbpfcpcd1c1bcaf8bd444ab4de44f7613da22c~tplv-k3u1fbpfcp-zoom-1.image) + 本书深入剖析Tomcat 4和Tomcat 5中的每个组件，并揭示其内部工作原理。通过学习本书，你将可以自行开发Tomcat组件，或者扩展已有的组件。 + +- 综合评分：8.4 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 对Tomcat感兴趣的朋友可以去读一读~ + +#### 深入理解Nginx +![](httpsp3-juejin.byteimg.comtos-cn-i-k3u1fbpfcp979962fa403242b1aeeb74f02e64025c~tplv-k3u1fbpfcp-zoom-1.image) + 本书致力于说明开发Nginx模块的必备知识，深受广大读者的喜爱。 + +- 综合评分：8.7 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 好书是好书，但是有费咖啡，除了讲解nginx，还深入详解其相关知识。 + +### 专题四：操作系统 && 计算机底层 +- 《现代操作系统》 +- 《鸟哥的Linux私房菜基础学习篇》 +- 《鸟哥的Linux私房菜（服务器架设篇）》 +- 《Linux内核设计与实现》 +- 《编码隐匿在计算机软硬件背后的语言》 +- 《程序是怎么跑起来的》 + +#### 现代操作系统 +![](httpsp9-juejin.byteimg.comtos-cn-i-k3u1fbpfcp30d980eb30bd4152b11c1baacaddfe04~tplv-k3u1fbpfcp-zoom-1.image) +本书是操作系统领域的经典之作.书中集中讨论了操作系统的基本原理，包括进程、线程、存储管理、文件系统、输入输出、死锁等，同时还包含了有关计算机安全、多媒体操作系统、掌上计算机操作系统、微内核、多核处理机上的虚拟机以及操作系统设计等方面的内容。 + +- 综合评分：8.9 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 大学的教材，有时间可以复习一下~ + +#### 鸟哥的Linux私房菜基础学习篇 +![](httpsp9-juejin.byteimg.comtos-cn-i-k3u1fbpfcpfe0649b65c254b8d8c5828975810d06d~tplv-k3u1fbpfcp-zoom-1.image) + 本书内容丰富全面，基本概念的讲解非常细致，深入浅出。各种功能和命令的介绍，都配以大量的实例操作和详尽的解析。 + +- 综合评分：9.1 +- 个人推荐指数：五星 +- 适合对象：初级、中级 +- linux的入门书籍，非常推荐去读~ + +#### 鸟哥的Linux私房菜服务器架设篇 +![](httpsp9-juejin.byteimg.comtos-cn-i-k3u1fbpfcp293fae6443694c6b8e7e01e134bd2c98~tplv-k3u1fbpfcp-zoom-1.image) + 本书针对服务器的维护与管理，以及发生问题时的应对策略都加以说明。作者先从系统基础以及网络基础讲起，再谈到网络攻击与防火墙防护主机后，才进入服务器的架设。 + +- 综合评分：8.8 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 总体来说，非常不错，可以作为服务器架设的入门书籍。 + +#### Linux内核设计与实现 +![](httpsp6-juejin.byteimg.comtos-cn-i-k3u1fbpfcpc8c670cb4156469ead42f75ccc33a738~tplv-k3u1fbpfcp-zoom-1.image) +《Linux内核设计与实现(原书第3版)》详细描述了Linux内核的主要子系统和特点，包括Linux内核的设计、实现和接口。从理论到实践涵盖了Linux内核的方方面面，可以满足读者的各种兴趣和需求。 + +- 综合评分：8.6 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 没有纠缠于内核代码本身，而是把握Linux内核设计的思想，详略得当，特点鲜明，很不错。 + +#### 编码隐匿在计算机软硬件背后的语言 +![](httpsp9-juejin.byteimg.comtos-cn-i-k3u1fbpfcpe9f390087b834e628be74201951cf5f1~tplv-k3u1fbpfcp-zoom-1.image) + 一本讲述计算机工作原理的书，作者用丰富的想象和清晰的笔墨将看似繁杂的理论阐述得通俗易懂，你丝毫不会感到枯燥和生硬。 + +- 综合评分：9.3 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 大学的时候就值得读的一本书 + +#### 程序是怎么跑起来的 +![](httpsp1-juejin.byteimg.comtos-cn-i-k3u1fbpfcpd4782186490e42bd8c338923685beb4b~tplv-k3u1fbpfcp-zoom-1.image) + 本书从计算机的内部结构开始讲起，以图配文的形式详细讲解了二进制、内存、数据压缩、源文件和可执行文件、操作系统和应用程序的关系、汇编语言、硬件控制方法等内容，目的是让读者了解从用户双击程序图标到程序开始运行之间到底发生了什么。同时专设了“如果是你，你会怎样介绍？”专栏，以小学生、老奶奶为对象讲解程序的运行原理，颇为有趣。本书图文并茂，通俗易懂，非常适合计算机爱好者及相关从业人员阅读。 + +- 综合评分：8.0 +- 个人推荐指数：三星 +- 适合对象：初级、中级 +- 有空的话可以去看看，通俗易懂、图文并茂~ + +### 专题五：数据结构与算法 +- 《数据结构与算法分析：Java语言描述》 +- 《算法导论》 +- 《编程珠玑》 +- 《算法》 + +#### 数据结构与算法分析：Java语言描述 +![](httpsp6-juejin.byteimg.comtos-cn-i-k3u1fbpfcpb298b1f156914f78911b9d013d9fee56~tplv-k3u1fbpfcp-zoom-1.image) + 本书是国外数据结构与算法分析方面的经典教材，使用卓越的Java编程语言作为实现工具讨论了数据结构（组织大量数据的方法）和算法分析（对算法运行时间的估计）。 + +- 综合评分：8.3 +- 个人推荐指数：四星 +- 适合对象：初级、中级 +- 学习数据结构与算法，做个有想法的程序员。其实源码底层，就有数据结构与算法的体现，如Hashmap底层就是链表、红黑树~ + + +#### 算法导论 +![](httpsp6-juejin.byteimg.comtos-cn-i-k3u1fbpfcp2927cdf2a760463ca16942b6038d9cc5~tplv-k3u1fbpfcp-zoom-1.image) + 这本书深入浅出，全面地介绍了计算机算法。对每一个算法的分析既易于理解又十分有趣，并保持了数学严谨性。本书的设计目标全面，适用于多种用途。 + +- 综合评分：9.3 +- 个人推荐指数：五星 +- 适合对象：初级、中级、高级 +- 读书时代，搞ACM的伙伴必备的一本书，我们大学班主任也非常推荐这本书。这是本经典好书，值得多看几遍。 + +#### 编程珠玑 +![](httpsp6-juejin.byteimg.comtos-cn-i-k3u1fbpfcp6cbe12c3d2f1430585af583e478f222f~tplv-k3u1fbpfcp-zoom-1.image) + 本书的特色是通过一些精心设计的有趣而又颇具指导意义的程序，对实用程序设计技巧及基本设计原则进行了透彻而睿智的描述，为复杂的编程问题提供了清晰而完备的解决思路。本书对各个层次的程序员都具有很高的阅读价值。 + +- 综合评分：9.1 +- 个人推荐指数：五星 +- 适合对象：初级、中级、高级 +- 算法导论是经典好书，而这本书的作者是算法导论作者的老师~ + + +#### 算法 +![](httpsp9-juejin.byteimg.comtos-cn-i-k3u1fbpfcp1668e40f45024aa3a8af1c35616886d3~tplv-k3u1fbpfcp-zoom-1.image) + + 本书全面讲述算法和数据结构的必备知识，具有以下几大特色算法领域的经典参考书、内容全面、全新修订的代码、与实际应用相结合、与实际应用相结合等 + +- 综合评分：9.4 +- 个人推荐指数：五星 +- 适合对象：初级、中级、高级 +- 非常清晰的算法书，什么叫态度？什么叫好书？这本书就是最好的范例。 + +### 专题六：缓存编程书单 +- 《Redis设计与实现》 +- 《Redis开发与运维》 + +#### Redis设计与实现 +![](httpsp1-juejin.byteimg.comtos-cn-i-k3u1fbpfcp6c0b0eb7ad2c4477b324bb96687ed526~tplv-k3u1fbpfcp-zoom-1.image) + + 系统而全面地描述了 Redis 内部运行机制。图示丰富，描述清晰，并给出大量参考信息，是NoSQL数据库开发人员案头必备。包括大部分Redis单机特征，以及所有多机特性。 + +- 综合评分：8.6 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 本书通俗易懂，可以先快速读一遍，了解下redis 机制。 + + +#### Redis开发与运维 +![](httpsp1-juejin.byteimg.comtos-cn-i-k3u1fbpfcpc5df5188a5434042a914f251c4c11e47~tplv-k3u1fbpfcp-zoom-1.image) + + 本书全面讲解Redis基本功能及其应用，并结合线上开发与运维监控中的实际使用案例，深入分析并总结了实际开发运维中遇到的“陷阱”，以及背后的原因，包含大规模集群开发与管理的场景、应用案例与开发技巧，为高效开发运维提供了大量实际经验和建议。 + +- 综合评分：8.9 +- 个人推荐指数：五星 +- 适合对象：初级、中级、高级 +- 该书逻辑清晰，深度恰当，尤其适合运维人员和初级开发人员。 + +### 专题七：数据库书单 +- 《sql必知必会》 +- 《高性能Mysql》 +- 《MySQL技术内幕：innodb存储引擎》 + +#### sql必知必会 +![](httpsp3-juejin.byteimg.comtos-cn-i-k3u1fbpfcpd56471ad5efb475881cf37012a1d5a73~tplv-k3u1fbpfcp-zoom-1.image) + 本书是深受世界各地读者欢迎的SQL经典畅销书，内容丰富，文字简洁明快，针对Oracle、SQL Server、MySQL、DB2、PostgreSQL、SQLite等各种主流数据库提供了大量简明的实例。 + +- 综合评分：8.5 +- 个人推荐指数：四星 +- 适合对象：初级、中级 +- 本书内容比较简单，适合新手，非常精炼。 + +#### 高性能Mysql +![](httpsp9-juejin.byteimg.comtos-cn-i-k3u1fbpfcp15363beaf148451595f4a6b481def4aa~tplv-k3u1fbpfcp-zoom-1.image) + 《高性能mysql(第3版)》不但适合数据库管理员（dba）阅读，也适合开发人员参考学习。不管是数据库新手还是专家，相信都能从本书有所收获。 + +- 综合评分：9.3 +- 个人推荐指数：五星 +- 适合对象：初级、中级、高级 +- DBA必读，开发也推荐阅读，全面的一本有关mysql应用的书籍。 + +#### MySQL技术内幕：innodb存储引擎 +![](httpsp1-juejin.byteimg.comtos-cn-i-k3u1fbpfcp1f72706478e14b2cb7ff9835dbdac550~tplv-k3u1fbpfcp-zoom-1.image) + 《MySQL技术内幕InnoDB存储引擎(第2版)》从源代码的角度深度解析了InnoDB的体系结构、实现原理、工作机制，并给出了大量最佳实践，能帮助你系统而深入地掌握InnoDB，更重要的是，它能为你设计管理高性能、高可用的数据库系统提供绝佳的指导。 + +- 综合评分：8.5 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 简单易懂，讲解比较透彻，值得一读。尤其对InnoDB的事务、锁等方面讲得比较详细。 + + +### 专题八：微服务 && 分布式 +- 《微服务架构设计模式》 +- 《从Paxos到Zookeeper分布式一致性原理与实践》 + +#### 微服务架构设计模式 +![](httpsp1-juejin.byteimg.comtos-cn-i-k3u1fbpfcpa8577a8cca4a4ef98622366c927dd4e4~tplv-k3u1fbpfcp-zoom-1.image) + 本书将教会你如何开发和部署生产级别的微服务架构应用。这套宝贵的架构设计模式建立在数十年的分布式系统经验之上，Chris 还为开发服务添加了新的模式，并将它们组合成可在真实条件下可靠地扩展和执行的系统。本书不仅仅是一个模式目录，还提供了经验驱动的建议，以帮助你设计、实现、测试和部署基于微服务的应用程序。 + +- 综合评分：9.1 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 44 个架构设计模式，理论联系实际开发经验，并且涉及涉及接口设计、数据库设计、架构设计等各个方面，很不错的一本书~ + +#### 从Paxos到Zookeeper分布式一致性原理与实践 +![](httpsp3-juejin.byteimg.comtos-cn-i-k3u1fbpfcpb2565b26f5de48af94ab530d68d4ec2e~tplv-k3u1fbpfcp-zoom-1.image) + 《Paxos到Zookeeper：分布式一致性原理与实践》从分布式一致性的理论出发，向读者简要介绍几种典型的分布式一致性协议，以及解决分布式一致性问题的思路，其中重点讲解了Paxos和ZAB协议。同时，本书深入介绍了分布式一致性问题的工业解决方案——ZooKeeper，并着重向读者展示这一分布式协调框架的使用方法、内部实现及运维技巧，旨在帮助读者全面了解ZooKeeper，并更好地使用和运维ZooKeeper。 + +- 综合评分：7.7 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 可以当做zookeeper的入门书籍，偏理论，整体看一下是值得的。 + +### 专题九：消息中间件书单 +- 《Kafka权威指南》 +- 《RabbitMQ实战指南》 + +#### 《Kafka权威指南》 +![](httpsp9-juejin.byteimg.comtos-cn-i-k3u1fbpfcpb2a6370b0a294d77a4f2dcac5d179342~tplv-k3u1fbpfcp-zoom-1.image) + 本书详细介绍了如何部署Kafka集群、开发可靠的基于事件驱动的微服务，以及基于Kafka平台构建可伸缩的流式应用程序。通过详尽示例，你将会了解到Kafka的设计原则、可靠性保证、关键API，以及复制协议、控制器和存储层等架构细节。 + +- 综合评分：8.7 +- 个人推荐指数：四星 +- 适合对象：初级、中级 +- 学习Kafka入门一本不错的书籍 + +#### RabbitMQ实战指南 +![](httpsp1-juejin.byteimg.comtos-cn-i-k3u1fbpfcp3a900389498b433c807c8b013eac1234~tplv-k3u1fbpfcp-zoom-1.image) + 《RabbitMQ实战指南》从消息中间件的概念和RabbitMQ的历史切入，主要阐述RabbitMQ的安装、使用、配置、管理、运维、原理、扩展等方面的细节。 + +- 综合评分：8.7 +- 个人推荐指数：四星 +- 适合对象：初级、中级 +- 学习RabbitMQ 一本很不错的书籍 + +### 专题十：容器书单 +- 《Docker——容器与容器云》 + +#### Docker——容器与容器云（第2版） +![](httpsp3-juejin.byteimg.comtos-cn-i-k3u1fbpfcpd854fc3f26b3450599c970efcbaba10f~tplv-k3u1fbpfcp-zoom-1.image) + 从实践者的角度出发，以Docker和Kubernetes为重点，沿着“基本用法介绍”到“核心原理解读”到“高级实践技巧”的思路，一本书讲透当前主流的容器和容器云技术，有助于读者在实际场景中利用Docker容器和容器云解决问题并启发新的思考。 + +- 综合评分：8.4 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 市面上Docker的书不多，学习Docker的话，就推荐这本吧 + + +### 专题十一：面试相关书单 +- 《剑指offer》 +- 《程序员代码面试指南：IT名企算法与数据结构题目最优解》 +- 《编程之美微软技术面试心得》 +- leetCode + +#### 剑指offer +![](httpsp6-juejin.byteimg.comtos-cn-i-k3u1fbpfcpf615a0abb0cb47319042581152b6feab~tplv-k3u1fbpfcp-zoom-1.image) + 本书系统整理基础知识、代码质量、解题思路、优化效率和综合能力这5个面试要点，适合即将走向工作岗位的大学生阅读，也适合作为正在应聘软件行业的相关就业人员和计算机爱好者的参考书。 + +- 综合评分：9.2 +- 个人推荐指数：四星 +- 适合对象：初级、中级 +- 非常棒的书，把解题技巧、面试需要的能力等等都讲解到了。 + +#### 程序员代码面试指南：IT名企算法与数据结构题目最优解 +![](httpsp9-juejin.byteimg.comtos-cn-i-k3u1fbpfcpc1297d84543540339f79d7982ff057f8~tplv-k3u1fbpfcp-zoom-1.image) + 这是一本程序员面试宝典！书中对IT名企代码面试各类题目的最优解进行了总结，并提供了相关代码实现。针对当前程序员面试缺乏权威题目汇总这一痛点，本书选取将近200道真实出现过的经典代码面试题，帮助广大程序员的面试准备做到万无一失。 + +- 综合评分：8.9 +- 个人推荐指数：四星 +- 适合对象：初级、中级 +- 书中题目挺经典的，讲解也很详细。 + + +#### 编程之美微软技术面试心得 +![](httpsp6-juejin.byteimg.comtos-cn-i-k3u1fbpfcp531d18c72c8a4cd594a383a0386b1be2~tplv-k3u1fbpfcp-zoom-1.image) + 这本书收集了约60道算法和程序设计题目，这些题目大部分在近年的笔试、面试中出现过，或者是被微软员工热烈讨论过。作者试图从书中各种有趣的问题出发，引导读者发现问题，分析问题，解决问题，寻找更优的解法。 + +- 综合评分：8.4 +- 个人推荐指数：四星 +- 适合对象：初级、中级 +- 以前大四我们班同学找工作的时候，手上都有这基本书《剑指offer》、《编程之美》 + +#### letecode +![](httpsp1-juejin.byteimg.comtos-cn-i-k3u1fbpfcp4b4d3470fa6344f8b7f282ca92f02bd8~tplv-k3u1fbpfcp-zoom-1.image) +- 综合评分：9.6 +- 个人推荐指数：五星 +- 适合对象：初级、中级、高级 +- leetCode不是一本书，而是一个编程题网站，如果你面试找工作，尤其是面大厂，一定记得先去leetCode刷题哈。 + + +### 专题十二：软件开发&&程序人生相关书单 +- 《领域驱动设计软件核心复杂性应对之道》 +- 《人月神话》 +- 《程序员修炼之道》 +- 《软技能：代码之外的生存指南》 +- 《程序员思维修炼》 +- 《代码大全（第2版）》 + +#### 领域驱动设计软件核心复杂性应对之道 +![](httpsp6-juejin.byteimg.comtos-cn-i-k3u1fbpfcp863375dcf1434ac4a4e55783de47e0e4~tplv-k3u1fbpfcp-zoom-1.image) + 《领域驱动设计软件核心复杂性应对之道》是领域驱动设计方面的经典之作。全书围绕着设计和开发实践，结合若干真实的项目案例，向读者阐述如何在真实的软件开发中应用领域驱动设计。 + +- 综合评分：9.2 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 多读几遍，尤其做过几个比较大规模的系统后，再回来看这本书，会有不少收获的。 + + +#### 人月神话 +![](httpsp6-juejin.byteimg.comtos-cn-i-k3u1fbpfcp98efbe0ba94b43309684d31ae5e5afd2~tplv-k3u1fbpfcp-zoom-1.image) + 在软件领域，很少能有像《人月神话》一样具有深远影响力和畅销不衰的著作。Brooks博士为人们管理复杂项目提供了最具洞察力的见解，既有很多发人深省的观点，又有大量软件工程的实践。 + +- 综合评分：8.6 +- 个人推荐指数：五星 +- 适合对象：初级、中级、高级 +- 软件工程的经典著作，值得细细品味~ + +#### 程序员修炼之道(第2版) +![](httpsp1-juejin.byteimg.comtos-cn-i-k3u1fbpfcp06d3d31de9ae4345b37884c72e8a66d5~tplv-k3u1fbpfcp-zoom-1.image) + 《程序员修炼之道》之所以在全球范围内广泛传播，被一代代开发者奉为圭臬，盖因它可以创造出真正的价值：或编写出更好的软件，或探究出编程的本质，而所有收获均不依赖于特定语言、框架和方法。 + +- 综合评分：9.1 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 有朋友说，这本书改变了他的一生。 + +#### 软技能：代码之外的生存指南 +![](httpsp3-juejin.byteimg.comtos-cn-i-k3u1fbpfcpaa59bc55f1ec441f91b7a9b5d06591f2~tplv-k3u1fbpfcp-zoom-1.image) + 这是一本为软件开发者量身定做的职业发展指南，处于任何发展阶段的软件开发者，都将从本书中获益。 + +- 综合评分：9.1 +- 个人推荐指数：四星 +- 适合对象：初级、中级、高级 +- 我们从事软件开发这个行业，真的不仅仅有编码呢，你的职业发展是怎样的？如果迷茫就去看书，可以先看看这本~ + +#### 代码大全（第2版） +![](httpsp1-juejin.byteimg.comtos-cn-i-k3u1fbpfcp381471f5e33e46c6af7afc2a89a85fd6~tplv-k3u1fbpfcp-zoom-1.image) + 这是一本完整的软件构建手册，涵盖了软件构建过程中的所有细节。它从软件质量和编程思想等方面论述了软件构建的各个问题，并详细论述了紧跟潮流的新技术、高屋建瓴的观点、通用的概念，还含有丰富而典型的程序示例。 + +- 综合评分：9.1 +- 个人推荐指数：五星 +- 适合对象：初级、中级、高级 +- 作为一名程序员，感觉这本书必读 + + +### 个人公众号 +![](httpsp3-juejin.byteimg.comtos-cn-i-k3u1fbpfcpe6b23c704fc94ca09207b779f953cce6~tplv-k3u1fbpfcp-zoom-1.image) +- 更多干货，关注公众号 + + + + diff --git "a/\345\267\245\344\275\234\346\200\273\347\273\223/\344\270\200\346\254\241\344\273\243\347\240\201\344\274\230\345\214\226.md" "b/\345\267\245\344\275\234\346\200\273\347\273\223/\344\270\200\346\254\241\344\273\243\347\240\201\344\274\230\345\214\226.md" new file mode 100644 index 0000000..6052878 --- /dev/null +++ "b/\345\267\245\344\275\234\346\200\273\347\273\223/\344\270\200\346\254\241\344\273\243\347\240\201\344\274\230\345\214\226.md" @@ -0,0 +1,204 @@ +## 前言 +好久没分享工作总结啦，今天来一份代码优化总结。用模板方法+策略+工厂方法模式优化了代码，耐心点看完，应该对大家有帮助的~ + +本文已经收录到github +> https://github.com/whx123/JavaHome + +**公众号：捡田螺的小男孩** + +### 优化代码前 +先来了解一下类似的业务场景，简言之，就是：多个商户接入我们系统，都是走一个类似的流程通过http请求出去的。 +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b5ad1d5b5f57469894ecc83df77d68d9~tplv-k3u1fbpfcp-zoom-1.image) + +优化前，每个公司对应一个句柄服务，伪代码如下： +``` +// 商户A处理句柄 +CompanyAHandler implements RequestHandler { + Resp hander(req){ + //查询商户信息 + queryMerchantInfo(); + //加签 + signature(); + // http请求（走代理） + httpRequestbyProxy() + // 验签 + verify(); + } +} +// 商户B处理句柄 +CompanyBHandler implements RequestHandler { + Resp hander(Rreq){ + //查询商户信息 + queryMerchantInfo(); + //加签 + signature(); + // http请求（不走代理） + httpRequestbyDirect(); + // 验签 + verify(); + } +} +// 商户C处理句柄 +CompanyBHandler implements RequestHandler { + Resp hander(Rreq){ + //查询商户信息 + queryMerchantInfo(); + // webservice 方式调用 + requestByWebservice(); + } +} +``` +### 优化代码思路 +我的优化代码思路，是有**重复代码，先把它抽出来，或者公用变量，或者公用方法，伸着公用类**。所以呢，查询商户信息呀，加签呀，http请求呀先全部各抽成一个公用方法。你细心点会发现，连每个Handler处理过程都很类似的，大概都是查询商户信息+加签+http请求+验签，于是呢，可以直接把它们抽象成一个公用类呀~在这里就要引入模板方法模式咯 + +#### 模板方法模式 +``` +在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。 +这种类型的设计模式属于行为型模式。 +``` +既然每个Handler处理，都是类似的流程，那**定义一个抽象类，把查询商户信息，加签，http请求，验签什么的，都放到里面去，俨然一个模板一样**。然后，因为有些商户走http代理，有些又没走代理，怎么办呢? 定义**一个抽象方法，给子类实现**嘛，因为能共用就放到父类（当前的抽象类），不能共用就放到子类嘛~代码如下： +``` +abstract class AbstractCompanyCommonService implements ICompanyCommonService { + //模板方法 + Resp handlerTempPlate(req){ + //查询商户信息 + queryMerchantInfo(); + // 加签 + signature(); + //http 请求 + if(isRequestByProxy()){ + httpProxy(); + }else{ + httpDirect(); + } + // 验签 + verifySinature(); + } + // Http是否走代理 + abstract boolean isRequestByProxy(); +} +``` + +子类商户A实现： +``` +CompanyAServiceImpl extends AbstractCompanyCommonService{ + Resp hander(req){ + return handlerTempPlate(req); + } + //公司A是走代理的 + boolean isRequestByProxy(){ + return true; + } +``` +子类商户B实现： +``` +CompanyBServiceImpl extends AbstractCompanyCommonService{ + Resp hander(req){ + return handlerTempPlate(req); + } + //公司B是不走代理的 + boolean isRequestByProxy(){ + return false; + } +``` + +#### 策略模式 +心细的读者会发现，甚至提出疑问，**你的商户C的服务实现跟你定义的公用模板，不太一样呢**，那当然，实际开发中，不跟你定义的模板一样太常见了，需求是产品提的嘛，又不是根据你模板提的，是代码服务于需求的。好了，不多说啦，我使用了策略模式，来优化这个问题。 +``` +在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。 +``` +策略模式理解起来其好抽象对不对？我个人理解，其实策略模式就是定义一个方法（所谓算法），给子类自己去实现。实际上就是**定义个方法/接口，让子类自己去实现**。看代码吧： +``` +// 定义一个方法，把策略交给子类去实现。 +interface ICompanyCommonService{ + Resp hander(req); +} +``` +前面商户A和商户B还是不变，使用抽象类AbstractCompanyCommonService的模板，模板不满足商户C，商户C只能自己去实现咯，各个子类自己去实现的行为，就是策略模式的体现呢，如下： + +``` +CompanyCServiceImpl extends AbstractCompanyCommonService{ + Res hander(req){ + //查询商户信息 + queryMerchantInfo(); + requestByWebservice(); + } + //随意了，你都不走模板了 + boolean isRequestByProxy(){ + return false; + } +``` + +#### 工厂方法模式 + 商户A、B、C服务怎么被管理呢，之前分别给A，B，C服务实现handler的，现在好了，都不知道怎么管理了，怎么知道调用哪个呢？别慌，解决方案是**工厂方法模式**。 +``` +在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 +``` +工厂方法模式具体实现就是：接口定义一个枚举，每个服务实现都重新实现枚举，设置唯一标志枚举，再交给spring容器管理。看代码咯： +``` +interface ICompanyCommonService{ + Resp hander(req); + CompanyEnum getCompanyEnum(); +} + +CompanyAServiceImpl extends AbstractCompanyCommonService{ + Resp hander(req){ + return handlerTempPlate(req); + } + //公司A是走代理的 + boolean isRequestByProxy(){ + return true; + } + CompanyEnum getCompanyEnum(){ + return CompanyEnum.A; + } + +CompanyBServiceImpl extends AbstractCompanyCommonService{ + Resp hander(req){ + return handlerTempPlate(req); + } + //公司B是不走代理的 + boolean isRequestByProxy(){ + return false; + } + CompanyEnum getCompanyEnum(){ + return CompanyEnum.B; + } +``` +来来来，工厂方法模式出炉咯： +``` +@Component +public class CompanyServiceFactory implements ApplicationContextAware { + + private static Map map = new HashMap<>(); + + @Override + public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { + Map tempMap = applicationContext.getBeansOfType(ICompanyCommonService.class); + tempMap.values().forEach(iCompanyCommonService -> + map.put(iCompanyCommonService.getCompanyEnum(), iCompanyCommonService)); + } + + public Resp handler(req) { + return map.get(CompanyEnum.getCompanyEnum(req.getCompanyFlag()).hander(req); + } +} +``` +### 最后建议 +最后，不要为了使用设计模式生搬硬套，而是优化代码过程中，发现这个设计模式刚好适用，才去用的哈。附上最后的代码咯： +``` +@Service +public class CompanyHandler implements RequestHandler { + @Autowire + private CompanyServiceFactory companyServiceFactory; + + Resp hander(req){ + return companyServiceFactory.handler(req); + } +} +``` + +### 个人公众号 + +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/3e531344ab1a417188a4d8ece4148c64~tplv-k3u1fbpfcp-zoom-1.image) + From 9f14a64321eb6c041082bb3cfb55426fc5989cc6 Mon Sep 17 00:00:00 2001 From: whx123 <327658337@qq.com> Date: Thu, 15 Oct 2020 07:55:13 +0800 Subject: [PATCH 21/77] =?UTF-8?q?mleetcode=E7=AE=97=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...00\351\201\215\345\260\261\346\207\202.md" | 182 +++++++++ ...27\346\263\225\350\257\246\350\247\243.md" | 382 ++++++++++++++++++ 2 files changed, 564 insertions(+) create mode 100644 "letecode\350\247\243\351\242\230\347\256\227\346\263\225\344\273\213\347\273\215/\345\217\215\350\275\254\351\223\276\350\241\250\347\234\213\344\270\200\351\201\215\345\260\261\346\207\202.md" create mode 100644 "letecode\350\247\243\351\242\230\347\256\227\346\263\225\344\273\213\347\273\215/\351\200\222\345\275\222\347\256\227\346\263\225\350\257\246\350\247\243.md" diff --git "a/letecode\350\247\243\351\242\230\347\256\227\346\263\225\344\273\213\347\273\215/\345\217\215\350\275\254\351\223\276\350\241\250\347\234\213\344\270\200\351\201\215\345\260\261\346\207\202.md" "b/letecode\350\247\243\351\242\230\347\256\227\346\263\225\344\273\213\347\273\215/\345\217\215\350\275\254\351\223\276\350\241\250\347\234\213\344\270\200\351\201\215\345\260\261\346\207\202.md" new file mode 100644 index 0000000..457a209 --- /dev/null +++ "b/letecode\350\247\243\351\242\230\347\256\227\346\263\225\344\273\213\347\273\215/\345\217\215\350\275\254\351\223\276\350\241\250\347\234\213\344\270\200\351\201\215\345\260\261\346\207\202.md" @@ -0,0 +1,182 @@ +## 前言 +反转链表是程序员必备的基本素养，经常在面试、笔试的过程中出现。一直觉得反转链表实现代码不是很好理解，决定搬leetcode那道经典反转链表题出来，用十多张图去解析它，希望加深大家对链表反转的理解，谢谢阅读。 + +### leetcode的反转链表原题&答案 + +**题目描述：** 反转一个单链表。 +``` +输入: 1->2->3->4->5->NULL +输出: 5->4->3->2->1->NULL +``` + +**分析：** + +假设存在链表 1 → 2 → 3 → Ø，我们想要把它改成 Ø ← 1 ← 2 ← 3。 + +在遍历列表时，将当前节点的 next 指针改为指向前一个元素。由于节点没有引用其上一个节点，因此必须事先存储其前一个元素。在更改引用之前，还需要另一个指针来存储下一个节点。不要忘记在最后返回新的头引用！ + +**代码实现：** +``` +public ListNode reverseList(ListNode head) { + ListNode prev = null; + ListNode curr = head; + while (curr != null) { + ListNode nextTemp = curr.next; + curr.next = prev; + prev = curr; + curr = nextTemp; + } + return prev; +} +``` + +### 图解链表反转代码的实现 +接下来，我们图解以上代码实现，先对以上实现代码加上行号，如下： +``` +public ListNode reverseList(ListNode head) { //1 + ListNode prev = null; // 2 + ListNode curr = head; // 3 + while (curr != null) { //4 + ListNode nextTemp = curr.next; //5 + curr.next = prev; // 6 + prev = curr; //7 + curr = nextTemp; //8 + } + return prev; //9 +} +``` + +#### 第一行代码图解 + +``` +public ListNode reverseList(ListNode head) { //1 +``` +我们顺着题目描述意思，假设链表就有1、2、3个元素吧，后面还跟着一个null，又因为输入是ListNode head，所以这个即将要反转的链表如下: + +![](https://user-gold-cdn.xitu.io/2020/2/7/1701fbe941179b51?w=909&h=245&f=png&s=21126) + +#### 第二行代码图解 + +``` +ListNode prev = null; // 2 +``` +将null赋值给prev，即prev指向null，可得图如下： +![](https://user-gold-cdn.xitu.io/2020/2/7/1701f9da5c94b500?w=216&h=210&f=png&s=7193) + +#### 第三行代码图解 + +``` +ListNode curr = head; +``` +将链表head赋值给curr，即curr指向head链表，可得图如下： + +![](https://user-gold-cdn.xitu.io/2020/2/7/1701fbfcaab4dd99?w=870&h=243&f=png&s=20089) + + +#### 循环部分代码图解 + +``` + while (curr != null) { //4 + ListNode nextTemp = curr.next; //5 + curr.next = prev; // 6 + prev = curr; //7 + curr = nextTemp; //8 + } +``` +循环部分是**链表反转的核心**部分，我们先走一遍循环，图解分析一波。 + +因为**curr指向了head**，**head不为null**，所以进入循环。**先来看第5行：** +``` +ListNode nextTemp = curr.next; //5 +``` +把curr.next 赋值给nextTemp变量，即nextTemp 指向curr的下一节点（即节点2），可得图如下： + + +![](https://user-gold-cdn.xitu.io/2020/2/7/1701ff3466fffa10?w=833&h=240&f=png&s=21780) + +再执行到第6行： +``` +curr.next = prev; // 6 +``` +把prev赋值给curr.next,因为prev初始化化指向null，即curr(节点1)指向了null，链表图解成这样了： + + +![](https://user-gold-cdn.xitu.io/2020/2/7/1701fbd124bde1f2?w=1068&h=263&f=png&s=27349) + +然后我们看执行到第7行 + +``` + prev = curr; //7 +``` +把curr赋值给prev，prev指向curr，图解如下： + +![](https://user-gold-cdn.xitu.io/2020/2/7/1701fc2fc9a7ba5c?w=1091&h=347&f=png&s=35650) + +接着，我们执行到第8行： + +``` +curr = nextTemp; //8 +``` +把nextTemp赋值给curr，即curr指向nextTemp，图解如下： + +![](https://user-gold-cdn.xitu.io/2020/2/7/1701fc5ceadd3e2f?w=1042&h=364&f=png&s=35340) + +至此，第一遍循环执行结束啦，回到循环条件，**curr依旧不为null**，我们继续图解完它。 + +5-8行代码又执行一遍，依次可得图： + +``` + ListNode nextTemp = curr.next; //5 + curr.next = prev; // 6 + prev = curr; //7 + curr = nextTemp; //8 +``` + +执行完```ListNode nextTemp = curr.next; ```后： +![](https://user-gold-cdn.xitu.io/2020/2/7/1701fceea65ac66e?w=1011&h=360&f=png&s=34547) + +执行完```curr.next = prev; ```后： +![](https://user-gold-cdn.xitu.io/2020/2/7/1701fd391ef75c17?w=1108&h=339&f=png&s=35342) + +执行完```prev = curr; ```后： +![](https://user-gold-cdn.xitu.io/2020/2/7/1701fd5ad58277e1?w=1091&h=359&f=png&s=36280) + +执行完```curr = nextTemp;```后： +![](https://user-gold-cdn.xitu.io/2020/2/7/1701fd73f53f1a2b?w=1103&h=346&f=png&s=35454) + +来到这里，发现curr还是不为null，再回到while循环，再执行一遍： + +``` + ListNode nextTemp = curr.next; //5 + curr.next = prev; // 6 + prev = curr; //7 + curr = nextTemp; //8 +``` +依次可得图： + +![](https://user-gold-cdn.xitu.io/2020/2/7/1701fdf5b6532ed5?w=1130&h=340&f=png&s=35491) + + +![](https://user-gold-cdn.xitu.io/2020/2/7/1702007c264eddd4?w=1077&h=320&f=png&s=32820) + + +![](https://user-gold-cdn.xitu.io/2020/2/7/1701fe5ac9b9d1d8?w=1135&h=330&f=png&s=34388) + +![](https://user-gold-cdn.xitu.io/2020/2/7/1701fe66d7971447?w=1137&h=330&f=png&s=34740) + +来到这里，我们发现curr已经为null了，可以跳出循环了。这时候prev指向的就是链表的反转呀，所以第9行执行完，反转链表功能实现： + +``` + return prev; //9 +``` + +### 参考与感谢 +- [LeetCode 官网](https://leetcode-cn.com/problems/reverse-linked-list/solution/) + + +### 个人公众号 + +![](https://user-gold-cdn.xitu.io/2019/7/28/16c381c89b127bbb?w=344&h=344&f=jpeg&s=8943) + +- 如果你是个爱学习的好孩子，可以关注我公众号，一起学习讨论。 +- 如果你觉得本文有哪些不正确的地方，可以评论，也可以关注我公众号，私聊我，大家一起学习进步哈。 \ No newline at end of file diff --git "a/letecode\350\247\243\351\242\230\347\256\227\346\263\225\344\273\213\347\273\215/\351\200\222\345\275\222\347\256\227\346\263\225\350\257\246\350\247\243.md" "b/letecode\350\247\243\351\242\230\347\256\227\346\263\225\344\273\213\347\273\215/\351\200\222\345\275\222\347\256\227\346\263\225\350\257\246\350\247\243.md" new file mode 100644 index 0000000..2e9cb40 --- /dev/null +++ "b/letecode\350\247\243\351\242\230\347\256\227\346\263\225\344\273\213\347\273\215/\351\200\222\345\275\222\347\256\227\346\263\225\350\257\246\350\247\243.md" @@ -0,0 +1,382 @@ +### 前言 +递归是一种非常重要的算法思想，无论你是前端开发，还是后端开发，都需要掌握它。在日常工作中，统计文件夹大小，解析xml文件等等，都需要用到递归算法。它太基础太重要了，这也是为什么面试的时候，面试官经常让我们手写递归算法。本文呢，将跟大家一起学习递归算法~ + +- 什么是递归？ +- 递归的特点 +- 递归与栈的关系 +- 递归应用场景 +- 递归解题思路 +- leetcode案例分析 +- 递归可能存在的问题以及解决方案 + +github地址，感谢每一颗Star +> https://github.com/whx123/JavaHome + +**公众号：捡田螺的小男孩** + +### 什么是递归？ + +递归，在计算机科学中是指一种通过重复将问题分解为同类的子问题而解决问题的方法。简单来说，递归表现为函数调用函数本身。在知乎看到一个比喻递归的例子，个人觉得非常形象，大家看一下： + +> 递归最恰当的比喻，就是查词典。我们使用的词典，本身就是递归，为了解释一个词，需要使用更多的词。当你查一个词，发现这个词的解释中某个词仍然不懂，于是你开始查这第二个词，可惜，第二个词里仍然有不懂的词，于是查第三个词，这样查下去，直到有一个词的解释是你完全能看懂的，那么递归走到了尽头，然后你开始后退，逐个明白之前查过的每一个词，最终，你明白了最开始那个词的意思。 + +来试试水，看一个递归的代码例子吧，如下： +``` +public int sum(int n) { + if (n <= 1) { + return 1; + } + return sum(n - 1) + n; +} +``` + +### 递归的特点 + +实际上，递归有两个显著的特征,终止条件和自身调用: +- 自身调用：原问题可以分解为子问题，子问题和原问题的求解方法是一致的，即都是调用自身的同一个函数。 +- 终止条件：递归必须有一个终止的条件，即不能无限循环地调用本身。 + +结合以上demo代码例子，看下递归的特点： + +![](//p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/44a74aecf0cc406aa8641b69a531a72c~tplv-k3u1fbpfcp-zoom-1.image) + + +### 递归与栈的关系 +其实，递归的过程，可以理解为出入栈的过程的，这个比喻呢，只是为了方便读者朋友更好理解递归哈。以上代码例子计算sum（n=3）的出入栈图如下： +![](//p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ce18f416a01a4900bd75250e781f799a~tplv-k3u1fbpfcp-zoom-1.image) + + +为了更容易理解一些，我们来看一下函数sum（n=5）的递归执行过程，如下： +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f587c37fea484be192fec7710634ec47~tplv-k3u1fbpfcp-zoom-1.image) + +- 计算sum（5）时，先sum（5）入栈，然后原问题sum（5）拆分为子问题sum（4），再入栈，直到终止条件sum（n=1）=1，就开始出栈。 +- sum（1）出栈后，sum（2）开始出栈，接着sum（3）。 +- 最后呢,sum（1）就是后进先出，sum（5）是先进后出，因此递归过程可以理解为栈出入过程啦~ + + +### 递归的经典应用场景 +哪些问题我们可以考虑使用递归来解决呢？即递归的应用场景一般有哪些呢？ +- 阶乘问题 +- 二叉树深度 +- 汉诺塔问题 +- 斐波那契数列 +- 快速排序、归并排序（分治算法也使用递归实现） +- 遍历文件，解析xml文件 + +### 递归解题思路 +解决递归问题一般就三步曲，分别是： +- 第一步，定义函数功能 +- 第二步，寻找递归终止条件 +- 第二步，递推函数的等价关系式 + +这个递归解题三板斧理解起来有点抽象，我们拿阶乘递归例子来喵喵吧~ + +#### 1.定义函数功能 +定义函数功能，就是说，你这个函数是干嘛的，做什么事情，换句话说，你要知道递归原问题是什么呀？比如你需要解决阶乘问题，定义的函数功能就是n的阶乘，如下： +``` +//n的阶乘（n为大于0的自然数） +int factorial (int n){ + +} +``` + +#### 2.寻找递归终止条件 +递归的一个典型特征就是必须有一个终止的条件，即不能无限循环地调用本身。所以，用递归思路去解决问题的时候，就需要寻找递归终止条件是什么。比如阶乘问题，当n=1的时候，不用再往下递归了，可以跳出循环啦，n=1就可以作为递归的终止条件，如下： +``` +//n的阶乘（n为大于0的自然数） +int factorial (int n){ + if(n==1){ + return 1; + } +} +``` + +#### 3.递推函数的等价关系式 +递归的**本义**，就是原问题可以拆为同类且更容易解决的子问题，即**原问题和子问题都可以用同一个函数关系表示。递推函数的等价关系式，这个步骤就等价于寻找原问题与子问题的关系，如何用一个公式把这个函数表达清楚**。阶乘的公式就可以表示为 f(n) = n * f(n-1), 因此，阶乘的递归程序代码就可以写成这样，如下： +``` +int factorial (int n){ + if(n==1){ + return 1; + } + return n * factorial(n-1); +} +``` +**注意啦**，不是所有递推函数的等价关系都像阶乘这么简单，一下子就能推导出来。需要我们多接触，多积累，多思考，多练习递归题目滴~ + +### leetcode案例分析 + +来分析一道leetcode递归的经典题目吧~ +> 原题链接在这里哈：https://leetcode-cn.com/problems/invert-binary-tree/ + +**题目：** 翻转一棵二叉树。 + +输入： +``` + 4 + / \ + 2 7 + / \ / \ +1 3 6 9 +``` +输出： +``` + 4 + / \ + 7 2 + / \ / \ +9 6 3 1 +``` + +我们按照以上递归解题的三板斧来： + +**1. 定义函数功能** + +函数功能（即这个递归原问题是），给出一颗树，然后翻转它，所以，函数可以定义为： +``` +//翻转一颗二叉树 +public TreeNode invertTree(TreeNode root) { +} + +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode(int x) { val = x; } + * } + */ +``` + +**2.寻找递归终止条件** + +这棵树什么时候不用翻转呢？当然是当前节点为null或者当前节点为叶子节点的时候啦。因此，加上终止条件就是： +``` +//翻转一颗二叉树 +public TreeNode invertTree(TreeNode root) { + if(root==null || (root.left ==null && root.right ==null)){ + return root; + } +} +``` + +**3. 递推函数的等价关系式** + +原问题之你要翻转一颗树，是不是可以拆分为子问题，分别翻转它的左子树和右子树？子问题之翻转它的左子树，是不是又可以拆分为，翻转它左子树的左子树以及它左子树的右子树？然后一直翻转到叶子节点为止。嗯，看图理解一下咯~ +![](//p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/989921d15f3d4986be085a5739c0ef62~tplv-k3u1fbpfcp-zoom-1.image) + + +首先，你要翻转根节点为4的树，就需要**翻转它的左子树（根节点为2）和右子树(根节点为7）**。这就是递归的**递**的过程啦 +![](//p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/9221f4ce5eeb4db6bde09eddb2029007~tplv-k3u1fbpfcp-zoom-1.image) + + +然后呢，根节点为2的树，不是叶子节点，你需要继续**翻转它的左子树（根节点为1）和右子树（根节点为3）**。因为节点1和3都是**叶子节点**了，所以就返回啦。这也是递归的**递**的过程~ + +![](//p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/005947098fcb4af4a1ac206c6c2ac004~tplv-k3u1fbpfcp-zoom-1.image) + +同理，根节点为7的树，也不是叶子节点，你需要翻转**它的左子树（根节点为6）和右子树（根节点为9）**。因为节点6和9都是叶子节点了，所以也返回啦。 + +![](//p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a6d0a17262234235aca86628beccb10d~tplv-k3u1fbpfcp-zoom-1.image) + + + +左子树（根节点为2）和右子树(根节点为7）都被翻转完后，这几个步骤就**归来**，即递归的归过程，翻转树的任务就完成了~ + +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/afada1b801734cdc899e896b0816b63f~tplv-k3u1fbpfcp-watermark.webp) + +显然，**递推关系式**就是： +``` +invertTree（root）= invertTree（root.left） + invertTree（root.right）; +``` + +于是，很容易可以得出以下代码： +``` +//翻转一颗二叉树 +public TreeNode invertTree(TreeNode root) { + if(root==null || (root.left ==null && root.right ==null){ + return root; + } + //翻转左子树 + TreeNode left = invertTree(root.left); + //翻转右子树 + TreeNode right= invertTree(root.right); +} +``` +这里代码有个地方需要注意，翻转完一棵树的左右子树，还要交换它左右子树的引用位置。 +``` + root.left = right; + root.right = left; +``` + +因此，leetcode这个递归经典题目的**终极解决代码**如下： +``` +class Solution { + public TreeNode invertTree(TreeNode root) { + if(root==null || (root.left ==null && root.right ==null)){ + return root; + } + //翻转左子树 + TreeNode left = invertTree(root.left); + //翻转右子树 + TreeNode right= invertTree(root.right); + //左右子树交换位置~ + root.left = right; + root.right = left; + return root; + } +} +``` +拿终极解决代码去leetcode提交一下，通过啦~ + + +![](//p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8cf1ccb571d44f45bfe9252bb12a79bb~tplv-k3u1fbpfcp-zoom-1.image) + + +### 递归存在的问题 +- 递归调用层级太多，导致栈溢出问题 +- 递归重复计算，导致效率低下 + +#### 栈溢出问题 +- 每一次函数调用在内存栈中分配空间，而每个进程的栈容量是有限的。 +- 当递归调用的层级太多时，就会超出栈的容量，从而导致调用栈溢出。 +- 其实，我们在前面小节也讨论了，递归过程类似于出栈入栈，如果递归次数过多，栈的深度就需要越深，最后栈容量真的不够咯 + +**代码例子如下：** +``` +/** + * 递归栈溢出测试 + */ +public class RecursionTest { + + public static void main(String[] args) { + sum(50000); + } + private static int sum(int n) { + if (n <= 1) { + return 1; + } + return sum(n - 1) + n; + } +} +``` +**运行结果:** +``` +Exception in thread "main" java.lang.StackOverflowError + at recursion.RecursionTest.sum(RecursionTest.java:13) +``` + +怎么解决这个栈溢出问题？首先需要**优化一下你的递归**，真的需要递归调用这么多次嘛？如果真的需要，先稍微**调大JVM的栈空间内存**，如果还是不行，那就需要弃用递归，**优化为其他方案**咯~ + +#### 重复计算，导致程序效率低下 +我们再来看一道经典的青蛙跳阶问题：一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。 + +绝大多数读者朋友，很容易就想到以下递归代码去解决： +``` +class Solution { + public int numWays(int n) { + if (n == 0){ + return 1; + } + if(n <= 2){ + return n; + } + return numWays(n-1) + numWays(n-2); + } +} +``` + +但是呢，去leetcode提交一下，就有问题啦，超出时间限制了 + + +![](//p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ccdfe1b9cc4a43aa917c9c84d81e2341~tplv-k3u1fbpfcp-zoom-1.image) + + +为什么超时了呢？递归耗时在哪里呢？先画出**递归树**看看： + +![](//p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/960f370eb35842eb9323538f7f6695ff~tplv-k3u1fbpfcp-zoom-1.image) + + +- 要计算原问题 f(10)，就需要先计算出子问题 f(9) 和 f(8) +- 然后要计算 f(9)，又要先算出子问题 f(8) 和 f(7)，以此类推。 +- 一直到 f(2) 和 f(1），递归树才终止。 + +我们先来看看这个递归的时间复杂度吧，**递归时间复杂度 = 解决一个子问题时间*子问题个数** +- 一个子问题时间 = f（n-1）+f（n-2），也就是一个加法的操作，所以复杂度是 **O(1)**； +- 问题个数 = 递归树节点的总数，递归树的总结点 = 2^n-1，所以是复杂度**O(2^n)**。 + +因此，青蛙跳阶，递归解法的时间复杂度 = O(1) * O(2^n) = O(2^n)，就是指数级别的，爆炸增长的，**如果n比较大的话，超时很正常的了**。 + +回过头来，你仔细观察这颗递归树，你会发现存在**大量重复计算**，比如f（8）被计算了两次，f（7）被重复计算了3次...所以这个递归算法低效的原因，就是存在大量的重复计算！ + +**那么，怎么解决这个问题呢？** + +既然存在大量重复计算，那么我们可以先把计算好的答案存下来，即造一个备忘录，等到下次需要的话，先去**备忘录**查一下，如果有，就直接取就好了，备忘录没有才再计算，那就可以省去重新重复计算的耗时啦！这就是**带备忘录的解法** + +我们来看一下**带备忘录的递归解法**吧~ + +一般使用一个数组或者一个哈希map充当这个**备忘录**。 + +假设f(10)求解加上**备忘录**，我们再来画一下递归树： + +**第一步**，f（10）= f(9) + f(8)，f(9) 和f（8）都需要计算出来，然后再加到备忘录中，如下： + +![](//p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/71ae2665e01e49c8bc88f8bf01f0d2b2~tplv-k3u1fbpfcp-zoom-1.image) + +**第二步，** f(9) = f（8）+ f（7），f（8）= f（7）+ f(6), 因为 f(8) 已经在备忘录中啦，所以可以省掉，f(7),f（6）都需要计算出来，加到备忘录中~ + + +![](//p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/13d385fb005a4784918f4fb810033a51~tplv-k3u1fbpfcp-zoom-1.image) + + + +**第三步，** f(8) = f（7）+ f(6),发现f(8)，f(7),f（6）全部都在备忘录上了，所以都可以剪掉。 +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ec535ab8a0d3401eae5cb041dabac221~tplv-k3u1fbpfcp-watermark.image) + +所以呢，用了备忘录递归算法，递归树变成光秃秃的树干咯，如下： +![](//p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5eb16b3032dc493389529e3821b22ba8~tplv-k3u1fbpfcp-zoom-1.image) + + +带「备忘录」的递归算法，子问题个数=树节点数=n，解决一个子问题还是O(1),所以**带「备忘录」的递归算法的时间复杂度是O(n)**。接下来呢，我们用带「备忘录」的递归算法去撸代码，解决这个青蛙跳阶问题的超时问题咯~，代码如下： + +``` +public class Solution { + //使用哈希map，充当备忘录的作用 + Map tempMap = new HashMap(); + public int numWays(int n) { + // n = 0 也算1种 + if (n == 0) { + return 1; + } + if (n <= 2) { + return n; + } + //先判断有没计算过，即看看备忘录有没有 + if (tempMap.containsKey(n)) { + //备忘录有，即计算过，直接返回 + return tempMap.get(n); + } else { + // 备忘录没有，即没有计算过，执行递归计算,并且把结果保存到备忘录map中，对1000000007取余（这个是leetcode题目规定的） + tempMap.put(n, (numWays(n - 1) + numWays(n - 2)) % 1000000007); + return tempMap.get(n); + } + } +} +``` + +去leetcode提交一下，如图，稳了： + +![](//p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1322a96e4eae44229fdea9f78e0d440b~tplv-k3u1fbpfcp-zoom-1.image) + +还有没有其他方案解决这个问题呢？只有**带备忘录的递归解法**？其实吧，还可以用**动态规划**去解决 + +动态规划算法思想怎么解题？我们下期继续~ 谢谢阅读~ + +### 参考与感谢 +- [一文学会递归解题] (https://mp.weixin.qq.com/s/Hew44D8rdXb3pf8mZGk67w) +- [动态规划详解] (https://mp.weixin.qq.com/s/1V3aHVonWBEXlNUvK3S28w) + +### 更多干货 +**公众号：捡田螺的小男孩** +- 更多干货，关注公众号 +- 回复pdf，获取学习电子书 + From 3970f0e0e93cc0e44ae9fc8cda564864e4099e64 Mon Sep 17 00:00:00 2001 From: whx123 <327658337@qq.com> Date: Sat, 17 Oct 2020 16:24:06 +0800 Subject: [PATCH 22/77] =?UTF-8?q?=E8=8C=B6=E4=BD=99=E9=A5=AD=E5=90=8E?= =?UTF-8?q?=E5=91=A8=E6=8A=A5=E4=BA=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...13\345\221\250\346\212\245\344\272\214.md" | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 "\350\214\266\344\275\231\351\245\255\345\220\216\350\260\210\347\274\226\347\250\213\345\255\246\344\271\240\345\221\250\346\212\245/\350\214\266\344\275\231\351\245\255\345\220\216\347\274\226\347\250\213\345\221\250\346\212\245\344\272\214.md" diff --git "a/\350\214\266\344\275\231\351\245\255\345\220\216\350\260\210\347\274\226\347\250\213\345\255\246\344\271\240\345\221\250\346\212\245/\350\214\266\344\275\231\351\245\255\345\220\216\347\274\226\347\250\213\345\221\250\346\212\245\344\272\214.md" "b/\350\214\266\344\275\231\351\245\255\345\220\216\350\260\210\347\274\226\347\250\213\345\255\246\344\271\240\345\221\250\346\212\245/\350\214\266\344\275\231\351\245\255\345\220\216\347\274\226\347\250\213\345\221\250\346\212\245\344\272\214.md" new file mode 100644 index 0000000..b5bb492 --- /dev/null +++ "b/\350\214\266\344\275\231\351\245\255\345\220\216\350\260\210\347\274\226\347\250\213\345\255\246\344\271\240\345\221\250\346\212\245/\350\214\266\344\275\231\351\245\255\345\220\216\347\274\226\347\250\213\345\221\250\346\212\245\344\272\214.md" @@ -0,0 +1,27 @@ +**问题一：** + +我现在用了一个静态线程池，用于整个请求共享。设置的参数是核心线程10个，最大线程147个，阻塞队列2048，策略是超过就丢弃并且抛异常。 +当qps在1000的时候，由于一个请求我需要分成三次去请求不同的接口，就相当于有3000个调用接口的请求。但是请求用的是实时接口，如果该接口响应很慢比如10秒钟，那么这147个线程就全部挂起了，没有空余的线程去处理新的业务了。整个系统的响应就非常慢了。 + +群上回复答案： +> - 响应很慢的接口走异步，把返回的数据丢到queue里面。 +> - 应该是10秒的接口得改 +> - 接口慢了的话，看下能不能用redis +> - 合并请求，减少网络传输时间 +> - 优化接口肯定需要，从源头解决 + +我觉得，先理解好线程池原理吧，就是，来个请求就拿个核心线程去处理，如果核心线程用完了，就放队列，队列满了，就拿非核心线程去处理，处理不过来之后，就根据策略去处理，线程干完活又会被拉取干别的~然后呢，就算每秒以前个请求过来，最多也是线程池供应不过来，然后抛弃一部分请求，跟响应慢不是一个因果关系。 + +![](https://imgkr2.cn-bj.ufileos.com/5f138381-05f3-4aa2-a344-98e8b970a920.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=yJuf5adRW5I%252BSl3%252FWX1oyVr9%252Ffo%253D&Expires=1603008626) + + +其实，如果每个请求30毫秒处理完，可能你的线程池也够用了。但是呢，如果你一个请求，接口处理10s，也就是说10秒，它没干完活，没法接别的活，肯定系统就处理不过来那么多请求啦，所以最后结果就是，一部分请求就会抛弃，因为线程池抛弃策略抛弃啦。回过头，你的系统响应慢，就是你的接口耗时问题呀，你需要优化它。 + +可以看下我这两篇文章。线程池和如何接口性能优化的~ + + + +关于线程池和接口性能优化的，可以看下我之前这两篇文章哈 +- [面试必备：Java线程池解析](https://mp.weixin.qq.com/s?__biz=MzIwOTE2MzU4NA==&mid=2247483728&idx=1&sn=0221dfd5eb7862c0aa749a7038b39307&chksm=9779457fa00ecc69d3bb554ccc1daa8aa204b16b15587759cf1f148bda51907f6f57418e150f&token=1319249232&lang=zh_CN#rd) + +- [记一次接口性能优化实践总结：优化接口性能的八个建议](https://mp.weixin.qq.com/s?__biz=MzIwOTE2MzU4NA==&mid=2247484426&idx=1&sn=7265be5a5c37e71e65a2e42c999d3f72&chksm=97794025a00ec93379ad537353dd58f9149f801e100786a2b9c8cf37257e6d863d7ce4b87a5e&token=1319249232&lang=zh_CN#rd) \ No newline at end of file From 0ddde5f51ba7776d3416f263b433559c93e3876b Mon Sep 17 00:00:00 2001 From: whx123 <327658337@qq.com> Date: Sun, 25 Oct 2020 18:42:12 +0800 Subject: [PATCH 23/77] =?UTF-8?q?=E5=91=A8=E6=8A=A5=E4=B8=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...13\345\221\250\346\212\245\344\270\211.md" | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 "\350\214\266\344\275\231\351\245\255\345\220\216\350\260\210\347\274\226\347\250\213\345\255\246\344\271\240\345\221\250\346\212\245/\350\214\266\344\275\231\351\245\255\345\220\216\350\260\210\347\274\226\347\250\213\345\221\250\346\212\245\344\270\211.md" diff --git "a/\350\214\266\344\275\231\351\245\255\345\220\216\350\260\210\347\274\226\347\250\213\345\255\246\344\271\240\345\221\250\346\212\245/\350\214\266\344\275\231\351\245\255\345\220\216\350\260\210\347\274\226\347\250\213\345\221\250\346\212\245\344\270\211.md" "b/\350\214\266\344\275\231\351\245\255\345\220\216\350\260\210\347\274\226\347\250\213\345\255\246\344\271\240\345\221\250\346\212\245/\350\214\266\344\275\231\351\245\255\345\220\216\350\260\210\347\274\226\347\250\213\345\221\250\346\212\245\344\270\211.md" new file mode 100644 index 0000000..947f1ef --- /dev/null +++ "b/\350\214\266\344\275\231\351\245\255\345\220\216\350\260\210\347\274\226\347\250\213\345\255\246\344\271\240\345\221\250\346\212\245/\350\214\266\344\275\231\351\245\255\345\220\216\350\260\210\347\274\226\347\250\213\345\221\250\346\212\245\344\270\211.md" @@ -0,0 +1,22 @@ +### 问题一: netty内存泄漏 + +**Magee:有没有大佬了解这个异常的啊,使用的springcloudgateway，底层没有改动** +> ERROR io.netty.util.ResourceLeakDetector -LEAK: ByteBuf.release() was not called before it's garbage-collected. See http://netty.io/wiki/reference-counted-objects.html for more information. + + +**Shawn：** +> ByteBuf.release()之后没有通知垃圾回收 + +**百里半：** +> - 内存泄漏了,应该是你们重写了他们的方法，在最后没有release. +> - netty有自己的内存检测机制，你这个报错不速度解决，过一会服务就不可用了 +> - 我遇到过，docker直接挂掉 +> - 解决方法：找到你们重写的地方，把release加上，怎么加可以参考netty源码里面release怎么用的就好了 + +### 问题二：消息队列应用场景 +**spring：** +> 请教下，消息队列你们在项目中实际用在哪些场景？ + +**张大树:** +> - 削峰，减少数据库压力. +> - 假设有10万个请求过来了，然后数据需要入库，但是如果同时写库会有压力，就可以自己生产，自己消费mq ，异步入库，前提是可以异步入库 From 39ce255ac93e2dff8230bb527562ac8e3b6529cd Mon Sep 17 00:00:00 2001 From: whx123 <327658337@qq.com> Date: Thu, 26 Nov 2020 00:28:29 +0800 Subject: [PATCH 24/77] =?UTF-8?q?=E2=80=98=E5=86=99=E4=BB=A3=E7=A0=81?= =?UTF-8?q?=E5=A5=BD=E4=B9=A0=E6=83=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md.bak | 0 ...22\345\275\222\350\257\246\350\247\243.md" | 380 ++++++++++++++++++ ...04\345\245\275\344\271\240\346\203\257.md" | 294 ++++++++++++++ ...\247\204\351\201\27780%\347\232\204bug.md" | 1 + 4 files changed, 675 insertions(+) delete mode 100644 README.md.bak create mode 100644 "\345\210\267leetcode\345\277\205\345\244\207\347\256\227\346\263\225/\351\200\222\345\275\222\350\257\246\350\247\243.md" create mode 100644 "\345\267\245\344\275\234\346\200\273\347\273\223/Mysql\344\270\255\357\274\21421\344\270\252\345\206\231SQL\347\232\204\345\245\275\344\271\240\346\203\257.md" create mode 100644 "\345\267\245\344\275\234\346\200\273\347\273\223/\345\206\231\344\273\243\347\240\201\346\234\211\350\277\23116\344\270\252\344\271\240\346\203\257\357\274\214\350\247\204\351\201\27780%\347\232\204bug.md" diff --git a/README.md.bak b/README.md.bak deleted file mode 100644 index e69de29..0000000 diff --git "a/\345\210\267leetcode\345\277\205\345\244\207\347\256\227\346\263\225/\351\200\222\345\275\222\350\257\246\350\247\243.md" "b/\345\210\267leetcode\345\277\205\345\244\207\347\256\227\346\263\225/\351\200\222\345\275\222\350\257\246\350\247\243.md" new file mode 100644 index 0000000..fb5ecdb --- /dev/null +++ "b/\345\210\267leetcode\345\277\205\345\244\207\347\256\227\346\263\225/\351\200\222\345\275\222\350\257\246\350\247\243.md" @@ -0,0 +1,380 @@ +### 前言 +递归是一种非常重要的算法思想，无论你是前端开发，还是后端开发，都需要掌握它。在日常工作中，统计文件夹大小，解析xml文件等等，都需要用到递归算法。它太基础太重要了，这也是为什么面试的时候，面试官经常让我们手写递归算法。本文呢，将跟大家一起学习递归算法~ + +- 什么是递归？ +- 递归的特点 +- 递归与栈的关系 +- 递归应用场景 +- 递归解题思路 +- leetcode案例分析 +- 递归可能存在的问题以及解决方案 + + +**公众号：捡田螺的小男孩** + +### 什么是递归？ + +递归，在计算机科学中是指一种通过重复将问题分解为同类的子问题而解决问题的方法。简单来说，递归表现为函数调用函数本身。在知乎看到一个比喻递归的例子，个人觉得非常形象，大家看一下： + +> 递归最恰当的比喻，就是查词典。我们使用的词典，本身就是递归，为了解释一个词，需要使用更多的词。当你查一个词，发现这个词的解释中某个词仍然不懂，于是你开始查这第二个词，可惜，第二个词里仍然有不懂的词，于是查第三个词，这样查下去，直到有一个词的解释是你完全能看懂的，那么递归走到了尽头，然后你开始后退，逐个明白之前查过的每一个词，最终，你明白了最开始那个词的意思。 + +来试试水，看一个递归的代码例子吧，如下： +``` +public int sum(int n) { + if (n <= 1) { + return 1; + } + return sum(n - 1) + n; +} +``` + +### 递归的特点 + +实际上，递归有两个显著的特征,终止条件和自身调用: +- 自身调用：原问题可以分解为子问题，子问题和原问题的求解方法是一致的，即都是调用自身的同一个函数。 +- 终止条件：递归必须有一个终止的条件，即不能无限循环地调用本身。 + +结合以上demo代码例子，看下递归的特点： + +![](https://imgkr2.cn-bj.ufileos.com/94f250ad-41ea-4760-ae79-060f91605aeb.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=gQGMVnPTDwM%252F5AX2OrH%252F0ugG9MA%253D&Expires=1602691176) + + +### 递归与栈的关系 +其实，递归的过程，可以理解为出入栈的过程的，这个比喻呢，只是为了方便读者朋友更好理解递归哈。以上代码例子计算sum（n=3）的出入栈图如下： +![](https://imgkr2.cn-bj.ufileos.com/d4f09883-727b-44b6-90e0-dfad9d768b8c.jpg?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=V%252BDCQxqTa24HsCxQcooMJ%252FzuOHc%253D&Expires=1602692111) + + +为了更容易理解一些，我们来看一下函数sum（n=5）的递归执行过程，如下： +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f587c37fea484be192fec7710634ec47~tplv-k3u1fbpfcp-zoom-1.image) + +- 计算sum（5）时，先sum（5）入栈，然后原问题sum（5）拆分为子问题sum（4），再入栈，直到终止条件sum（n=1）=1，就开始出栈。 +- sum（1）出栈后，sum（2）开始出栈，接着sum（3）。 +- 最后呢,sum（1）就是后进先出，sum（5）是先进后出，因此递归过程可以理解为栈出入过程啦~ + + +### 递归的经典应用场景 +哪些问题我们可以考虑使用递归来解决呢？即递归的应用场景一般有哪些呢？ +- 阶乘问题 +- 二叉树深度 +- 汉诺塔问题 +- 斐波那契数列 +- 快速排序、归并排序（分治算法也使用递归实现） +- 遍历文件，解析xml文件 + +### 递归解题思路 +解决递归问题一般就三步曲，分别是： +- 第一步，定义函数功能 +- 第二步，寻找递归终止条件 +- 第二步，递推函数的等价关系式 + +这个递归解题三板斧理解起来有点抽象，我们拿阶乘递归例子来喵喵吧~ + +#### 1.定义函数功能 +定义函数功能，就是说，你这个函数是干嘛的，做什么事情，换句话说，你要知道递归原问题是什么呀？比如你需要解决阶乘问题，定义的函数功能就是n的阶乘，如下： +``` +//n的阶乘（n为大于0的自然数） +int factorial (int n){ + +} +``` + +#### 2.寻找递归终止条件 +递归的一个典型特征就是必须有一个终止的条件，即不能无限循环地调用本身。所以，用递归思路去解决问题的时候，就需要寻找递归终止条件是什么。比如阶乘问题，当n=1的时候，不用再往下递归了，可以跳出循环啦，n=1就可以作为递归的终止条件，如下： +``` +//n的阶乘（n为大于0的自然数） +int factorial (int n){ + if(n==1){ + return 1; + } +} +``` + +#### 3.递推函数的等价关系式 +递归的**本义**，就是原问题可以拆为同类且更容易解决的子问题，即**原问题和子问题都可以用同一个函数关系表示。递推函数的等价关系式，这个步骤就等价于寻找原问题与子问题的关系，如何用一个公式把这个函数表达清楚**。阶乘的公式就可以表示为 f(n) = n * f(n-1), 因此，阶乘的递归程序代码就可以写成这样，如下： +``` +int factorial (int n){ + if(n==1){ + return 1; + } + return n * factorial(n-1); +} +``` +**注意啦**，不是所有递推函数的等价关系都像阶乘这么简单，一下子就能推导出来。需要我们多接触，多积累，多思考，多练习递归题目滴~ + +### leetcode案例分析 + +来分析一道leetcode递归的经典题目吧~ +> 原题链接在这里哈：https://leetcode-cn.com/problems/invert-binary-tree/ + +**题目：** 翻转一棵二叉树。 + +输入： +``` + 4 + / \ + 2 7 + / \ / \ +1 3 6 9 +``` +输出： +``` + 4 + / \ + 7 2 + / \ / \ +9 6 3 1 +``` + +我们按照以上递归解题的三板斧来： + +**1. 定义函数功能** + +函数功能（即这个递归原问题是），给出一颗树，然后翻转它，所以，函数可以定义为： +``` +//翻转一颗二叉树 +public TreeNode invertTree(TreeNode root) { +} + +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode(int x) { val = x; } + * } + */ +``` + +**2.寻找递归终止条件** + +这棵树什么时候不用翻转呢？当然是当前节点为null或者当前节点为叶子节点的时候啦。因此，加上终止条件就是： +``` +//翻转一颗二叉树 +public TreeNode invertTree(TreeNode root) { + if(root==null || (root.left ==null && root.right ==null)){ + return root; + } +} +``` + +**3. 递推函数的等价关系式** + +原问题之你要翻转一颗树，是不是可以拆分为子问题，分别翻转它的左子树和右子树？子问题之翻转它的左子树，是不是又可以拆分为，翻转它左子树的左子树以及它左子树的右子树？然后一直翻转到叶子节点为止。嗯，看图理解一下咯~ +![](https://imgkr2.cn-bj.ufileos.com/938b0fcf-7ab2-4c8f-833f-382be7f8b46d.jpg?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=9BiTdqNsNnz%252FqynFWb52CMQkMnU%253D&Expires=1602692880) + + +首先，你要翻转根节点为4的树，就需要**翻转它的左子树（根节点为2）和右子树(根节点为7）**。这就是递归的**递**的过程啦 +![](https://imgkr2.cn-bj.ufileos.com/381538fe-fe34-4cae-9d1e-b5894ea542b2.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=HK51fa4jYvucnu6r3829BqFWcys%253D&Expires=1602693025) + + +然后呢，根节点为2的树，不是叶子节点，你需要继续**翻转它的左子树（根节点为1）和右子树（根节点为3）**。因为节点1和3都是**叶子节点**了，所以就返回啦。这也是递归的**递**的过程~ + +![](https://imgkr2.cn-bj.ufileos.com/c9195723-d803-4b76-9cb3-bec8192a696f.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=n5Ct31iSBnMmK2HJ7kB0I6ZhEYs%253D&Expires=1602693145) + +同理，根节点为7的树，也不是叶子节点，你需要翻转**它的左子树（根节点为6）和右子树（根节点为9）**。因为节点6和9都是叶子节点了，所以也返回啦。 + +![](https://imgkr2.cn-bj.ufileos.com/63333c60-747b-45d3-a8eb-dacf0cf36231.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=8NTb2Fj1PBlwVIxwe1InO5YqoWg%253D&Expires=1602693197) + + + +左子树（根节点为2）和右子树(根节点为7）都被翻转完后，这几个步骤就**归来**，即递归的归过程，翻转树的任务就完成了~ + +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/afada1b801734cdc899e896b0816b63f~tplv-k3u1fbpfcp-watermark.webp) + +显然，**递推关系式**就是： +``` +invertTree（root）= invertTree（root.left） + invertTree（root.right）; +``` + +于是，很容易可以得出以下代码： +``` +//翻转一颗二叉树 +public TreeNode invertTree(TreeNode root) { + if(root==null || (root.left ==null && root.right ==null){ + return root; + } + //翻转左子树 + TreeNode left = invertTree(root.left); + //翻转右子树 + TreeNode right= invertTree(root.right); +} +``` +这里代码有个地方需要注意，就是翻转完一棵树的左右子树后，需要交换它左右子树的引用位置。 +``` + root.left = right; + root.right = left; +``` + +因此，leetcode这个递归经典题目的**终极解决代码**如下： +``` +class Solution { + public TreeNode invertTree(TreeNode root) { + if(root==null || (root.left ==null && root.right ==null)){ + return root; + } + //翻转左子树 + TreeNode left = invertTree(root.left); + //翻转右子树 + TreeNode right= invertTree(root.right); + //左右子树交换位置~ + root.left = right; + root.right = left; + return root; + } +} +``` +拿终极解决代码去leetcode提交一下，通过啦~ + + +![](https://imgkr2.cn-bj.ufileos.com/3c9bc7ba-1677-4b8b-a389-e7177fd2b747.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=oNJFxSVWmku%252FMg%252BKlGHop%252BQ%252BxIw%253D&Expires=1602693611) + + +### 递归存在的问题 +- 递归调用层级太多，导致栈溢出问题 +- 递归重复计算，导致效率低下 + +#### 栈溢出问题 +- 每一次函数调用在内存栈中分配空间，而每个进程的栈容量是有限的。 +- 当递归调用的层级太多时，就会超出栈的容量，从而导致调用栈溢出。 +- 其实，我们在前面小节也讨论了，递归过程类似于出栈入栈，如果递归次数过多，栈的深度就需要越深，最后栈容量真的不够咯 + +**代码例子如下：** +``` +/** + * 递归栈溢出测试 + */ +public class RecursionTest { + + public static void main(String[] args) { + sum(50000); + } + private static int sum(int n) { + if (n <= 1) { + return 1; + } + return sum(n - 1) + n; + } +} +``` +**运行结果:** +``` +Exception in thread "main" java.lang.StackOverflowError + at recursion.RecursionTest.sum(RecursionTest.java:13) +``` + +怎么解决这个栈溢出问题？首先需要**优化一下你的递归**，真的需要递归调用这么多次嘛？如果真的需要，先稍微**调大JVM的栈空间内存**，如果还是不行，那就需要弃用递归，**优化为其他方案**咯~ + +#### 重复计算，导致程序效率低下 +我们再来看一道经典的青蛙跳阶问题：一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。 + +绝大多数读者朋友，很容易就想到以下递归代码去解决： +``` +class Solution { + public int numWays(int n) { + if (n == 0){ + return 1; + } + if(n <= 2){ + return n; + } + return numWays(n-1) + numWays(n-2); + } +} +``` + +但是呢，去leetcode提交一下，就有问题啦，超出时间限制了 + + +![](https://imgkr2.cn-bj.ufileos.com/47049001-7fae-4c98-8f4c-2e55aca367f3.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=xELiHeOso7vAsXwthfHEIDarVGs%253D&Expires=1602693967) + + +为什么超时了呢？递归耗时在哪里呢？先画出**递归树**看看： + +![](https://imgkr2.cn-bj.ufileos.com/9539296a-f5b1-433e-94ba-2e23eddfc409.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=Rzlo2ChPE7UEkCSJhbMNTBbtfaA%253D&Expires=1602694031) + + +- 要计算原问题 f(10)，就需要先计算出子问题 f(9) 和 f(8) +- 然后要计算 f(9)，又要先算出子问题 f(8) 和 f(7)，以此类推。 +- 一直到 f(2) 和 f(1），递归树才终止。 + +**递归时间复杂度 = 解决一个问题时间*问题个数** +- 一个问题时间 = f（n-1）+f（n-2），也就是一个加法的操作，所以复杂度是 **O(1)**； +- 问题个数 = 递归树节点的总数，递归树的总结点 = 2^n-1，所以是复杂度**O(2^n)**。 + +因此，青蛙跳阶，递归解法的时间复杂度 = O(1) * O(2^n) = O(2^n)，就是指数级别的，**如果n比较大的话，超时很正常的了**。 + +你仔细观察这颗递归树，你会发现存在**大量重复计算**，比如f（8）被计算了两次，f（7）被重复计算了3次...所以这个递归算法低效的原因，就是存在大量的重复计算！ + +**那么，怎么解决这个问题呢？** + +既然存在大量重复计算，那么我们可以先把计算好的答案存下来，即造一个备忘录，等到下次需要的话，先去**备忘录**查一下，如果有，就直接取就好了，备忘录没有才再去计算，那就可以省去重新重复计算的耗时啦！这就是**带备忘录的解法** + +我们来看一下**带备忘录的递归解法**吧~ + +一般使用一个数组或者一个哈希map充当这个**备忘录**。 + +假设f(10)求解加上**备忘录**，我们再来画一下递归树： + +**第一步**，f（10）= f(9) + f(8)，f(9) 和f（8）都需要计算出来，然后再加到备忘录中，如下： + +![](https://imgkr2.cn-bj.ufileos.com/22fe0dc0-136e-4e8d-9b54-7f1ff2a9d066.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=gJl54y4g86XMhK2K1ZbaqmVl94Y%253D&Expires=1602694255) + + +**第二步，** f(9) = f（8）+ f（7），f（8）= f（7）+ f(6), 因为 f(8) 已经在备忘录中啦，所以可以省掉，f(7),f（6）都需要计算出来，加到备忘录中~ + +![](https://imgkr2.cn-bj.ufileos.com/f9b26b22-c745-4bad-b14d-d8b2b51075f4.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=RkOd5Zj5Wwqonn63eXfoWqStvx4%253D&Expires=1602694275) + + +**第三步，** f(8) = f（7）+ f(6),发现f(8)，f(7),f（6）全部都在备忘录上了，所以都可以剪掉。 +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ec535ab8a0d3401eae5cb041dabac221~tplv-k3u1fbpfcp-watermark.image) + +所以呢，用了备忘录递归算法，递归树变成光秃秃的咯，如下： +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5b78faafe49b4ee0ab939194459cf386~tplv-k3u1fbpfcp-watermark.image) + +带「备忘录」的递归算法，子问题个数就为n了，解决一个子问题还是O(1),所以**带「备忘录」的递归算法的时间复杂度是O(n)**。接下来呢，我们用带「备忘录」的递归算法去撸代码，解决这个青蛙跳阶问题咯~，代码如下： + +``` +public class Solution { + //哈希map充当备忘录的作用 + Map tempMap = new HashMap(); + public int numWays(int n) { + // n = 0 也算1种 + if (n == 0) { + return 1; + } + if (n <= 2) { + return n; + } + //先判断有没计算过，即看看备忘录有没有 + if (tempMap.containsKey(n)) { + //备忘录有，即计算过，直接返回 + return tempMap.get(n); + } else { + // 备忘录没有，即没有计算过，执行递归计算,并且把结果保存到备忘录map中，对1000000007取余（这个是leetcode题目规定的） + tempMap.put(n, (numWays(n - 1) + numWays(n - 2)) % 1000000007); + return tempMap.get(n); + } + } +} +``` + +去leetcode提交一下，如图，稳了： + +![](https://imgkr2.cn-bj.ufileos.com/8208e494-07e6-467b-96a2-8acf77121737.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=zNVyzVvQaWVQaQmABckQvIVh1XE%253D&Expires=1602694530) + +啥叫「自顶向下」？注意我们刚才画的递归树（或者说图），是从上向下延伸，都是从一个规模较大的原问题比如说 f(20)，向下逐渐分解规模，直到 f(1) 和 f(2) 触底，然后逐层返回答案，这就叫「自顶向下」。 + + +啥叫「自底向上」？反过来，我们直接从最底下，最简单，问题规模最小的 f(1) 和 f(2) 开始往上推，直到推到我们想要的答案 f(20)，这就是动态规划的思路，这也是为什么动态规划一般都脱离了递归，而是由循环迭代完成计算。 + +动态规划问题，下期分解 + +### 参考与感谢 +- [一文学会递归解题](https://mp.weixin.qq.com/s/Hew44D8rdXb3pf8mZGk67w) +- [动态规划详解](https://mp.weixin.qq.com/s/1V3aHVonWBEXlNUvK3S28w) + +### 个人公众号 +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e6b23c704fc94ca09207b779f953cce6~tplv-k3u1fbpfcp-zoom-1.image) +- 更多干货，关注公众号 + diff --git "a/\345\267\245\344\275\234\346\200\273\347\273\223/Mysql\344\270\255\357\274\21421\344\270\252\345\206\231SQL\347\232\204\345\245\275\344\271\240\346\203\257.md" "b/\345\267\245\344\275\234\346\200\273\347\273\223/Mysql\344\270\255\357\274\21421\344\270\252\345\206\231SQL\347\232\204\345\245\275\344\271\240\346\203\257.md" new file mode 100644 index 0000000..bfece93 --- /dev/null +++ "b/\345\267\245\344\275\234\346\200\273\347\273\223/Mysql\344\270\255\357\274\21421\344\270\252\345\206\231SQL\347\232\204\345\245\275\344\271\240\346\203\257.md" @@ -0,0 +1,294 @@ +### 前言 +每一个好习惯都是一笔财富，本文分SQL后悔药， SQL性能优化，SQL规范优雅三个方向，分享写SQL的21个好习惯，谢谢阅读，加油哈~ + +github地址，感谢每颗star +> https://github.com/whx123/JavaHome + +公众号：**捡田螺的小男孩** + + +### 1. 写完SQL先explain查看执行计划（SQL性能优化） + +日常开发写SQL的时候，尽量养成这个好习惯呀：写完SQL后，用explain分析一下，尤其注意走不走索引。 +``` +explain select * from user where userid =10086 or age =18; +``` + +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/758773bfbe904d5ba801bc83d81a6bbc~tplv-k3u1fbpfcp-watermark.image) + + +### 2、操作delete或者update语句，加个limit(SQL后悔药） + + +在执行删除或者更新语句，尽量加上limit，以下面的这条 SQL 为例吧： +``` +delete from euser where age > 30 limit 200; +``` + +因为加了limit 主要有这些好处： + +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e14bfc881f21454ca40981b777f56e3e~tplv-k3u1fbpfcp-watermark.image) + + +- **降低写错SQL的代价**, 你在命令行执行这个SQL的时候，如果不加limit，执行的时候一个**不小心手抖**，可能数据全删掉了，如果**删错**了呢？加了limit 200，就不一样了。删错也只是丢失200条数据，可以通过binlog日志快速恢复的。 +- **SQL效率很可能更高**，你在SQL行中，加了limit 1，如果第一条就命中目标return，没有limit的话，还会继续执行扫描表。 +- **避免了长事务**，delete执行时,如果age加了索引，MySQL会将所有相关的行加写锁和间隙锁，所有执行相关行会被锁住，如果删除数量大，会直接影响相关业务无法使用。 +- **数据量大的话，容易把CPU打满** ,如果你删除数据量很大时，不加 limit限制一下记录数，容易把cpu打满，导致越删越慢的。 + + +### 3. 设计表的时候，所有表和字段都添加相应的注释（SQL规范优雅） + +这个好习惯一定要养成啦，设计数据库表的时候，所有表和字段都添加相应的注释，后面更容易维护。 + +**正例：** +``` +CREATE TABLE `account` ( + `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键Id', + `name` varchar(255) DEFAULT NULL COMMENT '账户名', + `balance` int(11) DEFAULT NULL COMMENT '余额', + `create_time` datetime NOT NULL COMMENT '创建时间', + `update_time` datetime NOT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间', + PRIMARY KEY (`id`), + KEY `idx_name` (`name`) USING BTREE +) ENGINE=InnoDB AUTO_INCREMENT=1570068 DEFAULT CHARSET=utf8 ROW_FORMAT=REDUNDANT COMMENT='账户表'; +``` + +**反例：** +``` +CREATE TABLE `account` ( + `id` int(11) NOT NULL AUTO_INCREMENT, + `name` varchar(255) DEFAULT NULL, + `balance` int(11) DEFAULT NULL, + `create_time` datetime NOT NULL , + `update_time` datetime NOT NULL ON UPDATE CURRENT_TIMESTAMP, + PRIMARY KEY (`id`), + KEY `idx_name` (`name`) USING BTREE +) ENGINE=InnoDB AUTO_INCREMENT=1570068 DEFAULT CHARSET=utf8; +``` + +### 4. SQL书写格式，关键字大小保持一致，使用缩进。（SQL规范优雅） + +正例： +``` +SELECT stu.name, sum(stu.score) +FROM Student stu +WHERE stu.classNo = '1班' +GROUP BY stu.name +``` + +反例： +``` +SELECT stu.name, sum(stu.score) from Student stu WHERE stu.classNo = '1班' group by stu.name. +``` +显然，统一关键字大小写一致，使用缩进对齐，会使你的SQL看起来更优雅~ + +### 5. INSERT语句标明对应的字段名称（SQL规范优雅） + +反例： +``` +insert into Student values ('666','捡田螺的小男孩','100'); +``` +正例： +``` +insert into Student(student_id,name,score) values ('666','捡田螺的小男孩','100'); +``` + +### 6. 变更SQL操作先在测试环境执行，写明详细的操作步骤以及回滚方案，并在上生产前review。（SQL后悔药） + +- 变更SQL操作先在测试环境测试，避免有语法错误就放到生产上了。 +- 变更Sql操作需要写明详细操作步骤，尤其有依赖关系的时候，如：先修改表结构再补充对应的数据。 +- 变更Sql操作有回滚方案，并在上生产前，review对应变更SQL。 + +### 7.设计数据库表的时候，加上三个字段：主键，create_time,update_time。（SQL规范优雅） + + +反例： +``` +CREATE TABLE `account` ( + `name` varchar(255) DEFAULT NULL COMMENT '账户名', + `balance` int(11) DEFAULT NULL COMMENT '余额', +) ENGINE=InnoDB AUTO_INCREMENT=1570068 DEFAULT CHARSET=utf8 ROW_FORMAT=REDUNDANT COMMENT='账户表'; +``` +正例： +``` +CREATE TABLE `account` ( + `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键Id', + `name` varchar(255) DEFAULT NULL COMMENT '账户名', + `balance` int(11) DEFAULT NULL COMMENT '余额', + `create_time` datetime NOT NULL COMMENT '创建时间', + `update_time` datetime NOT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间', + PRIMARY KEY (`id`), + KEY `idx_name` (`name`) USING BTREE +) ENGINE=InnoDB AUTO_INCREMENT=1570068 DEFAULT CHARSET=utf8 ROW_FORMAT=REDUNDANT COMMENT='账户表'; +``` +理由： +- 主键一定要加上的，没有主键的表是没有灵魂的 +- 创建时间和更新时间的话，还是建议加上吧，详细审计、跟踪记录，都是有用的。 + +阿里开发手册也提到这个点，如图 +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8a71648ba03c4f0fa6772a3c03cd99f2~tplv-k3u1fbpfcp-watermark.image) + + +### 8. 写完SQL语句，检查where,order by,group by后面的列，多表关联的列是否已加索引，优先考虑组合索引。（SQL性能优化） + +反例： +``` +select * from user where address ='深圳' order by age ; +``` +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1320d5f64b2640ff8221251505cacf14~tplv-k3u1fbpfcp-watermark.image) + +正例： +``` +添加索引 +alter table user add index idx_address_age (address,age) +``` +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/480d9d01a71c40228696fd22850e111d~tplv-k3u1fbpfcp-watermark.image) + +### 9.修改或删除重要数据前，要先备份，先备份，先备份（SQL后悔药） + +如果要修改或删除数据，在执行SQL前一定要先备份要修改的数据，万一误操作，还能吃口**后悔药**~ + +### 10. where后面的字段，留意其数据类型的隐式转换（SQL性能优化） + +**反例：** +``` +//userid 是varchar字符串类型 +select * from user where userid =123; +``` +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/17ad6b34e5a646028d9a086fd7ef7db0~tplv-k3u1fbpfcp-watermark.image) + +**正例：** +``` +select * from user where userid ='123'; +``` +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4bae5bd0b3564484b18e6f145ff65fd6~tplv-k3u1fbpfcp-watermark.image) + +**理由：** +- 因为不加单引号时，是字符串跟数字的比较，它们类型不匹配，MySQL会做隐式的类型转换，把它们转换为浮点数再做比较，最后导致索引失效 + + +### 11. 尽量把所有列定义为NOT NULL（SQL规范优雅） + +- **NOT NULL列更节省空间**，NULL列需要一个额外字节作为判断是否为 NULL 的标志位。 +- **NULL列需要注意空指针问题**，NULL列在计算和比较的时候，需要注意空指针问题。 + + +### 12.修改或者删除SQL，先写WHERE查一下，确认后再补充 delete 或 update（SQL后悔药） + +尤其在操作生产的数据时，遇到修改或者删除的SQL，先加个where查询一下，确认OK之后，再执行update或者delete操作 + +### 13.减少不必要的字段返回，如使用select <具体字段> 代替 select * （SQL性能优化） + +反例： +``` +select * from employee; +``` +正例： +``` +select id，name from employee; +``` +理由： + +- 节省资源、减少网络开销。 +- 可能用到覆盖索引，减少回表，提高查询效率。 + + +### 14.所有表必须使用Innodb存储引擎（SQL规范优雅） + +Innodb 支持事务，支持行级锁，更好的恢复性，高并发下性能更好，所以呢，没有特殊要求（即Innodb无法满足的功能如：列存储，存储空间数据等）的情况下，所有表必须使用Innodb存储引擎 + +### 15.数据库和表的字符集统一使用UTF8（SQL规范优雅） + +统一使用UTF8编码 +- 可以避免乱码问题 +- 可以避免，不同字符集比较转换，导致的索引失效问题 + +如果是存储表情的，可以考虑 utf8mb4 + +### 16. 尽量使用varchar代替 char。（SQL性能优化） + +反例： +``` + `deptName` char(100) DEFAULT NULL COMMENT '部门名称' +``` +正例： +``` +`deptName` varchar(100) DEFAULT NULL COMMENT '部门名称' +``` +理由： +- 因为首先变长字段存储空间小，可以节省存储空间。 + + +### 17. 如果修改字段含义或对字段表示的状态追加时，需要及时更新字段注释。（SQL规范优雅） + +这个点，是阿里开发手册中，Mysql的规约。你的字段，尤其是表示枚举状态时，如果含义被修改了，或者状态追加时，为了后面更好维护，需要即时更新字段的注释。 + + +### 18. SQL修改数据，养成begin + commit 事务的习惯；(SQL后悔药) +正例： +``` +begin; +update account set balance =1000000 +where name ='捡田螺的小男孩'; +commit; +``` +反例： +``` +update account set balance =1000000 +where name ='捡田螺的小男孩'; +``` + + +### 19. 索引命名要规范，主键索引名为 pk_ 字段名；唯一索引名为 uk _字段名；普通索引名则为 idx _字段名。（SQL规范优雅） + +说明： pk_ 即 primary key；uk _ 即 unique key；idx _ 即 index 的简称。 + + +### 20. WHERE从句中不对列进行函数转换和表达式计算 + +假设loginTime加了索引 + +**反例：** +``` +select userId,loginTime from loginuser where Date_ADD(loginTime,Interval 7 DAY) >=now(); +``` +**正例：** +``` +explain select userId,loginTime from loginuser where loginTime >= Date_ADD(NOW(),INTERVAL - 7 DAY); +``` +**理由：** +- 索引列上使用mysql的内置函数，索引失效 +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/07bd6e743d974638a70c2db91c6cc9f2~tplv-k3u1fbpfcp-watermark.image) + + + +### 21.如果修改\更新数据过多，考虑批量进行。 + +反例： +``` +delete from account limit 100000; +``` +正例： +``` +for each(200次) +{ + delete from account limit 500; +} +``` + +理由： +- 大批量操作会会造成主从延迟。 +- 大批量操作会产生大事务，阻塞。 +- 大批量操作，数据量过大，会把cpu打满。 + +### 参考与感谢 +- [delete后加 limit是个好习惯么](https://blog.csdn.net/qq_39390545/article/details/107519747) +- 《阿里开发手册》 + +### 公众号 +后端技术栈公众号：捡田螺的小男孩 + + + + + diff --git "a/\345\267\245\344\275\234\346\200\273\347\273\223/\345\206\231\344\273\243\347\240\201\346\234\211\350\277\23116\344\270\252\344\271\240\346\203\257\357\274\214\350\247\204\351\201\27780%\347\232\204bug.md" "b/\345\267\245\344\275\234\346\200\273\347\273\223/\345\206\231\344\273\243\347\240\201\346\234\211\350\277\23116\344\270\252\344\271\240\346\203\257\357\274\214\350\247\204\351\201\27780%\347\232\204bug.md" new file mode 100644 index 0000000..dcb3d26 --- /dev/null +++ "b/\345\267\245\344\275\234\346\200\273\347\273\223/\345\206\231\344\273\243\347\240\201\346\234\211\350\277\23116\344\270\252\344\271\240\346\203\257\357\274\214\350\247\204\351\201\27780%\347\232\204bug.md" @@ -0,0 +1 @@ +### ǰ�� ÿһ��ϰ�߶��һ�ʲƸ��д��16��ϰ�ߣ�ÿ��ܾ��䣬��Щϰ�ߣ��Թ�ܶ��ҵ��bug��ϣ��Դ��а��лл�Ķ��Ŷ~ github��ַ��лÿ��star > https://github.com/whx123/JavaHome ��ںţ�**��ݵ�С�к�** ### 1. �޸��룬�ǵ��Բ�һ�� **��룬�Բ�һ��** ��ÿλ��Ա�ر��Ļ��䲻Ҫ��ֽ��**��ֻ�Ǹ��һ��ֻ��һ��ô��룬��Բ��**��룬��Ҫ��Լ��ȥ��һ�¹��Թ�ܺܶ಻��Ҫbug�ġ� ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c730a4fe0ebb47258af9fd31f8d9c890~tplv-k3u1fbpfcp-watermark.image) ### 2. ��ξ�� У��Ҳ��ÿ��Ա�ر��Ļ��ķ��**��У��**��Ƿ��Ϊ�գ��γ��Ƿ��Ԥ�ڳ��ȡ��ϰ�߰ɣ��ܶ�**�ͼ�bug**��**��У��**��µġ� > ��ݿ��ֶ��Ϊvarchar(16),�Է��һ��32λ��ַ��㲻У��**��ݿ�ֱ��쳣**�ˡ� ![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/d1e3375dcfad46ca9ad88dafe7574de0~tplv-k3u1fbpfcp-watermark.image) ### 3. �޸��Ͻӿڵ�ʱ��˼��ӿڵļ��ԡ� �ܶ�bug��Ϊ�޸��˶��Ͻӿڣ��ȴ**��ݵ��**�ġ��ؼ��ǱȽ��صģ��ֱ�ӵ��ϵͳ��ʧ�ܵġ��ֳ��Ա��׾ͷ��Ŷ~ ��ԣ��ԭ��ӿ��޸ģ��ӿ��Ƕ��ṩ��Ļ��һ��Ҫ��ǽӿڼ��ݡ��ٸ��Ӱɣ��dubbo�ӿڣ�ԭ��ֻ��A��B��һ��C��Ϳ��Կ�� ``` //�Ͻӿ� void oldService(A,B);{ //��½ӿڣ��null��C newService(A,B,null); } //�½ӿڣ��ʱ��ɾ��Ͻӿڣ��Ҫ��ݡ� void newService(A,B,C); ``` ![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b8d4434f90314d24bdec6742c718a5f0~tplv-k3u1fbpfcp-watermark.image) ### 4.��ڸ��ӵĴ��߼��ע�� д��ʱ��û�б�Ҫд̫��ע�͵ģ��õķ��õ�ע�͡��ǣ��**ҵ��߼��ܸ��ӵĴ��**��ķǳ��б�Ҫд**��ע��**��ע�ͣ��ں��ά�� ![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a5d732fc2dbb4144a84b7d566ff4861b~tplv-k3u1fbpfcp-watermark.image) ### 5. ʹ��IO��Դ��Ҫ�ر� Ӧ�ô�Ҷ��й��ľ��windowsϵͳ��**��̫��ļ�**��ϵͳ��ͻ��õ��Ժܿ��Ȼ��linux��Ҳһ��ƽʱ��ļ��ݿ��ӣ�IO��Դ��û�رգ��ô��IO��Դ�ͻᱻ��ռ�ţ��˾�û�а취��ˣ��**��Դ�˷�**�� ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e3081d16ec54487eb03a9bbd513565ec~tplv-k3u1fbpfcp-watermark.image) ��ʹ��IO��ʹ��finally�رչ� ``` FileInputStream fdIn = null; try { fdIn = new FileInputStream(new File("/jay.txt")); } catch (FileNotFoundException e) { log.error(e); } catch (IOException e) { log.error(e); }finally { try { if (fdIn != null) { fdIn.close(); } } catch (IOException e) { log.error(e); } } ``` JDK 7 ֮��и�˧�Ĺر��д��ʹ��**try-with-resource**�� ``` /* * ��ע��ںţ��ݵ�С�к� */ try (FileInputStream inputStream = new FileInputStream(new File("jay.txt")) { // use resources } catch (FileNotFoundException e) { log.error(e); } catch (IOException e) { log.error(e); } ``` ### 6.��ȡ��ʩ��ʱ��߽��ȣ� �ճ��У��Ҫ��ȡ��ʩ��**��߽��ָ��**��ʱ�� ƴ��Ƚϳ�� ``` String name = list.get(1).getName(); //list��Խ�磬��Ϊ��һ��2��Ԫ�ع� ``` ��ԣ�Ӧ��**��ȡ��ʩ��Ԥ��һ��߽��**�� ``` if(CollectionsUtil.isNotEmpty(list)&& list.size()>1){ String name = list.get(1).getName(); } ``` ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/3757643c6e4044d797cc60646ce6b9d1~tplv-k3u1fbpfcp-watermark.image) ### 7.��ѭ��Զ�̵��á��ݿ��ȿ��С� Զ�̲��ݿ��**�ȽϺ��硢IO��Դ**�ģ��Ծ��ѭ��Զ�̵��á��ѭ��ݿ⣬��**��һ��Բ��Ҫѭ��ȥ��**��أ�Ҳ��Ҫһ��Բ�̫��ݹ��Ҫ��500һ�ν��ϣ� �� ``` remoteBatchQuery(param); ``` �� ``` for(int i=0;i��һ��ӣ��һ��http��˵ķ��Ҫ��connect-time��retry�� ת�˵��Ҫ�ĵ��񣬻��Ҫ��**ǩ��ǩ**��**��**�ȡ�֮ǰд��һƪ��ǩ��ǩ�ģ��Ȥ��ѿ��Կ�һ�¹� [��Ա�ر��ǩ��ǩ](https://mp.weixin.qq.com/s?__biz=MzIwOTE2MzU4NA==&mid=2247484887&idx=1&sn=316cfd80f7c60b40998eab004211ebb0&chksm=977941f8a00ec8eea93bbcd7b47e7dc39c6d05117ac93f80363d171c34fd4ae64f2f5b46d0ce&token=1951383729&lang=zh_CN#rd) ![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/79e0932bca0143aa971e2b6a3de2d67b~tplv-k3u1fbpfcp-watermark.image) ### 13.�ӿ��Ҫ��ݵ�� ӿ��Ҫ��ݵ��Եģ��ת��Щ��Ҫ�ӿڡ��ֱ�۵�ҵ�񳡾��**�û��ŵ��**��Ľӿ��û��holdס�� > - �ݵȣ�idempotent��idempotence��һ��ѧ��ѧ����ڳ��С� > - �ڱ��.һ��ݵȲ��ص��ִ��Ӱ��һ��ִ�е�Ӱ��ͬ��ݵȺ��ݵȷ��ָ��ʹ��ͬ��ظ�ִ�У��ܻ��ͬ��ĺ�� һ��**�ݵȼ��**��⼸��: - ��ѯ�� - Ψһ�� - token��ƣ��ֹ�ظ��ύ - ��ݿ��deleteɾ�� - �ֹ�� - �� - Redis��zookeeper �ֲ�ʽ��ǰ��Redis�ֲ�ʽ�� - ״̬��ݵ� ![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/a65c2e6c0c0840a982704a0982467771~tplv-k3u1fbpfcp-watermark.image) ### 14. ��߳��£��԰�ȫ�� **�߲��**��£�HashMap��ܻ��ѭ��Ϊ��Ƿ��԰�ȫ�ģ��Կ��ʹ��ConcurrentHashMap�� Ҳ��ϰ�ߣ��Ҫ��־��һ��new HashMap(); > - Hashmap��Arraylist��LinkedList��TreeMap�ȶ��Բ��ȫ�ģ� > - Vector��Hashtable��ConcurrentHashMap�ȶ��԰�ȫ�� ![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/2477f57cad1d4b8ab49a5d4d9ddce6cb~tplv-k3u1fbpfcp-watermark.image) ### 15.��ӳ��⿼�� Ȳ��룬��ž�ȥ��ѯ,��߼��Ƚϳ��**��**��ġ�һ��ݿⶼ��⣬�ӿ�ġ�д��Ļ��д��⣬��һ��Ƕ��ӿ⡣��ӳ٣��ܿ��ܳ��ɹ��ˣ��ѯ�� ![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/72f32d1f00b94498adf139620f2decab~tplv-k3u1fbpfcp-watermark.image) - ��Ҫҵ��Ҫ��Ƿ�ǿ�ƶ��⣬��޸��Ʒ�� - ��أ��Щҵ�񳡾��ǿ��Խ��΢�ӳ�һ��ģ��ϰ�߻��Ҫ�аɡ� - д��ݿ�Ĵ��룬��Ƿ��ӳ��⡣ ### 16.ʹ�û��ʱ�򣬿��Ǹ�DB��һ��ԣ��У��洩͸��ѩ��ͻ�� ͨ�׵�˵��ʹ�û��Ϊ��**��ÿ죬�ӿں�ʱС**��أ��õ��棬��Ҫ**ע�⻺��ݿ��һ��**��⡣ͬʱ��Ҫ��ܻ��洩͸��ѩ��ͻ��⡣ > - ��ѩ��ָ��ݴ��ʱ�䣬��ѯ��޴��ݿ�ѹ��down�� > - ��洩͸��ָ��ѯһ��һ��ڵ��ݣ��ڻ��ǲ��ʱ��Ҫ��ݿ��ѯ��鲻��д�뻺�棬�⽫��ڵ��ÿ��Ҫ��ݿ�ȥ��ѯ��ݿ��ѹ�� > - ��ָ�ȵ�key��ĳ��ʱ��ڵ�ʱ�򣬶�ǡ��ʱ��Key�д��Ĳ��Ӷ��db�� ![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/30bf76e99aab4d3aae46b48580041e90~tplv-k3u1fbpfcp-watermark.image) ### ��˹��ں� ��Ȥ��ѣ��Թ�ע�ҹ��ںŹ� > ԭ��ں� **��ݵ�С�к�**��רע��̽�ֺ�˼��㣬��Java��ԡ��硢��ݿ⡢��ݽṹ��㷨��ϵͳ��ܽ�ȷ��档��ͨ��׶��~ \ No newline at end of file From c83e5afb4fd14594cf6f4d6a3676e3f0c5f283fe Mon Sep 17 00:00:00 2001 From: whx123 <327658337@qq.com> Date: Sun, 27 Dec 2020 17:52:31 +0800 Subject: [PATCH 25/77] =?UTF-8?q?=E6=97=A5=E5=B8=B8=E5=BC=80=E5=8F=91?= =?UTF-8?q?=E5=9D=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...\347\232\20421\344\270\252\345\235\221.md" | 860 ++++++++++++++++++ 1 file changed, 860 insertions(+) create mode 100644 "\345\267\245\344\275\234\346\200\273\347\273\223/Java\346\227\245\345\270\270\345\274\200\345\217\221\347\232\20421\344\270\252\345\235\221.md" diff --git "a/\345\267\245\344\275\234\346\200\273\347\273\223/Java\346\227\245\345\270\270\345\274\200\345\217\221\347\232\20421\344\270\252\345\235\221.md" "b/\345\267\245\344\275\234\346\200\273\347\273\223/Java\346\227\245\345\270\270\345\274\200\345\217\221\347\232\20421\344\270\252\345\235\221.md" new file mode 100644 index 0000000..8155c5c --- /dev/null +++ "b/\345\267\245\344\275\234\346\200\273\347\273\223/Java\346\227\245\345\270\270\345\274\200\345\217\221\347\232\20421\344\270\252\345\235\221.md" @@ -0,0 +1,860 @@ +### 前言 +最近看了极客时间的《Java业务开发常见错误100例》，再结合平时踩的一些代码坑，写写总结，希望对大家有帮助，感谢阅读~ + +### 1. 六类典型空指针问题 + +- 包装类型的空指针问题 +- 级联调用的空指针问题 +- Equals方法左边的空指针问题 +- ConcurrentHashMap 这样的容器不支持 Key 和 Value 为 null。 +- 集合，数组直接获取元素 +- 对象直接获取属性 + +#### 1.1包装类型的空指针问题 + +``` +public class NullPointTest { + + public static void main(String[] args) throws InterruptedException { + System.out.println(testInteger(null)); + } + + private static Integer testInteger(Integer i) { + return i + 1; //包装类型，传参可能为null，直接计算，则会导致空指针问题 + } +} +``` + +#### 1.2 级联调用的空指针问题 + +``` +public class NullPointTest { + public static void main(String[] args) { + //fruitService.getAppleService() 可能为空，会导致空指针问题 + fruitService.getAppleService().getWeight().equals("OK"); + } +} +``` +#### 1.3 Equals方法左边的空指针问题 +``` +public class NullPointTest { + public static void main(String[] args) { + String s = null; + if (s.equals("666")) { //s可能为空，会导致空指针问题 + System.out.println("公众号：捡田螺的小男孩，666"); + } + } +} +``` + +#### 1.4 ConcurrentHashMap 这样的容器不支持 Key，Value 为 null。 +``` +public class NullPointTest { + public static void main(String[] args) { + Map map = new ConcurrentHashMap<>(); + String key = null; + String value = null; + map.put(key, value); + } +} +``` + +#### 1.5 集合，数组直接获取元素 +``` +public class NullPointTest { + public static void main(String[] args) { + int [] array=null; + List list = null; + System.out.println(array[0]); //空指针异常 + System.out.println(list.get(0)); //空指针一场 + } +} +``` + +#### 1.6 对象直接获取属性 +``` +public class NullPointTest { + public static void main(String[] args) { + User user=null; + System.out.println(user.getAge()); //空指针异常 + } +} +``` + +### 2. 日期YYYY格式设置的坑 + +日常开发，经常需要对日期格式化，但是呢，年份设置为YYYY大写的时候，是有坑的哦。 + +反例： +``` +Calendar calendar = Calendar.getInstance(); +calendar.set(2019, Calendar.DECEMBER, 31); + +Date testDate = calendar.getTime(); + +SimpleDateFormat dtf = new SimpleDateFormat("YYYY-MM-dd"); +System.out.println("2019-12-31 转 YYYY-MM-dd 格式后 " + dtf.format(testDate)); + +``` +运行结果： +``` +2019-12-31 转 YYYY-MM-dd 格式后 2020-12-31 +``` + +**解析：** + +为什么明明是2019年12月31号，就转了一下格式，就变成了2020年12月31号了？因为YYYY是基于周来计算年的，它指向当天所在周属于的年份，一周从周日开始算起，周六结束，只要本周跨年，那么这一周就算下一年的了。正确姿势是使用yyyy格式。 + +![](https://imgkr2.cn-bj.ufileos.com/f9d23f03-215c-4d30-a19d-08bd5feb1c12.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=HuC%252F%252BLpyl4nGfl%252Bg%252BlAsxAfWvwM%253D&Expires=1609139925) + + +正例： +``` +Calendar calendar = Calendar.getInstance(); +calendar.set(2019, Calendar.DECEMBER, 31); + +Date testDate = calendar.getTime(); + +SimpleDateFormat dtf = new SimpleDateFormat("yyyy-MM-dd"); +System.out.println("2019-12-31 转 yyyy-MM-dd 格式后 " + dtf.format(testDate)); + +``` + +### 3.金额数值计算精度的坑 + +看下这个浮点数计算的例子吧： +``` +public class DoubleTest { + public static void main(String[] args) { + System.out.println(0.1+0.2); + System.out.println(1.0-0.8); + System.out.println(4.015*100); + System.out.println(123.3/100); + + double amount1 = 3.15; + double amount2 = 2.10; + if (amount1 - amount2 == 1.05){ + System.out.println("OK"); + } + } +} +``` +运行结果： +``` +0.30000000000000004 +0.19999999999999996 +401.49999999999994 +1.2329999999999999 +``` + +可以发现，结算结果跟我们预期不一致，其实是因为计算机是以二进制存储数值的，对于浮点数也是。对于计算机而言，0.1无法精确表达，这就是为什么浮点数会导致精确度缺失的。因此，**金额计算，一般都是用BigDecimal 类型** + +对于以上例子，我们改为BigDecimal，再看看运行效果： + +``` +System.out.println(new BigDecimal(0.1).add(new BigDecimal(0.2))); +System.out.println(new BigDecimal(1.0).subtract(new BigDecimal(0.8))); +System.out.println(new BigDecimal(4.015).multiply(new BigDecimal(100))); +System.out.println(new BigDecimal(123.3).divide(new BigDecimal(100))); +``` + +运行结果： +``` +0.3000000000000000166533453693773481063544750213623046875 +0.1999999999999999555910790149937383830547332763671875 +401.49999999999996802557689079549163579940795898437500 +1.232999999999999971578290569595992565155029296875 +``` + +发现结果还是不对，**其实**，使用 BigDecimal 表示和计算浮点数，必须使用**字符串的构造方法**来初始化 BigDecimal，正例如下： +``` +public class DoubleTest { + public static void main(String[] args) { + System.out.println(new BigDecimal("0.1").add(new BigDecimal("0.2"))); + System.out.println(new BigDecimal("1.0").subtract(new BigDecimal("0.8"))); + System.out.println(new BigDecimal("4.015").multiply(new BigDecimal("100"))); + System.out.println(new BigDecimal("123.3").divide(new BigDecimal("100"))); + } +} +``` +在进行金额计算，使用BigDecimal的时候，我们还需要**注意BigDecimal的几位小数点，还有它的八种舍入模式哈**。 + + +### 4. FileReader默认编码导致乱码问题 + +看下这个例子： +``` +public class FileReaderTest { + public static void main(String[] args) throws IOException { + + Files.deleteIfExists(Paths.get("jay.txt")); + Files.write(Paths.get("jay.txt"), "你好,捡田螺的小男孩".getBytes(Charset.forName("GBK"))); + System.out.println("系统默认编码："+Charset.defaultCharset()); + + char[] chars = new char[10]; + String content = ""; + try (FileReader fileReader = new FileReader("jay.txt")) { + int count; + while ((count = fileReader.read(chars)) != -1) { + content += new String(chars, 0, count); + } + } + System.out.println(content); + } +} +``` +运行结果： +``` +系统默认编码：UTF-8 +��,��ݵ�С�к� +``` +从运行结果，可以知道，系统默认编码是utf8，demo中读取出来，出现乱码了。为什么呢？ +> FileReader 是以当**前机器的默认字符集**来读取文件的，如果希望指定字符集的话，需要直接使用 InputStreamReader 和 FileInputStream。 + +正例如下： +``` +public class FileReaderTest { + public static void main(String[] args) throws IOException { + + Files.deleteIfExists(Paths.get("jay.txt")); + Files.write(Paths.get("jay.txt"), "你好,捡田螺的小男孩".getBytes(Charset.forName("GBK"))); + System.out.println("系统默认编码："+Charset.defaultCharset()); + + char[] chars = new char[10]; + String content = ""; + try (FileInputStream fileInputStream = new FileInputStream("jay.txt"); + InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, Charset.forName("GBK"))) { + int count; + while ((count = inputStreamReader.read(chars)) != -1) { + content += new String(chars, 0, count); + } + } + System.out.println(content); + } +} +``` + +### 5. Integer缓存的坑 + +``` +public class IntegerTest { + + public static void main(String[] args) { + Integer a = 127; + Integer b = 127; + System.out.println("a==b:"+ (a == b)); + + Integer c = 128; + Integer d = 128; + System.out.println("c==d:"+ (c == d)); + } +} +``` +运行结果： +``` +a==b:true +c==d:false +``` + +为什么Integer值如果是128就不相等了呢？**编译器会把 Integer a = 127 转换为 Integer.valueOf(127)。** 我们看下源码。 + +``` +public static Integer valueOf(int i) { + if (i >= IntegerCache.low && i <= IntegerCache.high) + return IntegerCache.cache[i + (-IntegerCache.low)]; + return new Integer(i); + } +``` + +可以发现，i在一定范围内，是会返回缓存的。 +> 默认情况下呢，这个缓存区间就是[-128, 127]，所以我们业务日常开发中，如果涉及Integer值的比较，需要注意这个坑哈。还有呢，设置 JVM 参数加上 -XX:AutoBoxCacheMax=1000，是可以调整这个区间参数的，大家可以自己试一下哈 + +### 6. static静态变量依赖spring实例化变量，可能导致初始化出错 + +之前看到过类似的代码。静态变量依赖于spring容器的bean。 +``` + private static SmsService smsService = SpringContextUtils.getBean(SmsService.class); +``` +这个静态的smsService有可能获取不到的，因为类加载顺序不是确定的，正确的写法可以这样，如下： +``` + private static SmsService smsService =null; + + //使用到的时候采取获取 + public static SmsService getSmsService(){ + if(smsService==null){ + smsService = SpringContextUtils.getBean(SmsService.class); + } + return smsService; + } +``` + +### 7. 使用ThreadLocal，线程重用导致信息错乱的坑 + +使用ThreadLocal缓存信息，有可能出现信息错乱的情况。看下下面这个例子吧。 + +``` +private static final ThreadLocal currentUser = ThreadLocal.withInitial(() -> null); + +@GetMapping("wrong") +public Map wrong(@RequestParam("userId") Integer userId) { + //设置用户信息之前先查询一次ThreadLocal中的用户信息 + String before = Thread.currentThread().getName() + ":" + currentUser.get(); + //设置用户信息到ThreadLocal + currentUser.set(userId); + //设置用户信息之后再查询一次ThreadLocal中的用户信息 + String after = Thread.currentThread().getName() + ":" + currentUser.get(); + //汇总输出两次查询结果 + Map result = new HashMap(); + result.put("before", before); + result.put("after", after); + return result; +} +``` + +按理说，每次获取的before应该都是null，但是呢，程序运行在 Tomcat 中，执行程序的线程是 Tomcat 的工作线程，而 Tomcat 的工作线程是基于线程池的。 +> 线程池会重用固定的几个线程，一旦线程重用，那么很可能首次从 ThreadLocal 获取的值是之前其他用户的请求遗留的值。这时，ThreadLocal 中的用户信息就是其他用户的信息。 + +把tomcat的工作线程设置为1 +``` +server.tomcat.max-threads=1 +``` + +用户1，请求过来，会有以下结果，符合预期： + +![](https://imgkr2.cn-bj.ufileos.com/662885f9-682b-4492-9857-0f18916e22ff.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=O3aIs4Fm54VUZJygN4qTLOgr590%253D&Expires=1609140055) + + +用户2请求过来，会有以下结果，**不符合预期**： + +![](https://imgkr2.cn-bj.ufileos.com/0e74d06e-f9a7-4a37-9991-8f7b4c9bf35f.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=D3YGQ%252FwMW%252B7cQnm1YDtA2Rjh61w%253D&Expires=1609140506) + +因此，使用类似 ThreadLocal 工具来存放一些数据时，需要特别注意在代码运行完后，显式地去清空设置的数据，正例如下： + +``` +@GetMapping("right") +public Map right(@RequestParam("userId") Integer userId) { + String before = Thread.currentThread().getName() + ":" + currentUser.get(); + currentUser.set(userId); + try { + String after = Thread.currentThread().getName() + ":" + currentUser.get(); + Map result = new HashMap(); + result.put("before", before); + result.put("after", after); + return result; + } finally { + //在finally代码块中删除ThreadLocal中的数据，确保数据不串 + currentUser.remove(); + } +} +``` + +### 8. 疏忽switch的return和break +这一点严格来说，应该不算坑，但是呢，大家写代码的时候，有些朋友容易疏忽了。直接看例子吧 +``` +/* + * 关注公众号： + * 捡田螺的小男孩 + */ +public class SwitchTest { + + public static void main(String[] args) throws InterruptedException { + System.out.println("testSwitch结果是："+testSwitch("1")); + } + + private static String testSwitch(String key) { + switch (key) { + case "1": + System.out.println("1"); + case "2": + System.out.println(2); + return "2"; + case "3": + System.out.println("3"); + default: + System.out.println("返回默认值"); + return "4"; + } + } +} +``` +输出结果： +``` +测试switch +1 +2 +testSwitch结果是：2 +``` +switch 是会**沿着case一直往下匹配的，知道遇到return或者break。** 所以，在写代码的时候留意一下，是不是你要的结果。 + + +### 9. Arrays.asList的几个坑 + +#### 9.1 基本类型不能作为 Arrays.asList方法的参数，否则会被当做一个参数。 +``` +public class ArrayAsListTest { + public static void main(String[] args) { + int[] array = {1, 2, 3}; + List list = Arrays.asList(array); + System.out.println(list.size()); + } +} +``` +运行结果： +``` +1 +``` + Arrays.asList源码如下： +``` +public static List asList(T... a) { + return new ArrayList<>(a); +} +``` + +#### 9.2 Arrays.asList 返回的 List 不支持增删操作。 +``` +public class ArrayAsListTest { + public static void main(String[] args) { + String[] array = {"1", "2", "3"}; + List list = Arrays.asList(array); + list.add("5"); + System.out.println(list.size()); + } +} +``` +运行结果： +``` +Exception in thread "main" java.lang.UnsupportedOperationException + at java.util.AbstractList.add(AbstractList.java:148) + at java.util.AbstractList.add(AbstractList.java:108) + at object.ArrayAsListTest.main(ArrayAsListTest.java:11) +``` + +Arrays.asList 返回的 List 并不是我们期望的 java.util.ArrayList，而是 Arrays 的内部类 ArrayList。内部类的ArrayList没有实现add方法，而是父类的add方法的实现，是会抛出异常的呢。 + +#### 9.3 使用Arrays.asLis的时候，对原始数组的修改会影响到我们获得的那个List + +``` +public class ArrayAsListTest { + public static void main(String[] args) { + String[] arr = {"1", "2", "3"}; + List list = Arrays.asList(arr); + arr[1] = "4"; + System.out.println("原始数组"+Arrays.toString(arr)); + System.out.println("list数组" + list); + } +} +``` +运行结果： +``` +原始数组[1, 4, 3] +list数组[1, 4, 3] +``` +从运行结果可以看到，原数组改变，Arrays.asList转化来的list也跟着改变啦，大家使用的时候要注意一下哦，可以用new ArrayList(Arrays.asList(arr))包一下的。 + +#### 10. ArrayList.toArray() 强转的坑 +``` +public class ArrayListTest { + public static void main(String[] args) { + List list = new ArrayList(1); + list.add("公众号：捡田螺的小男孩"); + String[] array21 = (String[])list.toArray();//类型转换异常 + } +} +``` +因为返回的是Object类型，Object类型数组强转String数组，会发生ClassCastException。解决方案是，使用toArray()重载方法toArray(T[] a) +``` +String[] array1 = list.toArray(new String[0]);//可以正常运行 +``` + +### 11. 异常使用的几个坑 + +#### 11.1 不要弄丢了你的堆栈异常信息 + +``` +public void wrong1(){ + try { + readFile(); + } catch (IOException e) { + //没有把异常e取出来，原始异常信息丢失 + throw new RuntimeException("系统忙请稍后再试"); + } +} + +public void wrong2(){ + try { + readFile(); + } catch (IOException e) { + //只保留了异常消息，栈没有记录啦 + log.error("文件读取错误, {}", e.getMessage()); + throw new RuntimeException("系统忙请稍后再试"); + } +} +``` + +正确的打印方式，应该酱紫 +``` +public void right(){ + try { + readFile(); + } catch (IOException e) { + //把整个IO异常都记录下来，而不是只打印消息 + log.error("文件读取错误", e); + throw new RuntimeException("系统忙请稍后再试"); + } +} +``` + +#### 11.2 不要把异常定义为静态变量 +``` +public void testStaticExeceptionOne{ + try { + exceptionOne(); + } catch (Exception ex) { + log.error("exception one error", ex); + } + try { + exceptionTwo(); + } catch (Exception ex) { + log.error("exception two error", ex); + } +} + +private void exceptionOne() { + //这里有问题 + throw Exceptions.ONEORTWO; +} + +private void exceptionTwo() { + //这里有问题 + throw Exceptions.ONEORTWO; +} +``` +exceptionTwo抛出的异常，很可能是 exceptionOne的异常哦。正确使用方法，应该是new 一个出来。 +``` +private void exceptionTwo() { + throw new BusinessException("业务异常", 0001); +} +``` + + +#### 11.3 生产环境不要使用e.printStackTrace(); +``` +public void wrong(){ + try { + readFile(); + } catch (IOException e) { + //生产环境别用它 + e.printStackTrace(); + } +} +``` +因为它占用太多内存，造成锁死，并且，日志交错混合，也不易读。正确使用如下： +``` +log.error("异常日志正常打印方式",e); +``` + +#### 11.4 线程池提交过程中，出现异常怎么办？ +``` +public class ThreadExceptionTest { + + public static void main(String[] args) { + ExecutorService executorService = Executors.newFixedThreadPool(10); + + IntStream.rangeClosed(1, 10).forEach(i -> executorService.submit(()-> { + if (i == 5) { + System.out.println("发生异常啦"); + throw new RuntimeException("error"); + } + System.out.println("当前执行第几:" + Thread.currentThread().getName() ); + } + )); + executorService.shutdown(); + } +} +``` +运行结果： +``` +当前执行第几:pool-1-thread-1 +当前执行第几:pool-1-thread-2 +当前执行第几:pool-1-thread-3 +当前执行第几:pool-1-thread-4 +发生异常啦 +当前执行第几:pool-1-thread-6 +当前执行第几:pool-1-thread-7 +当前执行第几:pool-1-thread-8 +当前执行第几:pool-1-thread-9 +当前执行第几:pool-1-thread-10 +``` +可以发现，如果是使用submit方法提交到线程池的异步任务，异常会被吞掉的，所以在日常发现中，如果会有可预见的异常，可以采取这几种方案处理： +- 1.在任务代码try/catch捕获异常 +- 2.通过Future对象的get方法接收抛出的异常，再处理 +- 3.为工作者线程设置UncaughtExceptionHandler，在uncaughtException方法中处理异常 +- 4.重写ThreadPoolExecutor的afterExecute方法，处理传递的异常引用 + +#### 11.5 finally重新抛出的异常也要注意啦 +``` +public void wrong() { + try { + log.info("try"); + //异常丢失 + throw new RuntimeException("try"); + } finally { + log.info("finally"); + throw new RuntimeException("finally"); + } +} +``` +一个方法是不会出现两个异常的呢，所以finally的异常会把try的**异常覆盖**。正确的使用方式应该是，finally 代码块**负责自己的异常捕获和处理**。 + +``` +public void right() { + try { + log.info("try"); + throw new RuntimeException("try"); + } finally { + log.info("finally"); + try { + throw new RuntimeException("finally"); + } catch (Exception ex) { + log.error("finally", ex); + } + } +} +``` + +### 12.JSON序列化,Long类型被转成Integer类型！ +``` +public class JSONTest { + public static void main(String[] args) { + + Long idValue = 3000L; + Map data = new HashMap<>(2); + data.put("id", idValue); + data.put("name", "捡田螺的小男孩"); + + Assert.assertEquals(idValue, (Long) data.get("id")); + String jsonString = JSON.toJSONString(data); + + // 反序列化时Long被转为了Integer + Map map = JSON.parseObject(jsonString, Map.class); + Object idObj = map.get("id"); + System.out.println("反序列化的类型是否为Integer："+(idObj instanceof Integer)); + Assert.assertEquals(idValue, (Long) idObj); + } +} +``` +**运行结果：** +``` +Exception in thread "main" 反序列化的类型是否为Integer：true +java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.Long + at object.JSONTest.main(JSONTest.java:24) +``` +> **注意啦**，序列化为Json串后，Josn串是没有Long类型呢。而且反序列化回来如果也是Object接收，数字小于Interger最大值的话，给转成Integer啦！ + + +### 13. 使用Executors声明线程池，newFixedThreadPool的OOM问题 + +``` +ExecutorService executor = Executors.newFixedThreadPool(10); + for (int i = 0; i < Integer.MAX_VALUE; i++) { + executor.execute(() -> { + try { + Thread.sleep(10000); + } catch (InterruptedException e) { + //do nothing + } + }); + } +``` + +**IDE指定JVM参数：-Xmx8m -Xms8m :** + +![](https://imgkr2.cn-bj.ufileos.com/f9163a30-4c4c-4470-ac97-0c7383ac0cc0.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=uDMyGRF6Tbc537CWx3zhAhOBAVg%253D&Expires=1609141355) + + +运行结果： + +![](https://imgkr2.cn-bj.ufileos.com/fd925823-faea-479d-a6a1-ba604a1e8e35.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=BC3G94zA9iBbH0bkxoUEidZhB2M%253D&Expires=1609141373) + + +我们看下源码，其实newFixedThreadPool使用的是无界队列！ +``` +public static ExecutorService newFixedThreadPool(int nThreads) { + return new ThreadPoolExecutor(nThreads, nThreads, + 0L, TimeUnit.MILLISECONDS, + new LinkedBlockingQueue()); +} + +public class LinkedBlockingQueue extends AbstractQueue + implements BlockingQueue, java.io.Serializable { + ... + + + /** + * Creates a {@code LinkedBlockingQueue} with a capacity of + * {@link Integer#MAX_VALUE}. + */ + public LinkedBlockingQueue() { + this(Integer.MAX_VALUE); + } +... +} +``` + +> newFixedThreadPool线程池的核心线程数是固定的，它使用了近乎于无界的LinkedBlockingQueue阻塞队列。当核心线程用完后，任务会入队到阻塞队列，如果任务执行的时间比较长，没有释放，会导致越来越多的任务堆积到阻塞队列，最后导致机器的内存使用不停的飙升，造成JVM OOM。 + + +### 14. 直接大文件或者一次性从数据库读取太多数据到内存，可能导致OOM问题 + +如果一次性把大文件或者数据库太多数据达到内存，是会导致OOM的。所以，为什么查询DB数据库，一般都建议分批。 + +读取文件的话，一般问文件不会太大，才使用```Files.readAllLines()```。为什么呢？因为它是直接把文件都读到内存的，预估下不会OOM才使用这个吧，可以看下它的源码： + +``` +public static List readAllLines(Path path, Charset cs) throws IOException { + try (BufferedReader reader = newBufferedReader(path, cs)) { + List result = new ArrayList<>(); + for (;;) { + String line = reader.readLine(); + if (line == null) + break; + result.add(line); + } + return result; + } +} +``` +如果是太大的文件，可以使用Files.line()按需读取，当时读取文件这些，一般是使用完需要**关闭资源流**的哈 + +### 15. 先查询，再更新/删除的并发一致性问题 + +再日常开发中，这种代码实现经常可见：先查询是否有剩余可用的票，再去更新票余量。 +``` +if(selectIsAvailable(ticketId){ + 1、deleteTicketById(ticketId) + 2、给现金增加操作 +}else{ + return “没有可用现金券” +} +``` +如果是并发执行，很可能有问题的，应该利用数据库更新/删除的原子性，正解如下： +``` +if(deleteAvailableTicketById(ticketId) == 1){ + 1、给现金增加操作 +}else{ + return “没有可用现金券” +} +``` + +### 16. 数据库使用utf-8存储，插入表情异常的坑 + +低版本的MySQL支持的utf8编码，最大字符长度为 3 字节，但是呢，存储表情需要4个字节，因此如果用utf8存储表情的话，会报```SQLException: Incorrect string value: '\xF0\x9F\x98\x84' for column```，所以一般用utf8mb4编码去存储表情。 + +### 17. 事务未生效的坑 + +日常业务开发中，我们经常跟事务打交道，**事务失效**主要有以下几个场景： +- 底层数据库引擎不支持事务 +- 在非public修饰的方法使用 +- rollbackFor属性设置错误 +- 本类方法直接调用 +- 异常被try...catch吃了，导致事务失效。 + +其中，最容易踩的坑就是后面两个，**注解的事务方法给本类方法直接调用**，伪代码如下： + +``` +public class TransactionTest{ + public void A(){ + //插入一条数据 + //调用方法B (本地的类调用，事务失效了) + B(); + } + + @Transactional + public void B(){ + //插入数据 + } +} +``` + +如果用异常catch住，**那事务也是会失效呢**~，伪代码如下： +``` +@Transactional +public void method(){ + try{ + //插入一条数据 + insertA(); + //更改一条数据 + updateB(); + }catch(Exception e){ + logger.error("异常被捕获了，那你的事务就失效咯",e); + } +} +``` + +### 18. 当反射遇到方法重载的坑 +``` +/** + * 反射demo + * @author 捡田螺的小男孩 + */ +public class ReflectionTest { + + private void score(int score) { + System.out.println("int grade =" + score); + } + + private void score(Integer score) { + System.out.println("Integer grade =" + score); + } + + public static void main(String[] args) throws Exception { + ReflectionTest reflectionTest = new ReflectionTest(); + reflectionTest.score(100); + reflectionTest.score(Integer.valueOf(100)); + + reflectionTest.getClass().getDeclaredMethod("score", Integer.TYPE).invoke(reflectionTest, Integer.valueOf("60")); + reflectionTest.getClass().getDeclaredMethod("score", Integer.class).invoke(reflectionTest, Integer.valueOf("60")); + } +} +``` +运行结果： +``` +int grade =100 +Integer grade =100 +int grade =60 +Integer grade =60 +``` +如果**不通过反射**，传入```Integer.valueOf(100)```，走的是Integer重载。但是呢，反射不是根据入参类型确定方法重载的，而是**以反射获取方法时传入的方法名称和参数类型来确定**的，正例如下： +``` +getClass().getDeclaredMethod("score", Integer.class) +getClass().getDeclaredMethod("score", Integer.TYPE) +``` + +### 19. mysql 时间 timestamp的坑 +有更新语句的时候，timestamp可能会自动更新为当前时间，看个demo +``` +CREATE TABLE `t` ( + `a` int(11) DEFAULT NULL, + `b` timestamp NOT NULL, + `c` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP +) ENGINE=InnoDB DEFAULT CHARSET=utf8 +``` + +我们可以发现 **c列** 是有```CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP```，所以c列会随着记录更新而**更新为当前时间**。但是b列也会随着有记录更新为而**更新为当前时间**。 + +![](https://imgkr2.cn-bj.ufileos.com/0e5bad2d-d1b8-41a3-a40c-e697f2bfa8d1.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=BXTPAIbW04Nfy25lqi25PMPjbqI%253D&Expires=1609141018) + +可以使用datetime代替它,需要更新为当前时间，就把```now()```赋值进来，或者修改mysql的这个参数```explicit_defaults_for_timestamp```。 + +### 20. mysql8数据库的时区坑 + +之前我们对mysql数据库进行升级，新版本为8.0.12。但是升级完之后，发现now()函数，获取到的时间比北京时间早8小时，原来是因为mysql8默认为美国那边的时间，需要指定下时区 + +``` +jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8& +serverTimezone=Asia/Shanghai +``` + +### 参考与感谢 +- [Java业务开发常见错误100例](https://time.geekbang.org/column/article/220230 "Java业务开发常见错误100例") + From bfb434457199a0fc7f9988da081f449a7b88f2ba Mon Sep 17 00:00:00 2001 From: whx123 <327658337@qq.com> Date: Sun, 16 May 2021 17:40:57 +0800 Subject: [PATCH 26/77] =?UTF-8?q?=E5=B7=A5=E4=BD=9C=E6=80=BB=E7=BB=93?= =?UTF-8?q?=E6=9B=B4=E6=96=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...04\345\210\222\350\257\246\350\247\243.md" | 440 +++++ ...45\210\222\350\257\246\350\247\243.md.bak" | 0 ...42\346\223\215\344\275\234\357\274\237.md" | 246 +++ ...04\345\260\217\345\273\272\350\256\256.md" | 1478 +++++++++++++++++ ...50\346\210\267\345\257\206\347\240\201.md" | 123 ++ ...46\210\267\345\257\206\347\240\201.md.bak" | 0 ...06\345\270\203\345\274\217\351\224\201.md" | 225 +++ ...52\346\263\250\346\204\217\347\202\271.md" | 386 +++++ 8 files changed, 2898 insertions(+) create mode 100644 "\345\210\267leetcode\345\277\205\345\244\207\347\256\227\346\263\225/\347\234\213\344\270\200\351\201\215\345\260\261\347\220\206\350\247\243\357\274\232\345\212\250\346\200\201\350\247\204\345\210\222\350\257\246\350\247\243.md" create mode 100644 "\345\210\267leetcode\345\277\205\345\244\207\347\256\227\346\263\225/\347\234\213\344\270\200\351\201\215\345\260\261\347\220\206\350\247\243\357\274\232\345\212\250\346\200\201\350\247\204\345\210\222\350\257\246\350\247\243.md.bak" create mode 100644 "\345\244\247\345\216\202\351\235\242\350\257\225\347\234\237\351\242\230/\351\230\277\351\207\214\344\270\200\351\235\242\357\274\214\347\273\231\344\272\206\345\207\240\346\235\241SQL\357\274\214\351\227\256\351\234\200\350\246\201\346\211\247\350\241\214\345\207\240\346\254\241\346\240\221\346\220\234\347\264\242\346\223\215\344\275\234\357\274\237.md" create mode 100644 "\345\267\245\344\275\234\346\200\273\347\273\223/\345\267\245\344\275\234\345\233\233\345\271\264\357\274\21450\344\270\252\350\256\251\344\275\240\344\273\243\347\240\201\346\233\264\345\245\275\347\232\204\345\260\217\345\273\272\350\256\256.md" create mode 100644 "\345\267\245\344\275\234\346\200\273\347\273\223/\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\345\237\272\347\241\200\357\274\232\345\246\202\344\275\225\345\256\211\345\205\250\344\274\240\350\276\223\345\255\230\345\202\250\347\224\250\346\210\267\345\257\206\347\240\201.md" create mode 100644 "\345\267\245\344\275\234\346\200\273\347\273\223/\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\345\237\272\347\241\200\357\274\232\345\246\202\344\275\225\345\256\211\345\205\250\344\274\240\350\276\223\345\255\230\345\202\250\347\224\250\346\210\267\345\257\206\347\240\201.md.bak" create mode 100644 "\347\274\223\345\255\230Redis\346\200\273\347\273\223/\344\270\203\347\247\215\346\226\271\346\241\210\345\257\271\346\257\224\345\210\206\345\270\203\345\274\217\351\224\201.md" create mode 100644 "\347\274\223\345\255\230Redis\346\200\273\347\273\223/\344\275\277\347\224\250Redis\347\232\20421\344\270\252\346\263\250\346\204\217\347\202\271.md" diff --git "a/\345\210\267leetcode\345\277\205\345\244\207\347\256\227\346\263\225/\347\234\213\344\270\200\351\201\215\345\260\261\347\220\206\350\247\243\357\274\232\345\212\250\346\200\201\350\247\204\345\210\222\350\257\246\350\247\243.md" "b/\345\210\267leetcode\345\277\205\345\244\207\347\256\227\346\263\225/\347\234\213\344\270\200\351\201\215\345\260\261\347\220\206\350\247\243\357\274\232\345\212\250\346\200\201\350\247\204\345\210\222\350\257\246\350\247\243.md" new file mode 100644 index 0000000..e8cc9b4 --- /dev/null +++ "b/\345\210\267leetcode\345\277\205\345\244\207\347\256\227\346\263\225/\347\234\213\344\270\200\351\201\215\345\260\261\347\220\206\350\247\243\357\274\232\345\212\250\346\200\201\350\247\204\345\210\222\350\257\246\350\247\243.md" @@ -0,0 +1,440 @@ + +### ǰ�� + +��ˢleetcode��ʱ�򣬾��̬�滮��Ŀ��̬�滮��ǳ��ǳ��䣬Ҳ��м��ԣ�һ��󳧶��ǳ�ϲ��ʡ��һ��ѧϰ��̬�滮��·��в��ȷ�ĵط��ӭ��ָ��л��л~ + +- ʲô�Ƕ�̬�滮�� +- ��̬�滮�ĺ��˼�� +- һ��߽��̬�滮 +- ��̬�滮�Ľ��· +- leetcode�� + + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/01fdad6c74864d7da07193203c2dcbf4~tplv-k3u1fbpfcp-zoom-1.image) + + +��ںţ�**��ݵ�С�к�** + +### ʲô�Ƕ�̬�滮�� + + +��̬�滮��Ӣ�Dynamic programming�� DP��һ��ѧ��ѧ��ѧ��ѧ��Ϣѧ��ʹ�õģ�ͨ��ԭ��ֽ�Ϊ��Լ򵥵��ķ�ʽ��⸴��ķ��̬�滮��ص��ӽṹ��ʵ��⡣ + +> dynamic programming is a method for solving a complex problem by breaking it down into a collection of simpler subproblems. + +��϶��ά��ٿƣ��о��е��󡣼��˵��̬�滮��ʵ��ǣ��һ��⣬��ǰ��һ��⣬ֱ��ֱ�ӽ��Ȼ��أ��𰸱��Լ��ظ��㡣�ٸ��𰸷��ƣ��ó�ԭ��һ�ַ�� +> һ��Щ��ƣ��ͨ��ϵʽ��Ƴ��Ȼ��أ��̬�滮��ڽ��ÿ��һ�Σ��ظ��,��쳲��оͿ��Կ��ż��ľ��䶯̬�滮��⡣ + + +### ��̬�滮��˼�� + +��̬�滮��ĵ�˼�룬��**��⣬��ס��ظ��**�� + +![��̬�滮��ڼ�ס��](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/d26f967ff6e447d291b0b196c4edaa07~tplv-k3u1fbpfcp-watermark.image) + +��£��ϱȽ��е�һ��ӣ� +> - A �� "1+1+1+1+1+1+1+1 =��" +> - A �� "��ʽ��ֵ�Ƕ��" +> - B �� "8" +> - A : ��ʽ��д�� "1+" �أ� +> - A : "��ʱ��ʽ��ֵΪ��" +> - B : �ܿ�ó�� "9" +> - A : "��ô��ô��֪��" +> - A : "ֻҪ��8�Ļ��ϼ�1��" +> - A : "��㲻��¼��㣬��Ϊ��ס�˵�һ��ʽ��ֵΪ8!��̬�滮�㷨Ҳ��˵�� '��ס��Ľ��ʡʱ��'" + +### һ��Ӵ��߽��̬�滮 -- �� + +#### ��ݹ� + +> leetcodeԭ�⣺һֻ��һ�ο��1��̨�ף�Ҳ��2��̨�ס��һ�� 10 ��̨��ܹ��ж�� + +��ЩС��һ�μ��ʱ�򣬿��ܻ��е��Ȧ��֪��ô��ʵ��룺 +> - Ҫ��10��̨�ף�Ҫô��9��Ȼ��1��̨��ȥ;Ҫô��8��Ȼ��һ��2��̨��ȥ�� +> - ͬ��Ҫ��9��̨�ף�Ҫô��8��Ȼ��1��̨��ȥ;Ҫô��7��Ȼ��һ��2��̨��ȥ�� +> - Ҫ��8��̨�ף�Ҫô��7��Ȼ��1��̨��ȥ;Ҫô��6��Ȼ��һ��2��̨��ȥ�� + +��n��̨�׵��Ƕ��Ϊf(n)��Ȼ�Ϳ��Եó��¹�ʽ�� + +``` +f��10�� = f��9��+f(8) +f (9) = f(8) + f(7) +f (8) = f(7) + f(6) +... +f(3) = f(2) + f(1) + +��ͨ�ù�ʽΪ: f(n) = f(n-1) + f(n-2) +``` + +��f(2) �� f(1) ��ڶ��أ� +- ��ֻ��2��̨��ʱ��һ��ֱ��ڶ��һ��Ȼ��һ��f(2) = 2; +- ��ֻ��1��̨��ʱ��ֻ��һ��f��1��= 1�� + + +��˿��õݹ�ȥ��⣺ +``` +class Solution { + public int numWays(int n) { + if(n == 1){ + return 1; + } + if(n == 2){ + return 2; + } + return numWays(n-1) + numWays(n-2); + } +} +``` + +ȥleetcode�ύһ�£��⣬��ʱ�� + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/3e0608ec89a246568e01c7ba4b8f50d8~tplv-k3u1fbpfcp-zoom-1.image) + + +Ϊʲô��ʱ��أ��ݹ��ʱ��أ��Ȼ��**�ݹ��**�� + + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/2dd95840552e4a7db9536884b7a9b558~tplv-k3u1fbpfcp-zoom-1.image) + +- Ҫ��ԭ�� f(10)��Ҫ�ȼ�� f(9) �� f(8) +- Ȼ��Ҫ�� f(9)��Ҫ�� f(8) �� f(7)��Դ��ơ� +- һֱ�� f(2) �� f(1��ݹ��ֹ�� + +��ݹ��ʱ�临�ӶȰɣ� + + +``` +�ݹ�ʱ�临�Ӷ� = ��һ��ʱ��*�� +``` + +- һ��ʱ�� = f��n-1��+f��n-2��Ҳ��һ��ӷ��Ĳ��Ը��Ӷ�� O(1)�� +- �� = �ݹ��ڵ��ݹ��ܽڵ� = 2^n-1��Ǹ��Ӷ�O(2^n)�� + +��ˣ��ף��ݹ�ⷨ��ʱ�临�Ӷ� = O(1) * O(2^n) = O(2^n)��ָ��ģ��ը��ģ��n�Ƚϴ�Ļ��ʱ��ˡ� + +�ع�ͷ��ϸ�۲��ŵݹ��ᷢ�ִ��ڴ��ظ��㣬��f��8��Σ�f��7��ظ��3��...��ݹ��㷨��Ч��ԭ�򣬾��**��ڴ��ظ��**�� + +��Ȼ��ڴ��ظ��㣬��ô��ǿ��ȰѼ��õĴ𰸴��һ��¼��ȵ��´��Ҫ�Ļ��ȥ��¼��һ�£��У��ֱ��ȡ�ͺ��ˣ��¼û�вſ�ʼ��㣬�ǾͿ��ʡȥ��ظ��ĺ�ʱ��Ǵ��¼�Ľⷨ�� + + + +#### ��¼�ĵݹ�ⷨ��Զ��£� + +һ��ʹ��һ��һ��ϣmap�䵱��**��¼**�� +- ��һ��f��10��= f(9) + f(8)��f(9) ��f��8��Ҫ��Ȼ��ټӵ��¼�У��£� + + + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/94484290462e45c799609b0a581b14b0~tplv-k3u1fbpfcp-zoom-1.image) + +- �ڶ�� f(9) = f��8��+ f��7��f��8��= f��7��+ f(6), ��Ϊ f(8) �Ѿ��ڱ��¼��Կ��ʡ��f(7),f��6��Ҫ��ӵ��¼��~ + + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/12900b17d77f4adfbdb71920f729d61a~tplv-k3u1fbpfcp-zoom-1.image) + + +�� f(8) = f��7��+ f(6),��f(8)��f(7),f��6��ȫ��ڱ��¼��ˣ��Զ��Լ�� + + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/9a8c7ba6b5ae413799c6a33490bb1f8f~tplv-k3u1fbpfcp-zoom-1.image) + +��أ��˱��¼�ݹ��㷨��ݹ��ɹ�ͺͺ��ɿ��£� + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/18a78d6b99a84ff8a1df834f3c085014~tplv-k3u1fbpfcp-zoom-1.image) + +��**��¼**�ĵݹ��㷨��=��ڵ��=n��һ��⻹��O(1),��Դ�**��¼**�ĵݹ��㷨��ʱ�临�Ӷ��O(n)��أ��ô�**��¼**�ĵݹ��㷨ȥߣ��룬��ĳ�ʱ��⿩~��£� + + + +``` +public class Solution { + //ʹ�ù�ϣmap��䵱��¼�� + Map tempMap = new HashMap(); + public int numWays(int n) { + // n = 0 Ҳ��1�� + if (n == 0) { + return 1; + } + if (n <= 2) { + return n; + } + //��ж��û��¼��û�� + if (tempMap.containsKey(n)) { + //��¼�У��ֱ�ӷ�� + return tempMap.get(n); + } else { + // ��¼û�У��û�м��ִ�еݹ��,��Ұѽ��浽��¼map�У��1000000007ȡ�ࣨ��leetcode��Ŀ�涨�ģ� + tempMap.put(n, (numWays(n - 1) + numWays(n - 2)) % 1000000007); + return tempMap.get(n); + } + } +} +``` +ȥleetcode�ύһ�£��ͼ��ˣ� + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e5f0fb1998c542dc8cb3826de800f443~tplv-k3u1fbpfcp-zoom-1.image) + +��ʵ��ö�̬�滮��⡣ + +#### �Ե��ϵĶ�̬�滮 + +��̬�滮��¼�ĵݹ�ⷨ��˼��һ�µģ��Ǽ��ظ��㣬ʱ�临�Ӷ�Ҳ��ǲ�ࡣ��أ� +- ��¼�ĵݹ飬�Ǵ�f(10)��f(1��ģ��Ҳ��Ϊ**�Զ��**�Ľⷨ�� +- ��̬�滮�ӽ�С��Ľ⣬�ɽ��ʣ��𲽾��߳��ϴ��Ľ⣬��Ǵ�f(1)��f(10��⣬��Գ�Ϊ**�Ե��**�Ľⷨ�� + + +��̬�滮�м��**��ӽṹ��״̬ת�Ʒ��̡��߽硢�ص��**��У� +- f(n-1)��f(n-2) ��Ϊ f(n) ��ӽṹ +- f(n)= f��n-1��+f��n-2��ͳ�Ϊ״̬ת�Ʒ�� +- f(1) = 1, f(2) = 2 ��Ǳ߽�� +- ��f(10)= f(9)+f(8),f(9) = f(8) + f(7) ,f(8)��ص��⡣ + +��Ե��ϵĽⷨ��f(1)��f(10��ǲ��ֱ��һ��forѭ��Ϳ��Խ��£� + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8e21b14d47e64afa958506d49972827b~tplv-k3u1fbpfcp-zoom-1.image) + +��¼�ĵݹ�ⷨ��ռ临�Ӷ��O(n)��أ��ϸ�۲��ͼ��Է��֣�f��n��ֻ��ǰ��ֻ��Ҫ��a��b��洢��Ϳ��ˣ��˿ռ临�Ӷ��O(1)�Ϳ�� + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8b202b2364eb4aae9122cfa8474c045e~tplv-k3u1fbpfcp-zoom-1.image) + +��̬�滮ʵ�ִ��£� + +``` +public class Solution { + public int numWays(int n) { + if (n<= 1) { + return 1; + } + if (n == 2) { + return 2; + } + int a = 1; + int b = 2; + int temp = 0; + for (int i = 3; i <= n; i++) { + temp = (a + b)% 1000000007; + a = b; + b = temp; + } + return temp; + } + } +``` + +### ��̬�滮�Ľ��· + +#### ʲô��Կ��ʹ�ö�̬�滮��أ� + +> ��һ��⣬��԰��п��ܵĴ��ٳ��ٳ��󣬷��ִ��ص��⣬�Ϳ��Կ��ʹ�ö�̬�滮�� + +��һЩ��ֵ�ĳ��**���С��С�༭��롢��⡢��Ǯ��**�ȵȣ��Ƕ�̬�滮�ľ��Ӧ�ó�� + + +### ��̬�滮�Ľ��˼· + + +��̬�滮�ĺ��˼��**��⣬��ס��ظ��㡣** ��Ҷ�̬�滮һ�㶼��Ե��ϵģ��˵����**��**��⣬��ܽ��һ��̬�滮��˼·�� + +- ��ٷ�� +- ȷ��߽� +- �ҳ��ɣ�ȷ��ӽṹ +- д��״̬ת�Ʒ�� + + +#### 1. ��ٷ�� + + +- ��̨��1��ʱ��һ��f��1�� =1 +- ��ֻ��2��̨��ʱ��һ��ֱ��ڶ��һ��Ȼ��һ��f(2) = 2; +- ��̨��3��ʱ��3��̨�ף�Ҫô��2��Ȼ��1��̨��ȥ��Ҫô�� 1��Ȼ��һ�� 2 ��̨��ȥ��f(3) = f(2) + f(1) =3 +- ��̨��4��ʱ��3��̨�ף�Ҫô��3��Ȼ��1��̨��ȥ��Ҫô�� 2��Ȼ��һ�� 2 ��̨��ȥ��f(4) = f(3) + f(2) =5 +- ��̨��5��ʱ...... + +![�Ե��ϵĶ�̬�滮](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/29cd6d0d31514336baf9905f8084a624~tplv-k3u1fbpfcp-zoom-1.image) + + + +#### 2. ȷ��߽� + +ͨ��ٷ��Ƿ��֣��̨��1��ʱ��2��ʱ�򣬿��ȷ֪��f��1�� =1��f(2) = 2��̨��n>=3ʱ��Ѿ��ֳ��f(3) = f(2) + f(1) =3��f��1�� =1��f(2) = 2��׵ı߽硣 + + +#### 3. �ҹ��ɣ�ȷ��ӽṹ + +n>=3ʱ��Ѿ��ֳ�� f(n) = f(n-1) + f(n-2) ��ˣ�f(n-1)��f(n-2) ��Ϊ f(n) ��ӽṹ��ʲô��ӽṹ��ôһ��ͣ� + +> һ��̬�滮��⣬��ʵ��һ��⡣��赱ǰ��߽��f(n),��ӽṹ��Ҫ�� f(n-k) ��,��ӽṹ��ʾ��ת�Ƶ�n��״̬��ŵ�,��ľ��û�й�ϵ,��ú��ľ��߰��ĵ�ʹ��ǰ��ľֲ��Ž��һ�� + + +#### 4�� д��״̬ת�Ʒ�� + +ͨ��ǰ��3��ٷ��ȷ��߽磬��ӽṹ��ǾͿ��Եó�״̬ת�Ʒ�� + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/4fb4cd7257ff4fcbac9d87be96f353bd~tplv-k3u1fbpfcp-zoom-1.image) + +#### 5. ��ʵ�� + +��ʵ�ִ��ʱ��һ��ע��ӵ��ϱ��Ȼ��ע�±߽��ռ临�Ӷȣ�Ҳ�Ͳ��̬�滮�и��ܵģ��ʵ�ֵ�ʱ�򣬿��Կ��ʵ��ο�һ�£� + + +``` +dp[0][0][...] = �߽�ֵ +for(״̬1 ��״̬1��ֵ){ + for(״̬2 ��״̬2��ֵ){ + for(...){ + //״̬ת�Ʒ�� + dp[״̬1][״̬2][...] = ��ֵ + } + } +} +``` + + +### leetcode�� + +��һ��һ��leetcode��Ŀ�� + +> ��һ�� nums ��ҵ���ϸ��еĳ��ȡ� + +ʾ�� 1�� + +``` +��룺nums = [10,9,2,5,3,7,101,18] +��4 +��ͣ���� [2,3,7,101]��˳��Ϊ 4 �� +``` + +ʾ�� 2�� + + +``` +��룺nums = [0,1,0,3,2,3] +��4 +``` + +��ǰ��϶�̬�滮�Ľ��˼·�� + +- ��ٷ�� +- ȷ��߽� +- �ҹ��ɣ�ȷ��ӽṹ +- ״̬ת�Ʒ�� + + +#### 1.��ٷ�� + + +��Ϊ��̬�滮��˼��**��⣬��ס��ظ��㡣** ��˼��ԭ��⣺**��num[i]����г��ʱ**��˼��**��**��ԭ��Ƿ��**��**num[i-1]����г��й��أ� + +##### �Զ��ϵ�� + +��۲��ɣ��Ȼ��й�ϵ�ģ��ǻ��ѭ��̬�滮**�Ե��**��ԭ�򣬻��ʾ��1��ݣ��ֻ��һ��Ԫ�ؿ�ʼ�� + +- ��numsֻ��һ��Ԫ��10ʱ����[10],��1. +- ��nums��Ҫ��һ��Ԫ��9ʱ����[10]��[9],��1�� +- ��nums�ټ��һ��Ԫ��2ʱ����[10]��[9]��[2],��1�� +- ��nums�ټ��һ��Ԫ��5ʱ����[2,5],��2�� +- ��nums�ټ��һ��Ԫ��3ʱ����[2,5]��[2,3],��2�� +- ��nums�ټ��һ��Ԫ��7ʱ��,���[2,5,7]��[2,3,7],��3�� +- ��nums�ټ��һ��Ԫ��101ʱ����[2,5,7,101]��[2,3,7,101],��4�� +- ��nums�ټ��һ��Ԫ��18ʱ����[2,5,7,101]��[2,3,7,101]��[2,5,7,18]��[2,3,7,18],��4�� +- ��nums�ټ��һ��Ԫ��7ʱ,���[2,5,7,101]��[2,3,7,101]��[2,5,7,18]��[2,3,7,18],��4. + +##### ��ҹ��ɣ�� +ͨ��ǿ��**��һ��**�� + +��¼��һ��Ԫ��nums[i], ���Ҫô**��nums[i]��β�ĵ��**��Ҫô��**nums[i-1]����**��ǲ��Ǻܿ��ģ�nums[i]����Ѿ��**��** nums[i-1]����й��ˡ� + +``` +ԭ��nums[i]���� = ��nums[i-1]����/nums[i]��β���� +``` + +�ǲ��Ǹо��ɹ��һ��أ��**��ΰ�nums[i]��β�ĵ��Ҳת��Ϊ��Ӧ��**�أ�Ҫ��nums[i]��β�ĵ��Ҳ��nums[i-1]����йؾͺ��ˡ��ֻ��nums[i]��β����У��ǰ��num[j]��0= - nums[3]=5,��```5```��β����о��```[2,5]```,��Ϊ��±�```0��3```��ֻ�ҵ��```[2]```��```5```С��Ծ��```[2]+[5]```��```dp[4]=2``` +> - nums[4]=3,��```3```��β����о��```[2,3]```,��Ϊ��±�```0��4```��ֻ�ҵ��```[2]```��```3```С��Ծ��```[2]+[3]```��```dp[4]=2``` +> - nums[5]=7��```7```��β����о��```[2,5,7]```��```[2,3,7]```,��Ϊ��±�```0��5```��ҵ�```2,5��3```��7С��Ծ��```[2,7],[5,7],[3,7],[2,5,7]��[2,3,7]```��Щ��У����о��```[2,5,7]��[2,3,7]```��```5```��β��```3```��β����+[7]����ԣ�**```dp[5]=3 =dp[3]+1=dp[4]+1```**�� + + +��Ȼ��ɣ�һ��nums[i]��β��nums +- ��j��[0��i-1],��num[i]>num[j]�Ļ��У�dp(i) =max(dp(j))+1�� + +#### ��򵥵ı߽�� + +��nums��ֻ��һ��Ԫ��ʱ����еĳ��dp(1)=1,��nums��Ԫ��ʱ��dp(2) =2��1�� +��˱߽��dp(1)=1�� + +#### ȷ��ӽṹ + +��ٷ��ǿ��Եó��µ��Žṹ�� + +``` +dp(i) =max(dp(j))+1��j��[0��i-1],��num[i]>num[j]�� +``` +**max(dp(j))** ��ӽṹ�� + +#### ״̬ת�Ʒ�� + +ͨ��ǰ��ǾͿ��Եó�״̬ת�Ʒ�� + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/457ce281c1ec4e91b8c868aa593e41b6~tplv-k3u1fbpfcp-zoom-1.image) + +��num[i]����о��ǣ� +``` +��� =max(dp[i]) +``` + + + + +#### ��ʵ�� + +``` +class Solution { + public int lengthOfLIS(int[] nums) { + if (nums.length == 0) { + return 0; + } + int[] dp = new int[nums.length]; + //��ʼ��Ǳ߽�� + dp[0] = 1; + int maxans = 1; + //�Ե��ϱ�� + for (int i = 1; i < nums.length; i++) { + dp[i] = 1; + //��±�0��i�� + for (int j = 0; j < i; j++) { + //�ҵ�ǰ��nums[i]С��nums[j],��dp[i]= dp[j]+1 + if (nums[j] < nums[i]) { + //��Ϊ��ж��С��nums[i]��Ҳ��ǻ��ڶ����Ǿ�ȡ��ŵ�dp[i] + dp[i] = Math.max(dp[i], dp[j] + 1); + } + } + //��dp[i]��dp��Ǹ��nums���� + maxans = Math.max(maxans, dp[i]); + } + return maxans; + } +} +``` + + + + + + + + + + + + + diff --git "a/\345\210\267leetcode\345\277\205\345\244\207\347\256\227\346\263\225/\347\234\213\344\270\200\351\201\215\345\260\261\347\220\206\350\247\243\357\274\232\345\212\250\346\200\201\350\247\204\345\210\222\350\257\246\350\247\243.md.bak" "b/\345\210\267leetcode\345\277\205\345\244\207\347\256\227\346\263\225/\347\234\213\344\270\200\351\201\215\345\260\261\347\220\206\350\247\243\357\274\232\345\212\250\346\200\201\350\247\204\345\210\222\350\257\246\350\247\243.md.bak" new file mode 100644 index 0000000..e69de29 diff --git "a/\345\244\247\345\216\202\351\235\242\350\257\225\347\234\237\351\242\230/\351\230\277\351\207\214\344\270\200\351\235\242\357\274\214\347\273\231\344\272\206\345\207\240\346\235\241SQL\357\274\214\351\227\256\351\234\200\350\246\201\346\211\247\350\241\214\345\207\240\346\254\241\346\240\221\346\220\234\347\264\242\346\223\215\344\275\234\357\274\237.md" "b/\345\244\247\345\216\202\351\235\242\350\257\225\347\234\237\351\242\230/\351\230\277\351\207\214\344\270\200\351\235\242\357\274\214\347\273\231\344\272\206\345\207\240\346\235\241SQL\357\274\214\351\227\256\351\234\200\350\246\201\346\211\247\350\241\214\345\207\240\346\254\241\346\240\221\346\220\234\347\264\242\346\223\215\344\275\234\357\274\237.md" new file mode 100644 index 0000000..a695048 --- /dev/null +++ "b/\345\244\247\345\216\202\351\235\242\350\257\225\347\234\237\351\242\230/\351\230\277\351\207\214\344\270\200\351\235\242\357\274\214\347\273\231\344\272\206\345\207\240\346\235\241SQL\357\274\214\351\227\256\351\234\200\350\246\201\346\211\247\350\241\214\345\207\240\346\254\241\346\240\221\346\220\234\347\264\242\346\223\215\344\275\234\357\274\237.md" @@ -0,0 +1,246 @@ +### ǰ�� + +��λ��ȥ��ԣ��˵��Թٸ��˼��ѯSQL��:��Ҫִ�м��ѵ�ʱ��е��µģ��侲˼��ŷ��־��ǿ��ļ��֪ʶ��~~ ��Ƿ־Ÿ��֪ʶ�㣬һ��̽��һ�¡��в��ȷ�Ļ��ӭָ��һ��ѧϰ~ + +- ��ںţ�**��ݵ�С�к�** +- github��ַ��лÿ��star +> https://github.com/whx123/JavaHome + +- ��Թٿ��֮��ʲô�� +- ��Թٿ��֮�� +- ��Թٿ��֮Ϊʲôѡ��B+��Ϊ��ṹ +- ��Թٿ��֮һ�� +- ��Թٿ��֮�� +- ��Թٿ��֮��ʧЧ�� +- ��Թٿ��֮��ǰ׺ +- ��Թٿ��֮�� +- ��Թٿ��֮�� + +### һ��Թٿ��֮��ʲô�� + +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/21eed26e34534b51aadf28d5defaed7e~tplv-k3u1fbpfcp-watermark.image) + +- ��һ��ݿ��ѯЧ�ʵ��ݽṹ��Ա��һ��ֵ��Ŀ¼��԰��ҵ��Ӧ�ļ�¼�� +- ��һ��洢�ڴ��̵��ļ��У��ռ��ռ�ġ� +- ��νˮ��ۣ�Ҳ�ܸ��ۡ��ʵ��߲�ѯЧ�ʣ��Ӱ��ݿ��Ĳ��͸��¹��ܡ� + +### ��Щ�� + +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/cf6725e1a8cb44b496cca8fa45e15c2f~tplv-k3u1fbpfcp-watermark.image) + +#### ��ݽṹά�� + +- B+��ݴ洢��Ҷ�ӽڵ㣬��Ӷ�ΪO(logn)��ʺϷ�Χ��ѯ�� +- ��ϣ��: �ʺϵ�ֵ��ѯ��Ч�ʸߣ�һ�ε�λ�� +- ȫ��MyISAM��InnoDB�ж�֧��ʹ��ȫ��һ��ı��char,text,varchar��ϴ�� +- R-Tree��: ��GIS��ʹ��SPATIAL�� + +#### ��洢ά�� + +- �ۼ��ۼ��Ҷ�ӽڵ�洢��Ǳ��е��ݡ� +- �Ǿۼ��Ǿۼ��Է��Ҷ�ӽڵ�洢��С� + +#### �߼�ά�� + +- ��һ��Ψһ��п�ֵ�� +- ��ͨ��MySQL�л��ͣ��ֵ��ظ�ֵ�� +- ��ֶδ��ʹ��ʱ��ѭ��ǰ׺ԭ�� +- Ψһ��е�ֵ��Ψһ�ģ��Ϊ��ֵ�� +- �ռ��MySQL5.7֮��֧�ֿռ��ڿռ��ⷽ��ѭOpenGIS��ģ�͹�� + +### ��Թٿ��֮Ϊʲôѡ��B+��Ϊ��ṹ + +��ԴӼ��ά��ȥ��⣬��ѯ�Ƿ񹻿죬Ч��Ƿ��ȶ��洢��ݶ��٣��Լ��Ҵ��̴��ȵȡ�Ϊʲô��ǹ�ϣ�ṹ��Ϊʲô��Ƕ��Ϊʲô��ƽ��Ϊʲô��B��ƫƫ��B+��أ� + +��дҵ��SQL��ѯʱ��£��Ƿ�Χ��ѯ�ģ��һ��SQL +``` +select * from employee where age between 18 and 28; +``` +#### Ϊʲô��ʹ�ù�ϣ�ṹ�� +��֪��ϣ�ṹ��k-v�ṹ��Ҳ��ǣ�key��value��һ��һ��ϵ��**��ֵ��ѯ**��ԣ��Ƿ�Χ��ѯ��Ϊ��Ŷ�� + +#### Ϊʲô��ʹ�ö��أ� + +�Ȼ��¶��֪ʶ��~ ��ν**��ص��£�** +- ÿ��ֱ��Ϊ�� +- ��ӽڵ��ֵС�ڵ�ǰ�ڵ��ֵ��ǰ�ڵ�ֵС��ӽڵ�ֵ +- ��˵Ľڵ��Ϊ��ڵ㣬û��ӽڵ�Ľڵ�ֵ��ΪҶ�ӽڵ㡣 + +��Ժ��У��׾͸��ֳ��ֶ��ṹͼ�� +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8d4c349a7bda4b3db1791f9cff9c093e~tplv-k3u1fbpfcp-watermark.image) + +��أ��Щ��Ŷ�� +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/97b71a48d43545a0bc20a55adf2be207~tplv-k3u1fbpfcp-watermark.image) + +��⻯Ϊһ��൱��ȫ��ɨ�衣��ô��Ҫ��ѽ��ˣ�һ��ʺ��Ϊ��ṹ�� + +#### Ϊʲô��ʹ��ƽ��أ� + +ƽ��ص㣺��Ҳ��һ�Ŷ��κνڵ��߶��Ϊ1��ԾͲ��⻯һ�� + +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/74afa9b54e7f4c0996ff83e66016c09a~tplv-k3u1fbpfcp-watermark.image) + +��أ� +- ƽ��߸��ǣ��Ҫ��ά��ƽ�⣬ά��۴� +- ��Ļ��ĸ߶Ȼ�ܸߡ��Ϊ��Ǵ��ڴ��̵ģ��Ϊ��ṹ��ÿ�δӴ��̶�ȡһ��ڵ㣬��IO�Ĵ��Ͷ�� + + +#### Ϊʲô��ʹ��B��أ� + + +��Ļ��ƽ��ĸ߶Ȼ�ܸߣ��IO���Ϊʲô��ѡ��ͬ��**�߶ȸ��B��**�أ� + +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/acc8f2e2cfb54092b4fb131e500334a3~tplv-k3u1fbpfcp-watermark.image) + +B��ƽ��Ϳ��Դ洢��ݣ��߶ȸ��͡��Ϊ��ѡ��B+��أ��ΪB+��B��棺 +- B+��Ҷ�ӽڵ��ǲ��洢��ݵģ��洢��ֵ��B��ڵ��в��洢��ֵ��Ҳ��洢��ݡ�innodb��ҳ��Ĭ�ϴ�С��16KB��洢��ݣ��ô�ͻ�洢��ļ�ֵ��Ӧ��Ľ��ڵ��ӽڵ��ͻ��ͻ��֣��һ��ǲ��ݽ��д��̵�IO��л��ٴμ��٣��ݲ�ѯ��Ч��Ҳ��졣 +- B+��ݾ��洢��Ҷ�ӽڵ㣬��ǰ��˳��еģ��ŵġ��ôB+��ʹ�÷�Χ��ң��ң��Լ�ȥ�ز��ұ��쳣�򵥡� + +### �ġ��Թٿ��֮һ��B+�� + +**��Թ٣�** ��±��ṹ��⼸�� +``` +CREATE TABLE `employee` ( + `id` int(11) NOT NULL, + `name` varchar(255) DEFAULT NULL, + `age` int(11) DEFAULT NULL, + `date` datetime DEFAULT NULL, + `sex` int(1) DEFAULT NULL, + PRIMARY KEY (`id`), + KEY `idx_age` (`age`) USING BTREE +) ENGINE=InnoDB DEFAULT CHARSET=utf8; + +insert into employee values(100,'С��',43,'2021-01-20','0'); +insert into employee values(200,'��',48,'2021-01-21','0'); +insert into employee values(300,'��',36,'2020-01-21','1'); +insert into employee values(400,'��',32,'2020-01-21','0'); +insert into employee values(500,'��Ѹ',37,'2020-01-21','1'); +insert into employee values(600,'С��',49,'2021-01-21','0'); +insert into employee values(700,'С��',28,'2021-01-21','1'); +``` + +**��Թ٣�** ��ִ��µĲ�ѯSQL��Ҫִ�м��ε��Ի��¶�Ӧ��ṹͼ~ +``` +select * from Temployee where age=32; +``` + +**��** ��ʵ��Թپ��ǿ��ѡ��Ƿ��ϤB+��ṹͼ��ϻش�~ + +- �Ȼ��`idx_age`��ṹͼ��£� + +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/f88457b43e354ca18795fa0033ad075f~tplv-k3u1fbpfcp-watermark.image) + +- �ٻ��id��Ȼ��ṹͼ��£� + +![](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/963a8dacb39345008c93b1d0ea079eec~tplv-k3u1fbpfcp-watermark.image) + + +��ˣ�� SQL ��ѯ��ִ�д��̾��ǽ��ϣ� +- 1. ��`idx_age`��̿�1��ص��ڴ棬��32<37,��·��֧��Ѱַ��̿�2�� +- 2. ��̿�2��ص��ڴ��У��ڴ��ҵ�age=32�ļ�¼��ȡ��id = 400. +- 3. �õ�id=400�󣬻ص�id�� +- 4. ��`id��`��̿�1��ڴ棬��ڴ��ҵ��400��B+��Ҷ�ӽڵ��ǲ��ݵġ��400��ҷ�֧��Ѱַ��̿�3. +- 5. ��̿�3��ڴ棬��ڴ��ҵ�id=400�ļ�¼��õ�R4��һ�е��ݣ��õģ��󹦸�ɡ� + +��ˣ��SQL��ѯ��ִ��˼��ǲ��һ��Ȼ��ѽ��**�ر��**��`idx_age`��ҵ��`id`�󣬻ص�id��Ĺ��,�ͳ�Ϊ�ر�� +> ʲô�ǻر��õ��ٻص��ѯ�Ĺ��̣��ͽ��**�ر�** + +### �塢��Թٿ��֮�� + +**��Թ٣�** ��`select *`, ��ʹ��`select id,age`��ϵ��Ŀִ��˼��أ� + +**��** ��⣬��Ҫ��ѡ�˵ĸ��֪ʶ�㡣�ص�`idx_age`��Է��ֲ�ѯѡ��id��age��Ҷ�ӽڵ��ˡ��ˣ��ֱ��ṩ��ѯ��Ͳ��Ҫ�ٻر��~ + +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/629b6cfd08614adcbb20154707c0c8e0~tplv-k3u1fbpfcp-watermark.image) + +> ��ڲ�ѯ��棬��Ҫ�ر�ȥ�飬ֱ�Ӵ��о��ȡ��Ҫ�Ľ��仰˵��SQL�õ��ݣ��˲�ѯ��У��ϸ��ˡ� + +��ԣ��ϸ��⣬��ʡȥ�˻ر�� + +### ��Թٿ��֮��ʧЧ + +**��Թ٣�** ��ڸ�`name`�ֶμ��ͨ��Ȼ��ø�likeģ��ǻ�ִ�ж��ٴβ�ѯ�أ�SQL��£� +``` +select * from employee where name like '%��%'; +``` +**��** ��֪ʶ��ǣ�like�Ƿ�ᵼ�²��ȸ�SQL��explainִ�мƻ��ɡ��ʵlike ģ��ᵼ�²��ģ��£� + +![](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/3b01bb44ff5744729e55939cc88bd424~tplv-k3u1fbpfcp-watermark.image) + +��ˣ��SQL��ȫ��ɨ��~�ճ��У��⼸��ɧ��ܻᵼ��ʧЧ��£� +- ��ѯ��or��ܵ��ʧЧ +- ��ֶ��ַ��whereʱһ��ʧЧ +- likeͨ��ܵ��ʧЧ�� +- ��ѯʱ��в��еĵ�һ��У��ʧЧ�� +- ��ʹ��mysql��ú��ʧЧ�� +- ��㣨�磬+��-��*��/��ʧЧ�� +- ��ֶ��ʹ�ã��= �� < >��not in��ʱ��ܻᵼ��ʧЧ�� +- ��ֶ��ʹ��is null�� is not null��ܵ��ʧЧ�� +- ��Ӳ�ѯ��Ӳ�ѯ��ѯ��ֶα��ʽ��һ��ܵ��ʧЧ�� +- mysql��ʹ��ȫ��ɨ��Ҫ��ʹ��,��ʹ�� + +### �ߡ��Թٿ��֮��ǰ׺ԭ�� + +**��Թ٣�** ��ڸ�name,age�ֶμ��SQLִ�ж��ٴ��أ��Ȼ�� +``` +select * from employee where name like 'С%' order by age desc; +``` +**��** ��ǰ׺ԭ��Լ�like�Ƿ��֪ʶ�㡣��ʾ��ͼ��£� + +![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/29df075df94549b693a6a0ee06730666~tplv-k3u1fbpfcp-watermark.image) + +��Ȱ��name��С��name��ͬ��age��С��Թ�Ҫ��ֵ�һ��ǡ�С��ˣ�SQL��like 'С%'�ǿ��```idx_name_age```��ġ� + +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/58b49f88f75f48be873deb395431c2fa~tplv-k3u1fbpfcp-watermark.image) + +�ò�ѯ��idx_name_age��ҵ��һ��С��ֵ��ҵ�```С��С�ס�С�ࡢ```��ֱ��õ�Id=```600��100��700```��Ȼ��α��ȥ�Ҷ�Ӧ�ļ�¼�� ǰ׺```С```��ַ��M��ַ��ʵ��ϣ� +- ��ǰ׺��N��ֶΡ��a,b,c��൱�ڽ��ˣ�a��a,b��,(a,b,c)�� +- ��ǰ׺Ҳ��ַ��M��ַ�� + +### �ˡ��Թٿ��֮�� + +**��Թ٣�** ��ǻ��Ǿ�� idx_name_age��SQLִ�м��أ� + +``` +select * from employee where name like 'С%' and age=28 and sex='0'; +``` + +**��** ��Ƶ�֪ʶ�㣬��**Mysql5.6֮ǰ**��idx_name_age��ҳ��ֵ�һ��ǡ�С��ˣ��õ��ǵ��id��Ȼ��ر��ҳ��У��ȥ�Ա��Ա��ֶΡ��ͼ�� + +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c5729b1a84fd4ee9b872717903ca6f75~tplv-k3u1fbpfcp-watermark.image) + +��Щ��ѿ��ܾ��֣��name,age)��Ϊʲôѡ��С��ֺ󣬲��˳�㿴��age�ٻر��أ��Ǹ��Ч���ѽ��MySQL 5.6 ��**��Ż�**��У��а��ֶ��жϣ�ֱ�ӹ��˵��ļ�¼��ٻر�� + + +��ˣ�MySQL5.6�汾֮��ѡ��С��ֺ�˳��age=28��,��Ծ�ֻ��һ�λر�� + +![](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/168aecb4709d4c30bc93c489ad76d712~tplv-k3u1fbpfcp-watermark.image) + +### �š� ��Թٿ��֮�� + +**��Թ٣�** ��һ�ű��ǧ�򼶱��ϵģ��ô��ű��Ҫ��ô��أ� + +**��** ��Ҫ֪��һ�㣬��ʱ��ǻ�Ա��ġ��п��ܳ��¹ʵġ��Բο��·�� + +- 1.�ȴ��һ�Ÿ�ԭ��A��ݽṹ��ͬ��±�B�� +- 2.��±�B��Ҫ��ϵ�� +- 3.��ԭ��A��ݵ��±�B +- 4.rename�±�BΪԭ��ı��A��ԭ��A��ı�� + +### �ܽ��ϰ + +��Ҫ��9��ؼ�֪ʶ�㣬ϣ��Դ��а��أ��ҳ�һ��й��ҵ�񿪷��ļ��SQL��´��ô�ش�ģ��Ȥ��ϵ�ҹ�~��Ŀ��£� +``` + +select * from A where type ='1' and status ='s' order by create_time desc; +``` +��type��9��ͣ��ֶ��Ի��ԣ�status��ֶȲ��ߣ��3��ͣ��ô��μ��أ� +- �Ǹ�type�ӵ�� +- ��ǣ�type��status��create_time�� +- ��ǣ�type��create_time��أ� + +### �ο��л +- [ MySQL��Щ�� ?](https://segmentfault.com/q/1010000003832312) +- [��](https://zhuanlan.zhihu.com/p/151460679) +- [MySQLʵս45��](https://time.geekbang.org/column/article/69636) + diff --git "a/\345\267\245\344\275\234\346\200\273\347\273\223/\345\267\245\344\275\234\345\233\233\345\271\264\357\274\21450\344\270\252\350\256\251\344\275\240\344\273\243\347\240\201\346\233\264\345\245\275\347\232\204\345\260\217\345\273\272\350\256\256.md" "b/\345\267\245\344\275\234\346\200\273\347\273\223/\345\267\245\344\275\234\345\233\233\345\271\264\357\274\21450\344\270\252\350\256\251\344\275\240\344\273\243\347\240\201\346\233\264\345\245\275\347\232\204\345\260\217\345\273\272\350\256\256.md" new file mode 100644 index 0000000..e47a0ba --- /dev/null +++ "b/\345\267\245\344\275\234\346\200\273\347\273\223/\345\267\245\344\275\234\345\233\233\345\271\264\357\274\21450\344\270\252\350\256\251\344\275\240\344\273\243\347\240\201\346\233\264\345\245\275\347\232\204\345\260\217\345\273\272\350\256\256.md" @@ -0,0 +1,1478 @@ +### ǰ�� +��꣬��ܶ�˼��Ĵ��룬��дһ��ܽ�ɣ�50��õĽ��顣��е�һЩ�㣬��ǰ��Ҳд��Ҫ��һ�¡�ϣ��ճ�д��˼��ܽᣬ��ͣ�ͬʱ��в��Եģ�Ҳ��ָ��л��~ + +- ��ںţ�**��ݵ�С�к�** +- github��ַ��https://github.com/whx123/JavaHome + +### 1. ��ж��Ƿ��ʱ��select count �� select ��У��á� + +��Ǿ��Ƶ�ҵ�񳡾��磬�ж�ĳ��û�```userId```�Ƿ��ǻ�Ա�� + +**��** һЩС��ʵ�֣��Ȳ��û��Ϣ��û��¼��Ȼ��ȥ�ж��Ƿ��ǻ�Ա: +``` + + +boolean isVip (String userId){ + UserInfo userInfo = userInfoDAp.selectUserByUserId(userId); + return UserInfo!=null && "Y".equals(userInfo.getVipFlag()) +} +``` + +**��** ��ҵ�񳡾��ʵ��õ�ʵ�֣��ֱ��```select count```һ�£��£� + +``` + + + boolean isVip (String userId){ + int vipNum = userInfoDAp.countVipUserByUserId(userId); + return vipNum>0 +} +``` + + +### 2. ��ӵ�if�߼��Ե��˳��ó��Ч + + +��ҵ��û��ǻ�Ա��ҵ�һ�ε�½ʱ��Ҫ��һ��֪ͨ�Ķ��š��û�о��˼��ܿ��ֱ��д�ˡ� + +``` +if(isUserVip && isFirstLogin){ + sendMsgNotify(); +} +``` + +��ܹ��5��isUserVipͨ��3��isFirstLoginͨ��1�� ô��ϴ��룬isUserVipִ�еĴ��Ϊ5�Σ�isFirstLoginִ�еĴ��Ҳ��3�Σ��£� + +![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b30c2899d10f4258bf1fc94a9ebf324c~tplv-k3u1fbpfcp-watermark.image) + + +��һ��isUserVip��isFirstLogin��˳��أ� +``` +if(isFirstLogin && isUserVip ){ + sendMsg(); +} +``` +isFirstLoginִ�еĴ��5�Σ�isUserVipִ�еĴ��1�Σ��£� + +![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/103a20c642e04ea899d74c4cb8187b28~tplv-k3u1fbpfcp-watermark.image) + +��isFirstLogin��ж��߼�ֻ��select count һ��ݿ��isUserVipҲ��select count һ��ݿ��Ļ��Ȼ��isFirstLogin��ǰ��Ч�� + + +### 3. д��ѯSql��ʱ��ֻ��Ҫ�õ��ֶΣ��ͨ�õ��ֶΣ��ܾ��ֵ�select * + +**��** + +``` +select * from user_info where user_id =#{userId}; +``` + +**��** + + +``` + selct user_id , vip_flag from user_info where user_id =#{userId}; +``` + +**��ɣ�** + +- ��ʡ��Դ��翪�� +- ��õ��ٻر��߲�ѯЧ�ʡ� + +### 4. �Ż��ĳ��򣬾ܾ��Ҫ�Ķ�� + + +��ı��߼��жϣ�һ��ᱻ��ֵ��˵��ֻ��һ��ַ��ֱ�ӳ�ʼ��ַ��Ϳ��ˣ�û�б�Ҫ��Ҫnew String(). + + +�� +``` +String s = new String ("��ӭ��ע��ںţ��ݵ�С�к�"); +``` + +�� + +``` +String s= "��ӭ��ע��ںţ��ݵ�С�к� ��; +``` + + +### 5. ��ʼ��ʱ��ָ�� + + +��Ŀ��ֲᣬҲ��ȷ�ᵽ��㣺 +![image.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/2ac43ab291794c608537f1c4da6a9caa~tplv-k3u1fbpfcp-watermark.image) + + +��mapҪ�洢��Ԫ�ظ��15��ң��д�� +``` + //initialCapacity = 15/0.75+1=21 + Map map = new HashMap(21); + ��ΪhashMap��2��йأ��Կ��ȡ32�� + Map map = new HashMap(32); +``` + +### 6.catch��쳣��Ҫ��ӡ��exception��ö�λ�� + +**��** +``` +try{ + // do something +}catch(Exception e){ + log.info("��ݵ�С�к��ĳ��쳣��"); +} +``` + +**��** + +``` +try{ + // do something +}catch(Exception e){ + log.info("��ݵ�С�к��ĳ��쳣��",e); //��exception��ӡ�� +} +``` + +**��ɣ�** +- ��У��û�а�exception��ʱ��Ų��Ͳ��ò��SQlд��쳣��IO�쳣��أ��Ӧ�ð�exception��ӡ��־��Ŷ~ + +### 7. ��ӡ��־��ʱ�򣬶��û�и��Object��toString�ķ��ֱ�Ӱ��ӡ��ˡ� + + +��ڴ�ӡ��־��ʱ�򣬾��뿴��һ��request��ʲô��Ǻ��Щ��룺 + + +``` +publick Response dealWithRequest(Request request){ + log.info("��ǣ�".request.toString) +} +``` +��ӡ��£� + +``` +��ǣ�local.Request@49476842 +``` + +��Ϊ��toString��Ĭ�ϵ�ʵ��ǡ��@ɢ��޷��ʮ��ơ��㿴�ɣ��Ӵ�ӡ��־��ûɶ��˼��㶼��֪��ӡ��ʲô��ݡ� + +��һ��(��Ϊ��εĶ��󣩣�**��дtoString()��**�� + +``` +class Request { + + private String age; + + private String name; + + @Override + public String toString() { + return "Request{" + + "age='" + age + '\'' + + ", name='" + name + '\'' + + '}'; + } +} + +publick Response dealWithRequest(Request request){ + log.info("��ǣ�".request.toString) +} + + +``` +��ӡ��£� + +``` +��ǣ�Request{age='26', name='��ںţ��ݵ�С�к�'} +``` + +### 8. һ��ܾ��Ĳ��б�� + +��ôһ��з��β��ĸ�� + +``` +public void getUserInfo��String name,String age,String sex,String mobile){ + // do something ... +} +``` + +��Ҫ�ഫһ��version��Ĺ��з��dubbo��ֶ��ṩ�ĽӿڵĻ��ô��Ľӿ��ǲ��Ҫ��ϰ汾�� + +``` +public void getUserInfo��String name,String age,String sex,String mobile){ + // do something ... +} + +/** + * �½ӿڵ�� + */ +public void getNewUserInfo��String name,String age,String sex,String mobile��String version){ + // do something ... +} +``` + +��أ�һ��һ��Ĳ��һ�㲻�˹��Ĳ��б��ţ��ҽӿ��ʱ��ܻ�Ҫ��ϰ汾��ݡ��ʵ��Ƕ��ô��أ��ø�DTO��װһ��Щ��~��£� + +``` +public void getUserInfo��UserInfoParamDTO userInfoParamDTO){ + // do something ... +} + +class UserInfoParamDTO{ + private String name; + private String age; + private String sex; + private String mobile; +} +``` +�ø�DTO��װһ�£��ʹ��в��䶯��Ҳ��Բ��ö��ӿ��ˣ��ô��ܸܵġ� + +### 9. ʹ�û��IO�� + +**��** + +``` +/** + * ��ںţ��ݵ�С�к� + * @desc: ��һ��ͼƬ�ļ� + */ +public class MainTest { + public static void main(String[] args) throws FileNotFoundException { + long begin = System.currentTimeMillis(); + try (FileInputStream input = new FileInputStream("C:/456.png"); + FileOutputStream output = new FileOutputStream("C:/789.png")) { + byte[] bytes = new byte[1024]; + int i; + while ((i = input.read(bytes)) != -1) { + output.write(bytes,0,i); + } + } catch (IOException e) { + log.error("��ļ��쳣",e); + } + log.info("��д��ܹ��ʱms��"+(System.currentTimeMillis() - begin)); + } +} +``` + +��н�� + +``` +��д��ܹ��ʱms:52 +``` + + + +ʹ��```FileInputStream```��```FileOutputStream```ʵ��ļ��д��ܣ��û��ʲô��ġ��أ��ʹ�û��```BufferedReader```��```BufferedWriter```��```BufferedInputStream```��```BufferedOutputStream```�ȣ��IO��߶�дЧ�ʡ� +> ��ǲ��ȡ��һ��ֽڻ��ַ��ģ��ͻ�ֱ��ˡ��ȡ��һ��ֽڻ��ַ�ʱ��Ȳ��ǵȴﵽ��һ�� + +**��** + + +``` +/** + * ��ںţ��ݵ�С�к� + * @desc: ��һ��ͼƬ�ļ� + */ +public class MainTest { + public static void main(String[] args) throws FileNotFoundException { + long begin = System.currentTimeMillis(); + try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("C:/456.png")); + BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("C:/789.png"))) { + byte[] bytes = new byte[1024]; + int i; + while ((i = input.read(bytes)) != -1) { + output.write(bytes,0,i); + } + } catch (IOException e) { + log.error("��ļ��쳣",e); + } + log.info("�ܹ��ʱms"+(System.currentTimeMillis() - begin)); + } +} +``` +��н�� + +``` +��д��ܹ��ʱms:12 +``` + +### 10. �Ż��ĳ��߼��ǰ��Ѿ��鵽��ݣ��ں��ķ��Ҳ�õ��Ļ��ǿ��԰��´��εģ��ٷ��/�� + +**��** +``` +public Response dealRequest(Request request){ + + UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId); + if(Objects.isNull(request)){ + return ; + } + + insertUserVip(request.getUserId); + +} + +private int insertUserVip��String userId��{ + //�ֲ��һ�� + UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId); + //��û�vip��ˮ + insertUserVipFlow(userInfo); + .... +} + +``` + +��Ȼ��ϳ��룬�Ѿ��鵽 userInfo��Ȼ��ְ�userId��ȥ��ֲ��һ�Ρ��ʵ��ϣ��԰�userInfo��ȥ�ģ��ʡȥһ�β��Ч�� + +**��** + +``` +public Response dealRequest(Request request){ + + UserInfo userInfo = userInfoDao.selectUserByUserId(request.getUserId); + if(Objects.isNull(request)){ + return ; + } + + insertUserVip(userInfo); +} + +private int insertUserVip��UserInfo userInfo��{ + //��û�vip��ˮ + insertUserVipFlow(userInfo); + .... +} +``` + + +### 11. ��ҪΪ�˷��㣬ֱ��ڴ��ʹ��0,1��ħ��ֵ��Ӧ��Ҫ��enumö�ٴ��档 + + +**��** + +``` +if("0".equals(userInfo.getVipFlag)){ + //�ǻ�Ա��ʾȥ��ͨ��Ա + tipOpenVip(userInfo); +}else if("1".equals(userInfo.getVipFlag)){ + //��Ա��ѫ�·�� + addMedal��userInfo��; +} +``` + +**��** + + +``` +if(UserVipEnum.NOT_VIP.getCode.equals(userInfo.getVipFlag)){ + //�ǻ�Ա��ʾȥ��ͨ��Ա + tipOpenVip(userInfo); +}else if(UserVipEnum.VIP.getCode.equals(userInfo.getVipFlag)){ + //��Ա��ѫ�·�� + addMedal��userInfo��; +} + +public enum UserVipEnum { + + VIP("1","��Ա"), + NOT_VIP("0","�ǻ�Ա"),:; + + private String code; + private String desc; + + UserVipEnum(String code, String desc) { + this.code = code; + this.desc = desc; + } +} +``` + +д��ʱ�򣬲�Ҫһʱ��𣬾�ֱ��ʹ��ħ��ֵ��ʹ��ħ��ֵ��ά��ܵġ� + +### 12. ��Ա��ֵ��ı�ʱ��ȶ��Ϊ��̬�� + +**��** + + +``` +public class Task { + private final long timeout = 10L; + ... +} +``` + +**��** + +``` +public class Task { + private static final long TIMEOUT = 10L; + ... +} +``` + +> ��Ϊ��Ϊstatic��ྲ̬��ÿ��ʵ��У��ֻ��һ�ݸ��ǳ�Ա��ÿ��ʵ��У��һ�ݸ��Ȼ��Ļ��Ϊ��̬��һЩ�� + +### 13. ע��ָ�룬��Ҫ��ҵ��˵��߼�ĳ��Ϊ�ա� + +NullPointerException ��ճ��зǳ��Ǵ��뿪��У�һ��Ҫ�Կ�ָ�뱣�� + +��Ҫ��⼸��ָ��⣺ + +- ��װ��͵Ŀ�ָ�� +- ��õĿ�ָ�� +- Equals��ߵĿ�ָ�� +- ConcurrentHashMap ��֧�� k-vΪ null�� +- ��ϣ��ֱ�ӻ�ȡԪ�� +- ��ֱ�ӻ�ȡ�� + +**��** +``` +public class NullPointTest { + public static void main(String[] args) { + String s = null; + if (s.equals("666")) { //s��Ϊ�գ��ᵼ�¿�ָ�� + System.out.println("��ںţ��ݵ�С�к��ɻ��"); + } + } +} + +``` + +### 14��񵽵��쳣��ܺ��ٴ��־�� + +**��** + +``` +public static void testIgnoreException() throws Exception { + try { + // �� + } catch (Exception e) { + //��쳣��ɶ��鲻��־Ҳ��򣿣� + } +} + +``` + +**��** + +``` +public static void testIgnoreException() { + try { + // �� + } catch (Exception e) { + log.error("�쳣�ˣ��ϵ��С��翴��",e); + } +} +``` + +### 15. ��Lambda��ʽ�滻�ڲ��࣬ʹ�� + +JDK8��-Lambda��ʽ��Lambda��ʽ��ڲ��ţ��ڴ��У��ǲ��invokeDynamicָ��ʵ�֣��ڲ��࣬Ч��Ҳ�� + + +**��** +``` + public void sortUserInfoList(List userInfoList){ + userInfoList.sort(new Comparator() { + @Override + public int compare(UserInfo user1, UserInfo user2) { + Long userId1 = user1.getUserId(); + Long userId2 = user2.getUserId(); + return userId1.compareTo(userId2); + }}); + } +``` + +**��** + +``` + public void sortUserInfoList(List userInfoList){ + userInfoList.sort((user1, user2) -> { + Long userId1 = user1.getUserId(); + Long userId2 = user2.getUserId(); + return userId1.compareTo(userId2); + }); + } +``` + +### 16. ֪ͨ�ࣨ�緢�ʼ��ж��ţ��Ĵ��룬��첽�� + +��ҵ��Ҫ��û��½ʱ��Ӹ��֪ͨ��ķ�˿�� 뵽��ʵ��£� + + +![image.png](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ed6daf4932b34452b1aacdb98aa2dcc8~tplv-k3u1fbpfcp-watermark.image) + +��ṩsendMsgNotify��ϵͳ��ˣ��ߵ��sendMsgNotifyʧ��ˣ��ô�û��½��ʧ��ˡ�� +һ��֪ͨ��ܵ��˵�½��̲��ã��Եļ��֥�鶪��ϡ��ô��û��Ƽ�õķ��أ��еģ��Žӿڲ��쳣��߳��첽��£� + + +![image.png](https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/58a956dc04c6456395b39d02afe3187e~tplv-k3u1fbpfcp-watermark.image) + +��ˣ��֪ͨ��Ȳ��Ƿ��Ҫ��ɽ��Ľӿ�ʱ��Ӧ�þ��Ƿ��Ӱ��Ҫ��̣�˼��ô��á� + +### 17. ��Java��ʱ��YYYY��ʽ��õ��⡣ + +�ճ��У��Ǿ��Ҫ��ڡ��Ҫ��ʱ��ڸ�ʽ��ʱ��Ǵ�д```YYYY```�Ŀӡ� + + +``` +Calendar calendar = Calendar.getInstance(); +calendar.set(2019, Calendar.DECEMBER, 31); + +Date testDate = calendar.getTime(); + +SimpleDateFormat dtf = new SimpleDateFormat("YYYY-MM-dd"); +System.out.println("2019-12-31 ת YYYY-MM-dd ��ʽ�� " + dtf.format(testDate)); +``` +��н�� + +``` +2019-12-31 ת YYYY-MM-dd ��ʽ�� 2020-12-31 +``` + +> Ϊʲô��2019��12��31�ţ��ת��һ�¸�ʽ��ͱ��2020��12��31��ˣ��ΪYYYY�ǻ��ģ��ָ��ڵ��ݣ�һ�ܴ��տ�ʼ��ֻҪ��ܿ��꣬��ô��һ�ܾ��һ��ˡ��ȷ��ʹ��yyyy��ʽ�� + + +![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/d2e3654c06cd4727b203ea5710cc8410~tplv-k3u1fbpfcp-watermark.image) + +### 18. ��һ��ȷ��ᱻ�̳У��AOPɧ��ָ��final��η��final��һ��ࡣ + +**��** +``` +public final class Tools { + public static void testFinal(){ + System.out.println("��෽��"); + } +} +``` + +һ��ָ��final��η��ᱻ�̳��ˣ��з��final��ˡ�Java��һ��е�final��Java��Ч�ʡ� + + +### 19. static��̬��Ҫ��springʵ��ܻᵼ�³�ʼ�� + +֮ǰ��Ŀ��ƵĴ��롣��̬��spring��bean�� +``` + private static SmsService smsService = SpringContextUtils.getBean(SmsService.class); +``` + +��̬��smsService�п��ܻ�ȡ��ģ��Ϊ��˳��ȷ��ģ��ϵĴ��룬��̬��smsService��ʼ��ǿ��spring��ʵ��ˡ��ȷ��д��£� + + +``` + private static SmsService smsService =null; + + //ʹ�õ��ʱ��ȡ��ȡ + public static SmsService getSmsService(){ + if(smsService==null){ + smsService = SpringContextUtils.getBean(SmsService.class); + } + return smsService; + } + +``` + +### 20. ��Ա��޹صķ��Ӧ��ɾ�̬�� + + + +��Щ��ʵ��Ա��޹أ��Ϳ��Ϊ��̬��һ�㣬��õúܶࡣ**��**�� + +``` +/** + * BigDecimal�Ĺ�� + */ +public class BigDecimalUtils { + + public BigDecimal ifNullSetZERO(BigDecimal in) { + return in != null �� in : BigDecimal.ZERO; + } + + public BigDecimal sum(BigDecimal ...in){ + BigDecimal result = BigDecimal.ZERO; + for (int i = 0; i < in.length; i++){ + result = result.add(ifNullSetZERO(in[i])); + } + return result; + } +``` + +��ΪBigDecimalUtils��ķ��û��static��Σ��ԣ��Ҫʹ�õ�ʱ��ÿ�ζ�Ҫnewһ��,�ǲ��ͺ��Դȥ**��**���� + +``` +BigDecimalUtils bigDecimalUtils = new BigDecimalUtils��; +bigDecimalUtils.sum(a,b); +``` +��Կ��ɾ�̬��ʹ�õ�ʱ��ֱ��```��.��```��ü��ɣ��£� + + +``` +/** + * BigDecimal�Ĺ�� + */ +public class BigDecimalUtils { + + public static BigDecimal ifNullSetZERO(BigDecimal in) { + return in != null �� in : BigDecimal.ZERO; + } + + public static BigDecimal sum(BigDecimal ...in){ + BigDecimal result = BigDecimal.ZERO; + for (int i = 0; i < in.length; i++){ + result = result.add(ifNullSetZERO(in[i])); + } + return result; + } +``` + +### 21. ��Ҫ��һ��Exception��׽��п��ܵ��쳣�� + +**��:** + +``` + +public void test(){ + try{ + //��׳� IOException �Ĵ�� + //��׳� SQLException �Ĵ�� + }catch(Exception e){ + //�û�� Exception ��׽��п��ܵ��쳣��ζ��׽��ᶪʧԭʼ�쳣��Ч��ϢŶ + log.info(��Exception in test,exception:{}��, e); + } +} + +``` + +**��** + + +``` +public void test(){ + try{ + //��׳� IOException �Ĵ�� + //��׳� SQLException �Ĵ�� + }catch(IOException e){ + //��׽ IOException + log.info(��IOException in test,exception:{}��, e); + }catch(SQLException e){ + //��׽ SQLException + log.info(��SQLException in test,exception:{}��, e); + } +} +``` + +### 22. ��Ҫ��ȷ�װ��Լ��༴�ɡ� + +**��** + +``` +// ��װ +public static boolean isUserVip(Boolean isVip) { + return Boolean.TRUE.equals(isVip); +} + +// ʹ�ô�� +boolean isVip = isVip(user.getUserVip()); +``` + +**��** + + +``` +boolean isVip = Boolean.TRUE.equals(user.getUserVip()); +``` + +��Ҫ��ȷ�װ��˼��ɡ��ң��û��ջ�ͳ�ջ��ĸ��CPU��ڴ棬��ȷ�װ��ܵģ� + + +### 23. ��ĳ�ֵһ��ᱻ��ǣ��û�б�Ҫ��ֵ�� + +**��:** + +``` +List userList = new ArrayList<>(); +if (isAll) { + userList = userInfoDAO.queryAll(); +} else { + userList = userInfoDAO.queryActive(); +} + +``` +**��** + + +``` +List userList ; +if (isAll) { + userList = userInfoDAO.queryAll(); +} else { + userList = userInfoDAO.queryActive(); +} + +``` + + +### 24.��ֵ��Ҫʹ��BigDecimal + +��Ӱɣ� +``` +public class DoubleTest { + public static void main(String[] args) { + System.out.println(0.1+0.2); + System.out.println(1.0-0.8); + System.out.println(4.015*100); + System.out.println(123.3/100); + + double amount1 = 3.15; + double amount2 = 2.10; + if (amount1 - amount2 == 1.05){ + System.out.println("OK"); + } + } +} +``` +��н�� + +``` +0.30000000000000004 +0.19999999999999996 +401.49999999999994 +1.2329999999999999 +``` +> ��Ϊ��Զ��ƴ洢��ֵ�ģ��ڸ��Ҳ�ǡ��ڼ��ԣ�0.1�޷��ȷ����Ϊʲô��ᵼ�¾�ȷ��ȱʧ�ġ��ˣ��㣬һ�㶼��BigDecimal �� + + +``` +System.out.println(new BigDecimal(0.1).add(new BigDecimal(0.2))); +//output: +0.3000000000000000166533453693773481063544750213623046875 +``` +��ʵ��ʹ�� BigDecimal ��ʾ�ͼ��㸡��ʹ��ַ��Ĺ��췽��ʼ�� BigDecimal��ң��Ҫ��עBigDecimal�ļ�λС��㣬��а��ģʽ�� + +### 25. ע��Arrays.asList�ļ�� + +- **��Ͳ��Ϊ Arrays.asList��Ĳ��ᱻ��һ��** + +``` +public class ArrayAsListTest { + public static void main(String[] args) { + int[] array = {1, 2, 3}; + List list = Arrays.asList(array); + System.out.println(list.size()); + } +} +//��н�� +1 +``` +- **Arrays.asList ��ص� List ��֧��ɾ��** + + +``` +public class ArrayAsListTest { + public static void main(String[] args) { + String[] array = {"1", "2", "3"}; + List list = Arrays.asList(array); + list.add("5"); + System.out.println(list.size()); + } +} + +// ��н�� +Exception in thread "main" java.lang.UnsupportedOperationException + at java.util.AbstractList.add(AbstractList.java:148) + at java.util.AbstractList.add(AbstractList.java:108) + at object.ArrayAsListTest.main(ArrayAsListTest.java:11) + +``` + Arrays.asList ��ص� List �� java.util.ArrayList�� Arrays ��ڲ��ArrayList��ڲ��ArrayListû��ʵ��add��Ǹ��add��ʵ�֣��ǻ��׳��쳣��ء� + +- **ʹ��Arrays.asLis��ʱ�򣬶�ԭʼ��޸Ļ�Ӱ�쵽��ǻ�õ��Ǹ�List** + +``` +public class ArrayAsListTest { + public static void main(String[] args) { + String[] arr = {"1", "2", "3"}; + List list = Arrays.asList(arr); + arr[1] = "4"; + System.out.println("ԭʼ��"+Arrays.toString(arr)); + System.out.println("list��" + list); + } +} + +//��н�� +ԭʼ��[1, 4, 3] +list��[1, 4, 3] +``` + +### 26��ʱ�ر�IO��Դ�� + +Ӧ�ô�Ҷ��й��ľ��windowsϵͳ��̫��ļ��ϵͳ��ͻ��õ��Ժܿ��Ȼ��linux��Ҳһ��ƽʱ��ļ��ݿ��ӣ�IO��Դ��û�رգ��ô��IO��Դ�ͻᱻ��ռ�ţ��˾�û�а취��ˣ��Դ�˷ѡ� + + +��ʹ��IO��ǵùرչ��ʹ��try-with-resource�رյģ� +``` +/* + * ��ע��ںţ��ݵ�С�к� + */ +try (FileInputStream inputStream = new FileInputStream(new File("jay.txt")) { + // use resources +} catch (FileNotFoundException e) { + log.error(e); +} catch (IOException e) { + log.error(e); +} +``` + +### 27. ��ʹ�ú��ڵĻ��ʱ�� + +> - �ڷ��ڣ��Ͳ��Լ��ʱ��Ǳ��ջ�еģ��ٶȱȽϿ졣 +> - ��͵Ĳ��ʱ��ö��ջ�У��ݶ��ڶ��У��ٶȽ�� +> - ��У��κ��͵ĳ�Ա��ڶѣ�Heap��У��ٶȽ�� + +``` +public class AccumulatorUtil { + + private double result = 0.0D; + //�� + public void addAllOne( double[] values) { + for(double value : values) { + result += value; + } + } + //��ڷ��һ��ֲ��ʱ��ۼ��ٸ�ֵ��ĳ�Ա�� + public void addAll1Two(double[] values) { + double sum = 0.0D; + for(double value : values) { + sum += value; + } + result += sum; + } +} + +``` + +### 28. ��ݿ�һ�β�ѯ��࣬��ҳ�� + +��Sqlһ��Բ��Ƚ϶࣬��ҳ�� + + +**��** +``` + +select user_id,name,age from user_info ; + +``` + +**��** + +``` +select user_id,name,age from user_info limit #{offset},#{pageSize}; +``` + +��ƫ��ر��ʱ�򣬲�ѯЧ�ʾͱ�õ��¡��ַ�ʽ�Ż�� + +``` +//��һ ��ϴβ�ѯ��¼(ƫ��) +select id��name from user_info where id>10000 limit #{pageSize}. + +//��order by + �� +select id��name from user_info order by id limit #{offset},#{pageSize} + +//��ҵ��ҳ�� + +``` + +### 29. ��ٶԱ��ظ�� + +һ��д��ʱ�򣬻��µķ�ʽʵ�ֱ�� +``` +for (int i = 0; i < list.size; i++){ + +} +``` +��list��Ƚ�С�ǻ��á��list�Ƚϴ�ʱ��Ż�� +``` +for (int i = 0, int length = list.size; i < length; i++){ + +} +``` + +��ɣ� +- �Է��ĵ��ã��ʹ��ֻ��һ��䣬Ҳ��ĵģ��紴��ջ֡��list�Ƚϴ�ʱ��ε��list.sizeҲ�ǻ��Դ��ĵġ� + + +### 30. �޸Ķ��Ͻӿڵ�ʱ��˼��ӿڵļ��ԡ� + +�ܶ�bug��Ϊ�޸��˶��Ͻӿڣ��ȴ��ݵ��µġ��ؼ��ǱȽ��صģ��ֱ�ӵ��ϵͳ��ʧ�ܵġ��ֳ��Ա��׾ͷ��Ŷ~ + +��ԣ��ԭ��ӿ��޸ģ��ӿ��Ƕ��ṩ��Ļ��һ��Ҫ��ǽӿڼ��ݡ��ٸ��Ӱɣ��dubbo�ӿڣ�ԭ��ֻ��A��B��һ��C��Ϳ��Կ�� + +``` +//�Ͻӿ� +void oldService(A,B);{ + //��½ӿڣ��null��C + newService(A,B,null); +} + +//�½ӿڣ��ʱ��ɾ��Ͻӿڣ��Ҫ��ݡ� +void newService(A,B,C); +``` + + +### 31 ��ȡ��ʩ��ʱ��߽��ȣ� + +�ճ��У��Ҫ��ȡ��ʩ��߽��ָ��ʱ�� + + +��ƴ��Ƚϳ��: + +``` +String name = list.get(1).getName(); //list��Խ�磬��Ϊ��һ��2��Ԫ�ع� +``` + +��ԣ�Ӧ�ò�ȡ��ʩ��Ԥ��һ��߽��**��** + +``` +if(CollectionsUtil.isNotEmpty(list)&& list.size()>1){ + String name = list.get(1).getName(); +} +``` + + +### 32. ע�� ArrayList.toArray() ǿת�Ŀ� + +``` +public class ArrayListTest { + public static void main(String[] args) { + List list = new ArrayList(1); + list.add("��ںţ��ݵ�С�к�"); + String[] array21 = (String[])list.toArray();//��ת��쳣 + } +} + +``` + +��Ϊ��ص��Object��ͣ�Object��ǿתString��飬�ᷢ��ClassCastException��ǣ�ʹ��toArray()��ط��toArray(T[] a) + +``` +String[] array1 = list.toArray(new String[0]);//�� +``` + + +### 33. ��ѭ��Զ�̵��á��ݿ��ȿ��С� + +�̲��ݿ��ǱȽϺ��硢IO��Դ�ģ��Ծ��ѭ��Զ�̵��á��ѭ��ݿ⣬��һ��Բ��Ҫѭ��ȥ�顣��أ�Ҳ��Ҫһ��Բ�̫��ݹ��Ҫ��500һ�ν��ϣ� + + +**��** +``` +remoteBatchQuery(param); +``` + +**��** + +``` +for(int i=0;i userInfoList) { + for (int i = 0; i < userInfoList.size(); i++) { + //�ظ��userList.size()�� + } + } +``` + +**��** + + +``` + public static void listDetail(List userInfoList) { + int length = userInfoList.size(); + for (int i = 0; i < length; i++) { + //��ٵ��userList.size()��ֻ��length��һ�Ρ� + } + } +``` + +### 37��ֱ�Ӵ��ļ��һ��Դ��ݿ��ȡ̫��ݵ��ڴ棬��ܵ��OOM�� + +��һ��԰Ѵ��ļ��ݿ�̫��ݴﵽ�ڴ棬�ǻᵼ��OOM�ġ��ԣ�Ϊʲô��ѯDB��ݿ⣬һ�㶼�� + +��ȡ�ļ��Ļ��һ��ļ��̫�󣬲�ʹ��Files.readAllLines()��Ϊʲô�أ��Ϊ��ֱ�Ӱ��ļ��ڴ�ģ�Ԥ��²��OOM��ʹ��ɣ��Կ��Դ�룺 + + +``` +public static List readAllLines(Path path, Charset cs) throws IOException { + try (BufferedReader reader = newBufferedReader(path, cs)) { + List result = new ArrayList<>(); + for (;;) { + String line = reader.readLine(); + if (line == null) + break; + result.add(line); + } + return result; + } +} +``` +��̫��ļ��ʹ��Files.line()��ȡ��ʱ��ȡ�ļ��Щ��һ��ʹ��Ҫ�ر��Դ��Ĺ�� + +### 38. ��õ��ӿڣ��Ҫ��쳣��ȫ�ԣ��ʱ��⼸��㡣 + +�ճ��У��Ҫ��õ��񣬻��߷ֲ�ʽԶ�̷��ĵĻ��Ҫ��ǣ� + + +- �쳣��磬��˵Ľӿڣ��쳣�ˣ��ô��Ի��ǵ��ʧ�ܣ� +- ��ʱ��û��Ԥ��Է��ӿ�һ��÷��أ�һ��ø��ʱ�Ͽ�ʱ�䣬�Ա��Ľӿڣ� +- ��Դ��Ľӿڵ�ʧ�ܣ��費��Ҫ��ԣ��Ҫվ��ҵ��ϽǶ�˼��⣩ + +> ��һ��ӣ��һ��http��˵ķ��Ҫ��connect-time��retry�� + + +### 39 ��Ҫʹ��ѭ��ϣ��ʹ��JDK�ṩ�ķ�� + +> - JDK�ṩԭ��API��ֱ��ָ��ϵ��ܡ� +> - ��Щ��ĵײ��System.arraycopy��ʵ�֣��ݵ��Ч�ʸ��ߡ� + +**��** + +``` +public List copyMergeList(List user1List, List user2List) { + List userList = new ArrayList<>(user1List.size() + user2List.size()); + for (UserInfo user : user1List) { + userList.add(user); + } + for (UserInfo user : user2List) { + userList.add(user); + } + + return user1List; + } +``` + +**��** + +``` +public List copyMergeList(List user1List, List user2List) { + List userList = new ArrayList<>(user1List.size() + user2List.size()); + userList.addAll(user1List); + userList.addAll(user2List); + return user1List; + } +``` + +### 40. ��ڸ��ӵĴ��߼��ע�� + +д��ʱ��û�б�Ҫд̫��ע�͵ģ��õķ��õ�ע�͡��ǣ��ҵ��߼��ܸ��ӵĴ��룬��ķǳ��б�Ҫд��ע�͡��ע�ͣ��ں��ά�� + + +### 41. ��߳��£��԰�ȫ�� + +�ڸ߲��£�HashMap��ܻ��ѭ��Ϊ��Ƿ��԰�ȫ�ģ��Կ��ʹ��ConcurrentHashMap�� Ҳ��ϰ�ߣ��Ҫ��־��һ��new HashMap(); + +- Hashmap��Arraylist��LinkedList��TreeMap�ȶ��Բ��ȫ�ģ� +- Vector��Hashtable��ConcurrentHashMap�ȶ��԰�ȫ�� + +### 42. ʹ��spring��ʱ��ע��⼸��δ��Ч�Ŀ� + +�ճ�ҵ�񿪷��У��Ǿ��򽻵��ʧЧ��Ҫ��¼�� + +- �ײ��ݿ��治֧�� +- �ڷ�public��εķ��ʹ�� +- rollbackFor��ô�� +- ��෽��ֱ�ӵ�� +- �쳣��try...catch��ˣ��ʧЧ�� + +**��** + + +``` +public class TransactionTest{ + public void A(){ + //��һ�� + //��÷��B (��ص��ã��ʧЧ��) + B(); + } + + @Transactional + public void B(){ + //�� + } +} +``` + +**ע��񷽷��෽��ֱ�ӵ��ã��ʧЧ** + + +### 43. ʹ��Executors��̳߳أ�newFixedThreadPool��OOM�� + + +``` + ExecutorService executor = Executors.newFixedThreadPool(10); + for (int i = 0; i < Integer.MAX_VALUE; i++) { + executor.execute(() -> { + try { + Thread.sleep(10000); + } catch (InterruptedException e) { + //do nothing + } + }); + } + +``` +IDEָ��JVM��-Xmx8m -Xms8m : + +![image.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b7154077d1074b3c8e1f5670e754adfd~tplv-k3u1fbpfcp-watermark.image) + +��н�� + +![image.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/fa3de03ca1924787aa1775b0a94890b4~tplv-k3u1fbpfcp-watermark.image) + +��ǿ��Դ�룬��ʵnewFixedThreadPoolʹ�õ��޽��У� + + +``` +public static ExecutorService newFixedThreadPool(int nThreads) { + return new ThreadPoolExecutor(nThreads, nThreads, + 0L, TimeUnit.MILLISECONDS, + new LinkedBlockingQueue()); +} + +public class LinkedBlockingQueue extends AbstractQueue + implements BlockingQueue, java.io.Serializable { + ... + /** + * Creates a {@code LinkedBlockingQueue} with a capacity of + * {@link Integer#MAX_VALUE}. + */ + public LinkedBlockingQueue() { + this(Integer.MAX_VALUE); + } +... +} + +``` + +> newFixedThreadPool�̳߳صĺ��߳��ǹ̶��ģ��ʹ��˽��޽��LinkedBlockingQueue��С��߳��ӵ��У��ִ�е�ʱ��Ƚϳ��û��ͷţ��ᵼ��Խ��Խ��ѻ��У��»��ڴ�ʹ�ò�ͣ��JVM OOM�� + + +### 44. catchס�쳣�󣬾��Ҫʹ��e.printStackTrace(),��ʹ��log��ӡ�� + +**��** + +``` +try{ + // do what you want +}catch(Exception e){ + e.printStackTrace(); +} +``` + +**��** + +``` +try{ + // do what you want +}catch(Exception e){ + log.info("��ĳ��쳣��",e); +} +``` + +### 45. �ӿ��Ҫ��ݵ�� + +�ӿ��Ҫ��ݵ��Եģ��ת��Щ��Ҫ�ӿڡ��ֱ�۵�ҵ�񳡾��û��ŵ��Σ��Ľӿ��û��holdס�� + +һ��ݵȼ��⼸��: + +- ��ѯ�� +- Ψһ�� +- token��ƣ��ֹ�ظ��ύ +- ��ݿ��delete/update�� +- �ֹ�� +- �� +- Redis��zookeeper �ֲ�ʽ��ǰ��Redis�ֲ�ʽ�� +- ״̬��ݵ� + + +### 46. ��Ƚ϶�ĺ��黮��С��ǿ�ɶ��ԡ� + +**��** +``` +public class Test { + private String name; + private Vector orders = new Vector(); + + public void printOwing() { + //print banner + System.out.println("****************"); + System.out.println("*****customer Owes *****"); + System.out.println("****************"); + + //calculate totalAmount + Enumeration env = orders.elements(); + double totalAmount = 0.0; + while (env.hasMoreElements()) { + Order order = (Order) env.nextElement(); + totalAmount += order.getAmout(); + } + + //print details + System.out.println("name:" + name); + System.out.println("amount:" + totalAmount); + } +} + +``` + +**��** + + +``` +public class Test { + private String name; + private Vector orders = new Vector(); + + public void printOwing() { + + //print banner + printBanner(); + //calculate totalAmount + double totalAmount = getTotalAmount(); + //print details + printDetail(totalAmount); + } + + void printBanner(){ + System.out.println("****************"); + System.out.println("*****customer Owes *****"); + System.out.println("****************"); + } + + double getTotalAmount(){ + Enumeration env = orders.elements(); + double totalAmount = 0.0; + while (env.hasMoreElements()) { + Order order = (Order) env.nextElement(); + totalAmount += order.getAmout(); + } + return totalAmount; + } + + void printDetail(double totalAmount){ + System.out.println("name:" + name); + System.out.println("amount:" + totalAmount); + } + +} + +``` + +һ��߳��ĺ��һ��Ҫע�Ͳ��;�Ĵ��룬��Կ��ǰ��зֳ�һ��ȷ�ĺ��Ԫ��̵ĺ��ô��ø��š� + + +### 47. ��Ĺؼ�ҵ��룬һ�㽨��־��ݻ�� + +�ؼ�ҵ��εأ��Ӧ��㹻��־��ݻ�� + +> ��磺��ʵ��ת��ҵ��ת��Ȼ��תʧ��ˣ��ſͻ�Ͷ�ߣ�Ȼ��㻹û�д�ӡ��־��ˮ��ȵ��£��ȴ��ް취�� + +��ô��ת��ҵ��Ҫ��Щ��־��Ϣ�أ��٣��ǰ��Ҫ��ӡ��Ҫ�ɣ��ӿڵ��ú��Ҫ��һ��쳣�ɣ�ͬʱ��ӡ�쳣��־�ɣ��£� + +``` +public void transfer(TransferDTO transferDTO){ + log.info("invoke tranfer begin"); + //��ӡ�� + log.info("invoke tranfer,paramters:{}",transferDTO); + try { + res= transferService.transfer(transferDTO); + }catch(Exception e){ + log.error("transfer fail,cifno:{}��account��{}",transferDTO.getCifno�� + transferDTO.getaccount��) + log.error("transfer fail,exception:{}",e); + } + log.info("invoke tranfer end"); + } +``` + +��˴�ӡ�㹻��־��ǻ��Ҫע��һ��ǣ��־��ʹ�ã��𱾸ô�ӡinfo��־��ȴ��ӡ��error��𣬸澯��ҹ��Ų��Ͳ��ˡ� + +### 48. ĳЩ�ɱ��أ��Ƥ��ȵȣ��û��Ƿ��ء� + +��Ʒ��˸��ʥ��ڵ�ʱ�򣬺��Ƥ��Ϊʥ��صģ��ڵ�ʱ�򣬺��Ƥ��ȡ� + +��: + +``` +if(duringChristmas){ + img = redPacketChristmasSkin; +}else if(duringSpringFestival){ + img = redSpringFestivalSkin; +} +``` + +��Ԫ��ڵ�ʱ��ӪС��ͻȻ��뷨��Ƥ��ɵ��صģ��ʱ��ǲ��Ҫȥ�޸Ĵ��ˣ��·��ˣ��һ��ʼ��ʵ��һ�ź��Ƥ��ñ��Ƥ��û��أ��Ƥ��ֻ��޸�һ�±��ݾͺ��ˡ� + +### 49��.ֱ�ӵ��Ҫʹ�õļ��,��ڶ�� + +ֱ�ӵ��Ҫʹ�õļ��ϣ��ͨ��ȡ��ݣ��Ƚϵ��;��Map�ĵ�� + + +**��** +``` +Map userMap = ...; +for (Long userId : userMap.keySet()) { + UserDO user = userMap.get(userId); + ... +} +``` + +**��** + + +``` +Map userMap = ...; +for (Map.Entry userEntry : userMap.entrySet()) { + Long userId = userEntry.getKey(); + UserDO user = userEntry.getValue(); + ... +} +``` + +### 50. ��ģʽ+��Ż��if else + + +�� + +``` + String medalType = "guest"; + if ("guest".equals(medalType)) { + System.out.println("�α�ѫ��"); + } else if ("vip".equals(medalType)) { + System.out.println("��Աѫ��"); + } else if ("guard".equals(medalType)) { + System.out.println("չʾ�ػ�ѫ��"); + } + ... + +``` + +��ȣ��ǰ�ÿ��߼��飬��һ��Ľӿڣ��Ǹ��ÿ��߼��Ӧ�Ĳ��ʵ��࣬�ɵ��´��룺 + + +``` +//ѫ�½ӿ� +public interface IMedalService { + void showMedal(); +} + +//�ػ�ѫ�²��ʵ�� +public class GuardMedalServiceImpl implements IMedalService { + @Override + public void showMedal() { + System.out.println("չʾ�ػ�ѫ��"); + } +} +//�α�ѫ�²��ʵ�� +public class GuestMedalServiceImpl implements IMedalService { + @Override + public void showMedal() { + System.out.println("�α�ѫ��"); + } +} +//VIPѫ�²��ʵ�� +public class VipMedalServiceImpl implements IMedalService { + @Override + public void showMedal() { + System.out.println("��Աѫ��"); + } +} + +``` + +��ٶ��Թ��࣬��Щѫ��ʵ�ֲ��࣬��£� + + +``` +//ѫ�·��񹤲�� +public class MedalServicesFactory { + + private static final Map map = new HashMap<>(); + static { + map.put("guard", new GuardMedalServiceImpl()); + map.put("vip", new VipMedalServiceImpl()); + map.put("guest", new GuestMedalServiceImpl()); + } + public static IMedalService getMedalService(String medalType) { + return map.get(medalType); + } +} + +``` + +�Ż��£� + +``` +ublic class Test { + public static void main(String[] args) { + String medalType = "guest"; + IMedalService medalService = MedalServicesFactory.getMedalService(medalType); + medalService.showMedal(); + } +} +``` + diff --git "a/\345\267\245\344\275\234\346\200\273\347\273\223/\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\345\237\272\347\241\200\357\274\232\345\246\202\344\275\225\345\256\211\345\205\250\344\274\240\350\276\223\345\255\230\345\202\250\347\224\250\346\210\267\345\257\206\347\240\201.md" "b/\345\267\245\344\275\234\346\200\273\347\273\223/\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\345\237\272\347\241\200\357\274\232\345\246\202\344\275\225\345\256\211\345\205\250\344\274\240\350\276\223\345\255\230\345\202\250\347\224\250\346\210\267\345\257\206\347\240\201.md" new file mode 100644 index 0000000..978ae68 --- /dev/null +++ "b/\345\267\245\344\275\234\346\200\273\347\273\223/\347\250\213\345\272\217\345\221\230\345\277\205\345\244\207\345\237\272\347\241\200\357\274\232\345\246\202\344\275\225\345\256\211\345\205\250\344\274\240\350\276\223\345\255\230\345\202\250\347\224\250\346\210\267\345\257\206\347\240\201.md" @@ -0,0 +1,123 @@ +

前言

我们开发网站或者APP的时候，首先要解决的问题，就是「如何安全传输和存储用户的密码」。一些大公司的用户数据库泄露事件也时有发生，带来非常大的负面影响。因此，如何安全传输存储用户密码，是每位程序员必备的基础。本文将跟大家一起学习，如何安全传输存储用户的密码。

公众号：「捡田螺的小男孩」（一起讨论密码传输存储问题）

1. 如何安全地传输用户的密码

要拒绝用户密码在网络上裸奔，我们很容易就想到使用https协议，那先来回顾下https相关知识吧~

1.1 https 协议

「http的三大风险」

为什么要使用https协议呢？「http它不香」吗? 因为http是明文信息传输的。如果在茫茫的网络海洋，使用http协议，有以下三大风险：

❝ +
+
窃听/嗅探风险：第三方可以截获通信数据。
数据篡改风险：第三方获取到通信数据后，会进行恶意修改。
身份伪造风险：第三方可以冒充他人身份参与通信。
+❞

如果传输不重要的信息还好，但是传输用户密码这些敏感信息，那可不得了。所以一般都要使用「https协议」传输用户密码信息。

「https 原理」

https原理是什么呢？为什么它能解决http的三大风险呢？

❝ +
https = http + SSL/TLS, SSL/TLS 是传输层加密协议，它提供内容加密、身份认证、数据完整性校验，以解决数据传输的安全性问题。
+❞

为了加深https原理的理解，我们一起复习一下「一次完整https的请求流程」吧~

❝ +
+
+
客户端发起https请求
+
+
服务器必须要有一套数字证书，可以自己制作，也可以向权威机构申请。这套证书其实就是一对公私钥。
+
+
服务器将自己的数字证书（含有公钥、证书的颁发机构等）发送给客户端。
+
+
客户端收到服务器端的数字证书之后，会对其进行验证，主要验证公钥是否有效，比如颁发机构，过期时间等等。如果不通过，则弹出警告框。如果证书没问题，则生成一个密钥（对称加密算法的密钥，其实是一个随机值），并且用证书的公钥对这个随机值加密。
+
+
客户端会发起https中的第二个请求，将加密之后的客户端密钥(随机值)发送给服务器。
+
+
服务器接收到客户端发来的密钥之后，会用自己的私钥对其进行非对称解密，解密之后得到客户端密钥，然后用客户端密钥对返回数据进行对称加密，这样数据就变成了密文。
+
+
服务器将加密后的密文返回给客户端。
+
+
客户端收到服务器发返回的密文，用自己的密钥（客户端密钥）对其进行对称解密，得到服务器返回的数据。
+
+❞

「https一定安全吗？」

https的数据传输过程，数据都是密文的，那么，使用了https协议传输密码信息，一定是安全的吗？其实「不然」~

❝ +
+
比如，https 完全就是建立在证书可信的基础上的呢。但是如果遇到中间人伪造证书，一旦客户端通过验证，安全性顿时就没了哦！平时各种钓鱼不可描述的网站，很可能就是黑客在诱导用户安装它们的伪造证书！
通过伪造证书，https也是可能被抓包的哦。
+❞

1.2 对称加密算法

既然使用了https协议传输用户密码，还是「不一定安全」，那么，我们就给用户密码「加密再传输」呗~

加密算法有「对称加密」和「非对称加密」两大类。用哪种类型的加密算法「靠谱」呢？

❝ +
对称加密：加密和解密使用「相同密钥」的加密算法。 +
+❞

常用的对称加密算法主要有以下几种哈： +

如果使用对称加密算法，需要考虑「密钥如何给到对方」，如果密钥还是网络传输给对方，传输过程，被中间人拿到的话，也是有风险的哦。

1.3 非对称加密算法

再考虑一下非对称加密算法呢？

❝ +
「非对称加密：」 非对称加密算法需要两个密钥（公开密钥和私有密钥）。公钥与私钥是成对存在的，如果用公钥对数据进行加密，只有对应的私钥才能解密。
+❞

常用的非对称加密算法主要有以下几种哈： +

❝ +
如果使用非对称加密算法，也需要考虑「密钥公钥如何给到对方」，如果公钥还是网络传输给对方，传输过程，被中间人拿到的话，会有什么问题呢？「他们是不是可以伪造公钥，把伪造的公钥给客户端，然后，用自己的私钥等公钥加密的数据过来？」 大家可以思考下这个问题哈~
+❞

我们直接「登录一下百度」，抓下接口请求，验证一发大厂是怎么加密的。可以发现有获取公钥接口，如下:

再看下登录接口，发现就是RSA算法，RSA就是「非对称加密算法」。其实百度前端是用了JavaScript库「jsencrypt」，在github的star还挺多的。

因此，我们可以用「https + 非对称加密算法（如RSA）」 传输用户密码~

2. 如何安全地存储你的密码？

假设密码已经安全到达服务端啦，那么，如何存储用户的密码呢？一定不能明文存储密码到数据库哦！可以用「哈希摘要算法加密密码」，再保存到数据库。

❝ +
哈希摘要算法：只能从明文生成一个对应的哈希值，不能反过来根据哈希值得到对应的明文。
+❞

2.1 MD5摘要算法保护你的密码

MD5 是一种非常经典的哈希摘要算法，被广泛应用于数据完整性校验、数据（消息）摘要、数据加密等。但是仅仅使用 MD5 对密码进行摘要，并不安全。我们看个例子，如下：

public class MD5Test {
    public static void main(String[] args) {
        String password = "abc123456";
        System.out.println(DigestUtils.md5Hex(password));
    }
}

运行结果：

0659c7992e268962384eb17fafe88364

在MD5免费破解网站一输入，马上就可以看到原密码了。。。

试想一下，如果黑客构建一个超大的数据库，把所有20位数字以内的数字和字母组合的密码全部计算MD5哈希值出来，并且把密码和它们对应的哈希值存到里面去（这就是「彩虹表」）。在破解密码的时候，只需要查一下这个彩虹表就完事了。所以「单单MD5对密码取哈希值存储」，已经不安全啦~

2.2 MD5+盐摘要算法保护用户的密码

那么，为什么不试一下MD5+盐呢？什么是「加盐」？

❝ +
在密码学中，是指通过在密码任意固定位置插入特定的字符串，让散列后的结果和使用原始密码的散列结果不相符，这种过程称之为“加盐”。
+❞

用户密码+盐之后，进行哈希散列，再保存到数据库。这样可以有效应对彩虹表破解法。但是呢，使用加盐，需要注意一下几点：

❝ +
+
不能在代码中写死盐，且盐需要有一定的长度（盐写死太简单的话，黑客可能注册几个账号反推出来）
每一个密码都有独立的盐，并且盐要长一点，比如超过 20 位。(盐太短，加上原始密码太短，容易破解)
最好是随机的值，并且是全球唯一的，意味着全球不可能有现成的彩虹表给你用。
+❞

2.3 提升密码存储安全的利器登场，Bcrypt

即使是加了盐，密码仍有可能被暴力破解。因此，我们可以采取更「慢一点」的算法，让黑客破解密码付出更大的代价，甚至迫使他们放弃。提升密码存储安全的利器~Bcrypt，可以闪亮登场啦。

❝ +
实际上，Spring Security 已经废弃了 MessageDigestPasswordEncoder，推荐使用BCryptPasswordEncoder，也就是BCrypt来进行密码哈希。BCrypt 生而为保存密码设计的算法，相比 MD5 要慢很多。
+❞

看个例子对比一下吧：

public class BCryptTest {

    public static void main(String[] args) {
        String password = "123456";
        long md5Begin = System.currentTimeMillis();
        DigestUtils.md5Hex(password);
        long md5End = System.currentTimeMillis();
        System.out.println("md5 time:"+(md5End - md5Begin));
        long bcrytBegin = System.currentTimeMillis();
        BCrypt.hashpw(password, BCrypt.gensalt(10));
        long bcrytEnd = System.currentTimeMillis();
        System.out.println("bcrypt Time:" + (bcrytEnd- bcrytBegin));
    }
}

运行结果：

md5 time:47
bcrypt Time:1597

粗略对比发现，BCrypt比MD5慢几十倍，黑客想暴力破解的话，就需要花费几十倍的代价。因此一般情况，建议使用Bcrypt来存储用户的密码

3. 总结

因此，一般使用https 协议 + 非对称加密算法（如RSA）来传输用户密码，为了更加安全，可以在前端构造一下随机因子哦。
使用BCrypt + 盐存储用户密码。
在感知到暴力破解危害的时候，「开启短信验证、图形验证码、账号暂时锁定」等防御机制来抵御暴力破解。

参考与感谢

如何正确保存和传输敏感数据？ https://time.geekbang.org/column/article/239150^[1]
如何加密传输和存储用户密码 https://juejin.cn/post/6844903604944371726#heading-8^[2]

公众号

公众号：「捡田螺的小男孩」
github地址：https://github.com/whx123/JavaHome

+ + +