技术之内思维导图模板_ProcessOn思维导图、流程图

利用开源代码和读相关论文来提高写代码能力

开源代码

熟悉

阅读文档，熟悉基本概念

常用文档 Read List

官方文档：常用的开源代码都有其公开的网站。

wiki：对应github仓库的wiki文档。

系统对应的发表论文：比如Bigtable、Zookeeper、Kafka等都有论文发表。

以Storm源码阅读为例

文档中，storm提出了一些新的概念，spouts，bolts，详细阅读这些名词背后所表述的含义以及在系统中担任的职责。

文档内容需要反复的读，每次读都会有不同的新的认识

实践使用

具体实践活动

按官方文档部署相关软件，准备运行环境。

写一个hello world的demo运行起来：开发包中一般存在文件夹名包含starter 和example字眼的文件夹，该文件夹下会有许多官方使用例子。

修改demo实现自己的业务逻辑。

构建数据流图

storm数据流图

子主题

为什么要花时间构建这样一个图呢？

理解概念，了解系统的运行机制。

逼迫自己去思考，比如模块之间如何交互，数据流怎么流动。脑海里有越多的问题，看源码的动力就越足。

随着对系统的逐渐了解，可以一步步完善，添加一些具体的实现细节，比如task如何知道输出结果应该发往那个task呢，其地址是多少呢？

遇到问题时，可以依照该图猜测问题可能出在哪个模块，迅速找到切入点。

在分析系统时，可以从数据流动的角度来思考这个问题。

阅读

准备阶段

切入阶段

如何选择切入点

（1）从熟悉的基础依赖库入手，查看它在代码中是如何使用的。

（2）从使用过程中遇到的bug入手，依赖错误日志的上下文来查看代码。

（3）从概念模型中提到的概念模块入手

（4）从问题出发，查看相应的技术文章，进一步缩小范围，查看相关代码。

（5）从demo代码开始一步步debug。

深入阶段

忽略ifelse分支，和异常代码，先看主线流程

整理阶段

应用实践

概念模型和命名

开源基础库的使用

部分代码的ｃｏｐｙ

论文

阅读

论文的选择

（1）在阅读开源代码的时候，有些代码注释会标注其涉及到的论文

（2）比较出名的开源系统（kafka，zookeeper，disruptor等）都会有相对应的论文。对于想学习分布式系统的同学，有网友已经总结了一些好的论文readlist，有兴趣的可以看下。

阅读方法

着重花时间在论文的introduction部分，并试着翻译成中文记录下来

应用实践

阅读论文是为了更好的解决实际遇到的问题。有些论文描述了解决思路和方法，在遇到问题提出解决方案时会有一定的指导作用。有些论文则会具体论述其实现细节，比如一篇论文Implementing Linearizability at Large Scale and Low Latency

可以利用业余时间，动手做个小项目，从论文到工程实现，提高自己的代码能力。

总结

开发代码就如搭积木，每个开源工具就好比每个积木快，论文和具体开源代码的实现思路则是搭积木的粘合剂。只要有正确的指导思想，再配备正确高效的基础工具，代码开发真的可以做到如奶茶般润滑。但是这个过程是极其漫长的，需要长期的积累，才会在工作中潜移默化的提高自己的能力，送大家一句，以共勉。

在成功的道路上都是艰辛而且孤独的。

最后，每个人都有自己的学习方法体系，欢迎提出自己的意见积极讨论，谢谢大家！！

Java多线程

不要改变同步代码块锁住的对象，防止使用动态的String内容作为锁对象，
如果不使用inter方法加入常量池，会有线程不安全的风险

运行时使用动态生成字符串的API一般都会返回一个new String，比如StringBuffer或者StringBuilder的toString方法

更不要直接使用new String

直接使用字符串字面量的形式定义的字符串可以作为锁对象，因为在编译期就已经加入到常量池，能够保证多线程访问的是同一个对象锁

Java多线程1：进程与线程概述

进程

线程

Java中创建线程的方式

extends Thread

单继承，Thread类本身也是实现了Runnable

implements Runnable

可以多继承

线程的状态

NEW

RUNNABLE

BLOCKED

WAITING

超时等待TIMED_WAITING

TERMINATED

Java多线程2：Thread中的实例方法

Thread类中的方法调用方式：

this.XXX()

这种调用方式表示的线程是线程实例本身

Thread.currentThread.XXX()或Thread.XXX()

正在执行Thread.currentThread.XXX()所在代码块的线程

Thread类中的实例方法

start()

CPU执行哪个线程的代码具有不确定性

调用start()方法的顺序不代表线程启动的顺序，线程启动顺序具有不确定性。

run()

线程开始执行，虚拟机调用的是线程run()方法中的内容。

调用run方法不能启动线程，启动线程调用start

isAlive()

getId()

getName()

getPriority()和setPriority(int newPriority)

isDaeMon、setDaemon(boolean on)

interrupt()

isInterrupted()

join()

sleep(2000)不释放锁，join(2000)释放锁

join()方法内部使用的是wait()

官方Javadoc上对这类的注释说，不建议在线程实例上使用wait, notify, or notifyAll

join无参方法会调用参数为0的有参方法，0代表一直等待，join本身有超时机制。

Java多线程3：Thread中的静态方法

Thread类中的静态方法

currentThread()

线程类的构造方法、静态块是被main线程调用的，而线程类的run()方法才是应用线程自己调用的。

当前执行的Thread未必就是Thread本身

sleep(long millis)

yield()

interrupted()

Java多线程4：synchronized锁机制

A线程持有Object对象的Lock锁，B线程可以以异步方式调用Object对象中的非synchronized类型的方法

A线程持有Object对象的Lock锁，B线程如果在这时调用Object对象中的synchronized类型的方法则需要等待，也就是同步

synchronized锁重入

当一个线程得到一个对象锁后，再次请求此对象锁时时可以再次得到该对象的锁的

支持在父子类继承的环境中

异常自动释放锁

Java多线程5：synchronized锁方法块

两个synchronized块之间具有互斥性

如果线程1访问了一个对象A方法的synchronized块，那么线程B对同一对象B方法的synchronized块的访问将被阻塞

synchronized块获得的是一个对象锁，换句话说，synchronized块锁定的是整个对象。

synchronized块和synchronized方法

synchronized同步方法

对其他synchronized同步方法或synchronized(this)同步代码块呈阻塞状态

同一时间只有一个线程可以执行synchronized同步方法中的代码

synchronized同步代码块

对其他synchronized同步方法或synchronized(this)同步代码块呈阻塞状态

同一时间只有一个线程可以执行synchronized(this)同步代码块中的代码

多个线程持有"对象监视器"为同一个对象的前提下，同一时间只能有一个线程可以执行synchronized(非this对象x)代码块中的代码。

synchronized(非this对象x)，这个对象如果是实例变量的话，指的是对象的引用，只要对象的引用不变，即使改变了对象的属性，运行结果依然是同步的。

Java多线程6：synchronized锁定类方法、volatile关键字及其他

同步静态方法

对当前.java文件对应的Class类加锁

volatile关键字

volatile只保证可见性，原子类在使用的时候也不一定就能保证原子性，使用不当依然不行

比如两个原子操作组成一个事务，虽然单个是原子性的，但是这整个事务如果不加锁，依然不能保证原子性

synchronized除了保障了原子性外，其实也保障了可见性。

原子类也无法保证线程安全

Java多线程7：死锁

什么情况产生死锁

如果线程A持有锁L并且想获得锁M，线程B持有锁M并且想获得锁L，那么这两个线程将永远等待下去

数据库如果监测到了一组事务发生了死锁时，将选择一个牺牲者并放弃这个事务

如何进行死锁检测

类似CAS，检查版本号？

死锁的触发

避免死锁的方式

使用超时机制

Java多线程8：wait()和notify()/notifyAll()

wait和notify必须在同步方法或者同步代码块中使用

wait()方法可以使调用该线程的方法释放共享资源的锁，然后从运行状态退出，进入等待队列，直到再次被唤醒。

notify()方法可以随机唤醒等待队列中等待同一共享资源的一个线程，并使得该线程退出等待状态，进入可运行状态

notifyAll()方法可以使所有正在等待队列中等待同一共享资源的全部线程从等待状态退出，进入可运行状态

wait()释放锁以及notify()不释放锁

interrupt()方法的作用不是中断线程，而是在线程阻塞的时候给线程一个中断标识，表示该线程中断。wait()就是"阻塞的一种场景"

Java多线程9：ThreadLocal源码剖析

关于ThreadLocal

每个线程都有一个自己的ThreadLocal.ThreadLocalMap对象

每一个ThreadLocal对象都有一个循环计数器

ThreadLocal.get()取值，就是根据当前的线程，获取线程中自己的ThreadLocal.ThreadLocalMap，然后在这个Map中根据第二点中循环计数器取得一个特定value值

当table的位置上有数据的时候，ThreadLocal采取的是办法是找最近的一个空的位置设置数据。

ThreadLocal不是用来解决共享对象的多线程访问问题的

ThreadLocal不是集合，它不存储任何内容，真正存储数据的集合在Thread中。
ThreadLocal只是一个工具，一个往各个线程的ThreadLocal.ThreadLocalMap中table的某一位置set一个值的工具而已

同步与ThreadLocal是解决多线程中数据访问问题的两种思路，前者是数据共享的思路，后者是数据隔离的思路

同步是一种以时间换空间的思想，ThreadLocal是一种空间换时间的思想

ThreadLocal与线程有关，只在一次请求中有效，对比request

ThreadLocal只能存一个值，一个Request由于是Map形式的，可以用key-value形式存多个值

ThreadLocal一般用在框架，Request一般用在表示层、Action、Servlet

Java多线程11：ReentrantLock的使用和Condition

ReentrantLock，一个可重入的互斥锁，它具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

ReentrantLock持有的是对象监视器

ReentrantLock和synchronized持有的对象监视器不同

Condition

一个Lock里面可以创建多个Condition实例，实现多路通知

ReentrantLock结合Condition可以实现有选择性地通知

Condition的await()方法是释放锁

如果想单独唤醒部分线程该怎么办呢？new出多个Condition就可以了，这样也有助于提升程序运行的效率。
使用多个Condition的场景是很常见的，像ArrayBlockingQueue里就有。

Java多线程12：ReentrantLock中的方法

可以指定锁是公平锁还是非公平锁

默认是非公平锁

getHoldCount()

ReentrantLock和synchronized一样，锁都是可重入的，同一线程的同一个ReentrantLock的lock()方法被调用了多少次，getHoldCount()方法就返回多少

getQueueLength()

isFair()

hasQueuedThread()

hasQueuedThreads()

isHeldByCurrentThread()

isLocked()

tryLock()

tryLock(long timeout, TimeUnit unit)

getWaitQueueLength(Condition condition)

hasWaiters(Condition condition)

lockInterruptibly()

getWaitingThreads(Condition condition)

Java多线程13：读写锁和两种同步方式的对比

读写锁ReentrantReadWriteLock概述

多个Thread可以同时进行读取操作，但是同一时刻只允许一个Thread进行写入操作。

读读共享，读写，写写互斥

synchronized和ReentrantLock的对比

synchronized是关键字，synchronized获取锁以及释放锁都是Java虚拟机帮助用户完成的。ReentrantLock是类层面的实现，因此锁的获取以及锁的释放都需要用户自己去操作。特别再次提醒，ReentrantLock在lock()完了，一定要手动unlock()

synchronized简单，简单意味着不灵活，而ReentrantLock的锁机制给用户的使用提供了极大的灵活性。这点在Hashtable和ConcurrentHashMap中体现得淋漓尽致。synchronized一锁就锁整个Hash表，而ConcurrentHashMap则利用ReentrantLock实现了锁分离，锁的只是segment而不是整个Hash表

Java中的锁是对象锁，意味着，同一个类的不同方法使用同一个锁的时候，锁的是同一个对象，访问A方法的同步代码的时候，其他的线程也不能访问B方法的同步代码，但是如果有这样的需求，希望线程1在访问A方法的同步代码的同时，运行其他线程访问B方法的同步代码呢？这个时候可以对A和B方法使用不同的锁对象监视器，即所谓的锁分离思想，例子：ConcurrentHashMap和HashTable的区别。

synchronized是不公平锁，而ReentrantLock可以指定锁是公平的还是非公平的

synchronized实现等待/通知机制通知的线程是随机的，ReentrantLock实现等待/通知机制可以有选择性地通知

和synchronized相比，ReentrantLock提供给用户多种方法用于锁信息的获取，比如可以知道lock是否被当前线程获取、lock被同一个线程调用了几次、lock是否被任意线程获取等等。ReentrantLock比synchronized更强大

如果只需要锁定简单的方法、简单的代码块，那么考虑使用synchronized，复杂的多线程处理场景下可以考虑使用ReentrantLock

1.5以后JDK对synchronized进行了多项优化，性能和ReentrantLock差不多。

具体哪些优化，优化思路？

加入了偏向锁、锁膨胀升级逻辑

Java多线程14：生产者/消费者模型

自己的理解：特别适合数据积压场景，比如秒杀场景中的发货，面对大量的订单，使用消息队列做一个缓冲

一种重要的模型，基于等待/通知机制。生产者/消费者模型描述的是有一块缓冲区作为仓库，
生产者可将产品放入仓库，消费者可以从仓库中取出产品，生产者/消费者模型关注的是以下几个点

生产者生产的时候消费者不能消费

消费者消费的时候生产者不能生产

缓冲区空时消费者不能消费

缓冲区满时生产者不能生产

优点

解耦。因为多了一个缓冲区，所以生产者和消费者并不直接相互调用，这一点很容易想到，这样生产者和消费者的代码发生变化，都不会对对方产生影响，这样其实就把生产者和消费者之间的强耦合解开，变为了生产者和缓冲区/消费者和缓冲区之间的弱耦合

通过平衡生产者和消费者的处理能力来提高整体处理数据的速度，这是生产者/消费者模型最重要的一个优点。如果消费者直接从生产者这里拿数据，如果生产者生产的速度很慢，但消费者消费的速度很快，那消费者就得占用CPU的时间片白白等在那边。有了生产者/消费者模型，生产者和消费者就是两个独立的并发体，生产者把生产出来的数据往缓冲区一丢就好了，不必管消费者；消费者也是，从缓冲区去拿数据就好了，也不必管生产者，缓冲区满了就不生产，缓冲区空了就不消费，使生产者/消费者的处理能力达到一个动态的平衡

小心多生产者和多消费者场景的假死

假死出现的原因是因为notify的是同类，所以非单生产者/单消费者的场景，可以采取两种方法解决这个问题

synchronized用notifyAll()唤醒所有线程、ReentrantLock用signalAll()唤醒所有线程

用ReentrantLock定义两个Condition，一个表示生产者的Condition，一个表示消费者的Condition，唤醒的时候调用相应的Condition的signal()方法就可以了

原文例子中的生产者和消费者写在同一个类中，使用一个锁对象上的condition，而实际业务中，生产者和消费者不可能在同一个实例中，生产消费逻辑本身不会耦合在一个类中。

一般会把生产和消费的对象抽出来单独的共享类，这个类中实例化lock和condition，让生产者和消费者公用同一个lock和condition。生产者和消费者类各自维护一个共享类的引用，客户端使用的时候为生产者和消费者类传入同一个共享类。

Java多线程15：Queue、BlockingQueue以及利用BlockingQueue实现生产者/消费者模型

Queue是什么

Queue通常不允许插入Null，尽管某些实现（比如LinkedList）是允许的，但是也不建议。

BlockingQueue

可以用来实现消费者生产者

BlockingQueue中的方法

void put(E e) throws InterruptedException

void take() throws InterruptedException

int drainTo(Collection c, int maxElements)

ArrayBlockingQueue

LinkedBlockingQueue

SynchronousQueue

公平模式

非公平模式

Java多线程16：线程组

线程组的作用是：可以批量管理线程或线程组对象，有效地对线程或线程组对象进行组织。

线程必须启动后才能归到指定线程组中

线程组自动归属特性

根线程组

Java多线程17：中断机制

概述

interrupt()

设置标志位

isInterrupted()

是测试线程是否已经中断，中断标识位的状态并不受到该方法的影响

interrupted()

测试当前线程是否已经中断，线程的中断标识位由该方法清除。换句话说，连续两次调用该方法的返回值必定是false

中断处理时机

像sleep、wait、notify、join，这些方法遇到中断必须有对应的措施，可以直接在catch块中处理，也可以抛给上一层。

Java多线程18：线程池

线程池的作用

减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务

可以根据系统的承受能力，调整线程池中工作线程的数据，防止因为消耗过多的内存导致服务器崩溃

线程池类结构

最顶级的接口是Executor，不过Executor严格意义上来说并不是一个线程池而只是提供了一种任务如何运行的机制而已

ExecutorService才可以认为是真正的线程池接口，接口提供了管理线程池的方法

下面两个分支，AbstractExecutorService分支就是普通的线程池分支，ScheduledExecutorService是用来创建定时任务的

ThreadPoolExecutor六个核心参数

corePoolSize

maximumPoolSize

keepAliveTime

unit

workQueue

threadFactory

handler

corePoolSize与maximumPoolSize举例理解

池中线程数小于corePoolSize，新任务都不排队而是直接添加新线程

池中线程数大于等于corePoolSize，workQueue未满，首选将新任务加入workQueue而不是添加新线程

池中线程数大于等于corePoolSize，workQueue已满，但是线程数小于maximumPoolSize，添加新的线程来处理被添加的任务

池中线程数大于大于corePoolSize，workQueue已满，并且线程数大于等于maximumPoolSize，新任务被拒绝，使用handler处理被拒绝的任务

强烈建议程序员使用较为方便的Executors工厂方法Executors.newCachedThreadPool()（无界线程池，可以进行线程自动回收）、Executors.newFixedThreadPool(int)（固定大小线程池）和Executors.newSingleThreadExecutor()（单个后台线程），它们均为大多数使用场景预定义了设置。

Executors

线程池的重点

在合适的场景下使用合适的线程池，所谓"合适的线程池"的意思就是，ThreadPoolExecutor的构造方法传入不同的参数，
构造出不同的线程池，以满足使用的需要

newSingleThreadExecutos() 单线程线程池

无界队列

newFixedThreadPool(int nThreads) 固定大小线程池

无界队列

newCachedThreadPool() 无界线程池

不管多少任务提交进来，都直接运行

只要60秒没有被用到的线程都会被直接移除

workQueue

当前线程大于corePoolSize时，线程以什么样的方式排队等待被运行。排队有三种策略：直接提交、有界队列、无界队列。

有界队列相对于无界队列的缺点

四种拒绝策略

Java多线程19：定时器Timer

Timer的schedule(TimeTask task, Date time)

执行任务的时间晚于当前时间：未来执行

计划时间早于当前时间：立即执行

多个TimerTask任务执行

Task是以队列的方式一个一个被顺序执行的，所以执行的时间有可能和预期的时间不一致，
因为前面的任务可能消耗过长，后面任务的运行时间也有可能被延迟。

Timer的schedule(TimerTask task, Date firstTime, long period)

在指定的日期之后，按指定的间隔周期性地无限循环地执行某一任务

TimerTask的cancel()方法

将自身从任务队列中清除

Timer的cancel()方法

schedule(TimerTask task, long delay)

以当前时间为参考，在此时间基础上延迟指定的毫秒数后执行一次TimerTask任务

schedule(TimerTask task, long delay, long period)

以当前时间为参考，在此时间基础上延迟指定的毫秒数后，以period为循环周期，循环执行TimerTask任务

scheduleAtFixedRate(TimerTask task, Date firstTime, long period)

Java多线程20：多线程下的其他组件之CountDownLatch、Semaphore、Exchanger

CountDownLatch

使用场景

如果有类似这样的场景：3、2、1，跑。

Semaphore

信号量为1的时候相当于互斥锁，只能被1个线程执行

信号量为多个，说明运行多个线程同时运行

控制并发数

可以配置公平非公平锁

acquire方法和release方法是可以有参数的，表示获取/返还的信号量个数

Exchanger

Java多线程21：多线程下的其他组件之CyclicBarrier、Callable、Future和FutureTask

CyclicBarrier

Callable、Future和FutureTask

Callable可以返回结果

Future

判断任务是否完成

中断任务

获取任务执行结果

使用方法

主要的好处：异步执行任务时，API完善

常用框架和工具内部原理

Spring源码解读

Spring可以做些什么，提供的功能

三个核心组件

Core

主要类

Resource

定义了资源的访问方式

屏蔽了文件类型的不同，屏蔽资源使用者

继承了 InputStreamSource 接口，屏蔽了资源提供者

ResourceLoader，屏蔽资源加载方式

DefaultResourceLoader

ResourcePatternResolver

Context资源的加载、解析和描述工作给了该类去做

Context

org.springframework.context

作用就是给Spring 提供一个运行时的环境，用以保存各个对象的状态

顶级父类

ApplicationContext