今天你Java了吗思维导图模板_ProcessOn思维导图、流程图

痛点进化发展线路

IO发展

阻塞IO

多线程模型

一个线程一个链接

被阻塞

非阻塞IO

for循环多个链接

主动遍历，不知道哪个连接有数据了

一个线程可以处理多个链接

用户态到内核态切换的花费

多路复用

select模型

一个线程处理多个链接

select系统调用能一次读取多个链接

fd集合要用户态到内核态切换的花费

1024个连接

poll模型

一个线程处理多个链接

fd集合要用户态到内核态切换的花费

没有连接数的限制

epoll模型

基于mmap内核和用户态共享

基于事件回调，不用主动遍历

技术架构发展

传统应用

CS

BS

桌面应用

前后端分离

分布式

微服务

服务网格-serviceMesh

serviceless

数据存储发展

单文件

数据库

全量IO

查找慢

sql

nosql

doc

kv

内存数据库

热点缓存

子主题

时代发展

原始时代

蒸气时代

电力时代

计算机时代

科研计算机时代

PC时代

互联网时代

移动互联网

大数据时代

云计算时代

物联网时代

人工智能AI

调用方法发展

webservice

soap

xml

rpc

tcp

dubbo

restful

http

json

微服务

http

操作系统

环境安装

nasm

NASM是一个为可移植性与模块化而设计的一个80x86的汇编器。它支持相当多的目标文件格式，包括Linux和NetBSD/FreeBSD、a.out、ELF、COFF，微软16位的OBJ和Win32。它还可以输出纯二进制文件。它的语法设计得相当的简洁易懂，和Intel语法相似但更简单。它支持Pentium、P6、MMX、3DNow!、SSE和SSE2指令集。

bochs

数据结构

数组

稀疏数组

五子棋棋盘存档读档

队列

数组实现

环形队列

数组实现

丢手绢问题

链表

单向链表

双向链表

环形链表

常用设计模式

单例模式

静态工厂单例模式

饱汉式

饿汉式

DCL

双重锁校验，在多线程下需要

观察者模式

装饰者模式

适配器模式

工厂模式

代理模式

动态代理的2种实现方式及区别

JDK动态代理

只能代理实现了InvocationHandler接口的类

cglib动态代理

通过asm修改类的字节码来完成代理

区别：JDK代理针对的是接口，cglib是类，但是无法代理final修饰的类

多线程高并发

cas

AtomicInteger a = new AtomicInteger();
int b = a.incrementAndGet();

unsafe.getAndAddInt

native compareAndSwapInt

Hotspot里的cpp源码Atomic::cmpxchg

汇编指令Lock cmpxchg指令

unsafe 类似c++里的指针，能开辟内存

compare and swap

aba问题

记录数据外，加版本

AtomicStampedReference

自旋锁，一直循环，消耗cpu

对象布局

jol工具包

java object layout

<dependency>
<groupId>org.openjdk.jol</groupId>
<artifactId>jol-core</artifactId>
<version>0.13</version>
<scope>provided</scope>
</dependency>

对象头 object header

markword

32位jvm是4个字节

64位jvm是8个字节

classpointer

class对象的加载后的内存地址

4个字节

补齐 padding

补齐8的整数倍

对象属性

属于对象内容了，不是对象头

int的属性占4字节

对象类型的存的是引用的地址，占4字节

数组长度

如果不是数组则无该部分

demo

Object对象布局

java.lang.Object object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 01 00 00 00 (00000001 00000000 00000000 00000000) (1)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
12 4 (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

String对象布局

java.lang.String object internals:
OFFSET SIZE TYPE DESCRIPTION VALUE
0 4 (object header) 01 00 00 00 (00000001 00000000 00000000 00000000) (1)
4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)
8 4 (object header) da 02 00 f8 (11011010 00000010 00000000 11111000) (-134216998)
12 4 char[] String.value []
16 4 int String.hash 0
20 4 (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

synchronized

特性

锁的是对象不是代码（this T.class)

能加在方法上，代码块

加速在jdk1.6之后就做了锁优化，会有锁升级的优化过程

保证原子性和可见性

可重入锁

注意事项

不要锁基础类型，如String常量，Integer，Long等

实现

源码synchronized

ACC_SYNCHRONIZED字节码

monitorenter,monitorexit

监视器锁

Mutex Lock（互斥锁）

重量级锁，内核态与用户态切换，性能消耗大

锁升级（hotspot实现）

new

偏向锁

记录当前线程的ID（hashCode)

轻量级锁/自旋锁

基于cas实现

自适应自旋

10次自旋

所谓自适应自旋锁就是线程空循环等待的自旋次数并非是固定的，而是会动态着根据实际情况来改变自旋等待的次数

执行时间短并且线程数少的

重量级锁

OS锁

内核态和用户态切换，消耗性能

执行时间长的用OS锁

jdk1.6对锁做了优化

锁只能升级没法降级

锁消除/锁细化

StringBuffer vs StringBuilder

StringBuffer的append方法时线程安全的

StringBuffer a = new StringBuffer();
a.append('111').append('bbb'').append('ccc')

在同一个方法内的sb a的append只有一个线程去访问的时候就会将append内的synchronized锁给消除掉

锁粗化

StringBuffer a = new StringBuffer();
for(int i=0;i<1000;i++){
a.append("i"+i);
}

@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}

如果append执行1000次，则会粗化锁到

synchronized (a){
for(int i=0;i<1000;i++){
a.append("i"+i);
}
}

volatile

特性

保证变量在多线程中的可见性

MESI - CPU缓存一致性协议

Modify，修改缓存

当前cpu缓存已经被修改，与内存中数据不一致

Exclusive，独占缓存

当前CPU的缓存和内存中数据保持一致，而且其他处理器并没有可使用的缓存数据

Share，共享缓存

和内存保持一致的一份拷贝，多组缓存可以同时拥有针对同一内存地址的共享缓存段

Invalid，失效缓存

当前cpu缓存已经不能使用

缓存行cache line

64个字节宽

当修改volatile变量时，会给cpu发送一个信号告诉其他cpu这个变量已修改，当其他cpu调用这个变量时，就会先检查是否有收到修改该变量的信号，有则重新从内存中读取。volatile是无锁的，类似于乐观锁的机制。

在没有MESI的时候，用的是锁总线的方式，比较重

禁止指令重排

实现

源码volatile

ACC_VALATILE字节码

内存屏障

ReadRead

LoadLoad

ReadLoad

LoadRead

JVM的hotspot实现采用较兼容的汇编指令lock addl

没有使用cpu的原语ifence,mfence

不能保证原子性

new Object

count++

CPU指令乱序执行

指令A

指令B

有可能指令B先执行完，A再执行完，这总现象称之为乱序执行

前提是该CPU是多核的

JIT

及时编译-just in time

热点代码会被编译成汇编语言，加快执行

四种引用

强软弱虚

强引用

String a = new String();

内存不足，gc时也不会回收strong reference

软引用

SoftReference<T>

内存不足时，gc会将软引用回收

弱引用

WeakReference<T>

无论内存足不足，gc时都会将弱引用回收

应用在ThreadLocal

虚引用

PhantomReference<T>

应用在管理堆外内存，java nio里有DirectByteBuffer

DCL

Double check lock双重锁校验

单例模式之双重校验方式的变量还需要用volatile修饰吗？

需要，禁止指令重拍，得到初始化完整对象

Object obj = new Object（）

NEW java/lang/Object

申请内存

INVOKESPECIAL java/lang/Object.<init> ()V

执行构造方法

ASTORE 1

将obj指向内存空间

如果不加可能拿到半初始化状态的对象，导致业务出错

class SingletTon {
private static volatile SingletTon instance = null;
private SingletTon(){}
public static SingletTon getInstance(){
if(null == instance) {
synchronized (SingletTon.class) {
if(null == instance){
instance = new SingletTon();
}
}
}
return instance;
}
}

ThreadLocal

线程间隔离

实现

public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}

每个线程的ThreadLocal作为key存放在hashMap里，互相隔离

tab[i] = new Entry(key, value);

map里的行Entry继承了WeakReference

防止tl=null后，threadlocal无法被gc回收的问题

但是如果map里的key=null，value还指向了其他对象，也会有一行无法被回收，因此需要手动调用tl.remove

线程Thread

概念

程序

d:/qq/qq.exe

进程

qq.exe进程

线程

thread

协程/纤程

创建

Thread

Runable

lambda方式，其实也是runable

Excutor.newFixedPool线程池，其实也是thread或者runable之一

api

sleep

休眠，进入睡眠，时间过后自动复活回到就绪态

yield

礼让，让出一下cpu,返回到就绪状态

join

t1线程里调t2.join，等t2运行完，t1再运行

stop

线程运行完成后，就等于停止

setDeamon(true)

线程状态

new

runable

ready

running

timedWating

waiting

blocked

teminated

线程池

线程池创建类

public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
// 省略...
}

Excutors6大线程池

newCachedThreadPool

创建一个可缓存的线程池，若线程数超过处理所需，缓存一段时间后会回收，若线程数不够，则新建线程。

newFixedThreadPool

创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待。

newScheduledThreadPool

创建一个周期性的线程池，支持定时及周期性执行任务。

ScheduledExecutorService类的schedule()方法调度

newSingleThreadExecutor

创建一个单线程的线程池，可保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

newSingleThreadScheduledExecutor

创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行

newWorkStealingPool

newWorkStealingPool线程池的实现用到了ForkJoinPool，用到了分而治之，递归计算的算法，

4种拒绝策略

AbortPolicy 拒绝策略

这是线程池默认的拒绝策略，在任务不能再提交的时候，抛出异常，及时反馈程序运行状态。如果是比较关键的业务，推荐使用此拒绝策略，这样子在系统不能承载更大的并发量的时候，能够及时的通过异常发现。

DiscardPolicy 丢弃任务

丢弃任务，但是不抛出异常。如果线程队列已满，则后续提交的任务都会被丢弃，且是静默丢弃

DiscardOldestPolicy

丢弃队列最前面的任务，然后重新提交被拒绝的任务

CallerRunsPolicy

由调用线程处理该任务

递增解决方案

Atomic

sync

LongAdder

新的锁

可重入锁ReentrantLock

lock.lock()

支持公平

newCondition

等待队列多个

notifyAll 一个等待队列

门闩CountDownLatch

countdown

循环栅栏CyclicBarrier

满人发车

分段Phaser

读写锁ReadWriteLock

共享锁

读锁

排他锁/互斥锁

写锁

ReentrantReadWriteLock

可用做读写分离场景

信号量Semaphore

s.acquire()阻塞方法

s.release()释放

控制同时执行线程的数量

支持公平

可用做限流

交换器Exchanger

exchange() 会阻塞

2个线程交换数据的

可用做交易的场景

锁支持LockSupport

ls.park()

ls.unpark()

同步容器

Collections.synchroizedList(list)

AQS - AbstractQueuedSynchronizer

volatile state + CAS

线程队列

如何阅读源码

LinkedBlockingQueue