mirror of
https://github.com/Snailclimb/JavaGuide
synced 2025-08-01 16:28:03 +08:00
Merge remote-tracking branch 'remotes/origin/dev'
# Conflicts: # .gitignore
This commit is contained in:
Billhu
commit
10ef8542a2
3
.gitattributes
vendored
3
.gitattributes
vendored
@ -1,5 +1,4 @@
|
||||
# Auto detect text files and perform LF normalization
|
||||
* text=auto
|
||||
*.js linguist-language=java
|
||||
*.css linguist-language=java
|
||||
*.html linguist-language=java
|
||||
*.html linguist-language=java
|
||||
|
||||
83
.gitignore
vendored
83
.gitignore
vendored
@ -1,59 +1,34 @@
|
||||
# Created by .ignore support plugin (hsz.mobi)
|
||||
### Java template
|
||||
# Compiled class file
|
||||
*.class
|
||||
.gradle
|
||||
/build/
|
||||
/**/build/
|
||||
|
||||
# Log file
|
||||
*.log
|
||||
### STS ###
|
||||
.apt_generated
|
||||
.classpath
|
||||
.factorypath
|
||||
.project
|
||||
.settings
|
||||
.springBeans
|
||||
.sts4-cache
|
||||
|
||||
# BlueJ files
|
||||
*.ctxt
|
||||
### IntelliJ IDEA ###
|
||||
.idea
|
||||
*.iws
|
||||
*.iml
|
||||
*.ipr
|
||||
/out/
|
||||
/**/out/
|
||||
.shelf/
|
||||
.ideaDataSources/
|
||||
dataSources/
|
||||
|
||||
# Mobile Tools for Java (J2ME)
|
||||
.mtj.tmp/
|
||||
### NetBeans ###
|
||||
/nbproject/private/
|
||||
/nbbuild/
|
||||
/dist/
|
||||
/nbdist/
|
||||
/.nb-gradle/
|
||||
/node_modules/
|
||||
|
||||
# Package Files #
|
||||
*.jar
|
||||
*.war
|
||||
*.nar
|
||||
*.ear
|
||||
*.zip
|
||||
*.tar.gz
|
||||
*.rar
|
||||
|
||||
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
|
||||
hs_err_pid*
|
||||
### macOS template
|
||||
# General
|
||||
### OS ###
|
||||
.DS_Store
|
||||
.AppleDouble
|
||||
.LSOverride
|
||||
|
||||
# Icon must end with two \r
|
||||
Icon
|
||||
|
||||
# Thumbnails
|
||||
._*
|
||||
|
||||
# Files that might appear in the root of a volume
|
||||
.DocumentRevisions-V100
|
||||
.fseventsd
|
||||
.Spotlight-V100
|
||||
.TemporaryItems
|
||||
.Trashes
|
||||
.VolumeIcon.icns
|
||||
.com.apple.timemachine.donotpresent
|
||||
|
||||
# Directories potentially created on remote AFP share
|
||||
.AppleDB
|
||||
.AppleDesktop
|
||||
Network Trash Folder
|
||||
Temporary Items
|
||||
.apdisk
|
||||
### JetBrains template
|
||||
# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
|
||||
# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
|
||||
|
||||
# User-specific stuff
|
||||
.idea/**
|
||||
|
||||
|
||||
236
HomePage.md
Normal file
236
HomePage.md
Normal file
@ -0,0 +1,236 @@
|
||||
点击订阅[Java面试进阶指南](https://xiaozhuanlan.com/javainterview?rel=javaguide)(专为Java面试方向准备)。[为什么要弄这个专栏?](https://shimo.im/./9BJjNsNg7S4dCnz3/)
|
||||
|
||||
<h1 align="center">Java 学习/面试指南</h1>
|
||||
<p align="center">
|
||||
<a href="https://github.com/Snailclimb/JavaGuide" target="_blank">
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3/logo - 副本.png" width=""/>
|
||||
</a>
|
||||
|
||||
## 目录
|
||||
|
||||
- [Java](#java)
|
||||
- [基础](#基础)
|
||||
- [容器](#容器)
|
||||
- [并发](#并发)
|
||||
- [JVM](#jvm)
|
||||
- [I/O](#io)
|
||||
- [Java 8](#java-8)
|
||||
- [编程规范](#编程规范)
|
||||
- [网络](#网络)
|
||||
- [操作系统](#操作系统)
|
||||
- [Linux相关](#linux相关)
|
||||
- [数据结构与算法](#数据结构与算法)
|
||||
- [数据结构](#数据结构)
|
||||
- [算法](#算法)
|
||||
- [数据库](#数据库)
|
||||
- [MySQL](#mysql)
|
||||
- [Redis](#redis)
|
||||
- [系统设计](#系统设计)
|
||||
- [设计模式(工厂模式、单例模式 ... )](#设计模式)
|
||||
- [常用框架(Spring、Zookeeper ... )](#常用框架)
|
||||
- [数据通信(消息队列、Dubbo ... )](#数据通信)
|
||||
- [网站架构](#网站架构)
|
||||
- [面试指南](#面试指南)
|
||||
- [备战面试](#备战面试)
|
||||
- [常见面试题总结](#常见面试题总结)
|
||||
- [面经](#面经)
|
||||
- [工具](#工具)
|
||||
- [Git](#git)
|
||||
- [Docker](#Docker)
|
||||
- [资料](#资料)
|
||||
- [书单](#书单)
|
||||
- [Github榜单](#Github榜单)
|
||||
- [待办](#待办)
|
||||
- [说明](#说明)
|
||||
|
||||
## Java
|
||||
|
||||
### 基础
|
||||
|
||||
* [Java 基础知识回顾](java/Java基础知识.md)
|
||||
* [Java 基础知识疑难点总结](java/Java疑难点.md)
|
||||
* [J2EE 基础知识回顾](java/J2EE基础知识.md)
|
||||
|
||||
### 容器
|
||||
|
||||
* [Java容器常见面试题/知识点总结](java/collection/Java集合框架常见面试题.md)
|
||||
* [ArrayList 源码学习](java/collection/ArrayList.md)
|
||||
* [LinkedList 源码学习](java/collection/LinkedList.md)
|
||||
* [HashMap(JDK1.8)源码学习](java/collection/HashMap.md)
|
||||
|
||||
### 并发
|
||||
|
||||
* [Java 并发基础常见面试题总结](java/Multithread/JavaConcurrencyBasicsCommonInterviewQuestionsSummary.md)
|
||||
* [Java 并发进阶常见面试题总结](java/Multithread/JavaConcurrencyAdvancedCommonInterviewQuestions.md)
|
||||
* [并发容器总结](java/Multithread/并发容器总结.md)
|
||||
* [乐观锁与悲观锁](essential-content-for-interview/面试必备之乐观锁与悲观锁.md)
|
||||
* [JUC 中的 Atomic 原子类总结](java/Multithread/Atomic.md)
|
||||
* [AQS 原理以及 AQS 同步组件总结](java/Multithread/AQS.md)
|
||||
|
||||
### JVM
|
||||
* [一 Java内存区域](java/jvm/Java内存区域.md)
|
||||
* [二 JVM垃圾回收](java/jvm/JVM垃圾回收.md)
|
||||
* [三 JDK 监控和故障处理工具](java/jvm/JDK监控和故障处理工具总结.md)
|
||||
* [四 类文件结构](java/jvm/类文件结构.md)
|
||||
* [五 类加载过程](java/jvm/类加载过程.md)
|
||||
* [六 类加载器](java/jvm/类加载器.md)
|
||||
|
||||
### I/O
|
||||
|
||||
* [BIO,NIO,AIO 总结 ](java/BIO-NIO-AIO.md)
|
||||
* [Java IO 与 NIO系列文章](java/Java%20IO与NIO.md)
|
||||
|
||||
### Java 8
|
||||
|
||||
* [Java 8 新特性总结](java/What's%20New%20in%20JDK8/Java8Tutorial.md)
|
||||
* [Java 8 学习资源推荐](java/What's%20New%20in%20JDK8/Java8教程推荐.md)
|
||||
|
||||
### 编程规范
|
||||
|
||||
- [Java 编程规范](java/Java编程规范.md)
|
||||
|
||||
## 网络
|
||||
|
||||
* [计算机网络常见面试题](network/计算机网络.md)
|
||||
* [计算机网络基础知识总结](network/干货：计算机网络知识总结.md)
|
||||
* [HTTPS中的TLS](network/HTTPS中的TLS.md)
|
||||
|
||||
## 操作系统
|
||||
|
||||
### Linux相关
|
||||
|
||||
* [后端程序员必备的 Linux 基础知识](operating-system/后端程序员必备的Linux基础知识.md)
|
||||
* [Shell 编程入门](operating-system/Shell.md)
|
||||
|
||||
## 数据结构与算法
|
||||
|
||||
### 数据结构
|
||||
|
||||
- [数据结构知识学习与面试](dataStructures-algorithms/数据结构.md)
|
||||
|
||||
### 算法
|
||||
|
||||
- [算法学习资源推荐](dataStructures-algorithms/算法学习资源推荐.md)
|
||||
- [几道常见的字符串算法题总结 ](dataStructures-algorithms/几道常见的子符串算法题.md)
|
||||
- [几道常见的链表算法题总结 ](dataStructures-algorithms/几道常见的链表算法题.md)
|
||||
- [剑指offer部分编程题](dataStructures-algorithms/剑指offer部分编程题.md)
|
||||
- [公司真题](dataStructures-algorithms/公司真题.md)
|
||||
- [回溯算法经典案例之N皇后问题](dataStructures-algorithms/Backtracking-NQueens.md)
|
||||
|
||||
## 数据库
|
||||
|
||||
### MySQL
|
||||
|
||||
* [MySQL 学习与面试](database/MySQL.md)
|
||||
* [一千行MySQL学习笔记](database/一千行MySQL命令.md)
|
||||
* [MySQL高性能优化规范建议](database/MySQL高性能优化规范建议.md)
|
||||
* [数据库索引总结](database/MySQL%20Index.md)
|
||||
* [事务隔离级别(图文详解)](database/事务隔离级别(图文详解).md)
|
||||
* [一条SQL语句在MySQL中如何执行的](database/一条sql语句在mysql中如何执行的.md)
|
||||
|
||||
### Redis
|
||||
|
||||
* [Redis 总结](database/Redis/Redis.md)
|
||||
* [Redlock分布式锁](database/Redis/Redlock分布式锁.md)
|
||||
* [如何做可靠的分布式锁，Redlock真的可行么](database/Redis/如何做可靠的分布式锁，Redlock真的可行么.md)
|
||||
|
||||
## 系统设计
|
||||
|
||||
### 设计模式
|
||||
|
||||
- [设计模式系列文章](system-design/设计模式.md)
|
||||
|
||||
### 常用框架
|
||||
|
||||
#### Spring
|
||||
|
||||
- [Spring 学习与面试](system-design/framework/spring/Spring.md)
|
||||
- [Spring 常见问题总结](system-design/framework/spring/SpringInterviewQuestions.md)
|
||||
- [Spring中bean的作用域与生命周期](system-design/framework/spring/SpringBean.md)
|
||||
- [SpringMVC 工作原理详解](system-design/framework/spring/SpringMVC-Principle.md)
|
||||
- [Spring中都用到了那些设计模式?](system-design/framework/spring/Spring-Design-Patterns.md)
|
||||
|
||||
#### ZooKeeper
|
||||
|
||||
- [ZooKeeper 相关概念总结](system-design/framework/ZooKeeper.md)
|
||||
- [ZooKeeper 数据模型和常见命令](system-design/framework/ZooKeeper数据模型和常见命令.md)
|
||||
|
||||
### 数据通信
|
||||
|
||||
- [数据通信(RESTful、RPC、消息队列)相关知识点总结](system-design/data-communication/summary.md)
|
||||
- [Dubbo 总结：关于 Dubbo 的重要知识点](system-design/data-communication/dubbo.md)
|
||||
- [消息队列总结](system-design/data-communication/message-queue.md)
|
||||
- [RabbitMQ 入门](system-design/data-communication/rabbitmq.md)
|
||||
- [RocketMQ的几个简单问题与答案](system-design/data-communication/RocketMQ-Questions.md)
|
||||
|
||||
### 网站架构
|
||||
|
||||
- [一文读懂分布式应该学什么](system-design/website-architecture/分布式.md)
|
||||
- [8 张图读懂大型网站技术架构](system-design/website-architecture/8%20张图读懂大型网站技术架构.md)
|
||||
- [【面试精选】关于大型网站系统架构你不得不懂的10个问题](system-design/website-architecture/【面试精选】关于大型网站系统架构你不得不懂的10个问题.md)
|
||||
|
||||
## 面试指南
|
||||
|
||||
### 备战面试
|
||||
|
||||
* [【备战面试1】程序员的简历就该这样写](essential-content-for-interview/PreparingForInterview/程序员的简历之道.md)
|
||||
* [【备战面试2】初出茅庐的程序员该如何准备面试？](essential-content-for-interview/PreparingForInterview/interviewPrepare.md)
|
||||
* [【备战面试3】7个大部分程序员在面试前很关心的问题](essential-content-for-interview/PreparingForInterview/JavaProgrammerNeedKnow.md)
|
||||
* [【备战面试4】Github上开源的Java面试/学习相关的仓库推荐](essential-content-for-interview/PreparingForInterview/JavaInterviewLibrary.md)
|
||||
* [【备战面试5】如果面试官问你“你有什么问题问我吗？”时，你该如何回答](essential-content-for-interview/PreparingForInterview/如果面试官问你“你有什么问题问我吗？”时，你该如何回答.md)
|
||||
* [【备战面试6】美团面试常见问题总结（附详解答案）](essential-content-for-interview/PreparingForInterview/美团面试常见问题总结.md)
|
||||
|
||||
### 常见面试题总结
|
||||
|
||||
* [第一周（2018-8-7）](essential-content-for-interview/MostCommonJavaInterviewQuestions/第一周（2018-8-7）.md) (为什么 Java 中只有值传递、==与equals、 hashCode与equals)
|
||||
* [第二周（2018-8-13）](essential-content-for-interview/MostCommonJavaInterviewQuestions/第二周(2018-8-13).md)(String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的？、什么是反射机制？反射机制的应用场景有哪些？......)
|
||||
* [第三周（2018-08-22）](java/collection/Java集合框架常见面试题.md) （Arraylist 与 LinkedList 异同、ArrayList 与 Vector 区别、HashMap的底层实现、HashMap 和 Hashtable 的区别、HashMap 的长度为什么是2的幂次方、HashSet 和 HashMap 区别、ConcurrentHashMap 和 Hashtable 的区别、ConcurrentHashMap线程安全的具体实现方式/底层具体实现、集合框架底层数据结构总结）
|
||||
* [第四周(2018-8-30).md](essential-content-for-interview/MostCommonJavaInterviewQuestions/第四周(2018-8-30).md) （主要内容是几道面试常问的多线程基础题。）
|
||||
|
||||
### 面经
|
||||
|
||||
- [5面阿里,终获offer(2018年秋招)](essential-content-for-interview/BATJrealInterviewExperience/5面阿里,终获offer.md)
|
||||
- [蚂蚁金服2019实习生面经总结(已拿口头offer)](essential-content-for-interview/BATJrealInterviewExperience/蚂蚁金服实习生面经总结(已拿口头offer).md)
|
||||
- [2019年蚂蚁金服、头条、拼多多的面试总结](essential-content-for-interview/BATJrealInterviewExperience/2019alipay-pinduoduo-toutiao.md)
|
||||
|
||||
## 工具
|
||||
|
||||
### Git
|
||||
|
||||
* [Git入门](tools/Git.md)
|
||||
|
||||
### Docker
|
||||
|
||||
* [Docker 入门](tools/Docker.md)
|
||||
* [一文搞懂 Docker 镜像的常用操作！](tools/Docker-Image.md)
|
||||
|
||||
## 资料
|
||||
|
||||
### 书单
|
||||
|
||||
- [Java程序员必备书单](data/java-recommended-books.md)
|
||||
|
||||
### Github榜单
|
||||
|
||||
- [Java 项目月榜单](github-trending/JavaGithubTrending.md)
|
||||
|
||||
***
|
||||
|
||||
## 待办
|
||||
|
||||
- [x] [Java 8 新特性总结](./java/What's%20New%20in%20JDK8/Java8Tutorial.md)
|
||||
- [x] [Java 8 新特性详解](./java/What's%20New%20in%20JDK8/Java8教程推荐.md)
|
||||
- [ ] Java 多线程类别知识重构(---正在进行中---)
|
||||
- [x] [BIO,NIO,AIO 总结 ](./java/BIO-NIO-AIO.md)
|
||||
- [ ] Netty 总结(---正在进行中---)
|
||||
- [ ] 数据结构总结重构(---正在进行中---)
|
||||
|
||||
## 公众号
|
||||
|
||||
- 如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。
|
||||
- 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本公众号后台回复 **"Java面试突击"** 即可免费领取！
|
||||
- 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
|
||||
|
||||
<p align="center">
|
||||
<img src="https://user-gold-cdn.xitu.io/2018/11/28/167598cd2e17b8ec?w=258&h=258&f=jpeg&s=27334" width=""/>
|
||||
</p>
|
||||
@ -1,453 +0,0 @@
|
||||
|
||||
|
||||
<!-- MarkdownTOC -->
|
||||
|
||||
- [1. 面向对象和面向过程的区别](#1-面向对象和面向过程的区别)
|
||||
- [面向过程](#面向过程)
|
||||
- [面向对象](#面向对象)
|
||||
- [2. Java 语言有哪些特点](#2-java-语言有哪些特点)
|
||||
- [3. 关于 JVM JDK 和 JRE 最详细通俗的解答](#3-关于-jvm-jdk-和-jre-最详细通俗的解答)
|
||||
- [JVM](#jvm)
|
||||
- [JDK 和 JRE](#jdk-和-jre)
|
||||
- [4. Oracle JDK 和 OpenJDK 的对比](#4-oracle-jdk-和-openjdk-的对比)
|
||||
- [5. Java和C++的区别](#5-java和c的区别)
|
||||
- [6. 什么是 Java 程序的主类 应用程序和小程序的主类有何不同](#6-什么是-java-程序的主类-应用程序和小程序的主类有何不同)
|
||||
- [7. Java 应用程序与小程序之间有那些差别](#7-java-应用程序与小程序之间有那些差别)
|
||||
- [8. 字符型常量和字符串常量的区别](#8-字符型常量和字符串常量的区别)
|
||||
- [9. 构造器 Constructor 是否可被 override](#9-构造器-constructor-是否可被-override)
|
||||
- [10. 重载和重写的区别](#10-重载和重写的区别)
|
||||
- [11. Java 面向对象编程三大特性: 封装 继承 多态](#11-java-面向对象编程三大特性-封装-继承-多态)
|
||||
- [封装](#封装)
|
||||
- [继承](#继承)
|
||||
- [多态](#多态)
|
||||
- [12. String StringBuffer 和 StringBuilder 的区别是什么 String 为什么是不可变的](#12-string-stringbuffer-和-stringbuilder-的区别是什么-string-为什么是不可变的)
|
||||
- [13. 自动装箱与拆箱](#13-自动装箱与拆箱)
|
||||
- [14. 在一个静态方法内调用一个非静态成员为什么是非法的](#14-在一个静态方法内调用一个非静态成员为什么是非法的)
|
||||
- [15. 在 Java 中定义一个不做事且没有参数的构造方法的作用](#15-在-java-中定义一个不做事且没有参数的构造方法的作用)
|
||||
- [16. import java和javax有什么区别](#16-import-java和javax有什么区别)
|
||||
- [17. 接口和抽象类的区别是什么](#17-接口和抽象类的区别是什么)
|
||||
- [18. 成员变量与局部变量的区别有那些](#18-成员变量与局部变量的区别有那些)
|
||||
- [19. 创建一个对象用什么运算符?对象实体与对象引用有何不同?](#19-创建一个对象用什么运算符对象实体与对象引用有何不同)
|
||||
- [20. 什么是方法的返回值?返回值在类的方法里的作用是什么?](#20-什么是方法的返回值返回值在类的方法里的作用是什么)
|
||||
- [21. 一个类的构造方法的作用是什么 若一个类没有声明构造方法,该程序能正确执行吗 ?为什么?](#21-一个类的构造方法的作用是什么-若一个类没有声明构造方法该程序能正确执行吗-为什么)
|
||||
- [22. 构造方法有哪些特性](#22-构造方法有哪些特性)
|
||||
- [23. 静态方法和实例方法有何不同](#23-静态方法和实例方法有何不同)
|
||||
- [24. 对象的相等与指向他们的引用相等，两者有什么不同？](#24-对象的相等与指向他们的引用相等两者有什么不同)
|
||||
- [25. 在调用子类构造方法之前会先调用父类没有参数的构造方法，其目的是?](#25-在调用子类构造方法之前会先调用父类没有参数的构造方法其目的是)
|
||||
- [26. == 与 equals\(重要\)](#26--与-equals重要)
|
||||
- [27. hashCode 与 equals \(重要\)](#27-hashcode-与-equals-重要)
|
||||
- [hashCode（）介绍](#hashcode（）介绍)
|
||||
- [为什么要有 hashCode](#为什么要有-hashcode)
|
||||
- [hashCode（）与equals（）的相关规定](#hashcode（）与equals（）的相关规定)
|
||||
- [28. 为什么Java中只有值传递](#28-为什么java中只有值传递)
|
||||
- [29. 简述线程，程序、进程的基本概念。以及他们之间关系是什么](#29-简述线程程序进程的基本概念以及他们之间关系是什么)
|
||||
- [30. 线程有哪些基本状态?](#30-线程有哪些基本状态)
|
||||
- [31 关于 final 关键字的一些总结](#31-关于-final-关键字的一些总结)
|
||||
- [32 Java 中的异常处理](#32-java-中的异常处理)
|
||||
- [Java异常类层次结构图](#java异常类层次结构图)
|
||||
- [Throwable类常用方法](#throwable类常用方法)
|
||||
- [异常处理总结](#异常处理总结)
|
||||
- [33 Java序列化中如果有些字段不想进行序列化 怎么办](#33-java序列化中如果有些字段不想进行序列化-怎么办)
|
||||
- [34 获取用键盘输入常用的的两种方法](#34-获取用键盘输入常用的的两种方法)
|
||||
- [参考](#参考)
|
||||
|
||||
<!-- /MarkdownTOC -->
|
||||
|
||||
|
||||
|
||||
## 1. 面向对象和面向过程的区别
|
||||
|
||||
### 面向过程
|
||||
|
||||
**优点：** 性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
|
||||
|
||||
**缺点：** 没有面向对象易维护、易复用、易扩展
|
||||
|
||||
### 面向对象
|
||||
|
||||
**优点：** 易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护
|
||||
|
||||
**缺点：** 性能比面向过程低
|
||||
|
||||
## 2. Java 语言有哪些特点
|
||||
|
||||
1. 简单易学；
|
||||
2. 面向对象（封装，继承，多态）；
|
||||
3. 平台无关性（ Java 虚拟机实现平台无关性）；
|
||||
4. 可靠性；
|
||||
5. 安全性；
|
||||
6. 支持多线程（ C++ 语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而 Java 语言却提供了多线程支持）；
|
||||
7. 支持网络编程并且很方便（ Java 语言诞生本身就是为简化网络编程设计的，因此 Java 语言不仅支持网络编程而且很方便）；
|
||||
8. 编译与解释并存；
|
||||
|
||||
## 3. 关于 JVM JDK 和 JRE 最详细通俗的解答
|
||||
|
||||
### JVM
|
||||
|
||||
Java虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。
|
||||
|
||||
**什么是字节码?采用字节码的好处是什么?**
|
||||
|
||||
> 在 Java 中，JVM可以理解的代码就叫做`字节码`（即扩展名为 `.class` 的文件），它不面向任何特定的处理器，只面向虚拟机。Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比较高效，而且，由于字节码并不专对一种特定的机器，因此，Java程序无须重新编译便可在多种不同的计算机上运行。
|
||||
|
||||
**Java 程序从源代码到运行一般有下面3步：**
|
||||
|
||||
|
||||
|
||||
我们需要格外注意的是 .class->机器码 这一步。在这一步 jvm 类加载器首先加载字节码文件，然后通过解释器逐行解释执行，这种方式的执行速度会相对比较慢。而且，有些方法和代码块是经常需要被调用的，也就是所谓的热点代码，所以后面引进了 JIT 编译器，JIT 属于运行时编译。当 JIT 编译器完成第一次编译后，其会将字节码对应的机器码保存下来，下次可以直接使用。而我们知道，机器码的运行效率肯定是高于 Java 解释器的。这也解释了我们为什么经常会说 Java 是编译与解释共存的语言。
|
||||
|
||||
> HotSpot采用了惰性评估(Lazy Evaluation)的做法，根据二八定律，消耗大部分系统资源的只有那一小部分的代码（热点代码），而这也就是JIT所需要编译的部分。JVM会根据代码每次被执行的情况收集信息并相应地做出一些优化，因此执行的次数越多，它的速度就越快。JDK 9引入了一种新的编译模式AOT(Ahead of Time Compilation)，它是直接将字节码编译成机器码，这样就避免了JIT预热等各方面的开销。JDK支持分层编译和AOT协作使用。但是 ，AOT 编译器的编译质量是肯定比不上 JIT 编译器的。
|
||||
|
||||
总结：Java虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。
|
||||
|
||||
### JDK 和 JRE
|
||||
|
||||
JDK是Java Development Kit，它是功能齐全的Java SDK。它拥有JRE所拥有的一切，还有编译器（javac）和工具（如javadoc和jdb）。它能够创建和编译程序。
|
||||
|
||||
JRE 是 Java运行时环境。它是运行已编译 Java 程序所需的所有内容的集合，包括 Java虚拟机（JVM），Java类库，java命令和其他的一些基础构件。但是，它不能用于创建新程序。
|
||||
|
||||
如果你只是为了运行一下 Java 程序的话，那么你只需要安装 JRE 就可以了。如果你需要进行一些 Java 编程方面的工作，那么你就需要安装JDK了。但是，这不是绝对的。有时，即使您不打算在计算机上进行任何Java开发，仍然需要安装JDK。例如，如果要使用JSP部署Web应用程序，那么从技术上讲，您只是在应用程序服务器中运行Java程序。那你为什么需要JDK呢？因为应用程序服务器会将 JSP 转换为 Java servlet，并且需要使用 JDK 来编译 servlet。
|
||||
|
||||
## 4. Oracle JDK 和 OpenJDK 的对比
|
||||
|
||||
可能在看这个问题之前很多人和我一样并没有接触和使用过 OpenJDK 。那么Oracle和OpenJDK之间是否存在重大差异？下面通过我通过我收集到一些资料对你解答这个被很多人忽视的问题。
|
||||
|
||||
对于Java 7，没什么关键的地方。OpenJDK项目主要基于Sun捐赠的HotSpot源代码。此外，OpenJDK被选为Java 7的参考实现，由Oracle工程师维护。关于JVM，JDK，JRE和OpenJDK之间的区别，Oracle博客帖子在2012年有一个更详细的答案：
|
||||
|
||||
> 问：OpenJDK存储库中的源代码与用于构建Oracle JDK的代码之间有什么区别？
|
||||
>
|
||||
> 答：非常接近 - 我们的Oracle JDK版本构建过程基于OpenJDK 7构建，只添加了几个部分，例如部署代码，其中包括Oracle的Java插件和Java WebStart的实现，以及一些封闭的源代码派对组件，如图形光栅化器，一些开源的第三方组件，如Rhino，以及一些零碎的东西，如附加文档或第三方字体。展望未来，我们的目的是开源Oracle JDK的所有部分，除了我们考虑商业功能的部分。
|
||||
|
||||
总结：
|
||||
|
||||
1. Oracle JDK版本将每三年发布一次，而OpenJDK版本每三个月发布一次；
|
||||
2. OpenJDK 是一个参考模型并且是完全开源的，而Oracle JDK是OpenJDK的一个实现，并不是完全开源的；
|
||||
3. Oracle JDK 比 OpenJDK 更稳定。OpenJDK和Oracle JDK的代码几乎相同，但Oracle JDK有更多的类和一些错误修复。因此，如果您想开发企业/商业软件，我建议您选择Oracle JDK，因为它经过了彻底的测试和稳定。某些情况下，有些人提到在使用OpenJDK 可能会遇到了许多应用程序崩溃的问题，但是，只需切换到Oracle JDK就可以解决问题；
|
||||
4. 在响应性和JVM性能方面，Oracle JDK与OpenJDK相比提供了更好的性能；
|
||||
5. Oracle JDK不会为即将发布的版本提供长期支持，用户每次都必须通过更新到最新版本获得支持来获取最新版本；
|
||||
6. Oracle JDK根据二进制代码许可协议获得许可，而OpenJDK根据GPL v2许可获得许可。
|
||||
|
||||
## 5. Java和C++的区别
|
||||
|
||||
我知道很多人没学过 C++，但是面试官就是没事喜欢拿咱们 Java 和 C++ 比呀！没办法！！！就算没学过C++，也要记下来！
|
||||
|
||||
- 都是面向对象的语言，都支持封装、继承和多态
|
||||
- Java 不提供指针来直接访问内存，程序内存更加安全
|
||||
- Java 的类是单继承的，C++ 支持多重继承；虽然 Java 的类不可以多继承，但是接口可以多继承。
|
||||
- Java 有自动内存管理机制，不需要程序员手动释放无用内存
|
||||
|
||||
|
||||
## 6. 什么是 Java 程序的主类 应用程序和小程序的主类有何不同
|
||||
|
||||
一个程序中可以有多个类，但只能有一个类是主类。在 Java 应用程序中，这个主类是指包含 main（）方法的类。而在 Java 小程序中，这个主类是一个继承自系统类 JApplet 或 Applet 的子类。应用程序的主类不一定要求是 public 类，但小程序的主类要求必须是 public 类。主类是 Java 程序执行的入口点。
|
||||
|
||||
## 7. Java 应用程序与小程序之间有那些差别
|
||||
|
||||
简单说应用程序是从主线程启动(也就是 main() 方法)。applet 小程序没有main方法，主要是嵌在浏览器页面上运行(调用init()线程或者run()来启动)，嵌入浏览器这点跟 flash 的小游戏类似。
|
||||
|
||||
## 8. 字符型常量和字符串常量的区别
|
||||
|
||||
1. 形式上: 字符常量是单引号引起的一个字符 字符串常量是双引号引起的若干个字符
|
||||
2. 含义上: 字符常量相当于一个整形值( ASCII 值),可以参加表达式运算 字符串常量代表一个地址值(该字符串在内存中存放位置)
|
||||
3. 占内存大小 字符常量只占2个字节 字符串常量占若干个字节(至少一个字符结束标志) (**注意： char在Java中占两个字节**)
|
||||
|
||||
> java编程思想第四版：2.2.2节
|
||||
|
||||
|
||||
## 9. 构造器 Constructor 是否可被 override
|
||||
|
||||
在讲继承的时候我们就知道父类的私有属性和构造方法并不能被继承，所以 Constructor 也就不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况。
|
||||
|
||||
## 10. 重载和重写的区别
|
||||
|
||||
**重载：** 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。
|
||||
|
||||
**重写：** 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能重写该方法。
|
||||
|
||||
## 11. Java 面向对象编程三大特性: 封装 继承 多态
|
||||
|
||||
### 封装
|
||||
|
||||
封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。
|
||||
|
||||
|
||||
### 继承
|
||||
继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码。
|
||||
|
||||
**关于继承如下 3 点请记住：**
|
||||
|
||||
1. 子类拥有父类非 private 的属性和方法。
|
||||
2. 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
|
||||
3. 子类可以用自己的方式实现父类的方法。（以后介绍）。
|
||||
|
||||
### 多态
|
||||
|
||||
所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
|
||||
|
||||
在Java中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）。
|
||||
|
||||
## 12. String StringBuffer 和 StringBuilder 的区别是什么 String 为什么是不可变的
|
||||
|
||||
**可变性**
|
||||
|
||||
|
||||
简单的来说：String 类中使用 final 关键字字符数组保存字符串，`private final char value[]`，所以 String 对象是不可变的。而StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串`char[]value` 但是没有用 final 关键字修饰，所以这两种对象都是可变的。
|
||||
|
||||
StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是 AbstractStringBuilder 实现的，大家可以自行查阅源码。
|
||||
|
||||
AbstractStringBuilder.java
|
||||
|
||||
```java
|
||||
abstract class AbstractStringBuilder implements Appendable, CharSequence {
|
||||
char[] value;
|
||||
int count;
|
||||
AbstractStringBuilder() {
|
||||
}
|
||||
AbstractStringBuilder(int capacity) {
|
||||
value = new char[capacity];
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
**线程安全性**
|
||||
|
||||
String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。
|
||||
|
||||
|
||||
**性能**
|
||||
|
||||
每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
|
||||
|
||||
**对于三者使用的总结：**
|
||||
1. 操作少量的数据 = String
|
||||
2. 单线程操作字符串缓冲区下操作大量数据 = StringBuilder
|
||||
3. 多线程操作字符串缓冲区下操作大量数据 = StringBuffer
|
||||
|
||||
## 13. 自动装箱与拆箱
|
||||
**装箱**：将基本类型用它们对应的引用类型包装起来；
|
||||
|
||||
**拆箱**：将包装类型转换为基本数据类型；
|
||||
|
||||
## 14. 在一个静态方法内调用一个非静态成员为什么是非法的
|
||||
|
||||
由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。
|
||||
|
||||
## 15. 在 Java 中定义一个不做事且没有参数的构造方法的作用
|
||||
Java 程序在执行子类的构造方法之前，如果没有用 super() 来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 super() 来调用父类中特定的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。
|
||||
|
||||
## 16. import java和javax有什么区别
|
||||
|
||||
刚开始的时候 JavaAPI 所必需的包是 java 开头的包，javax 当时只是扩展 API 包来说使用。然而随着时间的推移，javax 逐渐的扩展成为 Java API 的组成部分。但是，将扩展从 javax 包移动到 java 包将是太麻烦了，最终会破坏一堆现有的代码。因此，最终决定 javax 包将成为标准API的一部分。
|
||||
|
||||
所以，实际上java和javax没有区别。这都是一个名字。
|
||||
|
||||
## 17. 接口和抽象类的区别是什么
|
||||
|
||||
1. 接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现），抽象类可以有非抽象的方法
|
||||
2. 接口中的实例变量默认是 final 类型的，而抽象类中则不一定
|
||||
3. 一个类可以实现多个接口，但最多只能实现一个抽象类
|
||||
4. 一个类实现接口的话要实现接口的所有方法，而抽象类不一定
|
||||
5. 接口不能用 new 实例化，但可以声明，但是必须引用一个实现该接口的对象 从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。
|
||||
|
||||
备注:在JDK8中，接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。如果同时实现两个接口，接口中定义了一样的默认方法，必须重写，不然会报错。(详见issue:[https://github.com/Snailclimb/JavaGuide/issues/146](https://github.com/Snailclimb/JavaGuide/issues/146))
|
||||
|
||||
## 18. 成员变量与局部变量的区别有那些
|
||||
|
||||
1. 从语法形式上，看成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰；
|
||||
2. 从变量在内存中的存储方式来看:如果成员变量是使用`static`修饰的，那么这个成员变量是属于类的，如果没有使用使用`static`修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量存在于栈内存
|
||||
3. 从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。
|
||||
4. 成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外被 final 修饰的成员变量也必须显示地赋值）；而局部变量则不会自动赋值。
|
||||
|
||||
## 19. 创建一个对象用什么运算符?对象实体与对象引用有何不同?
|
||||
|
||||
new运算符，new创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。一个对象引用可以指向0个或1个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有n个引用指向它（可以用n条绳子系住一个气球）。
|
||||
|
||||
## 20. 什么是方法的返回值?返回值在类的方法里的作用是什么?
|
||||
|
||||
方法的返回值是指我们获取到的某个方法体中的代码执行后产生的结果！（前提是该方法可能产生结果）。返回值的作用:接收出结果，使得它可以用于其他的操作！
|
||||
|
||||
## 21. 一个类的构造方法的作用是什么 若一个类没有声明构造方法,该程序能正确执行吗 ?为什么?
|
||||
|
||||
主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。
|
||||
|
||||
## 22. 构造方法有哪些特性
|
||||
|
||||
1. 名字与类名相同；
|
||||
2. 没有返回值，但不能用void声明构造函数；
|
||||
3. 生成类的对象时自动执行，无需调用。
|
||||
|
||||
## 23. 静态方法和实例方法有何不同
|
||||
|
||||
1. 在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
|
||||
|
||||
2. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制.
|
||||
|
||||
## 24. 对象的相等与指向他们的引用相等,两者有什么不同?
|
||||
|
||||
对象的相等，比的是内存中存放的内容是否相等。而引用相等，比较的是他们指向的内存地址是否相等。
|
||||
|
||||
## 25. 在调用子类构造方法之前会先调用父类没有参数的构造方法,其目的是?
|
||||
|
||||
帮助子类做初始化工作。
|
||||
|
||||
## 26. == 与 equals(重要)
|
||||
|
||||
**==** : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。(基本数据类型==比较的是值，引用数据类型==比较的是内存地址)
|
||||
|
||||
**equals()** : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：
|
||||
- 情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。
|
||||
- 情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来两个对象的内容相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。
|
||||
|
||||
|
||||
**举个例子：**
|
||||
|
||||
```java
|
||||
public class test1 {
|
||||
public static void main(String[] args) {
|
||||
String a = new String("ab"); // a 为一个引用
|
||||
String b = new String("ab"); // b为另一个引用,对象的内容一样
|
||||
String aa = "ab"; // 放在常量池中
|
||||
String bb = "ab"; // 从常量池中查找
|
||||
if (aa == bb) // true
|
||||
System.out.println("aa==bb");
|
||||
if (a == b) // false，非同一对象
|
||||
System.out.println("a==b");
|
||||
if (a.equals(b)) // true
|
||||
System.out.println("aEQb");
|
||||
if (42 == 42.0) { // true
|
||||
System.out.println("true");
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**说明：**
|
||||
- String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是对象的值。
|
||||
- 当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。
|
||||
|
||||
|
||||
|
||||
## 27. hashCode 与 equals (重要)
|
||||
|
||||
面试官可能会问你：“你重写过 hashcode 和 equals 么，为什么重写equals时必须重写hashCode方法？”
|
||||
|
||||
### hashCode（）介绍
|
||||
hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。
|
||||
|
||||
散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）
|
||||
|
||||
### 为什么要有 hashCode
|
||||
|
||||
|
||||
**我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：**
|
||||
|
||||
当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals（）方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自我的Java启蒙书《Head first java》第二版）。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。
|
||||
|
||||
|
||||
|
||||
### hashCode（）与equals（）的相关规定
|
||||
|
||||
1. 如果两个对象相等，则hashcode一定也是相同的
|
||||
2. 两个对象相等,对两个对象分别调用equals方法都返回true
|
||||
3. 两个对象有相同的hashcode值，它们也不一定是相等的
|
||||
4. **因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖**
|
||||
5. hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）
|
||||
|
||||
|
||||
## 28. 为什么Java中只有值传递
|
||||
|
||||
[为什么Java中只有值传递？](https://github.com/Snailclimb/Java-Guide/blob/master/%E9%9D%A2%E8%AF%95%E5%BF%85%E5%A4%87/%E6%9C%80%E6%9C%80%E6%9C%80%E5%B8%B8%E8%A7%81%E7%9A%84Java%E9%9D%A2%E8%AF%95%E9%A2%98%E6%80%BB%E7%BB%93/%E7%AC%AC%E4%B8%80%E5%91%A8%EF%BC%882018-8-7%EF%BC%89.md)
|
||||
|
||||
|
||||
## 29. 简述线程,程序,进程的基本概念.以及他们之间关系是什么?
|
||||
|
||||
**线程**与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
|
||||
|
||||
**程序**是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。
|
||||
|
||||
**进程**是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。
|
||||
线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。
|
||||
|
||||
## 30. 线程有哪些基本状态?
|
||||
|
||||
参考《Java 并发编程艺术》4.1.4节。
|
||||
|
||||
Java 线程在运行的生命周期中的指定时刻只可能处于下面6种不同状态的其中一个状态。
|
||||
|
||||
|
||||
|
||||
线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变迁如下图所示：
|
||||
|
||||
|
||||
|
||||
## 31 关于 final 关键字的一些总结
|
||||
|
||||
final关键字主要用在三个地方：变量、方法、类。
|
||||
|
||||
1. 对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
|
||||
2. 当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。
|
||||
3. 使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。
|
||||
|
||||
## 32 Java 中的异常处理
|
||||
|
||||
### Java异常类层次结构图
|
||||
|
||||
|
||||
在 Java 中，所有的异常都有一个共同的祖先java.lang包中的 **Throwable类**。Throwable： 有两个重要的子类：**Exception（异常）** 和 **Error（错误）** ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。
|
||||
|
||||
**Error（错误）:是程序无法处理的错误**，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
|
||||
|
||||
这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。
|
||||
|
||||
**Exception（异常）:是程序本身可以处理的异常**。</font>Exception 类有一个重要的子类 **RuntimeException**。RuntimeException 异常由Java虚拟机抛出。**NullPointerException**（要访问的变量没有引用任何对象时，抛出该异常）、**ArithmeticException**（算术运算异常，一个整数除以0时，抛出该异常）和 **ArrayIndexOutOfBoundsException** （下标越界异常）。
|
||||
|
||||
**注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。**
|
||||
|
||||
### Throwable类常用方法
|
||||
|
||||
- **public string getMessage()**:返回异常发生时的详细信息
|
||||
- **public string toString()**:返回异常发生时的简要描述
|
||||
- **public string getLocalizedMessage()**:返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
|
||||
- **public void printStackTrace()**:在控制台上打印Throwable对象封装的异常信息
|
||||
|
||||
### 异常处理总结
|
||||
|
||||
- try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
|
||||
- catch 块：用于处理try捕获到的异常。
|
||||
- finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。
|
||||
|
||||
**在以下4种特殊情况下，finally块不会被执行：**
|
||||
|
||||
1. 在finally语句块中发生了异常。
|
||||
2. 在前面的代码中用了System.exit()退出程序。
|
||||
3. 程序所在的线程死亡。
|
||||
4. 关闭CPU。
|
||||
|
||||
## 33 Java序列化中如果有些字段不想进行序列化 怎么办
|
||||
|
||||
对于不想进行序列化的变量，使用transient关键字修饰。
|
||||
|
||||
transient关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被transient修饰的变量值不会被持久化和恢复。transient只能修饰变量，不能修饰类和方法。
|
||||
|
||||
## 34 获取用键盘输入常用的的两种方法
|
||||
|
||||
方法1：通过 Scanner
|
||||
|
||||
```java
|
||||
Scanner input = new Scanner(System.in);
|
||||
String s = input.nextLine();
|
||||
input.close();
|
||||
```
|
||||
|
||||
方法2：通过 BufferedReader
|
||||
|
||||
```java
|
||||
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
|
||||
String s = input.readLine();
|
||||
```
|
||||
|
||||
## 参考
|
||||
|
||||
- https://stackoverflow.com/questions/1906445/what-is-the-difference-between-jdk-and-jre
|
||||
- https://www.educba.com/oracle-vs-openjdk/
|
||||
- https://stackoverflow.com/questions/22358071/differences-between-oracle-jdk-and-openjdk?answertab=active#tab-top
|
||||
@ -1,67 +0,0 @@
|
||||
Java面试通关手册（Java学习指南）github地址（欢迎star和pull）：[https://github.com/Snailclimb/Java_Guide](https://github.com/Snailclimb/Java_Guide)
|
||||
|
||||
|
||||
|
||||
下面是按jvm虚拟机知识点分章节总结的一些jvm学习与面试相关的一些东西。一般作为Java程序员在面试的时候一般会问的大多就是**Java内存区域、虚拟机垃圾算法、虚拟垃圾收集器、JVM内存管理**这些问题了。这些内容参考周的《深入理解Java虚拟机》中第二章和第三章就足够了对应下面的[深入理解虚拟机之Java内存区域：](https://link.zhihu.com/?target=https%3A//mp.weixin.qq.com/s%3F__biz%3DMzU4NDQ4MzU5OA%3D%3D%26mid%3D2247483910%26idx%3D1%26sn%3D246f39051a85fc312577499691fba89f%26chksm%3Dfd985467caefdd71f9a7c275952be34484b14f9e092723c19bd4ef557c324169ed084f868bdb%23rd)和[深入理解虚拟机之垃圾回收](https://link.zhihu.com/?target=https%3A//mp.weixin.qq.com/s%3F__biz%3DMzU4NDQ4MzU5OA%3D%3D%26mid%3D2247483914%26idx%3D1%26sn%3D9aa157d4a1570962c39783cdeec7e539%26chksm%3Dfd98546bcaefdd7d9f61cd356e5584e56b64e234c3a403ed93cb6d4dde07a505e3000fd0c427%23rd)这两篇文章。
|
||||
|
||||
|
||||
> ### 常见面试题
|
||||
|
||||
[深入理解虚拟机之Java内存区域：](https://link.zhihu.com/?target=https%3A//mp.weixin.qq.com/s%3F__biz%3DMzU4NDQ4MzU5OA%3D%3D%26mid%3D2247483910%26idx%3D1%26sn%3D246f39051a85fc312577499691fba89f%26chksm%3Dfd985467caefdd71f9a7c275952be34484b14f9e092723c19bd4ef557c324169ed084f868bdb%23rd)
|
||||
|
||||
1. 介绍下Java内存区域（运行时数据区）。
|
||||
|
||||
2. 对象的访问定位的两种方式。
|
||||
|
||||
|
||||
[深入理解虚拟机之垃圾回收](https://link.zhihu.com/?target=https%3A//mp.weixin.qq.com/s%3F__biz%3DMzU4NDQ4MzU5OA%3D%3D%26mid%3D2247483914%26idx%3D1%26sn%3D9aa157d4a1570962c39783cdeec7e539%26chksm%3Dfd98546bcaefdd7d9f61cd356e5584e56b64e234c3a403ed93cb6d4dde07a505e3000fd0c427%23rd)
|
||||
|
||||
1. 如何判断对象是否死亡（两种方法）。
|
||||
|
||||
2. 简单的介绍一下强引用、软引用、弱引用、虚引用（虚引用与软引用和弱引用的区别、使用软引用能带来的好处）。
|
||||
|
||||
3. 垃圾收集有哪些算法，各自的特点？
|
||||
|
||||
4. HotSpot为什么要分为新生代和老年代？
|
||||
|
||||
5. 常见的垃圾回收器有那些？
|
||||
|
||||
6. 介绍一下CMS,G1收集器。
|
||||
|
||||
7. Minor Gc和Full GC 有什么不同呢？
|
||||
|
||||
|
||||
|
||||
[虚拟机性能监控和故障处理工具](https://link.zhihu.com/?target=https%3A//mp.weixin.qq.com/s%3F__biz%3DMzU4NDQ4MzU5OA%3D%3D%26mid%3D2247483922%26idx%3D1%26sn%3D0695ff4c2700ccebb8fbc39011866bd8%26chksm%3Dfd985473caefdd6583eb42dbbc7f01918dc6827c808292bb74a5b6333e3d526c097c9351e694%23rd)
|
||||
|
||||
1. JVM调优的常见命令行工具有哪些？
|
||||
|
||||
[深入理解虚拟机之类文件结构](https://link.zhihu.com/?target=https%3A//mp.weixin.qq.com/s%3F__biz%3DMzU4NDQ4MzU5OA%3D%3D%26mid%3D2247483926%26idx%3D1%26sn%3D224413da998f7e024f7b8d87397934d9%26chksm%3Dfd985477caefdd61a2fe1a3f0be29e057082252e579332f5b6d9072a150b838cefe2c47b6e5a%23rd)
|
||||
|
||||
1. 简单介绍一下Class类文件结构（常量池主要存放的是那两大常量？Class文件的继承关系是如何确定的？字段表、方法表、属性表主要包含那些信息？）
|
||||
|
||||
[深入理解虚拟机之虚拟机类加载机制](http://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247483934&idx=1&sn=f247f9bee4e240f5e7fac25659da3bff&chksm=fd98547fcaefdd6996e1a7046e03f29df9308bdf82ceeffd111112766ffd3187892700f64b40#rd)
|
||||
|
||||
1. 简单说说类加载过程，里面执行了哪些操作？
|
||||
|
||||
2. 对类加载器有了解吗？
|
||||
|
||||
3. 什么是双亲委派模型？
|
||||
|
||||
4. 双亲委派模型的工作过程以及使用它的好处。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
> ### 推荐阅读
|
||||
|
||||
[深入理解虚拟机之虚拟机字节码执行引擎](https://juejin.im/post/5aebcb076fb9a07a9a10b5f3)
|
||||
|
||||
[《深入理解 Java 内存模型》读书笔记](http://www.54tianzhisheng.cn/2018/02/28/Java-Memory-Model/) （非常不错的文章）
|
||||
|
||||
[全面理解Java内存模型(JMM)及volatile关键字 ](https://blog.csdn.net/javazejian/article/details/72772461)
|
||||
|
||||
**欢迎关注我的微信公众号:"Java面试通关手册"（一个有温度的微信公众号，期待与你共同进步~~~坚持原创，分享美文，分享各种Java学习资源）：**
|
||||
|
||||
|
||||
@ -1,352 +0,0 @@
|
||||
<!-- MarkdownTOC -->
|
||||
|
||||
1. [List，Set,Map三者的区别及总结](#list，setmap三者的区别及总结)
|
||||
1. [Arraylist 与 LinkedList 区别](#arraylist-与-linkedlist-区别)
|
||||
1. [ArrayList 与 Vector 区别（为什么要用Arraylist取代Vector呢？）](#arraylist-与-vector-区别)
|
||||
1. [HashMap 和 Hashtable 的区别](#hashmap-和-hashtable-的区别)
|
||||
1. [HashSet 和 HashMap 区别](#hashset-和-hashmap-区别)
|
||||
1. [HashMap 和 ConcurrentHashMap 的区别](#hashmap-和-concurrenthashmap-的区别)
|
||||
1. [HashSet如何检查重复](#hashset如何检查重复)
|
||||
1. [comparable 和 comparator的区别](#comparable-和-comparator的区别)
|
||||
1. [Comparator定制排序](#comparator定制排序)
|
||||
1. [重写compareTo方法实现按年龄来排序](#重写compareto方法实现按年龄来排序)
|
||||
1. [如何对Object的list排序？](#如何对object的list排序)
|
||||
1. [如何实现数组与List的相互转换？](#如何实现数组与list的相互转换)
|
||||
1. [如何求ArrayList集合的交集 并集 差集 去重复并集](#如何求arraylist集合的交集-并集-差集-去重复并集)
|
||||
1. [HashMap 的工作原理及代码实现](#hashmap-的工作原理及代码实现)
|
||||
1. [ConcurrentHashMap 的工作原理及代码实现](#concurrenthashmap-的工作原理及代码实现)
|
||||
1. [集合框架底层数据结构总结](#集合框架底层数据结构总结)
|
||||
1. [- Collection](#--collection)
|
||||
1. [1. List](#1-list)
|
||||
1. [2. Set](#2-set)
|
||||
1. [- Map](#--map)
|
||||
1. [集合的选用](#集合的选用)
|
||||
1. [集合的常用方法](#集合的常用方法)
|
||||
|
||||
<!-- /MarkdownTOC -->
|
||||
|
||||
|
||||
## <font face="楷体">List，Set,Map三者的区别及总结</font>
|
||||
- **List：对付顺序的好帮手**
|
||||
|
||||
List接口存储一组不唯一（可以有多个元素引用相同的对象），有序的对象
|
||||
- **Set:注重独一无二的性质**
|
||||
|
||||
不允许重复的集合。不会有多个元素引用相同的对象。
|
||||
|
||||
- **Map:用Key来搜索的专家**
|
||||
|
||||
使用键值对存储。Map会维护与Key有关联的值。两个Key可以引用相同的对象，但Key不能重复，典型的Key是String类型，但也可以是任何对象。
|
||||
|
||||
|
||||
## <font face="楷体">Arraylist 与 LinkedList 区别</font>
|
||||
Arraylist底层使用的是数组（存读数据效率高，插入删除特定位置效率低），LinkedList底层使用的是双向循环链表数据结构（插入，删除效率特别高）。学过数据结构这门课后我们就知道采用链表存储，插入，删除元素时间复杂度不受元素位置的影响，都是近似O（1）而数组为近似O（n），因此当数据特别多，而且经常需要插入删除元素时建议选用LinkedList.一般程序只用Arraylist就够用了，因为一般数据量都不会蛮大，Arraylist是使用最多的集合类。
|
||||
|
||||
## <font face="楷体">ArrayList 与 Vector 区别</font>
|
||||
Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象、但是一个线程访问Vector
|
||||
，代码要在同步操作上耗费大量的时间。Arraylist不是同步的，所以在不需要同步时建议使用Arraylist。
|
||||
|
||||
## <font face="楷体">HashMap 和 Hashtable 的区别</font>
|
||||
1. HashMap是非线程安全的，HashTable是线程安全的；HashTable内部的方法基本都经过synchronized修饰。
|
||||
|
||||
2. 因为线程安全的问题，HashMap要比HashTable效率高一点，HashTable基本被淘汰。
|
||||
3. HashMap允许有null值的存在，而在HashTable中put进的键值只要有一个null，直接抛出NullPointerException。
|
||||
|
||||
Hashtable和HashMap有几个主要的不同：线程安全以及速度。仅在你需要完全的线程安全的时候使用Hashtable，而如果你使用Java5或以上的话，请使用ConcurrentHashMap吧
|
||||
|
||||
## <font face="楷体">HashSet 和 HashMap 区别</font>
|
||||
|
||||
|
||||
## <font face="楷体">HashMap 和 ConcurrentHashMap 的区别</font>
|
||||
[HashMap与ConcurrentHashMap的区别](https://blog.csdn.net/xuefeng0707/article/details/40834595)
|
||||
|
||||
1. ConcurrentHashMap对整个桶数组进行了分割分段(Segment)，然后在每一个分段上都用lock锁进行保护，相对于HashTable的synchronized锁的粒度更精细了一些，并发性能更好，而HashMap没有锁机制，不是线程安全的。（JDK1.8之后ConcurrentHashMap启用了一种全新的方式实现,利用CAS算法。）
|
||||
2. HashMap的键值对允许有null，但是ConCurrentHashMap都不允许。
|
||||
|
||||
## <font face="楷体">HashSet如何检查重复</font>
|
||||
当你把对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，同时也会与其他加入的对象的hashcode值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同hashcode值的对象，这时会调用equals（）方法来检查hashcode相等的对象是否真的相同。如果两者相同，HashSet就不会让加入操作成功。（摘自我的Java启蒙书《Head fist java》第二版）
|
||||
|
||||
**hashCode（）与equals（）的相关规定：**
|
||||
1. 如果两个对象相等，则hashcode一定也是相同的
|
||||
2. 两个对象相等,对两个equals方法返回true
|
||||
3. 两个对象有相同的hashcode值，它们也不一定是相等的
|
||||
4. 综上，equals方法被覆盖过，则hashCode方法也必须被覆盖
|
||||
5. hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）。
|
||||
|
||||
**==与equals的区别**
|
||||
|
||||
1. ==是判断两个变量或实例是不是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是不是相同
|
||||
2. ==是指对内存地址进行比较 equals()是对字符串的内容进行比较3.==指引用是否相同 equals()指的是值是否相同
|
||||
|
||||
## <font face="楷体">comparable 和 comparator的区别</font>
|
||||
- comparable接口实际上是出自java.lang包 它有一个 compareTo(Object obj)方法用来排序
|
||||
- comparator接口实际上是出自 java.util 包它有一个compare(Object obj1, Object obj2)方法用来排序
|
||||
|
||||
一般我们需要对一个集合使用自定义排序时，我们就要重写compareTo方法或compare方法，当我们需要对某一个集合实现两种排序方式，比如一个song对象中的歌名和歌手名分别采用一种排序方法的话，我们可以重写compareTo方法和使用自制的Comparator方法或者以两个Comparator来实现歌名排序和歌星名排序，第二种代表我们只能使用两个参数版的Collections.sort().
|
||||
|
||||
### <font face="楷体">Comparator定制排序<font face="楷体">
|
||||
```java
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
|
||||
/**
|
||||
* TODO Collections类方法测试之排序
|
||||
* @author 寇爽
|
||||
* @date 2017年11月20日
|
||||
* @version 1.8
|
||||
*/
|
||||
public class CollectionsSort {
|
||||
|
||||
public static void main(String[] args) {
|
||||
|
||||
ArrayList<Integer> arrayList = new ArrayList<Integer>();
|
||||
arrayList.add(-1);
|
||||
arrayList.add(3);
|
||||
arrayList.add(3);
|
||||
arrayList.add(-5);
|
||||
arrayList.add(7);
|
||||
arrayList.add(4);
|
||||
arrayList.add(-9);
|
||||
arrayList.add(-7);
|
||||
System.out.println("原始数组:");
|
||||
System.out.println(arrayList);
|
||||
// void reverse(List list)：反转
|
||||
Collections.reverse(arrayList);
|
||||
System.out.println("Collections.reverse(arrayList):");
|
||||
System.out.println(arrayList);
|
||||
/*
|
||||
* void rotate(List list, int distance),旋转。
|
||||
* 当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将
|
||||
* list的前distance个元素整体移到后面。
|
||||
|
||||
Collections.rotate(arrayList, 4);
|
||||
System.out.println("Collections.rotate(arrayList, 4):");
|
||||
System.out.println(arrayList);*/
|
||||
|
||||
// void sort(List list),按自然排序的升序排序
|
||||
Collections.sort(arrayList);
|
||||
System.out.println("Collections.sort(arrayList):");
|
||||
System.out.println(arrayList);
|
||||
|
||||
// void shuffle(List list),随机排序
|
||||
Collections.shuffle(arrayList);
|
||||
System.out.println("Collections.shuffle(arrayList):");
|
||||
System.out.println(arrayList);
|
||||
|
||||
// 定制排序的用法
|
||||
Collections.sort(arrayList, new Comparator<Integer>() {
|
||||
|
||||
@Override
|
||||
public int compare(Integer o1, Integer o2) {
|
||||
return o2.compareTo(o1);
|
||||
}
|
||||
});
|
||||
System.out.println("定制排序后：");
|
||||
System.out.println(arrayList);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
```
|
||||
### <font face="楷体">重写compareTo方法实现按年龄来排序</font>
|
||||
```java
|
||||
package map;
|
||||
|
||||
import java.util.Set;
|
||||
import java.util.TreeMap;
|
||||
|
||||
public class TreeMap2 {
|
||||
|
||||
public static void main(String[] args) {
|
||||
// TODO Auto-generated method stub
|
||||
TreeMap<Person, String> pdata = new TreeMap<Person, String>();
|
||||
pdata.put(new Person("张三", 30), "zhangsan");
|
||||
pdata.put(new Person("李四", 20), "lisi");
|
||||
pdata.put(new Person("王五", 10), "wangwu");
|
||||
pdata.put(new Person("小红", 5), "xiaohong");
|
||||
// 得到key的值的同时得到key所对应的值
|
||||
Set<Person> keys = pdata.keySet();
|
||||
for (Person key : keys) {
|
||||
System.out.println(key.getAge() + "-" + key.getName());
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// person对象没有实现Comparable接口，所以必须实现，这样才不会出错，才可以使treemap中的数据按顺序排列
|
||||
// 前面一个例子的String类已经默认实现了Comparable接口，详细可以查看String类的API文档，另外其他
|
||||
// 像Integer类等都已经实现了Comparable接口，所以不需要另外实现了
|
||||
|
||||
class Person implements Comparable<Person> {
|
||||
private String name;
|
||||
private int age;
|
||||
|
||||
public Person(String name, int age) {
|
||||
super();
|
||||
this.name = name;
|
||||
this.age = age;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public void setName(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
public int getAge() {
|
||||
return age;
|
||||
}
|
||||
|
||||
public void setAge(int age) {
|
||||
this.age = age;
|
||||
}
|
||||
|
||||
/**
|
||||
* TODO重写compareTo方法实现按年龄来排序
|
||||
*/
|
||||
@Override
|
||||
public int compareTo(Person o) {
|
||||
// TODO Auto-generated method stub
|
||||
if (this.age > o.getAge()) {
|
||||
return 1;
|
||||
} else if (this.age < o.getAge()) {
|
||||
return -1;
|
||||
}
|
||||
return age;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## <font face="楷体">如何对Object的list排序</font>
|
||||
- 对objects数组进行排序，我们可以用Arrays.sort()方法
|
||||
- 对objects的集合进行排序，需要使用Collections.sort()方法
|
||||
|
||||
|
||||
## <font face="楷体">如何实现数组与List的相互转换</font>
|
||||
List转数组：toArray(arraylist.size()方法；数组转List:Arrays的asList(a)方法
|
||||
```java
|
||||
List<String> arrayList = new ArrayList<String>();
|
||||
arrayList.add("s");
|
||||
arrayList.add("e");
|
||||
arrayList.add("n");
|
||||
/**
|
||||
* ArrayList转数组
|
||||
*/
|
||||
int size=arrayList.size();
|
||||
String[] a = arrayList.toArray(new String[size]);
|
||||
//输出第二个元素
|
||||
System.out.println(a[1]);//结果：e
|
||||
//输出整个数组
|
||||
System.out.println(Arrays.toString(a));//结果：[s, e, n]
|
||||
/**
|
||||
* 数组转list
|
||||
*/
|
||||
List<String> list=Arrays.asList(a);
|
||||
/**
|
||||
* list转Arraylist
|
||||
*/
|
||||
List<String> arrayList2 = new ArrayList<String>();
|
||||
arrayList2.addAll(list);
|
||||
System.out.println(list);
|
||||
```
|
||||
## <font face="楷体">如何求ArrayList集合的交集 并集 差集 去重复并集</font>
|
||||
需要用到List接口中定义的几个方法：
|
||||
|
||||
- addAll(Collection<? extends E> c) :按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾
|
||||
实例代码：
|
||||
- retainAll(Collection<?> c): 仅保留此列表中包含在指定集合中的元素。
|
||||
- removeAll(Collection<?> c) :从此列表中删除指定集合中包含的所有元素。
|
||||
```java
|
||||
package list;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
*TODO 两个集合之间求交集 并集 差集 去重复并集
|
||||
* @author 寇爽
|
||||
* @date 2017年11月21日
|
||||
* @version 1.8
|
||||
*/
|
||||
public class MethodDemo {
|
||||
|
||||
public static void main(String[] args) {
|
||||
// TODO Auto-generated method stub
|
||||
List<Integer> list1 = new ArrayList<Integer>();
|
||||
list1.add(1);
|
||||
list1.add(2);
|
||||
list1.add(3);
|
||||
list1.add(4);
|
||||
|
||||
List<Integer> list2 = new ArrayList<Integer>();
|
||||
list2.add(2);
|
||||
list2.add(3);
|
||||
list2.add(4);
|
||||
list2.add(5);
|
||||
// 并集
|
||||
// list1.addAll(list2);
|
||||
// 交集
|
||||
//list1.retainAll(list2);
|
||||
// 差集
|
||||
// list1.removeAll(list2);
|
||||
// 无重复并集
|
||||
list2.removeAll(list1);
|
||||
list1.addAll(list2);
|
||||
for (Integer i : list1) {
|
||||
System.out.println(i);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
## <font face="楷体">HashMap 的工作原理及代码实现</font>
|
||||
|
||||
[集合框架源码学习之HashMap(JDK1.8)](https://juejin.im/post/5ab0568b5188255580020e56)
|
||||
|
||||
## <font face="楷体">ConcurrentHashMap 的工作原理及代码实现</font>
|
||||
|
||||
[ConcurrentHashMap实现原理及源码分析](http://www.cnblogs.com/chengxiao/p/6842045.html)
|
||||
|
||||
|
||||
## <font face="楷体">集合框架底层数据结构总结</font>
|
||||
### - Collection
|
||||
|
||||
#### 1. List
|
||||
- Arraylist：数组（查询快,增删慢 线程不安全,效率高 ）
|
||||
- Vector：数组（查询快,增删慢 线程安全,效率低 ）
|
||||
- LinkedList：链表（查询慢,增删快 线程不安全,效率高 ）
|
||||
|
||||
#### 2. Set
|
||||
- HashSet（无序，唯一）:哈希表或者叫散列集(hash table)
|
||||
- LinkedHashSet：链表和哈希表组成 。 由链表保证元素的排序 ， 由哈希表证元素的唯一性
|
||||
- TreeSet（有序，唯一）：红黑树(自平衡的排序二叉树。)
|
||||
|
||||
### - Map
|
||||
- HashMap：基于哈希表的Map接口实现（哈希表对键进行散列，Map结构即映射表存放键值对）
|
||||
- LinkedHashMap:HashMap 的基础上加上了链表数据结构
|
||||
- HashTable:哈希表
|
||||
- TreeMap:红黑树（自平衡的排序二叉树）
|
||||
|
||||
|
||||
## <font face="楷体">集合的选用</font>
|
||||
主要根据集合的特点来选用，比如我们需要根据键值获取到元素值时就选用Map接口下的集合，需要排序时选择TreeMap,不需要排序时就选择HashMap,需要保证线程安全就选用ConcurrentHashMap.当我们只需要存放元素值时，就选择实现Collection接口的集合，需要保证元素唯一时选择实现Set接口的集合比如TreeSet或HashSet，不需要就选择实现List接口的比如ArrayList或LinkedList，然后再根据实现这些接口的集合的特点来选用。
|
||||
|
||||
2018/3/11更新
|
||||
## <font face="楷体">集合的常用方法</font>
|
||||
今天下午无意看见一道某大厂的面试题，面试题的内容就是问你某一个集合常见的方法有哪些。虽然平时也经常见到这些集合，但是猛一下让我想某一个集合的常用的方法难免会有遗漏或者与其他集合搞混，所以建议大家还是照着API文档把常见的那几个集合的常用方法看一看。
|
||||
|
||||
会持续更新。。。
|
||||
|
||||
**参考书籍：**
|
||||
|
||||
《Head first java 》第二版 推荐阅读真心不错 （适合基础较差的）
|
||||
|
||||
《Java核心技术卷1》推荐阅读真心不错 （适合基础较好的）
|
||||
|
||||
《算法》第四版 （适合想对数据结构的Java实现感兴趣的）
|
||||
|
||||
@ -1,475 +0,0 @@
|
||||
|
||||
**目录：**
|
||||
<!-- MarkdownTOC -->
|
||||
|
||||
- [1 AQS 简单介绍](#1-aqs-简单介绍)
|
||||
- [2 AQS 原理](#2-aqs-原理)
|
||||
- [2.1 AQS 原理概览](#21-aqs-原理概览)
|
||||
- [2.2 AQS 对资源的共享方式](#22-aqs-对资源的共享方式)
|
||||
- [2.3 AQS底层使用了模板方法模式](#23-aqs底层使用了模板方法模式)
|
||||
- [3 Semaphore\(信号量\)-允许多个线程同时访问](#3-semaphore信号量-允许多个线程同时访问)
|
||||
- [4 CountDownLatch （倒计时器）](#4-countdownlatch-倒计时器)
|
||||
- [4.1 CountDownLatch 的三种典型用法](#41-countdownlatch-的三种典型用法)
|
||||
- [4.2 CountDownLatch 的使用示例](#42-countdownlatch-的使用示例)
|
||||
- [4.3 CountDownLatch 的不足](#43-countdownlatch-的不足)
|
||||
- [4.4 CountDownLatch相常见面试题：](#44-countdownlatch相常见面试题)
|
||||
- [5 CyclicBarrier\(循环栅栏\)](#5-cyclicbarrier循环栅栏)
|
||||
- [5.1 CyclicBarrier 的应用场景](#51-cyclicbarrier-的应用场景)
|
||||
- [5.2 CyclicBarrier 的使用示例](#52-cyclicbarrier-的使用示例)
|
||||
- [5.3 CyclicBarrier和CountDownLatch的区别](#53-cyclicbarrier和countdownlatch的区别)
|
||||
- [6 ReentrantLock 和 ReentrantReadWriteLock](#6-reentrantlock-和-reentrantreadwritelock)
|
||||
|
||||
<!-- /MarkdownTOC -->
|
||||
|
||||
> 常见问题：AQS原理？;CountDownLatch和CyclicBarrier了解吗,两者的区别是什么？用过Semaphore吗？
|
||||
|
||||
**本节思维导图：**
|
||||
|
||||
|
||||
|
||||
|
||||
### 1 AQS 简单介绍
|
||||
AQS的全称为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包下面。
|
||||
|
||||
|
||||
|
||||
AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的ReentrantLock，Semaphore，其他的诸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基于AQS的。当然，我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的同步器。
|
||||
|
||||
### 2 AQS 原理
|
||||
|
||||
> 在面试中被问到并发知识的时候，大多都会被问到“请你说一下自己对于AQS原理的理解”。下面给大家一个示例供大家参加，面试不是背题，大家一定要假如自己的思想，即使加入不了自己的思想也要保证自己能够通俗的讲出来而不是背出来。
|
||||
|
||||
下面大部分内容其实在AQS类注释上已经给出了，不过是英语看着比较吃力一点，感兴趣的话可以看看源码。
|
||||
|
||||
#### 2.1 AQS 原理概览
|
||||
|
||||
**AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。**
|
||||
|
||||
> CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS是将每条请求共享资源的线程封装成一个CLH锁队列的一个结点（Node）来实现锁的分配。
|
||||
|
||||
看个AQS(AbstractQueuedSynchronizer)原理图：
|
||||
|
||||
|
||||
|
||||
|
||||
AQS使用一个int成员变量来表示同步状态，通过内置的FIFO队列来完成获取资源线程的排队工作。AQS使用CAS对该同步状态进行原子操作实现对其值的修改。
|
||||
|
||||
```java
|
||||
private volatile int state;//共享变量，使用volatile修饰保证线程可见性
|
||||
```
|
||||
|
||||
状态信息通过protected类型的getState，setState，compareAndSetState进行操作
|
||||
|
||||
```java
|
||||
|
||||
//返回同步状态的当前值
|
||||
protected final int getState() {
|
||||
return state;
|
||||
}
|
||||
// 设置同步状态的值
|
||||
protected final void setState(int newState) {
|
||||
state = newState;
|
||||
}
|
||||
//原子地（CAS操作）将同步状态值设置为给定值update如果当前同步状态的值等于expect（期望值）
|
||||
protected final boolean compareAndSetState(int expect, int update) {
|
||||
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
|
||||
}
|
||||
```
|
||||
|
||||
#### 2.2 AQS 对资源的共享方式
|
||||
|
||||
**AQS定义两种资源共享方式**
|
||||
|
||||
- **Exclusive**（独占）：只有一个线程能执行，如ReentrantLock。又可分为公平锁和非公平锁：
|
||||
- 公平锁：按照线程在队列中的排队顺序，先到者先拿到锁
|
||||
- 非公平锁：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的
|
||||
- **Share**（共享）：多个线程可同时执行，如Semaphore/CountDownLatch。Semaphore、CountDownLatCh、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。
|
||||
|
||||
ReentrantReadWriteLock 可以看成是组合式，因为ReentrantReadWriteLock也就是读写锁允许多个线程同时对某一资源进行读。
|
||||
|
||||
不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在上层已经帮我们实现好了。
|
||||
|
||||
#### 2.3 AQS底层使用了模板方法模式
|
||||
|
||||
同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）：
|
||||
|
||||
1. 使用者继承AbstractQueuedSynchronizer并重写指定的方法。（这些重写方法很简单，无非是对于共享资源state的获取和释放）
|
||||
2. 将AQS组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。
|
||||
|
||||
这和我们以往通过实现接口的方式有很大区别，这是模板方法模式很经典的一个运用，下面简单的给大家介绍一下模板方法模式，模板方法模式是一个很容易理解的设计模式之一。
|
||||
|
||||
> 模板方法模式是基于”继承“的，主要是为了在不改变模板结构的前提下在子类中重新定义模板中的内容以实现复用代码。举个很简单的例子假如我们要去一个地方的步骤是：购票`buyTicket()`->安检`securityCheck()`->乘坐某某工具回家`ride()`->到达目的地`arrive()`。我们可能乘坐不同的交通工具回家比如飞机或者火车，所以除了`ride()`方法，其他方法的实现几乎相同。我们可以定义一个包含了这些方法的抽象类，然后用户根据自己的需要继承该抽象类然后修改 `ride()`方法。
|
||||
|
||||
**AQS使用了模板方法模式，自定义同步器时需要重写下面几个AQS提供的模板方法：**
|
||||
|
||||
```java
|
||||
isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。
|
||||
tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。
|
||||
tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。
|
||||
tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
|
||||
tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。
|
||||
|
||||
```
|
||||
|
||||
默认情况下，每个方法都抛出 `UnsupportedOperationException`。 这些方法的实现必须是内部线程安全的，并且通常应该简短而不是阻塞。AQS类中的其他方法都是final ，所以无法被其他类使用，只有这几个方法可以被其他类使用。
|
||||
|
||||
以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。
|
||||
|
||||
再以CountDownLatch以例，任务分为N个子线程去执行，state也初始化为N（注意N要与线程个数一致）。这N个子线程是并行执行的，每个子线程执行完后countDown()一次，state会CAS(Compare and Swap)减1。等到所有子线程都执行完后(即state=0)，会unpark()主调用线程，然后主调用线程就会从await()函数返回，继续后余动作。
|
||||
|
||||
一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现`tryAcquire-tryRelease`、`tryAcquireShared-tryReleaseShared`中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如`ReentrantReadWriteLock`。
|
||||
|
||||
推荐两篇 AQS 原理和相关源码分析的文章：
|
||||
|
||||
- http://www.cnblogs.com/waterystone/p/4920797.html
|
||||
- https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html
|
||||
|
||||
|
||||
|
||||
### 3 Semaphore(信号量)-允许多个线程同时访问
|
||||
|
||||
**synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。**示例代码如下：
|
||||
|
||||
```java
|
||||
/**
|
||||
*
|
||||
* @author Snailclimb
|
||||
* @date 2018年9月30日
|
||||
* @Description: 需要一次性拿一个许可的情况
|
||||
*/
|
||||
public class SemaphoreExample1 {
|
||||
// 请求的数量
|
||||
private static final int threadCount = 550;
|
||||
|
||||
public static void main(String[] args) throws InterruptedException {
|
||||
// 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很慢）
|
||||
ExecutorService threadPool = Executors.newFixedThreadPool(300);
|
||||
// 一次只能允许执行的线程数量。
|
||||
final Semaphore semaphore = new Semaphore(20);
|
||||
|
||||
for (int i = 0; i < threadCount; i++) {
|
||||
final int threadnum = i;
|
||||
threadPool.execute(() -> {// Lambda 表达式的运用
|
||||
try {
|
||||
semaphore.acquire();// 获取一个许可，所以可运行线程数量为20/1=20
|
||||
test(threadnum);
|
||||
semaphore.release();// 释放一个许可
|
||||
} catch (InterruptedException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
});
|
||||
}
|
||||
threadPool.shutdown();
|
||||
System.out.println("finish");
|
||||
}
|
||||
|
||||
public static void test(int threadnum) throws InterruptedException {
|
||||
Thread.sleep(1000);// 模拟请求的耗时操作
|
||||
System.out.println("threadnum:" + threadnum);
|
||||
Thread.sleep(1000);// 模拟请求的耗时操作
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
执行 `acquire` 方法阻塞，直到有一个许可证可以获得然后拿走一个许可证；每个 `release` 方法增加一个许可证，这可能会释放一个阻塞的acquire方法。然而，其实并没有实际的许可证这个对象，Semaphore只是维持了一个可获得许可证的数量。 Semaphore经常用于限制获取某种资源的线程数量。
|
||||
|
||||
当然一次也可以一次拿取和释放多个许可，不过一般没有必要这样做：
|
||||
|
||||
```java
|
||||
semaphore.acquire(5);// 获取5个许可，所以可运行线程数量为20/5=4
|
||||
test(threadnum);
|
||||
semaphore.release(5);// 获取5个许可，所以可运行线程数量为20/5=4
|
||||
```
|
||||
|
||||
除了 `acquire`方法之外，另一个比较常用的与之对应的方法是`tryAcquire`方法，该方法如果获取不到许可就立即返回false。
|
||||
|
||||
|
||||
Semaphore 有两种模式，公平模式和非公平模式。
|
||||
|
||||
- **公平模式：** 调用acquire的顺序就是获取许可证的顺序，遵循FIFO；
|
||||
- **非公平模式：** 抢占式的。
|
||||
|
||||
**Semaphore 对应的两个构造方法如下：**
|
||||
|
||||
```java
|
||||
public Semaphore(int permits) {
|
||||
sync = new NonfairSync(permits);
|
||||
}
|
||||
|
||||
public Semaphore(int permits, boolean fair) {
|
||||
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
|
||||
}
|
||||
```
|
||||
**这两个构造方法，都必须提供许可的数量，第二个构造方法可以指定是公平模式还是非公平模式，默认非公平模式。**
|
||||
|
||||
由于篇幅问题，如果对 Semaphore 源码感兴趣的朋友可以看下面这篇文章：
|
||||
|
||||
- https://blog.csdn.net/qq_19431333/article/details/70212663
|
||||
|
||||
### 4 CountDownLatch （倒计时器）
|
||||
|
||||
CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。在Java并发中，countdownlatch的概念是一个常见的面试题，所以一定要确保你很好的理解了它。
|
||||
|
||||
#### 4.1 CountDownLatch 的三种典型用法
|
||||
|
||||
①某一线程在开始运行前等待n个线程执行完毕。将 CountDownLatch 的计数器初始化为n ：`new CountDownLatch(n) `，每当一个任务线程执行完毕，就将计数器减1 `countdownlatch.countDown()`，当计数器的值变为0时，在`CountDownLatch上 await()` 的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。
|
||||
|
||||
②实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的 `CountDownLatch` 对象，将其计数器初始化为 1 ：`new CountDownLatch(1) `，多个线程在开始执行任务前首先 `coundownlatch.await()`，当主线程调用 countDown() 时，计数器变为0，多个线程同时被唤醒。
|
||||
|
||||
③死锁检测：一个非常方便的使用场景是，你可以使用n个线程访问共享资源，在每次测试阶段的线程数目是不同的，并尝试产生死锁。
|
||||
|
||||
#### 4.2 CountDownLatch 的使用示例
|
||||
|
||||
```java
|
||||
/**
|
||||
*
|
||||
* @author SnailClimb
|
||||
* @date 2018年10月1日
|
||||
* @Description: CountDownLatch 使用方法示例
|
||||
*/
|
||||
public class CountDownLatchExample1 {
|
||||
// 请求的数量
|
||||
private static final int threadCount = 550;
|
||||
|
||||
public static void main(String[] args) throws InterruptedException {
|
||||
// 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很慢）
|
||||
ExecutorService threadPool = Executors.newFixedThreadPool(300);
|
||||
final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
|
||||
for (int i = 0; i < threadCount; i++) {
|
||||
final int threadnum = i;
|
||||
threadPool.execute(() -> {// Lambda 表达式的运用
|
||||
try {
|
||||
test(threadnum);
|
||||
} catch (InterruptedException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
} finally {
|
||||
countDownLatch.countDown();// 表示一个请求已经被完成
|
||||
}
|
||||
|
||||
});
|
||||
}
|
||||
countDownLatch.await();
|
||||
threadPool.shutdown();
|
||||
System.out.println("finish");
|
||||
}
|
||||
|
||||
public static void test(int threadnum) throws InterruptedException {
|
||||
Thread.sleep(1000);// 模拟请求的耗时操作
|
||||
System.out.println("threadnum:" + threadnum);
|
||||
Thread.sleep(1000);// 模拟请求的耗时操作
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
上面的代码中，我们定义了请求的数量为550，当这550个请求被处理完成之后，才会执行`System.out.println("finish");`。
|
||||
|
||||
与CountDownLatch的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用CountDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。
|
||||
|
||||
其他N个线程必须引用闭锁对象，因为他们需要通知CountDownLatch对象，他们已经完成了各自的任务。这种通知机制是通过 CountDownLatch.countDown()方法来完成的；每调用一次这个方法，在构造函数中初始化的count值就减1。所以当N个线程都调 用了这个方法，count的值等于0，然后主线程就能通过await()方法，恢复执行自己的任务。
|
||||
|
||||
#### 4.3 CountDownLatch 的不足
|
||||
|
||||
CountDownLatch是一次性的，计数器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当CountDownLatch使用完毕后，它不能再次被使用。
|
||||
|
||||
#### 4.4 CountDownLatch相常见面试题：
|
||||
|
||||
解释一下CountDownLatch概念？
|
||||
|
||||
CountDownLatch 和CyclicBarrier的不同之处？
|
||||
|
||||
给出一些CountDownLatch使用的例子？
|
||||
|
||||
CountDownLatch 类中主要的方法？
|
||||
|
||||
### 5 CyclicBarrier(循环栅栏)
|
||||
|
||||
CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。
|
||||
|
||||
CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是 `CyclicBarrier(int parties)`，其参数表示屏障拦截的线程数量，每个线程调用`await`方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。
|
||||
|
||||
#### 5.1 CyclicBarrier 的应用场景
|
||||
|
||||
CyclicBarrier 可以用于多线程计算数据，最后合并计算结果的应用场景。比如我们用一个Excel保存了用户所有银行流水，每个Sheet保存一个帐户近一年的每笔银行流水，现在需要统计用户的日均银行流水，先用多线程处理每个sheet里的银行流水，都执行完之后，得到每个sheet的日均银行流水，最后，再用barrierAction用这些线程的计算结果，计算出整个Excel的日均银行流水。
|
||||
|
||||
#### 5.2 CyclicBarrier 的使用示例
|
||||
|
||||
示例1：
|
||||
|
||||
```java
|
||||
/**
|
||||
*
|
||||
* @author Snailclimb
|
||||
* @date 2018年10月1日
|
||||
* @Description: 测试 CyclicBarrier 类中带参数的 await() 方法
|
||||
*/
|
||||
public class CyclicBarrierExample2 {
|
||||
// 请求的数量
|
||||
private static final int threadCount = 550;
|
||||
// 需要同步的线程数量
|
||||
private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5);
|
||||
|
||||
public static void main(String[] args) throws InterruptedException {
|
||||
// 创建线程池
|
||||
ExecutorService threadPool = Executors.newFixedThreadPool(10);
|
||||
|
||||
for (int i = 0; i < threadCount; i++) {
|
||||
final int threadNum = i;
|
||||
Thread.sleep(1000);
|
||||
threadPool.execute(() -> {
|
||||
try {
|
||||
test(threadNum);
|
||||
} catch (InterruptedException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
} catch (BrokenBarrierException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
}
|
||||
threadPool.shutdown();
|
||||
}
|
||||
|
||||
public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {
|
||||
System.out.println("threadnum:" + threadnum + "is ready");
|
||||
try {
|
||||
cyclicBarrier.await(2000, TimeUnit.MILLISECONDS);
|
||||
} catch (Exception e) {
|
||||
System.out.println("-----CyclicBarrierException------");
|
||||
}
|
||||
System.out.println("threadnum:" + threadnum + "is finish");
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
运行结果，如下：
|
||||
|
||||
```
|
||||
threadnum:0is ready
|
||||
threadnum:1is ready
|
||||
threadnum:2is ready
|
||||
threadnum:3is ready
|
||||
threadnum:4is ready
|
||||
threadnum:4is finish
|
||||
threadnum:0is finish
|
||||
threadnum:1is finish
|
||||
threadnum:2is finish
|
||||
threadnum:3is finish
|
||||
threadnum:5is ready
|
||||
threadnum:6is ready
|
||||
threadnum:7is ready
|
||||
threadnum:8is ready
|
||||
threadnum:9is ready
|
||||
threadnum:9is finish
|
||||
threadnum:5is finish
|
||||
threadnum:8is finish
|
||||
threadnum:7is finish
|
||||
threadnum:6is finish
|
||||
......
|
||||
```
|
||||
可以看到当线程数量也就是请求数量达到我们定义的 5 个的时候， `await`方法之后的方法才被执行。
|
||||
|
||||
另外，CyclicBarrier还提供一个更高级的构造函数`CyclicBarrier(int parties, Runnable barrierAction)`，用于在线程到达屏障时，优先执行`barrierAction`，方便处理更复杂的业务场景。示例代码如下：
|
||||
|
||||
```java
|
||||
/**
|
||||
*
|
||||
* @author SnailClimb
|
||||
* @date 2018年10月1日
|
||||
* @Description: 新建 CyclicBarrier 的时候指定一个 Runnable
|
||||
*/
|
||||
public class CyclicBarrierExample3 {
|
||||
// 请求的数量
|
||||
private static final int threadCount = 550;
|
||||
// 需要同步的线程数量
|
||||
private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> {
|
||||
System.out.println("------当线程数达到之后，优先执行------");
|
||||
});
|
||||
|
||||
public static void main(String[] args) throws InterruptedException {
|
||||
// 创建线程池
|
||||
ExecutorService threadPool = Executors.newFixedThreadPool(10);
|
||||
|
||||
for (int i = 0; i < threadCount; i++) {
|
||||
final int threadNum = i;
|
||||
Thread.sleep(1000);
|
||||
threadPool.execute(() -> {
|
||||
try {
|
||||
test(threadNum);
|
||||
} catch (InterruptedException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
} catch (BrokenBarrierException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
}
|
||||
threadPool.shutdown();
|
||||
}
|
||||
|
||||
public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {
|
||||
System.out.println("threadnum:" + threadnum + "is ready");
|
||||
cyclicBarrier.await();
|
||||
System.out.println("threadnum:" + threadnum + "is finish");
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
运行结果，如下：
|
||||
|
||||
```
|
||||
threadnum:0is ready
|
||||
threadnum:1is ready
|
||||
threadnum:2is ready
|
||||
threadnum:3is ready
|
||||
threadnum:4is ready
|
||||
------当线程数达到之后，优先执行------
|
||||
threadnum:4is finish
|
||||
threadnum:0is finish
|
||||
threadnum:2is finish
|
||||
threadnum:1is finish
|
||||
threadnum:3is finish
|
||||
threadnum:5is ready
|
||||
threadnum:6is ready
|
||||
threadnum:7is ready
|
||||
threadnum:8is ready
|
||||
threadnum:9is ready
|
||||
------当线程数达到之后，优先执行------
|
||||
threadnum:9is finish
|
||||
threadnum:5is finish
|
||||
threadnum:6is finish
|
||||
threadnum:8is finish
|
||||
threadnum:7is finish
|
||||
......
|
||||
```
|
||||
#### 5.3 CyclicBarrier和CountDownLatch的区别
|
||||
|
||||
CountDownLatch是计数器，只能使用一次，而CyclicBarrier的计数器提供reset功能，可以多次使用。但是我不那么认为它们之间的区别仅仅就是这么简单的一点。我们来从jdk作者设计的目的来看，javadoc是这么描述它们的：
|
||||
|
||||
> CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.(CountDownLatch: 一个或者多个线程，等待其他多个线程完成某件事情之后才能执行；)
|
||||
> CyclicBarrier : A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.(CyclicBarrier : 多个线程互相等待，直到到达同一个同步点，再继续一起执行。)
|
||||
|
||||
对于CountDownLatch来说，重点是“一个线程（多个线程）等待”，而其他的N个线程在完成“某件事情”之后，可以终止，也可以等待。而对于CyclicBarrier，重点是多个线程，在任意一个线程没有完成，所有的线程都必须等待。
|
||||
|
||||
CountDownLatch是计数器，线程完成一个记录一个，只不过计数不是递增而是递减，而CyclicBarrier更像是一个阀门，需要所有线程都到达，阀门才能打开，然后继续执行。
|
||||
|
||||
|
||||
|
||||
CyclicBarrier和CountDownLatch的区别这部分内容参考了如下两篇文章：
|
||||
|
||||
- https://blog.csdn.net/u010185262/article/details/54692886
|
||||
- https://blog.csdn.net/tolcf/article/details/50925145?utm_source=blogxgwz0
|
||||
|
||||
### 6 ReentrantLock 和 ReentrantReadWriteLock
|
||||
|
||||
ReentrantLock 和 synchronized 的区别在上面已经讲过了这里就不多做讲解。另外，需要注意的是：读写锁 ReentrantReadWriteLock 可以保证多个线程可以同时读，所以在读操作远大于写操作的时候，读写锁就非常有用了。
|
||||
|
||||
由于篇幅问题，关于 ReentrantLock 和 ReentrantReadWriteLock 详细内容可以查看我的这篇原创文章。
|
||||
|
||||
- [ReentrantLock 和 ReentrantReadWriteLock](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247483745&idx=2&sn=6778ee954a19816310df54ef9a3c2f8a&chksm=fd985700caefde16b9970f5e093b0c140d3121fb3a8458b11871e5e9723c5fd1b5a961fd2228&token=1829606453&lang=zh_CN#rd)
|
||||
@ -1,337 +0,0 @@
|
||||
> 个人觉得这一节掌握基本的使用即可！
|
||||
|
||||
**本节思维导图:**
|
||||
|
||||
|
||||
|
||||
### 1 Atomic 原子类介绍
|
||||
|
||||
Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里 Atomic 是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。
|
||||
|
||||
所以，所谓原子类说简单点就是具有原子/原子操作特征的类。
|
||||
|
||||
并发包 `java.util.concurrent` 的原子类都存放在`java.util.concurrent.atomic`下,如下图所示。
|
||||
|
||||
|
||||
|
||||
根据操作的数据类型，可以将JUC包中的原子类分为4类
|
||||
|
||||
**基本类型**
|
||||
|
||||
使用原子的方式更新基本类型
|
||||
|
||||
- AtomicInteger：整形原子类
|
||||
- AtomicLong：长整型原子类
|
||||
- AtomicBoolean ：布尔型原子类
|
||||
|
||||
**数组类型**
|
||||
|
||||
使用原子的方式更新数组里的某个元素
|
||||
|
||||
|
||||
- AtomicIntegerArray：整形数组原子类
|
||||
- AtomicLongArray：长整形数组原子类
|
||||
- AtomicReferenceArray ：引用类型数组原子类
|
||||
|
||||
**引用类型**
|
||||
|
||||
- AtomicReference：引用类型原子类
|
||||
- AtomicStampedRerence：原子更新引用类型里的字段原子类
|
||||
- AtomicMarkableReference ：原子更新带有标记位的引用类型
|
||||
|
||||
**对象的属性修改类型**
|
||||
|
||||
- AtomicIntegerFieldUpdater:原子更新整形字段的更新器
|
||||
- AtomicLongFieldUpdater：原子更新长整形字段的更新器
|
||||
- AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。
|
||||
|
||||
下面我们来详细介绍一下这些原子类。
|
||||
|
||||
### 2 基本类型原子类
|
||||
|
||||
#### 2.1 基本类型原子类介绍
|
||||
|
||||
使用原子的方式更新基本类型
|
||||
|
||||
- AtomicInteger：整形原子类
|
||||
- AtomicLong：长整型原子类
|
||||
- AtomicBoolean ：布尔型原子类
|
||||
|
||||
上面三个类提供的方法几乎相同，所以我们这里以 AtomicInteger 为例子来介绍。
|
||||
|
||||
**AtomicInteger 类常用方法**
|
||||
|
||||
```java
|
||||
public final int get() //获取当前的值
|
||||
public final int getAndSet(int newValue)//获取当前的值，并设置新的值
|
||||
public final int getAndIncrement()//获取当前的值，并自增
|
||||
public final int getAndDecrement() //获取当前的值，并自减
|
||||
public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
|
||||
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
|
||||
public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。
|
||||
```
|
||||
|
||||
#### 2.2 AtomicInteger 常见方法使用
|
||||
|
||||
```java
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
public class AtomicIntegerTest {
|
||||
|
||||
public static void main(String[] args) {
|
||||
// TODO Auto-generated method stub
|
||||
int temvalue = 0;
|
||||
AtomicInteger i = new AtomicInteger(0);
|
||||
temvalue = i.getAndSet(3);
|
||||
System.out.println("temvalue:" + temvalue + "; i:" + i);//temvalue:0; i:3
|
||||
temvalue = i.getAndIncrement();
|
||||
System.out.println("temvalue:" + temvalue + "; i:" + i);//temvalue:3; i:4
|
||||
temvalue = i.getAndAdd(5);
|
||||
System.out.println("temvalue:" + temvalue + "; i:" + i);//temvalue:4; i:9
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
#### 2.3 基本数据类型原子类的优势
|
||||
|
||||
通过一个简单例子带大家看一下基本数据类型原子类的优势
|
||||
|
||||
**①多线程环境不使用原子类保证线程安全（基本数据类型）**
|
||||
|
||||
```java
|
||||
class Test {
|
||||
private volatile int count = 0;
|
||||
//若要线程安全执行执行count++，需要加锁
|
||||
public synchronized void increment() {
|
||||
count++;
|
||||
}
|
||||
|
||||
public int getCount() {
|
||||
return count;
|
||||
}
|
||||
}
|
||||
```
|
||||
**②多线程环境使用原子类保证线程安全（基本数据类型）**
|
||||
|
||||
```java
|
||||
class Test2 {
|
||||
private AtomicInteger count = new AtomicInteger();
|
||||
|
||||
public void increment() {
|
||||
count.incrementAndGet();
|
||||
}
|
||||
//使用AtomicInteger之后，不需要加锁，也可以实现线程安全。
|
||||
public int getCount() {
|
||||
return count.get();
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
#### 2.4 AtomicInteger 线程安全原理简单分析
|
||||
|
||||
AtomicInteger 类的部分源码：
|
||||
|
||||
```java
|
||||
// setup to use Unsafe.compareAndSwapInt for updates（更新操作时提供“比较并替换”的作用）
|
||||
private static final Unsafe unsafe = Unsafe.getUnsafe();
|
||||
private static final long valueOffset;
|
||||
|
||||
static {
|
||||
try {
|
||||
valueOffset = unsafe.objectFieldOffset
|
||||
(AtomicInteger.class.getDeclaredField("value"));
|
||||
} catch (Exception ex) { throw new Error(ex); }
|
||||
}
|
||||
|
||||
private volatile int value;
|
||||
```
|
||||
|
||||
AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。
|
||||
|
||||
CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址，返回值是 valueOffset。另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。
|
||||
|
||||
|
||||
### 3 数组类型原子类
|
||||
|
||||
#### 3.1 数组类型原子类介绍
|
||||
|
||||
使用原子的方式更新数组里的某个元素
|
||||
|
||||
|
||||
- AtomicIntegerArray：整形数组原子类
|
||||
- AtomicLongArray：长整形数组原子类
|
||||
- AtomicReferenceArray ：引用类型数组原子类
|
||||
|
||||
上面三个类提供的方法几乎相同，所以我们这里以 AtomicIntegerArray 为例子来介绍。
|
||||
|
||||
**AtomicIntegerArray 类常用方法**
|
||||
|
||||
```java
|
||||
public final int get(int i) //获取 index=i 位置元素的值
|
||||
public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValue
|
||||
public final int getAndIncrement(int i)//获取 index=i 位置元素的值，并让该位置的元素自增
|
||||
public final int getAndDecrement(int i) //获取 index=i 位置元素的值，并让该位置的元素自减
|
||||
public final int getAndAdd(int delta) //获取 index=i 位置元素的值，并加上预期的值
|
||||
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将 index=i 位置的元素值设置为输入值（update）
|
||||
public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。
|
||||
```
|
||||
#### 3.2 AtomicIntegerArray 常见方法使用
|
||||
|
||||
```java
|
||||
|
||||
import java.util.concurrent.atomic.AtomicIntegerArray;
|
||||
|
||||
public class AtomicIntegerArrayTest {
|
||||
|
||||
public static void main(String[] args) {
|
||||
// TODO Auto-generated method stub
|
||||
int temvalue = 0;
|
||||
int[] nums = { 1, 2, 3, 4, 5, 6 };
|
||||
AtomicIntegerArray i = new AtomicIntegerArray(nums);
|
||||
for (int j = 0; j < nums.length; j++) {
|
||||
System.out.println(i.get(j));
|
||||
}
|
||||
temvalue = i.getAndSet(0, 2);
|
||||
System.out.println("temvalue:" + temvalue + "; i:" + i);
|
||||
temvalue = i.getAndIncrement(0);
|
||||
System.out.println("temvalue:" + temvalue + "; i:" + i);
|
||||
temvalue = i.getAndAdd(0, 5);
|
||||
System.out.println("temvalue:" + temvalue + "; i:" + i);
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
### 4 引用类型原子类
|
||||
|
||||
#### 4.1 引用类型原子类介绍
|
||||
|
||||
基本类型原子类只能更新一个变量，如果需要原子更新多个变量，需要使用 引用类型原子类。
|
||||
|
||||
- AtomicReference：引用类型原子类
|
||||
- AtomicStampedRerence：原子更新引用类型里的字段原子类
|
||||
- AtomicMarkableReference ：原子更新带有标记位的引用类型
|
||||
|
||||
上面三个类提供的方法几乎相同，所以我们这里以 AtomicReference 为例子来介绍。
|
||||
|
||||
#### 4.2 AtomicReference 类使用示例
|
||||
|
||||
```java
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
|
||||
public class AtomicReferenceTest {
|
||||
|
||||
public static void main(String[] args) {
|
||||
AtomicReference<Person> ar = new AtomicReference<Person>();
|
||||
Person person = new Person("SnailClimb", 22);
|
||||
ar.set(person);
|
||||
Person updatePerson = new Person("Daisy", 20);
|
||||
ar.compareAndSet(person, updatePerson);
|
||||
|
||||
System.out.println(ar.get().getName());
|
||||
System.out.println(ar.get().getAge());
|
||||
}
|
||||
}
|
||||
|
||||
class Person {
|
||||
private String name;
|
||||
private int age;
|
||||
|
||||
public Person(String name, int age) {
|
||||
super();
|
||||
this.name = name;
|
||||
this.age = age;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public void setName(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
public int getAge() {
|
||||
return age;
|
||||
}
|
||||
|
||||
public void setAge(int age) {
|
||||
this.age = age;
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
上述代码首先创建了一个 Person 对象，然后把 Person 对象设置进 AtomicReference 对象中，然后调用 compareAndSet 方法，该方法就是通过通过 CAS 操作设置 ar。如果 ar 的值为 person 的话，则将其设置为 updatePerson。实现原理与 AtomicInteger 类中的 compareAndSet 方法相同。运行上面的代码后的输出结果如下：
|
||||
|
||||
```
|
||||
Daisy
|
||||
20
|
||||
```
|
||||
|
||||
|
||||
### 5 对象的属性修改类型原子类
|
||||
|
||||
#### 5.1 对象的属性修改类型原子类介绍
|
||||
|
||||
如果需要原子更新某个类里的某个字段时，需要用到对象的属性修改类型原子类。
|
||||
|
||||
- AtomicIntegerFieldUpdater:原子更新整形字段的更新器
|
||||
- AtomicLongFieldUpdater：原子更新长整形字段的更新器
|
||||
- AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。
|
||||
|
||||
要想原子地更新对象的属性需要两步。第一步，因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须使用静态方法 newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。第二步，更新的对象属性必须使用 public volatile 修饰符。
|
||||
|
||||
上面三个类提供的方法几乎相同，所以我们这里以 `AtomicIntegerFieldUpdater`为例子来介绍。
|
||||
|
||||
#### 5.2 AtomicIntegerFieldUpdater 类使用示例
|
||||
|
||||
```java
|
||||
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
|
||||
|
||||
public class AtomicIntegerFieldUpdaterTest {
|
||||
public static void main(String[] args) {
|
||||
AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");
|
||||
|
||||
User user = new User("Java", 22);
|
||||
System.out.println(a.getAndIncrement(user));// 22
|
||||
System.out.println(a.get(user));// 23
|
||||
}
|
||||
}
|
||||
|
||||
class User {
|
||||
private String name;
|
||||
public volatile int age;
|
||||
|
||||
public User(String name, int age) {
|
||||
super();
|
||||
this.name = name;
|
||||
this.age = age;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public void setName(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
public int getAge() {
|
||||
return age;
|
||||
}
|
||||
|
||||
public void setAge(int age) {
|
||||
this.age = age;
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
输出结果：
|
||||
|
||||
```
|
||||
22
|
||||
23
|
||||
```
|
||||
|
||||
@ -1,429 +0,0 @@
|
||||
|
||||
|
||||
|
||||
# 一 面试中关于 synchronized 关键字的 5 连击
|
||||
|
||||
### 1.1 说一说自己对于 synchronized 关键字的了解
|
||||
|
||||
synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。
|
||||
|
||||
另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的 Mutex Lock 来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，这也是为什么早期的 synchronized 效率低的原因。庆幸的是在 Java 6 之后 Java 官方对从 JVM 层面对synchronized 较大优化，所以现在的 synchronized 锁效率也优化得很不错了。JDK1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。
|
||||
|
||||
|
||||
### 1.2 说说自己是怎么使用 synchronized 关键字，在项目中用到了吗
|
||||
|
||||
**synchronized关键字最主要的三种使用方式：**
|
||||
|
||||
- **修饰实例方法，作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁**
|
||||
- **修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁** 。也就是给当前类加锁，会作用于类的所有对象实例，因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管new了多少个对象，只有一份，所以对该类的所有对象都加了锁）。所以如果一个线程A调用一个实例对象的非静态 synchronized 方法，而线程B需要调用这个实例对象所属类的静态 synchronized 方法，是允许的，不会发生互斥现象，**因为访问静态 synchronized 方法占用的锁是当前类的锁，而访问非静态 synchronized 方法占用的锁是当前实例对象锁**。
|
||||
- **修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。** 和 synchronized 方法一样，synchronized(this)代码块也是锁定当前对象的。synchronized 关键字加到 static 静态方法和 synchronized(class)代码块上都是是给 Class 类上锁。这里再提一下：synchronized关键字加到非 static 静态方法上是给对象实例上锁。另外需要注意的是：尽量不要使用 synchronized(String a) 因为JVM中，字符串常量池具有缓冲功能！
|
||||
|
||||
下面我已一个常见的面试题为例讲解一下 synchronized 关键字的具体使用。
|
||||
|
||||
面试中面试官经常会说：“单例模式了解吗？来给我手写一下！给我解释一下双重检验锁方式实现单例模式的原理呗！”
|
||||
|
||||
|
||||
|
||||
**双重校验锁实现对象单例（线程安全）**
|
||||
|
||||
```java
|
||||
public class Singleton {
|
||||
|
||||
private volatile static Singleton uniqueInstance;
|
||||
|
||||
private Singleton() {
|
||||
}
|
||||
|
||||
public static Singleton getUniqueInstance() {
|
||||
//先判断对象是否已经实例过，没有实例化过才进入加锁代码
|
||||
if (uniqueInstance == null) {
|
||||
//类对象加锁
|
||||
synchronized (Singleton.class) {
|
||||
if (uniqueInstance == null) {
|
||||
uniqueInstance = new Singleton();
|
||||
}
|
||||
}
|
||||
}
|
||||
return uniqueInstance;
|
||||
}
|
||||
}
|
||||
```
|
||||
另外，需要注意 uniqueInstance 采用 volatile 关键字修饰也是很有必要。
|
||||
|
||||
uniqueInstance 采用 volatile 关键字修饰也是很有必要的， uniqueInstance = new Singleton(); 这段代码其实是分为三步执行：
|
||||
|
||||
1. 为 uniqueInstance 分配内存空间
|
||||
2. 初始化 uniqueInstance
|
||||
3. 将 uniqueInstance 指向分配的内存地址
|
||||
|
||||
但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出先问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
|
||||
|
||||
使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。
|
||||
|
||||
### 1.3 讲一下 synchronized 关键字的底层原理
|
||||
|
||||
**synchronized 关键字底层原理属于 JVM 层面。**
|
||||
|
||||
**① synchronized 同步语句块的情况**
|
||||
|
||||
```java
|
||||
public class SynchronizedDemo {
|
||||
public void method() {
|
||||
synchronized (this) {
|
||||
System.out.println("synchronized 代码块");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
通过 JDK 自带的 javap 命令查看 SynchronizedDemo 类的相关字节码信息：首先切换到类的对应目录执行 `javac SynchronizedDemo.java` 命令生成编译后的 .class 文件，然后执行`javap -c -s -v -l SynchronizedDemo.class`。
|
||||
|
||||
|
||||
|
||||
从上面我们可以看出：
|
||||
|
||||
**synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。** 当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权.当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。
|
||||
|
||||
**② synchronized 修饰方法的的情况**
|
||||
|
||||
```java
|
||||
public class SynchronizedDemo2 {
|
||||
public synchronized void method() {
|
||||
System.out.println("synchronized 方法");
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
|
||||
|
||||
synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取得代之的确实是 ACC_SYNCHRONIZED 标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。
|
||||
|
||||
|
||||
### 1.4 说说 JDK1.6 之后的synchronized 关键字底层做了哪些优化，可以详细介绍一下这些优化吗
|
||||
|
||||
JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。
|
||||
|
||||
锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。
|
||||
|
||||
关于这几种优化的详细信息可以查看：[synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及 和ReenTrantLock 的对比](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484539&idx=1&sn=3500cdcd5188bdc253fb19a1bfa805e6&chksm=fd98521acaefdb0c5167247a1fa903a1a53bb4e050b558da574f894f9feda5378ec9d0fa1ac7&token=1604028915&lang=zh_CN#rd)
|
||||
|
||||
### 1.5 谈谈 synchronized和ReenTrantLock 的区别
|
||||
|
||||
|
||||
**① 两者都是可重入锁**
|
||||
|
||||
两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。
|
||||
|
||||
**② synchronized 依赖于 JVM 而 ReenTrantLock 依赖于 API**
|
||||
|
||||
synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReenTrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。
|
||||
|
||||
**③ ReenTrantLock 比 synchronized 增加了一些高级功能**
|
||||
|
||||
相比synchronized，ReenTrantLock增加了一些高级功能。主要来说主要有三点：**①等待可中断；②可实现公平锁；③可实现选择性通知（锁可以绑定多个条件）**
|
||||
|
||||
- **ReenTrantLock提供了一种能够中断等待锁的线程的机制**，通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。
|
||||
- **ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。** ReenTrantLock默认情况是非公平的，可以通过 ReenTrantLock类的`ReentrantLock(boolean fair)`构造方法来制定是否是公平的。
|
||||
- synchronized关键字与wait()和notify/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition() 方法。Condition是JDK1.5之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），**线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。 在使用notify/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，用ReentrantLock类结合Condition实例可以实现“选择性通知”** ，这个功能非常重要，而且是Condition接口默认提供的。而synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法 只会唤醒注册在该Condition实例中的所有等待线程。
|
||||
|
||||
如果你想使用上述功能，那么选择ReenTrantLock是一个不错的选择。
|
||||
|
||||
**④ 性能已不是选择标准**
|
||||
|
||||
# 二 面试中关于线程池的 4 连击
|
||||
|
||||
### 2.1 讲一下Java内存模型
|
||||
|
||||
|
||||
在 JDK1.2 之前，Java的内存模型实现总是从<font color="red">**主存**（即共享内存）读取变量</font>，是不需要进行特别的注意的。而在当前的 Java 内存模型下，线程可以把变量保存<font color="red">**本地内存**</font>（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成<font color="red">**数据的不一致**</font>。
|
||||
|
||||
|
||||
|
||||
要解决这个问题，就需要把变量声明为<font color="red"> **volatile**</font>，这就指示 JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。
|
||||
|
||||
说白了，<font color="red"> **volatile**</font> 关键字的主要作用就是保证变量的可见性然后还有一个作用是防止指令重排序。
|
||||
|
||||
|
||||
|
||||
|
||||
### 2.2 说说 synchronized 关键字和 volatile 关键字的区别
|
||||
|
||||
synchronized关键字和volatile关键字比较
|
||||
|
||||
- **volatile关键字**是线程同步的**轻量级实现**，所以**volatile性能肯定比synchronized关键字要好**。但是**volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块**。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，**实际开发中使用 synchronized 关键字的场景还是更多一些**。
|
||||
- **多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞**
|
||||
- **volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。**
|
||||
- **volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。**
|
||||
|
||||
|
||||
# 三 面试中关于 线程池的 2 连击
|
||||
|
||||
|
||||
### 3.1 为什么要用线程池？
|
||||
|
||||
线程池提供了一种限制和管理资源（包括执行一个任务）。 每个线程池还维护一些基本统计信息，例如已完成任务的数量。
|
||||
|
||||
这里借用《Java并发编程的艺术》提到的来说一下使用线程池的好处：
|
||||
|
||||
- **降低资源消耗。** 通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
|
||||
- **提高响应速度。** 当任务到达时，任务可以不需要的等到线程创建就能立即执行。
|
||||
- **提高线程的可管理性。** 线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
|
||||
|
||||
|
||||
### 3.2 实现Runnable接口和Callable接口的区别
|
||||
|
||||
如果想让线程池执行任务的话需要实现的Runnable接口或Callable接口。 Runnable接口或Callable接口实现类都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。两者的区别在于 Runnable 接口不会返回结果但是 Callable 接口可以返回结果。
|
||||
|
||||
**备注：** 工具类`Executors`可以实现`Runnable`对象和`Callable`对象之间的相互转换。（`Executors.callable（Runnable task）`或`Executors.callable（Runnable task，Object resule）`）。
|
||||
|
||||
### 3.3 执行execute()方法和submit()方法的区别是什么呢？
|
||||
|
||||
1)**`execute()` 方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；**
|
||||
|
||||
2)**submit()方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个future对象可以判断任务是否执行成功**，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用 `get（long timeout，TimeUnit unit）`方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。
|
||||
|
||||
|
||||
### 3.4 如何创建线程池
|
||||
|
||||
《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险
|
||||
|
||||
> Executors 返回线程池对象的弊端如下：
|
||||
>
|
||||
> - **FixedThreadPool 和 SingleThreadExecutor** ： 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致OOM。
|
||||
> - **CachedThreadPool 和 ScheduledThreadPool** ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致OOM。
|
||||
|
||||
**方式一：通过构造方法实现**
|
||||
|
||||
**方式二：通过Executor 框架的工具类Executors来实现**
|
||||
我们可以创建三种类型的ThreadPoolExecutor：
|
||||
|
||||
- **FixedThreadPool** ： 该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。
|
||||
- **SingleThreadExecutor：** 方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。
|
||||
- **CachedThreadPool：** 该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。
|
||||
|
||||
对应Executors工具类中的方法如图所示：
|
||||
|
||||
|
||||
|
||||
# 四 面试中关于 Atomic 原子类的 4 连击
|
||||
|
||||
### 4.1 介绍一下Atomic 原子类
|
||||
|
||||
Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里 Atomic 是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。
|
||||
|
||||
所以，所谓原子类说简单点就是具有原子/原子操作特征的类。
|
||||
|
||||
|
||||
并发包 `java.util.concurrent` 的原子类都存放在`java.util.concurrent.atomic`下,如下图所示。
|
||||
|
||||
|
||||
|
||||
### 4.2 JUC 包中的原子类是哪4类?
|
||||
|
||||
**基本类型**
|
||||
|
||||
使用原子的方式更新基本类型
|
||||
|
||||
- AtomicInteger：整形原子类
|
||||
- AtomicLong：长整型原子类
|
||||
- AtomicBoolean ：布尔型原子类
|
||||
|
||||
**数组类型**
|
||||
|
||||
使用原子的方式更新数组里的某个元素
|
||||
|
||||
|
||||
- AtomicIntegerArray：整形数组原子类
|
||||
- AtomicLongArray：长整形数组原子类
|
||||
- AtomicReferenceArray ：引用类型数组原子类
|
||||
|
||||
**引用类型**
|
||||
|
||||
- AtomicReference：引用类型原子类
|
||||
- AtomicStampedRerence：原子更新引用类型里的字段原子类
|
||||
- AtomicMarkableReference ：原子更新带有标记位的引用类型
|
||||
|
||||
**对象的属性修改类型**
|
||||
|
||||
- AtomicIntegerFieldUpdater:原子更新整形字段的更新器
|
||||
- AtomicLongFieldUpdater：原子更新长整形字段的更新器
|
||||
- AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。
|
||||
|
||||
|
||||
### 4.3 讲讲 AtomicInteger 的使用
|
||||
|
||||
**AtomicInteger 类常用方法**
|
||||
|
||||
```java
|
||||
public final int get() //获取当前的值
|
||||
public final int getAndSet(int newValue)//获取当前的值，并设置新的值
|
||||
public final int getAndIncrement()//获取当前的值，并自增
|
||||
public final int getAndDecrement() //获取当前的值，并自减
|
||||
public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
|
||||
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
|
||||
public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。
|
||||
```
|
||||
|
||||
**AtomicInteger 类的使用示例**
|
||||
|
||||
使用 AtomicInteger 之后，不用对 increment() 方法加锁也可以保证线程安全。
|
||||
```java
|
||||
class AtomicIntegerTest {
|
||||
private AtomicInteger count = new AtomicInteger();
|
||||
//使用AtomicInteger之后，不需要对该方法加锁，也可以实现线程安全。
|
||||
public void increment() {
|
||||
count.incrementAndGet();
|
||||
}
|
||||
|
||||
public int getCount() {
|
||||
return count.get();
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
### 4.4 能不能给我简单介绍一下 AtomicInteger 类的原理
|
||||
|
||||
AtomicInteger 线程安全原理简单分析
|
||||
|
||||
AtomicInteger 类的部分源码：
|
||||
|
||||
```java
|
||||
// setup to use Unsafe.compareAndSwapInt for updates（更新操作时提供“比较并替换”的作用）
|
||||
private static final Unsafe unsafe = Unsafe.getUnsafe();
|
||||
private static final long valueOffset;
|
||||
|
||||
static {
|
||||
try {
|
||||
valueOffset = unsafe.objectFieldOffset
|
||||
(AtomicInteger.class.getDeclaredField("value"));
|
||||
} catch (Exception ex) { throw new Error(ex); }
|
||||
}
|
||||
|
||||
private volatile int value;
|
||||
```
|
||||
|
||||
AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。
|
||||
|
||||
CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址，返回值是 valueOffset。另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。
|
||||
|
||||
关于 Atomic 原子类这部分更多内容可以查看我的这篇文章：并发编程面试必备：[JUC 中的 Atomic 原子类总结](https://mp.weixin.qq.com/s/joa-yOiTrYF67bElj8xqvg)
|
||||
|
||||
# 五 AQS
|
||||
|
||||
### 5.1 AQS 介绍
|
||||
|
||||
AQS的全称为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包下面。
|
||||
|
||||
|
||||
|
||||
AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的ReentrantLock，Semaphore，其他的诸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基于AQS的。当然，我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的同步器。
|
||||
|
||||
### 5.2 AQS 原理分析
|
||||
|
||||
AQS 原理这部分参考了部分博客，在5.2节末尾放了链接。
|
||||
|
||||
> 在面试中被问到并发知识的时候，大多都会被问到“请你说一下自己对于AQS原理的理解”。下面给大家一个示例供大家参加，面试不是背题，大家一定要假如自己的思想，即使加入不了自己的思想也要保证自己能够通俗的讲出来而不是背出来。
|
||||
|
||||
下面大部分内容其实在AQS类注释上已经给出了，不过是英语看着比较吃力一点，感兴趣的话可以看看源码。
|
||||
|
||||
#### 5.2.1 AQS 原理概览
|
||||
|
||||
|
||||
|
||||
**AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。**
|
||||
|
||||
> CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS是将每条请求共享资源的线程封装成一个CLH锁队列的一个结点（Node）来实现锁的分配。
|
||||
|
||||
看个AQS(AbstractQueuedSynchronizer)原理图：
|
||||
|
||||
|
||||
|
||||
|
||||
AQS使用一个int成员变量来表示同步状态，通过内置的FIFO队列来完成获取资源线程的排队工作。AQS使用CAS对该同步状态进行原子操作实现对其值的修改。
|
||||
|
||||
```java
|
||||
private volatile int state;//共享变量，使用volatile修饰保证线程可见性
|
||||
```
|
||||
|
||||
状态信息通过procted类型的getState，setState，compareAndSetState进行操作
|
||||
|
||||
```java
|
||||
|
||||
//返回同步状态的当前值
|
||||
protected final int getState() {
|
||||
return state;
|
||||
}
|
||||
// 设置同步状态的值
|
||||
protected final void setState(int newState) {
|
||||
state = newState;
|
||||
}
|
||||
//原子地（CAS操作）将同步状态值设置为给定值update如果当前同步状态的值等于expect（期望值）
|
||||
protected final boolean compareAndSetState(int expect, int update) {
|
||||
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
|
||||
}
|
||||
```
|
||||
|
||||
#### 5.2.2 AQS 对资源的共享方式
|
||||
|
||||
**AQS定义两种资源共享方式**
|
||||
|
||||
- **Exclusive**（独占）：只有一个线程能执行，如ReentrantLock。又可分为公平锁和非公平锁：
|
||||
- 公平锁：按照线程在队列中的排队顺序，先到者先拿到锁
|
||||
- 非公平锁：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的
|
||||
- **Share**（共享）：多个线程可同时执行，如Semaphore/CountDownLatch。Semaphore、CountDownLatCh、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。
|
||||
|
||||
ReentrantReadWriteLock 可以看成是组合式，因为ReentrantReadWriteLock也就是读写锁允许多个线程同时对某一资源进行读。
|
||||
|
||||
不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。
|
||||
|
||||
#### 5.2.3 AQS底层使用了模板方法模式
|
||||
|
||||
同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）：
|
||||
|
||||
1. 使用者继承AbstractQueuedSynchronizer并重写指定的方法。（这些重写方法很简单，无非是对于共享资源state的获取和释放）
|
||||
2. 将AQS组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。
|
||||
|
||||
这和我们以往通过实现接口的方式有很大区别，这是模板方法模式很经典的一个运用。
|
||||
|
||||
**AQS使用了模板方法模式，自定义同步器时需要重写下面几个AQS提供的模板方法：**
|
||||
|
||||
```java
|
||||
isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。
|
||||
tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。
|
||||
tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。
|
||||
tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
|
||||
tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。
|
||||
|
||||
```
|
||||
|
||||
默认情况下，每个方法都抛出 `UnsupportedOperationException`。 这些方法的实现必须是内部线程安全的，并且通常应该简短而不是阻塞。AQS类中的其他方法都是final ，所以无法被其他类使用，只有这几个方法可以被其他类使用。
|
||||
|
||||
以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。
|
||||
|
||||
再以CountDownLatch以例，任务分为N个子线程去执行，state也初始化为N（注意N要与线程个数一致）。这N个子线程是并行执行的，每个子线程执行完后countDown()一次，state会CAS(Compare and Swap)减1。等到所有子线程都执行完后(即state=0)，会unpark()主调用线程，然后主调用线程就会从await()函数返回，继续后余动作。
|
||||
|
||||
一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现`tryAcquire-tryRelease`、`tryAcquireShared-tryReleaseShared`中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如`ReentrantReadWriteLock`。
|
||||
|
||||
推荐两篇 AQS 原理和相关源码分析的文章：
|
||||
|
||||
- http://www.cnblogs.com/waterystone/p/4920797.html
|
||||
- https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html
|
||||
|
||||
### 5.3 AQS 组件总结
|
||||
|
||||
- **Semaphore(信号量)-允许多个线程同时访问：** synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。
|
||||
- **CountDownLatch （倒计时器）：** CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。
|
||||
- **CyclicBarrier(循环栅栏)：** CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是 CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。
|
||||
|
||||
关于AQS这部分的更多内容可以查看我的这篇文章:[并发编程面试必备：AQS 原理以及 AQS 同步组件总结](https://mp.weixin.qq.com/s/joa-yOiTrYF67bElj8xqvg)
|
||||
|
||||
# Reference
|
||||
|
||||
- 《深入理解 Java 虚拟机》
|
||||
- 《实战 Java 高并发程序设计》
|
||||
- 《Java并发编程的艺术》
|
||||
- http://www.cnblogs.com/waterystone/p/4920797.html
|
||||
- https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html
|
||||
@ -1,84 +0,0 @@
|
||||
## final 关键字
|
||||
|
||||
**final关键字主要用在三个地方：变量、方法、类。**
|
||||
|
||||
1. **对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。**
|
||||
|
||||
2. **当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。**
|
||||
|
||||
3. 使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。
|
||||
|
||||
## static 关键字
|
||||
|
||||
**static 关键字主要有以下四种使用场景：**
|
||||
|
||||
1. **修饰成员变量和成员方法:** 被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static 声明的成员变量属于静态成员变量，静态变量 存放在 Java 内存区域的方法区。调用格式：`类名.静态变量名` `类名.静态方法名()`
|
||||
2. **静态代码块:** 静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。 该类不管创建多少对象，静态代码块只执行一次.
|
||||
3. **静态内部类（static修饰类的话只能修饰内部类）：** 静态内部类与非静态内部类之间存在一个最大的区别: 非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，但是静态内部类却没有。没有这个引用就意味着：1. 它的创建是不需要依赖外围类的创建。2. 它不能使用任何外围类的非static成员变量和方法。
|
||||
4. **静态导包(用来导入类中的静态资源，1.5之后的新特性):** 格式为：`import static` 这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名调用类中静态成员，可以直接使用类中静态成员变量和成员方法。
|
||||
|
||||
## this 关键字
|
||||
|
||||
this关键字用于引用类的当前实例。 例如：
|
||||
|
||||
```java
|
||||
class Manager {
|
||||
Employees[] employees;
|
||||
|
||||
void manageEmployees() {
|
||||
int totalEmp = this.employees.length;
|
||||
System.out.println("Total employees: " + totalEmp);
|
||||
this.report();
|
||||
}
|
||||
|
||||
void report() { }
|
||||
}
|
||||
```
|
||||
|
||||
在上面的示例中，this关键字用于两个地方：
|
||||
|
||||
- this.employees.length：访问类Manager的当前实例的变量。
|
||||
- this.report（）：调用类Manager的当前实例的方法。
|
||||
|
||||
此关键字是可选的，这意味着如果上面的示例在不使用此关键字的情况下表现相同。 但是，使用此关键字可能会使代码更易读或易懂。
|
||||
|
||||
|
||||
|
||||
## super 关键字
|
||||
|
||||
super关键字用于从子类访问父类的变量和方法。 例如：
|
||||
|
||||
```java
|
||||
public class Super {
|
||||
protected int number;
|
||||
|
||||
protected showNumber() {
|
||||
System.out.println("number = " + number);
|
||||
}
|
||||
}
|
||||
|
||||
public class Sub extends Super {
|
||||
void bar() {
|
||||
super.number = 10;
|
||||
super.showNumber();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
在上面的例子中，Sub 类访问父类成员变量 number 并调用其其父类 Super 的 `showNumber（）` 方法。
|
||||
|
||||
**使用 this 和 super 要注意的问题：**
|
||||
|
||||
- super 调用父类中的其他构造方法时，调用时要放在构造方法的首行！this 调用本类中的其他构造方法时，也要放在首行。
|
||||
- this、super不能用在static方法中。
|
||||
|
||||
**简单解释一下：**
|
||||
|
||||
被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享。而 this 代表对本类对象的引用，指向本类对象；而 super 代表对父类对象的引用，指向父类对象；所以， **this和super是属于对象范畴的东西，而静态方法是属于类范畴的东西**。
|
||||
|
||||
|
||||
|
||||
## 参考
|
||||
|
||||
- https://www.codejava.net/java-core/the-java-language/java-keywords
|
||||
- https://blog.csdn.net/u013393958/article/details/79881037
|
||||
@ -1,341 +0,0 @@
|
||||
|
||||
|
||||
## 写在前面（常见面试题）
|
||||
|
||||
### 基本问题：
|
||||
|
||||
- **介绍下 Java 内存区域（运行时数据区）**
|
||||
- **Java 对象的创建过程（五步，建议能默写出来并且要知道每一步虚拟机做了什么）**
|
||||
- **对象的访问定位的两种方式（句柄和直接指针两种方式）**
|
||||
|
||||
### 拓展问题:
|
||||
|
||||
- **String类和常量池**
|
||||
- **8种基本类型的包装类和常量池**
|
||||
|
||||
|
||||
## 1 概述
|
||||
|
||||
对于 Java 程序员来说，在虚拟机自动内存管理机制下，不再需要像C/C++程序开发程序员这样为内一个 new 操作去写对应的 delete/free 操作，不容易出现内存泄漏和内存溢出问题。正是因为 Java 程序员把内存控制权利交给 Java 虚拟机，一旦出现内存泄漏和溢出方面的问题，如果不了解虚拟机是怎样使用内存的，那么排查错误将会是一个非常艰巨的任务。
|
||||
|
||||
|
||||
## 2 运行时数据区域
|
||||
Java 虚拟机在执行 Java 程序的过程中会把它管理的内存划分成若干个不同的数据区域。
|
||||
|
||||
这些组成部分一些是线程私有的，其他的则是线程共享的。
|
||||
|
||||
**线程私有的：**
|
||||
|
||||
- 程序计数器
|
||||
- 虚拟机栈
|
||||
- 本地方法栈
|
||||
|
||||
**线程共享的：**
|
||||
|
||||
- 堆
|
||||
- 方法区
|
||||
- 直接内存
|
||||
|
||||
|
||||
### 2.1 程序计数器
|
||||
程序计数器是一块较小的内存空间，可以看作是当前线程所执行的字节码的行号指示器。**字节码解释器工作时通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等功能都需要依赖这个计数器来完。**
|
||||
|
||||
另外，**为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各线程之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。**
|
||||
|
||||
**从上面的介绍中我们知道程序计数器主要有两个作用：**
|
||||
|
||||
1. 字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制，如：顺序执行、选择、循环、异常处理。
|
||||
2. 在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。
|
||||
|
||||
**注意：程序计数器是唯一一个不会出现OutOfMemoryError的内存区域，它的生命周期随着线程的创建而创建，随着线程的结束而死亡。**
|
||||
|
||||
### 2.2 Java 虚拟机栈
|
||||
|
||||
**与程序计数器一样，Java虚拟机栈也是线程私有的，它的生命周期和线程相同，描述的是 Java 方法执行的内存模型。**
|
||||
|
||||
**Java 内存可以粗糙的区分为堆内存（Heap）和栈内存(Stack),其中栈就是现在说的虚拟机栈，或者说是虚拟机栈中局部变量表部分。** （实际上，Java虚拟机栈是由一个个栈帧组成，而每个栈帧中都拥有：局部变量表、操作数栈、动态链接、方法出口信息。）
|
||||
|
||||
**局部变量表主要存放了编译器可知的各种数据类型**（boolean、byte、char、short、int、float、long、double）、**对象引用**（reference类型，它不同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或其他与此对象相关的位置）。
|
||||
|
||||
**Java 虚拟机栈会出现两种异常：StackOverFlowError 和 OutOfMemoryError。**
|
||||
|
||||
- **StackOverFlowError：** 若Java虚拟机栈的内存大小不允许动态扩展，那么当线程请求栈的深度超过当前Java虚拟机栈的最大深度的时候，就抛出StackOverFlowError异常。
|
||||
- **OutOfMemoryError：** 若 Java 虚拟机栈的内存大小允许动态扩展，且当线程请求栈时内存用完了，无法再动态扩展了，此时抛出OutOfMemoryError异常。
|
||||
|
||||
Java 虚拟机栈也是线程私有的，每个线程都有各自的Java虚拟机栈，而且随着线程的创建而创建，随着线程的死亡而死亡。
|
||||
|
||||
### 2.3 本地方法栈
|
||||
|
||||
和虚拟机栈所发挥的作用非常相似，区别是： **虚拟机栈为虚拟机执行 Java 方法 （也就是字节码）服务，而本地方法栈则为虚拟机使用到的 Native 方法服务。** 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。
|
||||
|
||||
本地方法被执行的时候，在本地方法栈也会创建一个栈帧，用于存放该本地方法的局部变量表、操作数栈、动态链接、出口信息。
|
||||
|
||||
方法执行完毕后相应的栈帧也会出栈并释放内存空间，也会出现 StackOverFlowError 和 OutOfMemoryError 两种异常。
|
||||
|
||||
### 2.4 堆
|
||||
Java 虚拟机所管理的内存中最大的一块，Java 堆是所有线程共享的一块内存区域，在虚拟机启动时创建。**此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例以及数组都在这里分配内存。**
|
||||
|
||||
Java 堆是垃圾收集器管理的主要区域，因此也被称作**GC堆（Garbage Collected Heap）**.从垃圾回收的角度，由于现在收集器基本都采用分代垃圾收集算法，所以Java堆还可以细分为：新生代和老年代：再细致一点有：Eden空间、From Survivor、To Survivor空间等。**进一步划分的目的是更好地回收内存，或者更快地分配内存。**
|
||||
|
||||
|
||||
|
||||
**在 JDK 1.8中移除整个永久代，取而代之的是一个叫元空间（Metaspace）的区域（永久代使用的是JVM的堆内存空间，而元空间使用的是物理内存，直接受到本机的物理内存限制）。**
|
||||
|
||||
推荐阅读：
|
||||
|
||||
- 《Java8内存模型—永久代(PermGen)和元空间(Metaspace)》：[http://www.cnblogs.com/paddix/p/5309550.html](http://www.cnblogs.com/paddix/p/5309550.html)
|
||||
|
||||
### 2.5 方法区
|
||||
|
||||
**方法区与 Java 堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做 Non-Heap（非堆），目的应该是与 Java 堆区分开来。**
|
||||
|
||||
HotSpot 虚拟机中方法区也常被称为 **“永久代”**，本质上两者并不等价。仅仅是因为 HotSpot 虚拟机设计团队用永久代来实现方法区而已，这样 HotSpot 虚拟机的垃圾收集器就可以像管理 Java 堆一样管理这部分内存了。但是这并不是一个好主意，因为这样更容易遇到内存溢出问题。
|
||||
|
||||
|
||||
|
||||
**相对而言，垃圾收集行为在这个区域是比较少出现的，但并非数据进入方法区后就“永久存在”了。**
|
||||
|
||||
### 2.6 运行时常量池
|
||||
|
||||
运行时常量池是方法区的一部分。Class 文件中除了有类的版本、字段、方法、接口等描述信息外，还有常量池信息（用于存放编译期生成的各种字面量和符号引用）
|
||||
|
||||
既然运行时常量池时方法区的一部分，自然受到方法区内存的限制，当常量池无法再申请到内存时会抛出 OutOfMemoryError 异常。
|
||||
|
||||
**JDK1.7及之后版本的 JVM 已经将运行时常量池从方法区中移了出来，在 Java 堆（Heap）中开辟了一块区域存放运行时常量池。**
|
||||
|
||||
|
||||
——图片来源：https://blog.csdn.net/wangbiao007/article/details/78545189
|
||||
|
||||
|
||||
|
||||
推荐阅读：
|
||||
|
||||
- 《Java 中几种常量池的区分》： [https://blog.csdn.net/qq_26222859/article/details/73135660](https://blog.csdn.net/qq_26222859/article/details/73135660)
|
||||
|
||||
|
||||
### 2.7 直接内存
|
||||
|
||||
直接内存并不是虚拟机运行时数据区的一部分，也不是虚拟机规范中定义的内存区域，但是这部分内存也被频繁地使用。而且也可能导致OutOfMemoryError异常出现。
|
||||
|
||||
JDK1.4中新加入的 **NIO(New Input/Output) 类**，引入了一种基于**通道（Channel）** 与**缓存区（Buffer）** 的 I/O 方式，它可以直接使用Native函数库直接分配堆外内存，然后通过一个存储在 Java 堆中的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样就能在一些场景中显著提高性能，因为**避免了在 Java 堆和 Native 堆之间来回复制数据**。
|
||||
|
||||
本机直接内存的分配不会收到 Java 堆的限制，但是，既然是内存就会受到本机总内存大小以及处理器寻址空间的限制。
|
||||
|
||||
|
||||
## 3 HotSpot 虚拟机对象探秘
|
||||
通过上面的介绍我们大概知道了虚拟机的内存情况，下面我们来详细的了解一下 HotSpot 虚拟机在 Java 堆中对象分配、布局和访问的全过程。
|
||||
|
||||
### 3.1 对象的创建
|
||||
下图便是 Java 对象的创建过程，我建议最好是能默写出来，并且要掌握每一步在做什么。
|
||||
|
||||
|
||||
**①类加载检查：** 虚拟机遇到一条 new 指令时，首先将去检查这个指令的参数是否能在常量池中定位到这个类的符号引用，并且检查这个符号引用代表的类是否已被加载过、解析和初始化过。如果没有，那必须先执行相应的类加载过程。
|
||||
|
||||
**②分配内存：** 在**类加载检查**通过后，接下来虚拟机将为新生对象**分配内存**。对象所需的内存大小在类加载完成后便可确定，为对象分配空间的任务等同于把一块确定大小的内存从 Java 堆中划分出来。**分配方式**有 **“指针碰撞”** 和 **“空闲列表”** 两种，**选择那种分配方式由 Java 堆是否规整决定，而Java堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定**。
|
||||
|
||||
|
||||
**内存分配的两种方式：（补充内容，需要掌握）**
|
||||
|
||||
选择以上两种方式中的哪一种，取决于 Java 堆内存是否规整。而 Java 堆内存是否规整，取决于 GC 收集器的算法是"标记-清除"，还是"标记-整理"（也称作"标记-压缩"），值得注意的是，复制算法内存也是规整的
|
||||
|
||||
|
||||
|
||||
**内存分配并发问题（补充内容，需要掌握）**
|
||||
|
||||
在创建对象的时候有一个很重要的问题，就是线程安全，因为在实际开发过程中，创建对象是很频繁的事情，作为虚拟机来说，必须要保证线程是安全的，通常来讲，虚拟机采用两种方式来保证线程安全：
|
||||
|
||||
- **CAS+失败重试：** CAS 是乐观锁的一种实现方式。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。**虚拟机采用 CAS 配上失败重试的方式保证更新操作的原子性。**
|
||||
- **TLAB：** 为每一个线程预先在Eden区分配一块儿内存，JVM在给线程中的对象分配内存时，首先在TLAB分配，当对象大于TLAB中的剩余内存或TLAB的内存已用尽时，再采用上述的CAS进行内存分配
|
||||
|
||||
|
||||
|
||||
**③初始化零值：** 内存分配完成后，虚拟机需要将分配到的内存空间都初始化为零值（不包括对象头），这一步操作保证了对象的实例字段在 Java 代码中可以不赋初始值就直接使用，程序能访问到这些字段的数据类型所对应的零值。
|
||||
|
||||
**④设置对象头：** 初始化零值完成之后，**虚拟机要对对象进行必要的设置**，例如这个对象是那个类的实例、如何才能找到类的元数据信息、对象的哈希吗、对象的 GC 分代年龄等信息。 **这些信息存放在对象头中。** 另外，根据虚拟机当前运行状态的不同，如是否启用偏向锁等，对象头会有不同的设置方式。
|
||||
|
||||
|
||||
**⑤执行 init 方法：** 在上面工作都完成之后，从虚拟机的视角来看，一个新的对象已经产生了，但从 Java 程序的视角来看，对象创建才刚开始，`<init>` 方法还没有执行，所有的字段都还为零。所以一般来说，执行 new 指令之后会接着执行 `<init>` 方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算完全产生出来。
|
||||
|
||||
|
||||
### 3.2 对象的内存布局
|
||||
|
||||
在 Hotspot 虚拟机中，对象在内存中的布局可以分为3块区域：**对象头**、**实例数据**和**对齐填充**。
|
||||
|
||||
**Hotspot虚拟机的对象头包括两部分信息**，**第一部分用于存储对象自身的自身运行时数据**（哈希码、GC分代年龄、锁状态标志等等），**另一部分是类型指针**，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是那个类的实例。
|
||||
|
||||
**实例数据部分是对象真正存储的有效信息**，也是在程序中所定义的各种类型的字段内容。
|
||||
|
||||
**对齐填充部分不是必然存在的，也没有什么特别的含义，仅仅起占位作用。** 因为Hotspot虚拟机的自动内存管理系统要求对象起始地址必须是8字节的整数倍，换句话说就是对象的大小必须是8字节的整数倍。而对象头部分正好是8字节的倍数（1倍或2倍），因此，当对象实例数据部分没有对齐时，就需要通过对齐填充来补全。
|
||||
|
||||
### 3.3 对象的访问定位
|
||||
建立对象就是为了使用对象，我们的Java程序通过栈上的 reference 数据来操作堆上的具体对象。对象的访问方式有虚拟机实现而定，目前主流的访问方式有**①使用句柄**和**②直接指针**两种：
|
||||
|
||||
1. **句柄：** 如果使用句柄的话，那么Java堆中将会划分出一块内存来作为句柄池，reference 中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自的具体地址信息；
|
||||
|
||||
|
||||
2. **直接指针：** 如果使用直接指针访问，那么 Java 堆对象的布局中就必须考虑如何放置访问类型数据的相关信息，而reference 中存储的直接就是对象的地址。
|
||||
|
||||
|
||||
|
||||
**这两种对象访问方式各有优势。使用句柄来访问的最大好处是 reference 中存储的是稳定的句柄地址，在对象被移动时只会改变句柄中的实例数据指针，而 reference 本身不需要修改。使用直接指针访问方式最大的好处就是速度快，它节省了一次指针定位的时间开销。**
|
||||
|
||||
|
||||
|
||||
|
||||
## 四 重点补充内容
|
||||
|
||||
### String 类和常量池
|
||||
|
||||
**1 String 对象的两种创建方式：**
|
||||
|
||||
```java
|
||||
String str1 = "abcd";
|
||||
String str2 = new String("abcd");
|
||||
System.out.println(str1==str2);//false
|
||||
```
|
||||
|
||||
这两种不同的创建方法是有差别的，第一种方式是在常量池中拿对象，第二种方式是直接在堆内存空间创建一个新的对象。
|
||||
|
||||
记住：只要使用new方法，便需要创建新的对象。
|
||||
|
||||
|
||||
|
||||
**2 String 类型的常量池比较特殊。它的主要使用方法有两种：**
|
||||
|
||||
- 直接使用双引号声明出来的 String 对象会直接存储在常量池中。
|
||||
- 如果不是用双引号声明的 String 对象，可以使用 String 提供的 intern 方法。String.intern() 是一个 Native 方法，它的作用是：如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量池中该字符串的引用；如果没有，则在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字符串的引用。
|
||||
|
||||
```java
|
||||
String s1 = new String("计算机");
|
||||
String s2 = s1.intern();
|
||||
String s3 = "计算机";
|
||||
System.out.println(s2);//计算机
|
||||
System.out.println(s1 == s2);//false，因为一个是堆内存中的String对象一个是常量池中的String对象，
|
||||
System.out.println(s3 == s2);//true，因为两个都是常量池中的String对象
|
||||
```
|
||||
**3 String 字符串拼接**
|
||||
```java
|
||||
String str1 = "str";
|
||||
String str2 = "ing";
|
||||
|
||||
String str3 = "str" + "ing";//常量池中的对象
|
||||
String str4 = str1 + str2; //在堆上创建的新的对象
|
||||
String str5 = "string";//常量池中的对象
|
||||
System.out.println(str3 == str4);//false
|
||||
System.out.println(str3 == str5);//true
|
||||
System.out.println(str4 == str5);//false
|
||||
```
|
||||
|
||||
|
||||
尽量避免多个字符串拼接，因为这样会重新创建对象。如果需要改变字符串的话，可以使用 StringBuilder 或者 StringBuffer。
|
||||
### String s1 = new String("abc");这句话创建了几个对象？
|
||||
|
||||
**创建了两个对象。**
|
||||
|
||||
**验证：**
|
||||
|
||||
```java
|
||||
String s1 = new String("abc");// 堆内存的地值值
|
||||
String s2 = "abc";
|
||||
System.out.println(s1 == s2);// 输出false,因为一个是堆内存，一个是常量池的内存，故两者是不同的。
|
||||
System.out.println(s1.equals(s2));// 输出true
|
||||
```
|
||||
|
||||
**结果：**
|
||||
|
||||
```
|
||||
false
|
||||
true
|
||||
```
|
||||
|
||||
**解释：**
|
||||
|
||||
先有字符串"abc"放入常量池，然后 new 了一份字符串"abc"放入Java堆(字符串常量"abc"在编译期就已经确定放入常量池，而 Java 堆上的"abc"是在运行期初始化阶段才确定)，然后 Java 栈的 str1 指向Java堆上的"abc"。
|
||||
|
||||
### 8种基本类型的包装类和常量池
|
||||
|
||||
- **Java 基本类型的包装类的大部分都实现了常量池技术，即Byte,Short,Integer,Long,Character,Boolean；这5种包装类默认创建了数值[-128，127]的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。**
|
||||
- **两种浮点数类型的包装类 Float,Double 并没有实现常量池技术。**
|
||||
|
||||
```java
|
||||
Integer i1 = 33;
|
||||
Integer i2 = 33;
|
||||
System.out.println(i1 == i2);// 输出true
|
||||
Integer i11 = 333;
|
||||
Integer i22 = 333;
|
||||
System.out.println(i11 == i22);// 输出false
|
||||
Double i3 = 1.2;
|
||||
Double i4 = 1.2;
|
||||
System.out.println(i3 == i4);// 输出false
|
||||
```
|
||||
|
||||
**Integer 缓存源代码：**
|
||||
|
||||
```java
|
||||
/**
|
||||
*此方法将始终缓存-128到127（包括端点）范围内的值，并可以缓存此范围之外的其他值。
|
||||
*/
|
||||
public static Integer valueOf(int i) {
|
||||
if (i >= IntegerCache.low && i <= IntegerCache.high)
|
||||
return IntegerCache.cache[i + (-IntegerCache.low)];
|
||||
return new Integer(i);
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
**应用场景：**
|
||||
1. Integer i1=40；Java 在编译的时候会直接将代码封装成Integer i1=Integer.valueOf(40);，从而使用常量池中的对象。
|
||||
2. Integer i1 = new Integer(40);这种情况下会创建新的对象。
|
||||
|
||||
```java
|
||||
Integer i1 = 40;
|
||||
Integer i2 = new Integer(40);
|
||||
System.out.println(i1==i2);//输出false
|
||||
```
|
||||
**Integer比较更丰富的一个例子:**
|
||||
|
||||
```java
|
||||
Integer i1 = 40;
|
||||
Integer i2 = 40;
|
||||
Integer i3 = 0;
|
||||
Integer i4 = new Integer(40);
|
||||
Integer i5 = new Integer(40);
|
||||
Integer i6 = new Integer(0);
|
||||
|
||||
System.out.println("i1=i2 " + (i1 == i2));
|
||||
System.out.println("i1=i2+i3 " + (i1 == i2 + i3));
|
||||
System.out.println("i1=i4 " + (i1 == i4));
|
||||
System.out.println("i4=i5 " + (i4 == i5));
|
||||
System.out.println("i4=i5+i6 " + (i4 == i5 + i6));
|
||||
System.out.println("40=i5+i6 " + (40 == i5 + i6));
|
||||
```
|
||||
|
||||
结果：
|
||||
|
||||
```
|
||||
i1=i2 true
|
||||
i1=i2+i3 true
|
||||
i1=i4 false
|
||||
i4=i5 false
|
||||
i4=i5+i6 true
|
||||
40=i5+i6 true
|
||||
```
|
||||
|
||||
解释：
|
||||
|
||||
语句i4 == i5 + i6，因为+这个操作符不适用于Integer对象，首先i5和i6进行自动拆箱操作，进行数值相加，即i4 == 40。然后Integer对象无法与数值进行直接比较，所以i4自动拆箱转为int值40，最终这条语句转为40 == 40进行数值比较。
|
||||
|
||||
|
||||
**参考：**
|
||||
|
||||
- 《深入理解Java虚拟机：JVM高级特性与最佳实践（第二版》
|
||||
- 《实战java虚拟机》
|
||||
- https://www.cnblogs.com/CZDblog/p/5589379.html
|
||||
- https://www.cnblogs.com/java-zhao/p/5180492.html
|
||||
- https://blog.csdn.net/qq_26222859/article/details/73135660
|
||||
- https://blog.csdn.net/cugwuhan2014/article/details/78038254
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,374 +0,0 @@
|
||||
|
||||
上文回顾：[《可能是把Java内存区域讲的最清楚的一篇文章》](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484303&idx=1&sn=af0fd436cef755463f59ee4dd0720cbd&chksm=fd9855eecaefdcf8d94ac581cfda4e16c8a730bda60c3b50bc55c124b92f23b6217f7f8e58d5&token=506869459&lang=zh_CN#rd)
|
||||
## 写在前面
|
||||
|
||||
### 本节常见面试题：
|
||||
|
||||
问题答案在文中都有提到
|
||||
|
||||
- 如何判断对象是否死亡（两种方法）。
|
||||
- 简单的介绍一下强引用、软引用、弱引用、虚引用（虚引用与软引用和弱引用的区别、使用软引用能带来的好处）。
|
||||
- 如何判断一个常量是废弃常量
|
||||
- 如何判断一个类是无用的类
|
||||
- 垃圾收集有哪些算法，各自的特点？
|
||||
- HotSpot为什么要分为新生代和老年代？
|
||||
- 常见的垃圾回收器有那些？
|
||||
- 介绍一下CMS,G1收集器。
|
||||
- Minor Gc和Full GC 有什么不同呢？
|
||||
|
||||
### 本文导火索
|
||||
|
||||
|
||||
|
||||
当需要排查各种 内存溢出问题、当垃圾收集成为系统达到更高并发的瓶颈时，我们就需要对这些“自动化”的技术实施必要的监控和调节。
|
||||
|
||||
|
||||
|
||||
## 1 揭开JVM内存分配与回收的神秘面纱
|
||||
|
||||
Java 的自动内存管理主要是针对对象内存的回收和对象内存的分配。同时，Java 自动内存管理最核心的功能是 **堆** 内存中对象的分配与回收。
|
||||
|
||||
**JDK1.8之前的堆内存示意图：**
|
||||
|
||||
|
||||
|
||||
从上图可以看出堆内存分为新生代、老年代和永久代。新生代又被进一步分为：Eden 区＋Survivor1 区＋Survivor2 区。值得注意的是，在 JDK 1.8中移除整个永久代，取而代之的是一个叫元空间（Metaspace）的区域（永久代使用的是JVM的堆内存空间，而元空间使用的是物理内存，直接受到本机的物理内存限制）。
|
||||
|
||||
|
||||
|
||||
### 1.1 对象优先在eden区分配
|
||||
|
||||
目前主流的垃圾收集器都会采用分代回收算法，因此需要将堆内存分为新生代和老年代，这样我们就可以根据各个年代的特点选择合适的垃圾收集算法。
|
||||
|
||||
大多数情况下，对象在新生代中 eden 区分配。当 eden 区没有足够空间进行分配时，虚拟机将发起一次Minor GC.下面我们来进行实际测试以下。
|
||||
|
||||
在测试之前我们先来看看 **Minor GC和Full GC 有什么不同呢？**
|
||||
|
||||
- **新生代GC（Minor GC）**:指发生新生代的的垃圾收集动作，Minor GC非常频繁，回收速度一般也比较快。
|
||||
- **老年代GC（Major GC/Full GC）**:指发生在老年代的GC，出现了Major GC经常会伴随至少一次的Minor GC（并非绝对），Major GC的速度一般会比Minor GC的慢10倍以上。
|
||||
|
||||
**测试：**
|
||||
|
||||
```java
|
||||
public class GCTest {
|
||||
|
||||
public static void main(String[] args) {
|
||||
byte[] allocation1, allocation2;
|
||||
allocation1 = new byte[30900*1024];
|
||||
//allocation2 = new byte[900*1024];
|
||||
}
|
||||
}
|
||||
```
|
||||
通过以下方式运行：
|
||||
|
||||
|
||||
添加的参数：`-XX:+PrintGCDetails`
|
||||
|
||||
|
||||
运行结果(红色字体描述有误，应该是对应于JDK1.7的永久代)：
|
||||
|
||||
|
||||
|
||||
从上图我们可以看出eden区内存几乎已经被分配完全（即使程序什么也不做，新生代也会使用2000多k内存）。假如我们再为allocation2分配内存会出现什么情况呢？
|
||||
|
||||
```java
|
||||
allocation2 = new byte[900*1024];
|
||||
```
|
||||
|
||||
|
||||
**简单解释一下为什么会出现这种情况：** 因为给allocation2分配内存的时候eden区内存几乎已经被分配完了，我们刚刚讲了当Eden区没有足够空间进行分配时，虚拟机将发起一次Minor GC.GC期间虚拟机又发现allocation1无法存入Survivor空间，所以只好通过 **分配担保机制** 把新生代的对象提前转移到老年代中去，老年代上的空间足够存放allocation1，所以不会出现Full GC。执行Minor GC后，后面分配的对象如果能够存在eden区的话，还是会在eden区分配内存。可以执行如下代码验证：
|
||||
|
||||
```java
|
||||
public class GCTest {
|
||||
|
||||
public static void main(String[] args) {
|
||||
byte[] allocation1, allocation2,allocation3,allocation4,allocation5;
|
||||
allocation1 = new byte[32000*1024];
|
||||
allocation2 = new byte[1000*1024];
|
||||
allocation3 = new byte[1000*1024];
|
||||
allocation4 = new byte[1000*1024];
|
||||
allocation5 = new byte[1000*1024];
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
|
||||
### 1.2 大对象直接进入老年代
|
||||
大对象就是需要大量连续内存空间的对象（比如：字符串、数组）。
|
||||
|
||||
**为什么要这样呢？**
|
||||
|
||||
为了避免为大对象分配内存时由于分配担保机制带来的复制而降低效率。
|
||||
|
||||
### 1.3 长期存活的对象将进入老年代
|
||||
既然虚拟机采用了分代收集的思想来管理内存，那么内存回收时就必须能识别哪些对象应放在新生代，哪些对象应放在老年代中。为了做到这一点，虚拟机给每个对象一个对象年龄（Age）计数器。
|
||||
|
||||
如果对象在 Eden 出生并经过第一次 Minor GC 后仍然能够存活，并且能被 Survivor 容纳的话，将被移动到 Survivor 空间中，并将对象年龄设为1.对象在 Survivor 中每熬过一次 MinorGC,年龄就增加1岁，当它的年龄增加到一定程度（默认为15岁），就会被晋升到老年代中。对象晋升到老年代的年龄阈值，可以通过参数 `-XX:MaxTenuringThreshold` 来设置。
|
||||
|
||||
### 1.4 动态对象年龄判定
|
||||
|
||||
为了更好的适应不同程序的内存情况，虚拟机不是永远要求对象年龄必须达到了某个值才能进入老年代，如果 Survivor 空间中相同年龄所有对象大小的总和大于 Survivor 空间的一半，年龄大于或等于该年龄的对象就可以直接进入老年代，无需达到要求的年龄。
|
||||
|
||||
|
||||
## 2 对象已经死亡？
|
||||
|
||||
堆中几乎放着所有的对象实例，对堆垃圾回收前的第一步就是要判断那些对象已经死亡（即不能再被任何途径使用的对象）。
|
||||
|
||||
|
||||
|
||||
### 2.1 引用计数法
|
||||
|
||||
给对象中添加一个引用计数器，每当有一个地方引用它，计数器就加1；当引用失效，计数器就减1；任何时候计数器为0的对象就是不可能再被使用的。
|
||||
|
||||
**这个方法实现简单，效率高，但是目前主流的虚拟机中并没有选择这个算法来管理内存，其最主要的原因是它很难解决对象之间相互循环引用的问题。** 所谓对象之间的相互引用问题，如下面代码所示：除了对象objA 和 objB 相互引用着对方之外，这两个对象之间再无任何引用。但是他们因为互相引用对方，导致它们的引用计数器都不为0，于是引用计数算法无法通知 GC 回收器回收他们。
|
||||
|
||||
```java
|
||||
public class ReferenceCountingGc {
|
||||
Object instance = null;
|
||||
public static void main(String[] args) {
|
||||
ReferenceCountingGc objA = new ReferenceCountingGc();
|
||||
ReferenceCountingGc objB = new ReferenceCountingGc();
|
||||
objA.instance = objB;
|
||||
objB.instance = objA;
|
||||
objA = null;
|
||||
objB = null;
|
||||
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
### 2.2 可达性分析算法
|
||||
|
||||
这个算法的基本思想就是通过一系列的称为 **“GC Roots”** 的对象作为起点，从这些节点开始向下搜索，节点所走过的路径称为引用链，当一个对象到 GC Roots 没有任何引用链相连的话，则证明此对象是不可用的。
|
||||
|
||||
|
||||
|
||||
|
||||
### 2.3 再谈引用
|
||||
|
||||
无论是通过引用计数法判断对象引用数量，还是通过可达性分析法判断对象的引用链是否可达，判定对象的存活都与“引用”有关。
|
||||
|
||||
JDK1.2之前，Java中引用的定义很传统：如果reference类型的数据存储的数值代表的是另一块内存的起始地址，就称这块内存代表一个引用。
|
||||
|
||||
JDK1.2以后，Java对引用的概念进行了扩充，将引用分为强引用、软引用、弱引用、虚引用四种（引用强度逐渐减弱）
|
||||
|
||||
|
||||
|
||||
**1．强引用**
|
||||
|
||||
以前我们使用的大部分引用实际上都是强引用，这是使用最普遍的引用。如果一个对象具有强引用，那就类似于**必不可少的生活用品**，垃圾回收器绝不会回收它。当内存空 间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。
|
||||
|
||||
**2．软引用（SoftReference）**
|
||||
|
||||
如果一个对象只具有软引用，那就类似于**可有可无的生活用品**。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。
|
||||
|
||||
软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，JAVA虚拟机就会把这个软引用加入到与之关联的引用队列中。
|
||||
|
||||
**3．弱引用（WeakReference）**
|
||||
|
||||
如果一个对象只具有弱引用，那就类似于**可有可无的生活用品**。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。
|
||||
|
||||
弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
|
||||
|
||||
**4．虚引用（PhantomReference）**
|
||||
|
||||
"虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。
|
||||
|
||||
**虚引用主要用来跟踪对象被垃圾回收的活动**。
|
||||
|
||||
**虚引用与软引用和弱引用的一个区别在于：** 虚引用必须和引用队列（ReferenceQueue）联合使用。当垃 圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是 否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
|
||||
|
||||
特别注意，在程序设计中一般很少使用弱引用与虚引用，使用软引用的情况较多，这是因为**软引用可以加速JVM对垃圾内存的回收速度，可以维护系统的运行安全，防止内存溢出（OutOfMemory）等问题的产生**。
|
||||
|
||||
### 2.4 不可达的对象并非“非死不可”
|
||||
|
||||
即使在可达性分析法中不可达的对象，也并非是“非死不可”的，这时候它们暂时处于“缓刑阶段”，要真正宣告一个对象死亡，至少要经历两次标记过程；可达性分析法中不可达的对象被第一次标记并且进行一次筛选，筛选的条件是此对象是否有必要执行 finalize 方法。当对象没有覆盖 finalize 方法，或 finalize 方法已经被虚拟机调用过时，虚拟机将这两种情况视为没有必要执行。
|
||||
|
||||
被判定为需要执行的对象将会被放在一个队列中进行第二次标记，除非这个对象与引用链上的任何一个对象建立关联，否则就会被真的回收。
|
||||
|
||||
### 2.5 如何判断一个常量是废弃常量
|
||||
|
||||
运行时常量池主要回收的是废弃的常量。那么，我们如何判断一个常量是废弃常量呢？
|
||||
|
||||
假如在常量池中存在字符串 "abc"，如果当前没有任何String对象引用该字符串常量的话，就说明常量 "abc" 就是废弃常量，如果这时发生内存回收的话而且有必要的话，"abc" 就会被系统清理出常量池。
|
||||
|
||||
注意：我们在 [可能是把Java内存区域讲的最清楚的一篇文章](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484303&idx=1&sn=af0fd436cef755463f59ee4dd0720cbd&chksm=fd9855eecaefdcf8d94ac581cfda4e16c8a730bda60c3b50bc55c124b92f23b6217f7f8e58d5&token=506869459&lang=zh_CN#rd) 也讲了JDK1.7及之后版本的 JVM 已经将运行时常量池从方法区中移了出来，在 Java 堆（Heap）中开辟了一块区域存放运行时常量池。
|
||||
|
||||
### 2.6 如何判断一个类是无用的类
|
||||
|
||||
方法区主要回收的是无用的类，那么如何判断一个类是无用的类的呢？
|
||||
|
||||
判定一个常量是否是“废弃常量”比较简单，而要判定一个类是否是“无用的类”的条件则相对苛刻许多。类需要同时满足下面3个条件才能算是 **“无用的类”** ：
|
||||
|
||||
- 该类所有的实例都已经被回收，也就是 Java 堆中不存在该类的任何实例。
|
||||
- 加载该类的 ClassLoader 已经被回收。
|
||||
- 该类对应的 java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。
|
||||
|
||||
虚拟机可以对满足上述3个条件的无用类进行回收，这里说的仅仅是“可以”，而并不是和对象一样不使用了就会必然被回收。
|
||||
|
||||
|
||||
## 3 垃圾收集算法
|
||||
|
||||
|
||||
|
||||
### 3.1 标记-清除算法
|
||||
|
||||
算法分为“标记”和“清除”阶段：首先标记出所有需要回收的对象，在标记完成后统一回收所有被标记的对象。它是最基础的收集算法，效率也很高，但是会带来两个明显的问题：
|
||||
|
||||
1. **效率问题**
|
||||
2. **空间问题（标记清除后会产生大量不连续的碎片）**
|
||||
|
||||
|
||||
|
||||
### 3.2 复制算法
|
||||
|
||||
为了解决效率问题，“复制”收集算法出现了。它可以将内存分为大小相同的两块，每次使用其中的一块。当这一块的内存使用完后，就将还存活的对象复制到另一块去，然后再把使用的空间一次清理掉。这样就使每次的内存回收都是对内存区间的一半进行回收。
|
||||
|
||||
|
||||
|
||||
### 3.3 标记-整理算法
|
||||
根据老年代的特点特出的一种标记算法，标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象回收，而是让所有存活的对象向一端移动，然后直接清理掉端边界以外的内存。
|
||||
|
||||
|
||||
|
||||
### 3.4 分代收集算法
|
||||
|
||||
当前虚拟机的垃圾收集都采用分代收集算法，这种算法没有什么新的思想，只是根据对象存活周期的不同将内存分为几块。一般将java堆分为新生代和老年代，这样我们就可以根据各个年代的特点选择合适的垃圾收集算法。
|
||||
|
||||
**比如在新生代中，每次收集都会有大量对象死去，所以可以选择复制算法，只需要付出少量对象的复制成本就可以完成每次垃圾收集。而老年代的对象存活几率是比较高的，而且没有额外的空间对它进行分配担保，所以我们必须选择“标记-清除”或“标记-整理”算法进行垃圾收集。**
|
||||
|
||||
**延伸面试问题：** HotSpot为什么要分为新生代和老年代？
|
||||
|
||||
根据上面的对分代收集算法的介绍回答。
|
||||
|
||||
## 4 垃圾收集器
|
||||
|
||||
|
||||
|
||||
**如果说收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现。**
|
||||
|
||||
虽然我们对各个收集器进行比较，但并非要挑选出一个最好的收集器。因为知道现在为止还没有最好的垃圾收集器出现，更加没有万能的垃圾收集器，**我们能做的就是根据具体应用场景选择适合自己的垃圾收集器**。试想一下：如果有一种四海之内、任何场景下都适用的完美收集器存在，那么我们的HotSpot虚拟机就不会实现那么多不同的垃圾收集器了。
|
||||
|
||||
|
||||
### 4.1 Serial收集器
|
||||
Serial（串行）收集器收集器是最基本、历史最悠久的垃圾收集器了。大家看名字就知道这个收集器是一个单线程收集器了。它的 **“单线程”** 的意义不仅仅意味着它只会使用一条垃圾收集线程去完成垃圾收集工作，更重要的是它在进行垃圾收集工作的时候必须暂停其他所有的工作线程（ **"Stop The World"** ），直到它收集结束。
|
||||
|
||||
**新生代采用复制算法，老年代采用标记-整理算法。**
|
||||
|
||||
|
||||
虚拟机的设计者们当然知道Stop The World带来的不良用户体验，所以在后续的垃圾收集器设计中停顿时间在不断缩短（仍然还有停顿，寻找最优秀的垃圾收集器的过程仍然在继续）。
|
||||
|
||||
但是Serial收集器有没有优于其他垃圾收集器的地方呢？当然有，它**简单而高效（与其他收集器的单线程相比）**。Serial收集器由于没有线程交互的开销，自然可以获得很高的单线程收集效率。Serial收集器对于运行在Client模式下的虚拟机来说是个不错的选择。
|
||||
|
||||
|
||||
|
||||
### 4.2 ParNew收集器
|
||||
**ParNew收集器其实就是Serial收集器的多线程版本，除了使用多线程进行垃圾收集外，其余行为（控制参数、收集算法、回收策略等等）和Serial收集器完全一样。**
|
||||
|
||||
**新生代采用复制算法，老年代采用标记-整理算法。**
|
||||
|
||||
|
||||
它是许多运行在Server模式下的虚拟机的首要选择，除了Serial收集器外，只有它能与CMS收集器（真正意义上的并发收集器，后面会介绍到）配合工作。
|
||||
|
||||
**并行和并发概念补充：**
|
||||
|
||||
- **并行（Parallel）** ：指多条垃圾收集线程并行工作，但此时用户线程仍然处于等待状态。
|
||||
|
||||
- **并发（Concurrent）**：指用户线程与垃圾收集线程同时执行（但不一定是并行，可能会交替执行），用户程序在继续运行，而垃圾收集器运行在另一个CPU上。
|
||||
|
||||
|
||||
### 4.3 Parallel Scavenge收集器
|
||||
|
||||
Parallel Scavenge 收集器类似于ParNew 收集器。 **那么它有什么特别之处呢？**
|
||||
|
||||
```
|
||||
-XX:+UseParallelGC
|
||||
|
||||
使用Parallel收集器+ 老年代串行
|
||||
|
||||
-XX:+UseParallelOldGC
|
||||
|
||||
使用Parallel收集器+ 老年代并行
|
||||
|
||||
```
|
||||
|
||||
**Parallel Scavenge收集器关注点是吞吐量（高效率的利用CPU）。CMS等垃圾收集器的关注点更多的是用户线程的停顿时间（提高用户体验）。所谓吞吐量就是CPU中用于运行用户代码的时间与CPU总消耗时间的比值。** Parallel Scavenge收集器提供了很多参数供用户找到最合适的停顿时间或最大吞吐量，如果对于收集器运作不太了解的话，手工优化存在的话可以选择把内存管理优化交给虚拟机去完成也是一个不错的选择。
|
||||
|
||||
**新生代采用复制算法，老年代采用标记-整理算法。**
|
||||
|
||||
|
||||
|
||||
### 4.4.Serial Old收集器
|
||||
**Serial收集器的老年代版本**，它同样是一个单线程收集器。它主要有两大用途：一种用途是在JDK1.5以及以前的版本中与Parallel Scavenge收集器搭配使用，另一种用途是作为CMS收集器的后备方案。
|
||||
|
||||
### 4.5 Parallel Old收集器
|
||||
**Parallel Scavenge收集器的老年代版本**。使用多线程和“标记-整理”算法。在注重吞吐量以及CPU资源的场合，都可以优先考虑 Parallel Scavenge收集器和Parallel Old收集器。
|
||||
|
||||
### 4.6 CMS收集器
|
||||
|
||||
**CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。它而非常符合在注重用户体验的应用上使用。**
|
||||
|
||||
**CMS（Concurrent Mark Sweep）收集器是HotSpot虚拟机第一款真正意义上的并发收集器，它第一次实现了让垃圾收集线程与用户线程（基本上）同时工作。**
|
||||
|
||||
从名字中的**Mark Sweep**这两个词可以看出，CMS收集器是一种 **“标记-清除”算法**实现的，它的运作过程相比于前面几种垃圾收集器来说更加复杂一些。整个过程分为四个步骤：
|
||||
|
||||
- **初始标记：** 暂停所有的其他线程，并记录下直接与root相连的对象，速度很快 ；
|
||||
- **并发标记：** 同时开启GC和用户线程，用一个闭包结构去记录可达对象。但在这个阶段结束，这个闭包结构并不能保证包含当前所有的可达对象。因为用户线程可能会不断的更新引用域，所以GC线程无法保证可达性分析的实时性。所以这个算法里会跟踪记录这些发生引用更新的地方。
|
||||
- **重新标记：** 重新标记阶段就是为了修正并发标记期间因为用户程序继续运行而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段的时间稍长，远远比并发标记阶段时间短
|
||||
- **并发清除：** 开启用户线程，同时GC线程开始对为标记的区域做清扫。
|
||||
|
||||
|
||||
|
||||
从它的名字就可以看出它是一款优秀的垃圾收集器，主要优点：**并发收集、低停顿**。但是它有下面三个明显的缺点：
|
||||
|
||||
- **对CPU资源敏感；**
|
||||
- **无法处理浮动垃圾；**
|
||||
- **它使用的回收算法-“标记-清除”算法会导致收集结束时会有大量空间碎片产生。**
|
||||
|
||||
### 4.7 G1收集器
|
||||
|
||||
|
||||
**G1 (Garbage-First)是一款面向服务器的垃圾收集器,主要针对配备多颗处理器及大容量内存的机器. 以极高概率满足GC停顿时间要求的同时,还具备高吞吐量性能特征.**
|
||||
|
||||
被视为JDK1.7中HotSpot虚拟机的一个重要进化特征。它具备一下特点：
|
||||
|
||||
- **并行与并发**：G1能充分利用CPU、多核环境下的硬件优势，使用多个CPU（CPU或者CPU核心）来缩短Stop-The-World停顿时间。部分其他收集器原本需要停顿Java线程执行的GC动作，G1收集器仍然可以通过并发的方式让java程序继续执行。
|
||||
- **分代收集**：虽然G1可以不需要其他收集器配合就能独立管理整个GC堆，但是还是保留了分代的概念。
|
||||
- **空间整合**：与CMS的“标记--清理”算法不同，G1从整体来看是基于“标记整理”算法实现的收集器；从局部上来看是基于“复制”算法实现的。
|
||||
- **可预测的停顿**：这是G1相对于CMS的另一个大优势，降低停顿时间是G1 和 CMS 共同的关注点，但G1 除了追求低停顿外，还能建立可预测的停顿时间模型，能让使用者明确指定在一个长度为M毫秒的时间片段内。
|
||||
|
||||
|
||||
G1收集器的运作大致分为以下几个步骤：
|
||||
|
||||
- **初始标记**
|
||||
- **并发标记**
|
||||
- **最终标记**
|
||||
- **筛选回收**
|
||||
|
||||
|
||||
**G1收集器在后台维护了一个优先列表，每次根据允许的收集时间，优先选择回收价值最大的Region(这也就是它的名字Garbage-First的由来)**。这种使用Region划分内存空间以及有优先级的区域回收方式，保证了GF收集器在有限时间内可以尽可能高的收集效率（把内存化整为零）。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
参考：
|
||||
|
||||
- 《深入理解Java虚拟机：JVM高级特性与最佳实践（第二版》
|
||||
- https://my.oschina.net/hosee/blog/644618
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,289 +0,0 @@
|
||||
|
||||
|
||||
<!-- MarkdownTOC -->
|
||||
|
||||
- [Arraylist 与 LinkedList 异同](#arraylist-与-linkedlist-异同)
|
||||
- [补充：数据结构基础之双向链表](#补充：数据结构基础之双向链表)
|
||||
- [ArrayList 与 Vector 区别](#arraylist-与-vector-区别)
|
||||
- [HashMap的底层实现](#hashmap的底层实现)
|
||||
- [JDK1.8之前](#jdk18之前)
|
||||
- [JDK1.8之后](#jdk18之后)
|
||||
- [HashMap 和 Hashtable 的区别](#hashmap-和-hashtable-的区别)
|
||||
- [HashMap 的长度为什么是2的幂次方](#hashmap-的长度为什么是2的幂次方)
|
||||
- [HashMap 多线程操作导致死循环问题](#hashmap-多线程操作导致死循环问题)
|
||||
- [HashSet 和 HashMap 区别](#hashset-和-hashmap-区别)
|
||||
- [ConcurrentHashMap 和 Hashtable 的区别](#concurrenthashmap-和-hashtable-的区别)
|
||||
- [ConcurrentHashMap线程安全的具体实现方式/底层具体实现](#concurrenthashmap线程安全的具体实现方式底层具体实现)
|
||||
- [JDK1.7（上面有示意图）](#jdk17（上面有示意图）)
|
||||
- [JDK1.8 （上面有示意图）](#jdk18-（上面有示意图）)
|
||||
- [集合框架底层数据结构总结](#集合框架底层数据结构总结)
|
||||
- [Collection](#collection)
|
||||
- [1. List](#1-list)
|
||||
- [2. Set](#2-set)
|
||||
- [Map](#map)
|
||||
- [推荐阅读：](#推荐阅读：)
|
||||
|
||||
<!-- /MarkdownTOC -->
|
||||
|
||||
## Arraylist 与 LinkedList 异同
|
||||
|
||||
- **1. 是否保证线程安全：** ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；
|
||||
- **2. 底层数据结构：** Arraylist 底层使用的是Object数组；LinkedList 底层使用的是双向链表数据结构（JDK1.6之前为循环链表，JDK1.7取消了循环。注意双向链表和双向循环链表的区别：）； 详细可阅读[JDK1.7-LinkedList循环链表优化](https://www.cnblogs.com/xingele0917/p/3696593.html)
|
||||
- **3. 插入和删除是否受元素位置的影响：** ① **ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。** 比如：执行`add(E e) `方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是O(1)。但是如果要在指定位置 i 插入和删除元素的话（`add(int index, E element) `）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 ② **LinkedList 采用链表存储，所以插入，删除元素时间复杂度不受元素位置的影响，都是近似 O（1）而数组为近似 O（n）。**
|
||||
- **4. 是否支持快速随机访问：** LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于`get(int index) `方法)。
|
||||
- **5. 内存空间占用：** ArrayList的空 间浪费主要体现在在list列表的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）。
|
||||
-**6. 发
|
||||
**补充内容:RandomAccess接口**
|
||||
|
||||
```java
|
||||
public interface RandomAccess {
|
||||
}
|
||||
```
|
||||
|
||||
查看源码我们发现实际上 RandomAccess 接口中什么都没有定义。所以，在我看来 RandomAccess 接口不过是一个标识罢了。标识什么？ 标识实现这个接口的类具有随机访问功能。
|
||||
|
||||
在binarySearch（）方法中，它要判断传入的list 是否RamdomAccess的实例，如果是，调用indexedBinarySearch（）方法，如果不是，那么调用iteratorBinarySearch（）方法
|
||||
|
||||
```java
|
||||
public static <T>
|
||||
int binarySearch(List<? extends Comparable<? super T>> list, T key) {
|
||||
if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
|
||||
return Collections.indexedBinarySearch(list, key);
|
||||
else
|
||||
return Collections.iteratorBinarySearch(list, key);
|
||||
}
|
||||
|
||||
```
|
||||
ArrayList 实现了 RandomAccess 接口， 而 LinkedList 没有实现。为什么呢？我觉得还是和底层数据结构有关！ArrayList 底层是数组，而 LinkedList 底层是链表。数组天然支持随机访问，时间复杂度为 O（1），所以称为快速随机访问。链表需要遍历到特定位置才能访问特定位置的元素，时间复杂度为 O（n），所以不支持快速随机访问。，ArrayList 实现了 RandomAccess 接口，就表明了他具有快速随机访问功能。 RandomAccess 接口只是标识，并不是说 ArrayList 实现 RandomAccess 接口才具有快速随机访问功能的！
|
||||
|
||||
|
||||
**下面再总结一下 list 的遍历方式选择：**
|
||||
|
||||
- 实现了RandomAccess接口的list，优先选择普通for循环 ，其次foreach,
|
||||
- 未实现RandomAccess接口的ist， 优先选择iterator遍历（foreach遍历底层也是通过iterator实现的），大size的数据，千万不要使用普通for循环
|
||||
|
||||
|
||||
### 补充：数据结构基础之双向链表
|
||||
|
||||
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表，如下图所示，同时下图也是LinkedList 底层使用的是双向循环链表数据结构。
|
||||
|
||||
|
||||
|
||||
|
||||
## ArrayList 与 Vector 区别
|
||||
|
||||
Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象、但是一个线程访问Vector的话代码要在同步操作上耗费大量的时间。
|
||||
|
||||
Arraylist不是同步的，所以在不需要保证线程安全时时建议使用Arraylist。
|
||||
|
||||
|
||||
## HashMap的底层实现
|
||||
|
||||
### JDK1.8之前
|
||||
|
||||
JDK1.8 之前 HashMap 底层是 **数组和链表** 结合在一起使用也就是 **链表散列**。**HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 `(n - 1) & hash` 判断当前元素存放的位置（这里的 n 指的是数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。**
|
||||
|
||||
**所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 换句话说使用扰动函数之后可以减少碰撞。**
|
||||
|
||||
**JDK 1.8 HashMap 的 hash 方法源码:**
|
||||
|
||||
JDK 1.8 的 hash方法 相比于 JDK 1.7 hash 方法更加简化，但是原理不变。
|
||||
|
||||
```java
|
||||
static final int hash(Object key) {
|
||||
int h;
|
||||
// key.hashCode()：返回散列值也就是hashcode
|
||||
// ^ ：按位异或
|
||||
// >>>:无符号右移，忽略符号位，空位都以0补齐
|
||||
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
|
||||
}
|
||||
```
|
||||
对比一下 JDK1.7的 HashMap 的 hash 方法源码.
|
||||
|
||||
```java
|
||||
static int hash(int h) {
|
||||
// This function ensures that hashCodes that differ only by
|
||||
// constant multiples at each bit position have a bounded
|
||||
// number of collisions (approximately 8 at default load factor).
|
||||
|
||||
h ^= (h >>> 20) ^ (h >>> 12);
|
||||
return h ^ (h >>> 7) ^ (h >>> 4);
|
||||
}
|
||||
```
|
||||
|
||||
相比于 JDK1.8 的 hash 方法 ，JDK 1.7 的 hash 方法的性能会稍差一点点，因为毕竟扰动了 4 次。
|
||||
|
||||
所谓 **“拉链法”** 就是：将链表和数组相结合。也就是说创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
### JDK1.8之后
|
||||
相比于之前的版本， JDK1.8之后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。
|
||||
|
||||
|
||||
|
||||
>TreeMap、TreeSet以及JDK1.8之后的HashMap底层都用到了红黑树。红黑树就是为了解决二叉查找树的缺陷，因为二叉查找树在某些情况下会退化成一个线性结构。
|
||||
|
||||
**推荐阅读：**
|
||||
|
||||
- 《Java 8系列之重新认识HashMap》 ：[https://zhuanlan.zhihu.com/p/21673805](https://zhuanlan.zhihu.com/p/21673805)
|
||||
|
||||
## HashMap 和 Hashtable 的区别
|
||||
|
||||
1. **线程是否安全：** HashMap 是非线程安全的，HashTable 是线程安全的；HashTable 内部的方法基本都经过 `synchronized` 修饰。（如果你要保证线程安全的话就使用 ConcurrentHashMap 吧！）；
|
||||
2. **效率：** 因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它；
|
||||
3. **对Null key 和Null value的支持：** HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。。但是在 HashTable 中 put 进的键值只要有一个 null，直接抛出 NullPointerException。
|
||||
4. **初始容量大小和每次扩充容量大小的不同 ：** ①创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。②创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为2的幂次方大小（HashMap 中的`tableSizeFor()`方法保证，下面给出了源代码）。也就是说 HashMap 总是使用2的幂作为哈希表的大小,后面会介绍到为什么是2的幂次方。
|
||||
5. **底层数据结构：** JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。
|
||||
|
||||
**HasMap 中带有初始容量的构造函数：**
|
||||
|
||||
```java
|
||||
public HashMap(int initialCapacity, float loadFactor) {
|
||||
if (initialCapacity < 0)
|
||||
throw new IllegalArgumentException("Illegal initial capacity: " +
|
||||
initialCapacity);
|
||||
if (initialCapacity > MAXIMUM_CAPACITY)
|
||||
initialCapacity = MAXIMUM_CAPACITY;
|
||||
if (loadFactor <= 0 || Float.isNaN(loadFactor))
|
||||
throw new IllegalArgumentException("Illegal load factor: " +
|
||||
loadFactor);
|
||||
this.loadFactor = loadFactor;
|
||||
this.threshold = tableSizeFor(initialCapacity);
|
||||
}
|
||||
public HashMap(int initialCapacity) {
|
||||
this(initialCapacity, DEFAULT_LOAD_FACTOR);
|
||||
}
|
||||
```
|
||||
|
||||
下面这个方法保证了 HashMap 总是使用2的幂作为哈希表的大小。
|
||||
|
||||
```java
|
||||
/**
|
||||
* Returns a power of two size for the given target capacity.
|
||||
*/
|
||||
static final int tableSizeFor(int cap) {
|
||||
int n = cap - 1;
|
||||
n |= n >>> 1;
|
||||
n |= n >>> 2;
|
||||
n |= n >>> 4;
|
||||
n |= n >>> 8;
|
||||
n |= n >>> 16;
|
||||
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
|
||||
}
|
||||
```
|
||||
|
||||
## HashMap 的长度为什么是2的幂次方
|
||||
|
||||
为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀。我们上面也讲到了过了，Hash 值的范围值-2147483648到2147483647，前后加起来大概40亿的映射空间，只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。但问题是一个40亿长度的数组，内存是放不下的。所以这个散列值是不能直接拿来用的。用之前还要先做对数组的长度取模运算，得到的余数才能用来要存放的位置也就是对应的数组下标。这个数组下标的计算方法是“ `(n - 1) & hash` ”。（n代表数组长度）。这也就解释了 HashMap 的长度为什么是2的幂次方。
|
||||
|
||||
**这个算法应该如何设计呢？**
|
||||
|
||||
我们首先可能会想到采用%取余的操作来实现。但是，重点来了：**“取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作（也就是说 hash%length==hash&(length-1)的前提是 length 是2的 n 次方；）。”** 并且 **采用二进制位操作 &，相对于%能够提高运算效率，这就解释了 HashMap 的长度为什么是2的幂次方。**
|
||||
|
||||
## HashMap 多线程操作导致死循环问题
|
||||
|
||||
在多线程下，进行 put 操作会导致 HashMap 死循环，原因在于 HashMap 的扩容 resize()方法。由于扩容是新建一个数组，复制原数据到数组。由于数组下标挂有链表，所以需要复制链表，但是多线程操作有可能导致环形链表。复制链表过程如下:
|
||||
以下模拟2个线程同时扩容。假设，当前 HashMap 的空间为2（临界值为1），hashcode 分别为 0 和 1，在散列地址 0 处有元素 A 和 B，这时候要添加元素 C，C 经过 hash 运算，得到散列地址为 1，这时候由于超过了临界值，空间不够，需要调用 resize 方法进行扩容，那么在多线程条件下，会出现条件竞争，模拟过程如下：
|
||||
|
||||
线程一：读取到当前的 HashMap 情况，在准备扩容时，线程二介入
|
||||
|
||||
|
||||
|
||||
线程二：读取 HashMap，进行扩容
|
||||
|
||||
|
||||
|
||||
线程一：继续执行
|
||||
|
||||
|
||||
|
||||
这个过程为，先将 A 复制到新的 hash 表中，然后接着复制 B 到链头（A 的前边：B.next=A），本来 B.next=null，到此也就结束了（跟线程二一样的过程），但是，由于线程二扩容的原因，将 B.next=A，所以，这里继续复制A，让 A.next=B，由此，环形链表出现：B.next=A; A.next=B
|
||||
|
||||
**注意：jdk1.8已经解决了死循环的问题。**
|
||||
|
||||
|
||||
## HashSet 和 HashMap 区别
|
||||
|
||||
如果你看过 HashSet 源码的话就应该知道：HashSet 底层就是基于 HashMap 实现的。（HashSet 的源码非常非常少，因为除了 clone() 方法、writeObject()方法、readObject()方法是 HashSet 自己不得不实现之外，其他方法都是直接调用 HashMap 中的方法。）
|
||||
|
||||
|
||||
|
||||
## ConcurrentHashMap 和 Hashtable 的区别
|
||||
|
||||
ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。
|
||||
|
||||
- **底层数据结构：** JDK1.7的 ConcurrentHashMap 底层采用 **分段的数组+链表** 实现，JDK1.8 采用的数据结构跟HashMap1.8的结构一样，数组+链表/红黑二叉树。Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 **数组+链表** 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的；
|
||||
- **实现线程安全的方式（重要）：** ① **在JDK1.7的时候，ConcurrentHashMap（分段锁）** 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。 **到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6以后 对 synchronized锁做了很多优化）** 整个看起来就像是优化过且线程安全的 HashMap，虽然在JDK1.8中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② **Hashtable(同一把锁)** :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。
|
||||
|
||||
**两者的对比图：**
|
||||
|
||||
图片来源：http://www.cnblogs.com/chengxiao/p/6842045.html
|
||||
|
||||
HashTable:
|
||||
|
||||
|
||||
JDK1.7的ConcurrentHashMap：
|
||||
|
||||
JDK1.8的ConcurrentHashMap（TreeBin: 红黑二叉树节点
|
||||
Node: 链表节点）：
|
||||
|
||||
|
||||
## ConcurrentHashMap线程安全的具体实现方式/底层具体实现
|
||||
|
||||
### JDK1.7（上面有示意图）
|
||||
|
||||
首先将数据分为一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据时，其他段的数据也能被其他线程访问。
|
||||
|
||||
**ConcurrentHashMap 是由 Segment 数组结构和 HashEntry 数组结构组成**。
|
||||
|
||||
Segment 实现了 ReentrantLock,所以 Segment 是一种可重入锁，扮演锁的角色。HashEntry 用于存储键值对数据。
|
||||
|
||||
```java
|
||||
static class Segment<K,V> extends ReentrantLock implements Serializable {
|
||||
}
|
||||
```
|
||||
|
||||
一个 ConcurrentHashMap 里包含一个 Segment 数组。Segment 的结构和HashMap类似，是一种数组和链表结构，一个 Segment 包含一个 HashEntry 数组，每个 HashEntry 是一个链表结构的元素，每个 Segment 守护着一个HashEntry数组里的元素，当对 HashEntry 数组的数据进行修改时，必须首先获得对应的 Segment的锁。
|
||||
|
||||
### JDK1.8 （上面有示意图）
|
||||
|
||||
ConcurrentHashMap取消了Segment分段锁，采用CAS和synchronized来保证并发安全。数据结构跟HashMap1.8的结构类似，数组+链表/红黑二叉树。
|
||||
|
||||
synchronized只锁定当前链表或红黑二叉树的首节点，这样只要hash不冲突，就不会产生并发，效率又提升N倍。
|
||||
|
||||
|
||||
|
||||
## 集合框架底层数据结构总结
|
||||
### Collection
|
||||
|
||||
#### 1. List
|
||||
- **Arraylist：** Object数组
|
||||
- **Vector：** Object数组
|
||||
- **LinkedList：** 双向链表(JDK1.6之前为循环链表，JDK1.7取消了循环)
|
||||
详细可阅读[JDK1.7-LinkedList循环链表优化](https://www.cnblogs.com/xingele0917/p/3696593.html)
|
||||
|
||||
#### 2. Set
|
||||
- **HashSet（无序，唯一）:** 基于 HashMap 实现的，底层采用 HashMap 来保存元素
|
||||
- **LinkedHashSet：** LinkedHashSet 继承与 HashSet，并且其内部是通过 LinkedHashMap 来实现的。有点类似于我们之前说的LinkedHashMap 其内部是基于 Hashmap 实现一样，不过还是有一点点区别的。
|
||||
- **TreeSet（有序，唯一）：** 红黑树(自平衡的排序二叉树。)
|
||||
|
||||
### Map
|
||||
- **HashMap：** JDK1.8之前HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）.JDK1.8以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间
|
||||
- **LinkedHashMap:** LinkedHashMap 继承自 HashMap，所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外，LinkedHashMap 在上面结构的基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作，实现了访问顺序相关逻辑。详细可以查看：[《LinkedHashMap 源码详细分析（JDK1.8）》](https://www.imooc.com/article/22931)
|
||||
- **HashTable:** 数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的
|
||||
- **TreeMap:** 红黑树（自平衡的排序二叉树）
|
||||
|
||||
|
||||
|
||||
|
||||
### 推荐阅读：
|
||||
|
||||
- [jdk1.8中ConcurrentHashMap的实现原理](https://blog.csdn.net/fjse51/article/details/55260493)
|
||||
- [HashMap? ConcurrentHashMap? 相信看完这篇没人能难住你！](https://crossoverjie.top/2018/07/23/java-senior/ConcurrentHashMap/)
|
||||
- [HASHMAP、HASHTABLE、CONCURRENTHASHMAP的原理与区别](http://www.yuanrengu.com/index.php/2017-01-17.html)
|
||||
- [ConcurrentHashMap实现原理及源码分析](https://www.cnblogs.com/chengxiao/p/6842045.html)
|
||||
- [java-并发-ConcurrentHashMap高并发机制-jdk1.8](https://blog.csdn.net/jianghuxiaojin/article/details/52006118#commentBox)
|
||||
532
README.md
532
README.md
@ -1,241 +1,453 @@
|
||||
点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。
|
||||
|
||||
为了优化大家的阅读体验，我重新进行了排版，并且增加了较为详细的目录供大家参考！如果有老哥对操作系统比较重要的知识总结过的话，欢迎找我哦！
|
||||
一些常用资源[公众号](#公众号)后台回复关键字“1”即可免费无套路获取。
|
||||
少部分原创文章更新在了知识星球，关于我为什么要弄知识星球，请看这里：**[犹豫了很久，还是做了一个很久没敢做的事情](https://javaguide.cn/2019/01/02/chat/%E5%81%9A%E4%BA%86%E4%B8%80%E4%B8%AA%E5%BE%88%E4%B9%85%E6%B2%A1%E6%95%A2%E5%81%9A%E7%9A%84%E4%BA%8B%E6%83%85/)** ，优惠卷地址：[https://t.zsxq.com/iIqZBUR](https://t.zsxq.com/iIqZBUR) 。
|
||||
|
||||
【限时福利，最后一天】极客时间[《Java 并发编程面试必备》](#Java并发编程专栏)专栏限时特惠，购买之后的小伙伴加 [我的微信](#我的微信) 报上自己的极客时间大名可以找我会把24元返现退给大家，减轻各位学习成本。
|
||||
|
||||
<div align="center">
|
||||
<img src="http://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-11-16/49833984.jpg" width=""/>
|
||||
</br>
|
||||
|
||||
[](//shang.qq.com/wpa/qunwpa?idkey=10aee68bd241e739e59a8dfb0d4b33690bd3a4b5af0d09142cbdae2cb8c3966a)
|
||||
</br>
|
||||
微信交流群添加 [我的微信](#我的微信) 后回复关键字“加群”即可入群。
|
||||
|
||||
</div>
|
||||
<p align="center">
|
||||
<a href="https://github.com/Snailclimb/JavaGuide" target="_blank">
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3/logo - 副本.png" width=""/>
|
||||
</a>
|
||||
</p>
|
||||
|
||||
<p align="center">
|
||||
<a href="https://snailclimb.gitee.io/javaguide"><img src="https://img.shields.io/badge/阅读-read-brightgreen.svg" alt="阅读"></a>
|
||||
<a href="#联系我"><img src="https://img.shields.io/badge/chat-微信群-blue.svg" alt="微信群"></a>
|
||||
<a href="#公众号"><img src="https://img.shields.io/badge/%E5%85%AC%E4%BC%97%E5%8F%B7-JavaGuide-lightgrey.svg" alt="公众号"></a>
|
||||
<a href="#公众号"><img src="https://img.shields.io/badge/PDF-Java面试突击-important.svg" alt="公众号"></a>
|
||||
<a href="#投稿"><img src="https://img.shields.io/badge/support-投稿-critical.svg" alt="投稿"></a>
|
||||
<a href="https://xiaozhuanlan.com/javainterview?rel=javaguide"><img src="https://img.shields.io/badge/Java-面试指南-important" alt="投稿"></a>
|
||||
</p>
|
||||
|
||||
推荐使用 https://snailclimb.gitee.io/javaguide 在线阅读，在线阅读内容本仓库同步一致。这种方式阅读的优势在于：阅读体验会更好。
|
||||
|
||||
## 目录
|
||||
|
||||
- [:coffee: Java](#coffee-java)
|
||||
- [Java/J2EE 基础](#javaj2ee-基础)
|
||||
- [Java 集合框架](#java-集合框架)
|
||||
- [Java 多线程](#java-多线程)
|
||||
- [Java BIO,NIO,AIO](#java-bionioaio)
|
||||
- [Java 虚拟机 jvm](#java-虚拟机-jvm)
|
||||
- [:open_file_folder: 数据结构与算法](#open_file_folder-数据结构与算法)
|
||||
- [数据结构](#数据结构)
|
||||
- [算法](#算法)
|
||||
- [:computer: 计算机网络与数据通信](#computer-计算机网络与数据通信)
|
||||
- [网络相关](#网络相关)
|
||||
- [数据通信\(RESTful,RPC,消息队列\)总结](#数据通信restfulrpc消息队列总结)
|
||||
- [:iphone: 操作系统](#iphone-操作系统)
|
||||
- [Linux相关](#linux相关)
|
||||
- [:pencil2: 主流框架/软件](#pencil2-主流框架软件)
|
||||
- [Spring](#spring)
|
||||
- [ZooKeeper](#zookeeper)
|
||||
- [:floppy_disk: 数据存储](#floppy_disk-数据存储)
|
||||
- [MySQL](#mysql)
|
||||
- [Redis](#redis)
|
||||
- [:punch: 架构](#punch-架构)
|
||||
- [:musical_note: 面试必备](#musical_note-面试必备)
|
||||
- [备战春招/秋招系列](#备战春招秋招系列)
|
||||
- [最最最常见的Java面试题总结](#最最最常见的java面试题总结)
|
||||
- [Java学习/面试开源仓库推荐](#java学习面试开源仓库推荐)
|
||||
- [:art: 闲谈](#art-闲谈)
|
||||
- [:envelope: 说明](#envelope-说明)
|
||||
- [Java](#java)
|
||||
- [基础](#基础)
|
||||
- [容器](#容器)
|
||||
- [并发](#并发)
|
||||
- [JVM](#jvm)
|
||||
- [I/O](#io)
|
||||
- [Java 8](#java-8)
|
||||
- [优雅 Java 代码必备实践(Java编程规范)](#优雅-java-代码必备实践java编程规范)
|
||||
- [网络](#网络)
|
||||
- [操作系统](#操作系统)
|
||||
- [Linux相关](#linux相关)
|
||||
- [数据结构与算法](#数据结构与算法)
|
||||
- [数据结构](#数据结构)
|
||||
- [算法](#算法)
|
||||
- [数据库](#数据库)
|
||||
- [MySQL](#mysql)
|
||||
- [Redis](#redis)
|
||||
- [数据库扩展](#数据库扩展)
|
||||
- [系统设计](#系统设计)
|
||||
- [常用框架(Spring,SpringBoot)](#常用框架)
|
||||
- [数据通信/中间件(消息队列、RPC ... )](#数据通信中间件)
|
||||
- [权限认证](#权限认证)
|
||||
- [分布式 & 微服务](#分布式--微服务)
|
||||
- [API 网关](#api-网关)
|
||||
- [配置中心](#配置中心)
|
||||
- [唯一 id 生成](#唯一-id-生成)
|
||||
- [服务治理：服务注册与发现、服务路由控制](#服务治理服务注册与发现服务路由控制)
|
||||
- [大型网站架构](#大型网站架构)
|
||||
- [性能测试](#性能测试)
|
||||
- [高并发](#高并发)
|
||||
- [高可用](#高可用)
|
||||
- [设计模式(工厂模式、单例模式 ... )](#设计模式)
|
||||
- [面试指南](#面试指南)
|
||||
- [备战面试](#备战面试)
|
||||
- [面经](#面经)
|
||||
- [Java学习常见问题汇总](#java学习常见问题汇总)
|
||||
- [工具](#工具)
|
||||
- [Git](#git)
|
||||
- [Docker](#Docker)
|
||||
- [资源](#资源)
|
||||
- [书单](#书单)
|
||||
- [Github榜单](#Github榜单)
|
||||
- [待办](#待办)
|
||||
- [说明](#说明)
|
||||
|
||||
## 待办
|
||||
## Java
|
||||
|
||||
- [ ] Java 8 新特性总结
|
||||
- [x] BIO,NIO,AIO 总结
|
||||
- [ ] Netty 总结
|
||||
- [ ] 数据结构总结重构
|
||||
### 基础
|
||||
|
||||
|
||||
## :coffee: Java
|
||||
**基础知识系统总结：**
|
||||
|
||||
### Java/J2EE 基础
|
||||
* **[Java 基础知识回顾](docs/java/Java基础知识.md)**
|
||||
* **[Java 基础知识疑难点/易错点](docs/java/Java疑难点.md)**
|
||||
* **[一些重要的Java程序设计题](docs/java/Java程序设计题.md)**
|
||||
* [J2EE 基础知识回顾](docs/java/J2EE基础知识.md)
|
||||
|
||||
* [Java 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/Java基础知识.md)
|
||||
* [J2EE 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/J2EE基础知识.md)
|
||||
* [static、final、this、super关键字总结](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/final、static、this、super.md)
|
||||
* [static 关键字详解](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/static.md)
|
||||
|
||||
### Java 集合框架
|
||||
**重要知识点详解：**
|
||||
|
||||
* [这几道Java集合框架面试题几乎必问](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/这几道Java集合框架面试题几乎必问.md)
|
||||
* [Java 集合框架常见面试题总结](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/Java集合框架常见面试题总结.md)
|
||||
* [ArrayList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/ArrayList.md)
|
||||
* [【面试必备】透过源码角度一步一步带你分析 ArrayList 扩容机制](https://github.com/Snailclimb/JavaGuide/blob/master/Java相关/ArrayList-Grow.md)
|
||||
* [LinkedList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/LinkedList.md)
|
||||
* [HashMap(JDK1.8)源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/HashMap.md)
|
||||
|
||||
### Java 多线程
|
||||
* [多线程系列文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/多线程系列.md)
|
||||
* [并发编程面试必备：synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及 和ReenTrantLock 的对比](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/synchronized.md)
|
||||
* [并发编程面试必备：乐观锁与悲观锁](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/面试必备之乐观锁与悲观锁.md)
|
||||
* [并发编程面试必备：JUC 中的 Atomic 原子类总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Multithread/Atomic.md)
|
||||
* [并发编程面试必备：AQS 原理以及 AQS 同步组件总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Multithread/AQS.md)
|
||||
* [BATJ都爱问的多线程面试题](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Multithread/BATJ都爱问的多线程面试题.md)
|
||||
* [并发容器总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Multithread/并发容器总结.md)
|
||||
- [用好Java中的枚举,真的没有那么简单!](docs/java/basis/用好Java中的枚举,真的没有那么简单!)
|
||||
- [Java 常见关键字总结：final、static、this、super!](docs/java/basis/final、static、this、super.md)
|
||||
|
||||
### Java 虚拟机 jvm
|
||||
### 容器
|
||||
|
||||
* [可能是把Java内存区域讲的最清楚的一篇文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/可能是把Java内存区域讲的最清楚的一篇文章.md)
|
||||
* [搞定JVM垃圾回收就是这么简单](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/搞定JVM垃圾回收就是这么简单.md)
|
||||
* [《深入理解Java虚拟机》第2版学习笔记](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Java虚拟机（jvm）.md)
|
||||
**总结：**
|
||||
|
||||
* **[Java容器常见面试题/知识点总结](docs/java/collection/Java集合框架常见面试题.md)**
|
||||
|
||||
### Java BIO,NIO,AIO
|
||||
**源码学习：**
|
||||
|
||||
* [BIO,NIO,AIO 总结 ](https://github.com/Snailclimb/JavaGuide/blob/master/Java%E7%9B%B8%E5%85%B3/BIO%2CNIO%2CAIO%20summary.md)
|
||||
* [Java IO 与 NIO系列文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Java%20IO与NIO.md)
|
||||
* [ArrayList 源码学习](docs/java/collection/ArrayList.md)
|
||||
* [LinkedList 源码学习](docs/java/collection/LinkedList.md)
|
||||
* [HashMap(JDK1.8)源码学习](docs/java/collection/HashMap.md)
|
||||
|
||||
### 设计模式
|
||||
### 并发
|
||||
|
||||
* [设计模式系列文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/设计模式.md)
|
||||
**面试题总结：**
|
||||
|
||||
## :open_file_folder: 数据结构与算法
|
||||
|
||||
### 数据结构
|
||||
* **[Java 并发基础常见面试题总结](docs/java/Multithread/JavaConcurrencyBasicsCommonInterviewQuestionsSummary.md)**
|
||||
* **[Java 并发进阶常见面试题总结](docs/java/Multithread/JavaConcurrencyAdvancedCommonInterviewQuestions.md)**
|
||||
|
||||
* [数据结构知识学习与面试](https://github.com/Snailclimb/Java_Guide/blob/master/数据结构与算法/数据结构.md)
|
||||
**必备知识点：**
|
||||
|
||||
### 算法
|
||||
* [并发容器总结](docs/java/Multithread/并发容器总结.md)
|
||||
* **[Java线程池学习总结](./docs/java/Multithread/java线程池学习总结.md)**
|
||||
* [乐观锁与悲观锁](docs/essential-content-for-interview/面试必备之乐观锁与悲观锁.md)
|
||||
* [JUC 中的 Atomic 原子类总结](docs/java/Multithread/Atomic.md)
|
||||
* [AQS 原理以及 AQS 同步组件总结](docs/java/Multithread/AQS.md)
|
||||
|
||||
* [算法学习与面试](https://github.com/Snailclimb/Java_Guide/blob/master/数据结构与算法/算法.md)
|
||||
* [常见安全算法（MD5、SHA1、Base64等等）总结](https://github.com/Snailclimb/Java_Guide/blob/master/数据结构与算法/常见安全算法（MD5、SHA1、Base64等等）总结.md)
|
||||
* [算法总结——几道常见的子符串算法题 ](https://github.com/Snailclimb/Java_Guide/blob/master/数据结构与算法/搞定BAT面试——几道常见的子符串算法题.md)
|
||||
* [算法总结——几道常见的链表算法题 ](https://github.com/Snailclimb/Java_Guide/blob/master/数据结构与算法/Leetcode-LinkList1.md)
|
||||
### JVM
|
||||
|
||||
## :computer: 计算机网络与数据通信
|
||||
* **[一 Java内存区域](docs/java/jvm/Java内存区域.md)**
|
||||
* **[二 JVM垃圾回收](docs/java/jvm/JVM垃圾回收.md)**
|
||||
* [三 JDK 监控和故障处理工具](docs/java/jvm/JDK监控和故障处理工具总结.md)
|
||||
* [四 类文件结构](docs/java/jvm/类文件结构.md)
|
||||
* **[五 类加载过程](docs/java/jvm/类加载过程.md)**
|
||||
* [六 类加载器](docs/java/jvm/类加载器.md)
|
||||
* **[【待完成】八 最重要的 JVM 参数指南（翻译完善了一半）](docs/java/jvm/最重要的JVM参数指南.md)**
|
||||
* [九 JVM 配置常用参数和常用 GC 调优策略](docs/java/jvm/GC调优参数.md)
|
||||
* **[【加餐】大白话带你认识JVM](docs/java/jvm/[加餐]大白话带你认识JVM.md)**
|
||||
|
||||
### 网络相关
|
||||
### I/O
|
||||
|
||||
* [计算机网络常见面试题](https://github.com/Snailclimb/Java_Guide/blob/master/计算机网络与数据通信/计算机网络.md)
|
||||
* [计算机网络基础知识总结](https://github.com/Snailclimb/Java_Guide/blob/master/计算机网络与数据通信/干货：计算机网络知识总结.md)
|
||||
* [HTTPS中的TLS](https://github.com/Snailclimb/Java_Guide/blob/master/计算机网络与数据通信/HTTPS中的TLS.md)
|
||||
* [BIO,NIO,AIO 总结 ](docs/java/BIO-NIO-AIO.md)
|
||||
* [Java IO 与 NIO系列文章](docs/java/Java%20IO与NIO.md)
|
||||
|
||||
### 数据通信(RESTful,RPC,消息队列)总结
|
||||
### Java 8
|
||||
|
||||
* [数据通信(RESTful、RPC、消息队列)相关知识点总结](https://github.com/Snailclimb/Java-Guide/blob/master/计算机网络与数据通信/数据通信(RESTful、RPC、消息队列).md)
|
||||
* [Dubbo 总结：关于 Dubbo 的重要知识点](https://github.com/Snailclimb/Java-Guide/blob/master/计算机网络与数据通信/dubbo.md)
|
||||
* [消息队列总结：新手也能看懂，消息队列其实很简单](https://github.com/Snailclimb/Java-Guide/blob/master/计算机网络与数据通信/message-queue.md)
|
||||
* [一文搞懂 RabbitMQ 的重要概念以及安装](https://github.com/Snailclimb/Java-Guide/blob/master/计算机网络与数据通信/rabbitmq.md)
|
||||
* [Java 8 新特性总结](docs/java/What's%20New%20in%20JDK8/Java8Tutorial.md)
|
||||
* [Java 8 学习资源推荐](docs/java/What's%20New%20in%20JDK8/Java8教程推荐.md)
|
||||
* [Java8 forEach 指南](docs/java/What's%20New%20in%20JDK8/Java8foreach指南.md)
|
||||
|
||||
## :iphone: 操作系统
|
||||
### 优雅 Java 代码必备实践(Java编程规范)
|
||||
|
||||
* [Java 编程规范以及优雅 Java 代码实践总结](docs/java/Java编程规范.md)
|
||||
|
||||
## 网络
|
||||
|
||||
* [计算机网络常见面试题](docs/network/计算机网络.md)
|
||||
* [计算机网络基础知识总结](docs/network/干货：计算机网络知识总结.md)
|
||||
* [HTTPS中的TLS](docs/network/HTTPS中的TLS.md)
|
||||
|
||||
## 操作系统
|
||||
|
||||
### Linux相关
|
||||
|
||||
* [后端程序员必备的 Linux 基础知识](https://github.com/Snailclimb/Java-Guide/blob/master/操作系统/后端程序员必备的Linux基础知识.md)
|
||||
* [Shell 编程入门](https://github.com/Snailclimb/Java-Guide/blob/master/操作系统/Shell.md)
|
||||
## :pencil2: 主流框架/软件
|
||||
* [后端程序员必备的 Linux 基础知识](docs/operating-system/后端程序员必备的Linux基础知识.md)
|
||||
* [Shell 编程入门](docs/operating-system/Shell.md)
|
||||
|
||||
### Spring
|
||||
## 数据结构与算法
|
||||
|
||||
* [Spring 学习与面试](https://github.com/Snailclimb/Java_Guide/blob/master/主流框架/Spring学习与面试.md)
|
||||
* [Spring中bean的作用域与生命周期](https://github.com/Snailclimb/Java_Guide/blob/master/主流框架/SpringBean.md)
|
||||
* [SpringMVC 工作原理详解](https://github.com/Snailclimb/JavaGuide/blob/master/主流框架/SpringMVC%20%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86%E8%AF%A6%E8%A7%A3.md)
|
||||
### 数据结构
|
||||
|
||||
### ZooKeeper
|
||||
- [不了解布隆过滤器？一文给你整的明明白白！](docs/dataStructures-algorithms/data-structure/bloom-filter.md)
|
||||
- [数据结构知识学习与面试](docs/dataStructures-algorithms/数据结构.md)
|
||||
|
||||
* [可能是把 ZooKeeper 概念讲的最清楚的一篇文章](https://github.com/Snailclimb/Java_Guide/blob/master/主流框架/ZooKeeper.md)
|
||||
* [ZooKeeper 数据模型和常见命令了解一下，速度收藏！](https://github.com/Snailclimb/Java_Guide/blob/master/主流框架/ZooKeeper数据模型和常见命令.md)
|
||||
|
||||
## :floppy_disk: 数据存储
|
||||
### 算法
|
||||
|
||||
- [算法学习资源推荐](docs/dataStructures-algorithms/算法学习资源推荐.md)
|
||||
- [几道常见的字符串算法题总结 ](docs/dataStructures-algorithms/几道常见的子符串算法题.md)
|
||||
- [几道常见的链表算法题总结 ](docs/dataStructures-algorithms/几道常见的链表算法题.md)
|
||||
- [剑指offer部分编程题](docs/dataStructures-algorithms/剑指offer部分编程题.md)
|
||||
- [公司真题](docs/dataStructures-algorithms/公司真题.md)
|
||||
- [回溯算法经典案例之N皇后问题](docs/dataStructures-algorithms/Backtracking-NQueens.md)
|
||||
|
||||
## 数据库
|
||||
|
||||
### MySQL
|
||||
|
||||
* [MySQL 学习与面试](https://github.com/Snailclimb/Java_Guide/blob/master/数据存储/MySQL.md)
|
||||
* [【思维导图-索引篇】搞定数据库索引就是这么简单](https://github.com/Snailclimb/Java_Guide/blob/master/数据存储/MySQL%20Index.md)
|
||||
* **[【推荐】MySQL/数据库 知识点总结](docs/database/MySQL.md)**
|
||||
* **[阿里巴巴开发手册数据库部分的一些最佳实践](docs/database/阿里巴巴开发手册数据库部分的一些最佳实践.md)**
|
||||
* **[一千行MySQL学习笔记](docs/database/一千行MySQL命令.md)**
|
||||
* [MySQL高性能优化规范建议](docs/database/MySQL高性能优化规范建议.md)
|
||||
* [数据库索引总结](docs/database/MySQL%20Index.md)
|
||||
* [事务隔离级别(图文详解)](docs/database/事务隔离级别(图文详解).md)
|
||||
* [一条SQL语句在MySQL中如何执行的](docs/database/一条sql语句在mysql中如何执行的.md)
|
||||
|
||||
### Redis
|
||||
|
||||
* [Redis 总结](https://github.com/Snailclimb/Java_Guide/blob/master/数据存储/Redis/Redis.md)
|
||||
* [Redlock分布式锁](https://github.com/Snailclimb/Java_Guide/blob/master/数据存储/Redis/Redlock分布式锁.md)
|
||||
* [如何做可靠的分布式锁，Redlock真的可行么](https://github.com/Snailclimb/Java_Guide/blob/master/数据存储/Redis/如何做可靠的分布式锁，Redlock真的可行么.md)
|
||||
* [Redis 总结](docs/database/Redis/Redis.md)
|
||||
* [Redlock分布式锁](docs/database/Redis/Redlock分布式锁.md)
|
||||
* [如何做可靠的分布式锁，Redlock真的可行么](docs/database/Redis/如何做可靠的分布式锁，Redlock真的可行么.md)
|
||||
* [几种常见的 Redis 集群以及使用场景](docs/database/Redis/redis集群以及应用场景.md)
|
||||
|
||||
## :punch: 架构
|
||||
### 数据库扩展
|
||||
|
||||
* [一文读懂分布式应该学什么](https://github.com/Snailclimb/Java_Guide/blob/master/架构/分布式.md)
|
||||
* [8 张图读懂大型网站技术架构](https://github.com/Snailclimb/JavaGuide/blob/master/架构/8%20张图读懂大型网站技术架构.md)
|
||||
* [【面试精选】关于大型网站系统架构你不得不懂的10个问题](https://github.com/Snailclimb/JavaGuide/blob/master/架构/【面试精选】关于大型网站系统架构你不得不懂的10个问题.md)
|
||||
待办......
|
||||
|
||||
## :musical_note: 面试必备
|
||||
## 系统设计
|
||||
|
||||
### 备战春招/秋招系列
|
||||
### 常用框架
|
||||
|
||||
* [【备战春招/秋招系列1】程序员的简历就该这样写](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/程序员的简历之道.md)
|
||||
* [手把手教你用Markdown写一份高质量的简历](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/手把手教你用Markdown写一份高质量的简历.md)
|
||||
* [【备战春招/秋招系列2】初出茅庐的程序员该如何准备面试？](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/interviewPrepare.md)
|
||||
* [【备战春招/秋招系列3】Java程序员必备书单](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/books.md)
|
||||
* [ 【备战春招/秋招系列4】美团面经总结基础篇 （附详解答案）](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/美团-基础篇.md)
|
||||
* [ 【备战春招/秋招系列5】美团面经总结进阶篇 （附详解答案）](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/美团-进阶篇.md)
|
||||
* [ 【备战春招/秋招系列5】美团面经总结终结篇篇 （附详解答案）](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/美团-终结篇.md)
|
||||
#### Spring
|
||||
|
||||
### 最最最常见的Java面试题总结
|
||||
|
||||
这里会分享一些出现频率极其极其高的面试题，初定周更一篇，什么时候更完什么时候停止。
|
||||
|
||||
* [第一周（2018-8-7）](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/最最最常见的Java面试题总结/第一周（2018-8-7）.md) (为什么 Java 中只有值传递、==与equals、 hashCode与equals)
|
||||
* [第二周（2018-8-13）](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/最最最常见的Java面试题总结/第二周(2018-8-13).md)(String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的？、什么是反射机制？反射机制的应用场景有哪些？......)
|
||||
* [第三周（2018-08-22）](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/这几道Java集合框架面试题几乎必问.md) （Arraylist 与 LinkedList 异同、ArrayList 与 Vector 区别、HashMap的底层实现、HashMap 和 Hashtable 的区别、HashMap 的长度为什么是2的幂次方、HashSet 和 HashMap 区别、ConcurrentHashMap 和 Hashtable 的区别、ConcurrentHashMap线程安全的具体实现方式/底层具体实现、集合框架底层数据结构总结）
|
||||
* [第四周(2018-8-30).md](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/最最最常见的Java面试题总结/第四周(2018-8-30).md) （主要内容是几道面试常问的多线程基础题。）
|
||||
- [Spring 学习与面试](docs/system-design/framework/spring/Spring.md)
|
||||
- **[Spring 常见问题总结](docs/system-design/framework/spring/SpringInterviewQuestions.md)**
|
||||
- [Spring中 Bean 的作用域与生命周期](docs/system-design/framework/spring/SpringBean.md)
|
||||
- [SpringMVC 工作原理详解](docs/system-design/framework/spring/SpringMVC-Principle.md)
|
||||
- [Spring中都用到了那些设计模式?](docs/system-design/framework/spring/Spring-Design-Patterns.md)
|
||||
|
||||
### Java学习/面试开源仓库推荐
|
||||
#### SpringBoot
|
||||
|
||||
* [盘点一下Github上开源的Java面试/学习相关的仓库，看完弄懂薪资至少增加10k](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/JavaInterviewGithub.md)
|
||||
|
||||
## :art: 闲谈
|
||||
- **[SpringBoot 指南/常见面试题总结](https://github.com/Snailclimb/springboot-guide)**
|
||||
|
||||
* [选择技术方向都要考虑哪些因素](https://github.com/Snailclimb/Java-Guide/blob/master/其他/选择技术方向都要考虑哪些因素.md)
|
||||
* [结束了我短暂的秋招，说点自己的感受](https://github.com/Snailclimb/JavaGuide/blob/master/%E5%85%B6%E4%BB%96/2018%20%E7%A7%8B%E6%8B%9B.md)
|
||||
* [这7个问题，可能大部分Java程序员都比较关心吧！](https://github.com/Snailclimb/JavaGuide/blob/master/%E9%9D%A2%E8%AF%95%E5%BF%85%E5%A4%87/java%20programmer%20need%20know.md)
|
||||
* [【2018总结】即使平凡，也要热爱自己的生活](https://github.com/Snailclimb/JavaGuide/blob/master/%E5%85%B6%E4%BB%96/2018%20summary.md)
|
||||
### 数据通信/中间件
|
||||
|
||||
- [数据通信(RESTful、RPC、消息队列)相关知识点总结](docs/system-design/data-communication/summary.md)
|
||||
|
||||
#### RPC
|
||||
|
||||
- [Dubbo 总结：关于 Dubbo 的重要知识点](docs/system-design/data-communication/dubbo.md)
|
||||
- [服务之间的调用为啥不直接用 HTTP 而用 RPC？](docs/system-design/data-communication/why-use-rpc.md)
|
||||
|
||||
#### 消息队列
|
||||
|
||||
- [消息队列总结](docs/system-design/data-communication/message-queue.md)
|
||||
- [RabbitMQ 入门](docs/system-design/data-communication/rabbitmq.md)
|
||||
- [RocketMQ 入门](docs/system-design/data-communication/RocketMQ.md)
|
||||
- [RocketMQ的几个简单问题与答案](docs/system-design/data-communication/RocketMQ-Questions.md)
|
||||
- [Kafka入门看这一篇就够了](docs/system-design/data-communication/Kafka入门看这一篇就够了.md)
|
||||
- [Kafka系统设计开篇-面试看这篇就够了](docs/system-design/data-communication/Kafka系统设计开篇-面试看这篇就够了.md)
|
||||
|
||||
### 权限认证
|
||||
|
||||
- **[权限认证基础:区分Authentication,Authorization以及Cookie、Session、Token](docs/system-design/authority-certification/basis-of-authority-certification.md)**
|
||||
- **[JWT 优缺点分析以及常见问题解决方案](docs/system-design/authority-certification/JWT-advantages-and-disadvantages.md)**
|
||||
- **[适合初学者入门 Spring Security With JWT 的 Demo](https://github.com/Snailclimb/spring-security-jwt-guide)**
|
||||
|
||||
### 分布式 & 微服务
|
||||
|
||||
- [分布式应该学什么](docs/system-design/website-architecture/分布式.md)
|
||||
|
||||
#### API 网关
|
||||
|
||||
网关主要用于请求转发、安全认证、协议转换、容灾。
|
||||
|
||||
- [浅析如何设计一个亿级网关(API Gateway)](docs/system-design/micro-service/API网关.md)
|
||||
|
||||
#### 配置中心
|
||||
|
||||
待办......
|
||||
|
||||
#### 唯一 id 生成
|
||||
|
||||
- [分布式id生成方案总结](docs/system-design/micro-service/分布式id生成方案总结.md)
|
||||
|
||||
#### 服务治理：服务注册与发现、服务路由控制
|
||||
|
||||
**ZooKeeper:**
|
||||
|
||||
> 前两篇文章可能有内容重合部分，推荐都看一遍。
|
||||
|
||||
- [【入门】ZooKeeper 相关概念总结](docs/system-design/framework/ZooKeeper.md)
|
||||
- [【进阶】Zookeeper 原理简单入门！](docs/system-design/framework/ZooKeeper-plus.md)
|
||||
- [【拓展】ZooKeeper 数据模型和常见命令](docs/system-design/framework/ZooKeeper数据模型和常见命令.md)
|
||||
|
||||
### 大型网站架构
|
||||
|
||||
- [8 张图读懂大型网站技术架构](docs/system-design/website-architecture/8%20张图读懂大型网站技术架构.md)
|
||||
- [【面试精选】关于大型网站系统架构你不得不懂的10个问题](docs/system-design/website-architecture/关于大型网站系统架构你不得不懂的10个问题.md)
|
||||
|
||||
#### 性能测试
|
||||
|
||||
- [后端程序员也要懂的性能测试知识](https://articles.zsxq.com/id_lwl39teglv3d.html) （知识星球）
|
||||
|
||||
#### 高并发
|
||||
|
||||
待办......
|
||||
|
||||
#### 高可用
|
||||
|
||||
- [如何设计一个高可用系统？要考虑哪些地方？](docs/system-design/website-architecture/如何设计一个高可用系统？要考虑哪些地方？.md)
|
||||
|
||||
### 设计模式
|
||||
|
||||
- [设计模式系列文章](docs/system-design/设计模式.md)
|
||||
|
||||
## 面试指南
|
||||
|
||||
### 备战面试
|
||||
|
||||
* **[【备战面试1】程序员的简历就该这样写](docs/essential-content-for-interview/PreparingForInterview/程序员的简历之道.md)**
|
||||
* **[【备战面试2】初出茅庐的程序员该如何准备面试？](docs/essential-content-for-interview/PreparingForInterview/interviewPrepare.md)**
|
||||
* **[【备战面试3】7个大部分程序员在面试前很关心的问题](docs/essential-content-for-interview/PreparingForInterview/JavaProgrammerNeedKnow.md)**
|
||||
* **[【备战面试4】Github上开源的Java面试/学习相关的仓库推荐](docs/essential-content-for-interview/PreparingForInterview/JavaInterviewLibrary.md)**
|
||||
* **[【备战面试5】如果面试官问你“你有什么问题问我吗？”时，你该如何回答](docs/essential-content-for-interview/PreparingForInterview/面试官-你有什么问题要问我.md)**
|
||||
* [【备战面试6】应届生面试最爱问的几道 Java 基础问题](docs/essential-content-for-interview/PreparingForInterview/应届生面试最爱问的几道Java基础问题.md)
|
||||
* **[【备战面试6】美团面试常见问题总结(附详解答案)](docs/essential-content-for-interview/PreparingForInterview/美团面试常见问题总结.md)**
|
||||
* **[【备战面试7】一些刁难的面试问题总结](https://xiaozhuanlan.com/topic/9056431872)**
|
||||
|
||||
### 真实面试经历分析
|
||||
|
||||
- [我和阿里面试官的一次“邂逅”(附问题详解)](docs/essential-content-for-interview/real-interview-experience-analysis/alibaba-1.md)
|
||||
|
||||
### 面经
|
||||
|
||||
- [5面阿里,终获offer(2018年秋招)](docs/essential-content-for-interview/BATJrealInterviewExperience/5面阿里,终获offer.md)
|
||||
- [蚂蚁金服2019实习生面经总结(已拿口头offer)](docs/essential-content-for-interview/BATJrealInterviewExperience/蚂蚁金服实习生面经总结(已拿口头offer).md)
|
||||
- [2019年蚂蚁金服、头条、拼多多的面试总结](docs/essential-content-for-interview/BATJrealInterviewExperience/2019alipay-pinduoduo-toutiao.md)
|
||||
|
||||
## Java学习常见问题汇总
|
||||
|
||||
- [Java学习路线和方法推荐](docs/questions/java-learning-path-and-methods.md)
|
||||
- [Java培训四个月能学会吗？](docs/questions/java-training-4-month.md)
|
||||
- [新手学习Java，有哪些Java相关的博客，专栏，和技术学习网站推荐？](docs/questions/java-learning-website-blog.md)
|
||||
|
||||
## 工具
|
||||
|
||||
### Git
|
||||
|
||||
* [Git入门](docs/tools/Git.md)
|
||||
|
||||
### Docker
|
||||
|
||||
* [Docker 基本概念解读](docs/tools/Docker.md)
|
||||
* [一文搞懂 Docker 镜像的常用操作！](docs/tools/Docker-Image.md )
|
||||
|
||||
### 其他
|
||||
|
||||
- [阿里云服务器使用经验](docs/tools/阿里云服务器使用经验.md)
|
||||
|
||||
## 资源
|
||||
|
||||
### 书单
|
||||
|
||||
- [Java程序员必备书单](docs/data/java-recommended-books.md)
|
||||
|
||||
### 实战项目推荐
|
||||
|
||||
- [Github 上热门的 Spring Boot 项目实战推荐](docs/data/spring-boot-practical-projects.md)
|
||||
|
||||
### Github
|
||||
|
||||
- [Github 上 Star 数最多的 10 个项目，看完之后很意外!](docs/tools/github/github-star-ranking.md)
|
||||
- [年末将至，值得你关注的16个Java 开源项目！](docs/github-trending/2019-12.md)
|
||||
- [Java 项目月榜单](docs/github-trending/JavaGithubTrending.md)
|
||||
|
||||
***
|
||||
|
||||
## :envelope: 说明
|
||||
## 待办
|
||||
|
||||
### 项目介绍
|
||||
- [x] Java 多线程类别知识重构
|
||||
- [ ] Netty 总结(---正在进行中---)
|
||||
- [ ] 数据结构总结重构(---正在进行中---)
|
||||
|
||||
该文档主要是笔主在学习 Java 的过程中的一些学习笔记，但是为了能够涉及到大部分后端学习所需的技术知识点我也会偶尔引用一些别人的优秀文章的链接。文档大部分内容都是笔者参考书籍以及自己的原创。少部分面试题回答参考了其他人已有答案，上面都已注明。
|
||||
## 说明
|
||||
|
||||
该文档涉及的主要内容包括： Java、 数据结构与算法、计算机网络与数据通信、 操作系统、主流框架、数据存储、架构、面试必备知识点等等。相信不论你是前端还是后端都能在这份文档中收获到东西。
|
||||
### JavaGuide介绍
|
||||
|
||||
* **对于 Java 初学者来说：** 本文档倾向于给你提供一个比较详细的学习路径，让你对于Java整体的知识体系有一个初步认识。另外，本文的一些文章
|
||||
也是你学习和复习 Java 知识不错的实践；
|
||||
* **对于非 Java 初学者来说：** 本文档更适合回顾知识，准备面试，搞清面试应该把重心放在那些问题上。要搞清楚这个道理：提前知道那些面试常见，不是为了背下来应付面试，而是为了让你可以更有针对的学习重点。
|
||||
|
||||
Markdown 格式参考：[Github Markdown格式](https://guides.github.com/features/mastering-markdown/)，表情素材来自：[EMOJI CHEAT SHEET](https://www.webpagefx.com/tools/emoji-cheat-sheet/)。
|
||||
|
||||
利用 docsify 生成文档部署在 Github pages: [docsify 官网介绍](https://docsify.js.org/#/)
|
||||
|
||||
### 作者的其他开源项目推荐
|
||||
|
||||
1. [springboot-guide](https://github.com/Snailclimb/springboot-guide) : 适合新手入门以及有经验的开发人员查阅的 Spring Boot 教程（业余时间维护中，欢迎一起维护）。
|
||||
2. [programmer-advancement](https://github.com/Snailclimb/programmer-advancement) : 我觉得技术人员应该有的一些好习惯！
|
||||
3. [spring-security-jwt-guide](https://github.com/Snailclimb/spring-security-jwt-guide) :从零入门 ！Spring Security With JWT（含权限验证）后端部分代码。
|
||||
|
||||
### 关于转载
|
||||
|
||||
**如果需要引用到本仓库的一些东西，必须注明转载地址！！！毕竟大多都是手敲的，或者引用的是我的原创文章，希望大家尊重一下作者的劳动**:smiley::smiley::smiley:！
|
||||
如果你需要转载本仓库的一些文章到自己的博客的话，记得注明原文地址就可以了。
|
||||
|
||||
### 如何对该开源文档进行贡献
|
||||
|
||||
1. 笔记内容大多是手敲，所以难免会有笔误，你可以帮我找错别字。
|
||||
2. 很多知识点我可能没有涉及到，所以你可以对其他知识点进行补充。
|
||||
3. 现有的知识点难免存在不完善或者错误，所以你可以对已有知识点的修改/补充。
|
||||
3. 现有的知识点难免存在不完善或者错误，所以你可以对已有知识点进行修改/补充。
|
||||
|
||||
### 为什么要做这个开源文档？
|
||||
|
||||
在我们学习Java的时候，很多人会面临我不知道继续学什么或者面试会问什么的尴尬情况（我本人之前就很迷茫:smile:）。所以，我决定通过这个开源平台来帮助一些有需要的人，通过下面的内容，你会掌握系统的Java学习以及面试的相关知识。本来是想通过Gitbook的形式来制作的，后来想了想觉得可能有点大题小做 :grin: 。另外，我自己一个人的力量毕竟有限，希望各位有想法的朋友可以提issue。开源的最大目的是，让更多人参与进来，这样文档的正确性才能得以保障！
|
||||
初始想法源于自己的个人那一段比较迷茫的学习经历。主要目的是为了通过这个开源平台来帮助一些在学习 Java 或者面试过程中遇到问题的小伙伴。
|
||||
|
||||
### 最后
|
||||
### 投稿
|
||||
|
||||
本人会利用业余时间一直更新下去，目前还有很多地方不完善，一些知识点我会原创总结，还有一些知识点如果说网上有比较好的文章了，我会把这些文章加入进去。您也可以关注我的微信公众号：“Java面试通关手册”，我会在这里分享一些自己的原创文章。 另外该文档格式参考：[Github Markdown格式](https://guides.github.com/features/mastering-markdown/)，表情素材来自：[EMOJI CHEAT SHEET](https://www.webpagefx.com/tools/emoji-cheat-sheet/)。如果大家需要与我交流，可以扫描下方二维码添加我的微信：
|
||||
由于我个人能力有限，很多知识点我可能没有涉及到，所以你可以对其他知识点进行补充。大家也可以对自己的文章进行自荐，对于不错的文章不仅可以成功在本仓库展示出来更可以获得作者送出的 50 元左右的任意书籍进行奖励(当然你也可以直接折现50元)。
|
||||
|
||||
### 我的微信
|
||||
### 联系我
|
||||
|
||||
|
||||
添加我的微信备注“Github”,回复关键字 **“加群”** 即可入群。
|
||||
|
||||
### Java并发编程专栏
|
||||
|
||||
|
||||
微信扫描下方二维码，购买之后我会将自己得到的24元返现都还给你，减轻各位的学习成本！
|
||||
### Contributor
|
||||
|
||||
|
||||
下面是笔主收集的一些对本仓库提过有价值的pr或者issue的朋友，人数较多，如果你也对本仓库提过不错的pr或者issue的话，你可以加我的微信与我联系。下面的排名不分先后！
|
||||
|
||||
<a href="https://github.com/fanofxiaofeng">
|
||||
<img src="https://avatars0.githubusercontent.com/u/3983683?s=460&v=4" width="45px">
|
||||
</a>
|
||||
<a href="https://github.com/LiWenGu">
|
||||
<img src="https://avatars0.githubusercontent.com/u/15909210?s=460&v=4" width="45px">
|
||||
</a>
|
||||
<a href="https://github.com/fanchenggang">
|
||||
<img src="https://avatars2.githubusercontent.com/u/8225921?s=460&v=4" width="45px">
|
||||
</a>
|
||||
<a href="https://github.com/Rustin-Liu">
|
||||
<img src="https://avatars2.githubusercontent.com/u/29879298?s=400&v=4" width="45px">
|
||||
</a>
|
||||
|
||||
<a href="https://github.com/ipofss">
|
||||
<img src="https://avatars1.githubusercontent.com/u/5917359?s=460&v=4" width="45px"></a>
|
||||
<a href="https://github.com/Gene1994">
|
||||
<img src="https://avatars3.githubusercontent.com/u/24930369?s=460&v=4" width="45px">
|
||||
</a>
|
||||
<a href="https://github.com/spikesp">
|
||||
<img src="https://avatars0.githubusercontent.com/u/12581996?s=460&v=4" width="45px"></a>
|
||||
<a href="https://github.com/illusorycloud">
|
||||
<img src="https://avatars3.githubusercontent.com/u/31980412?s=460&v=4" width="45px">
|
||||
</a>
|
||||
<a href="https://github.com/kinglaw1204">
|
||||
<img src="https://avatars1.githubusercontent.com/u/20039931?s=460&v=4" width="45px">
|
||||
</a>
|
||||
<a href="https://github.com/jun1st">
|
||||
<img src="https://avatars2.githubusercontent.com/u/14312378?s=460&v=4" width="45px">
|
||||
</a>"
|
||||
<a href="https://github.com/fantasygg">
|
||||
<img src="https://avatars3.githubusercontent.com/u/13445354?s=460&v=4" width="45px">
|
||||
</a>
|
||||
<a href="https://github.com/debugjoker">
|
||||
<img src="https://avatars3.githubusercontent.com/u/26218005?s=460&v=4" width="45px">
|
||||
</a>
|
||||
<a href="https://github.com/zhyank">
|
||||
<img src="https://avatars0.githubusercontent.com/u/17696240?s=460&v=4" width="45px">
|
||||
</a>
|
||||
<a href="https://github.com/Goose9527">
|
||||
<img src="https://avatars2.githubusercontent.com/u/43314997?s=460&v=4" width="45px">
|
||||
</a>
|
||||
<a href="https://github.com/yuechuanx">
|
||||
<img src="https://avatars3.githubusercontent.com/u/19339293?s=460&v=4" width="45px">
|
||||
</a>
|
||||
<a href="https://github.com/cnLGMing">
|
||||
<img src="https://avatars2.githubusercontent.com/u/15910705?s=460&v=4" width="45px">
|
||||
</a>
|
||||
<a href="https://github.com/fanchenggang">
|
||||
<img src="https://avatars0.githubusercontent.com/u/20358122?s=460&v=4" width="45px">
|
||||
</a>
|
||||
|
||||
### 公众号
|
||||
|
||||
如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。我是 ThoughtWorks 准入职Java工程师。专注Java知识分享！开源 Java 学习指南——JavaGuide（12k+ Star）的作者。公众号多篇文章被各大技术社区转载。公众号后台回复关键字“1”可以领取一份我精选的Java资源哦！可以扫描下方二维码或者通过微信的搜一搜搜索ID：“Java_Guide”即可。
|
||||
如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。
|
||||
|
||||
**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"Java面试突击"** 即可免费领取！
|
||||
|
||||
|
||||
**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
|
||||
|
||||
|
||||
|
||||
13
_coverpage.md
Normal file
13
_coverpage.md
Normal file
@ -0,0 +1,13 @@
|
||||
<p align="center">
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3logo-透明.png" width=""/>
|
||||
</p>
|
||||
|
||||
<h1 align="center">Java 学习/面试指南</h1>
|
||||
|
||||
[常用资源](https://shimo.im/docs/MuiACIg1HlYfVxrj/)
|
||||
[GitHub](<https://github.com/Snailclimb/JavaGuide>)
|
||||
[开始阅读](#java)
|
||||
|
||||
|
||||
|
||||
|
||||
2
code/java/ThreadPoolExecutorDemo/.idea/.gitignore
generated
vendored
Normal file
2
code/java/ThreadPoolExecutorDemo/.idea/.gitignore
generated
vendored
Normal file
@ -0,0 +1,2 @@
|
||||
# Default ignored files
|
||||
/workspace.xml
|
||||
16
code/java/ThreadPoolExecutorDemo/.idea/checkstyle-idea.xml
generated
Normal file
16
code/java/ThreadPoolExecutorDemo/.idea/checkstyle-idea.xml
generated
Normal file
@ -0,0 +1,16 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="CheckStyle-IDEA">
|
||||
<option name="configuration">
|
||||
<map>
|
||||
<entry key="checkstyle-version" value="8.25" />
|
||||
<entry key="copy-libs" value="false" />
|
||||
<entry key="location-0" value="BUNDLED:(bundled):Sun Checks" />
|
||||
<entry key="location-1" value="BUNDLED:(bundled):Google Checks" />
|
||||
<entry key="scan-before-checkin" value="false" />
|
||||
<entry key="scanscope" value="JavaOnly" />
|
||||
<entry key="suppress-errors" value="false" />
|
||||
</map>
|
||||
</option>
|
||||
</component>
|
||||
</project>
|
||||
36
code/java/ThreadPoolExecutorDemo/.idea/inspectionProfiles/Project_Default.xml
generated
Normal file
36
code/java/ThreadPoolExecutorDemo/.idea/inspectionProfiles/Project_Default.xml
generated
Normal file
@ -0,0 +1,36 @@
|
||||
<component name="InspectionProjectProfileManager">
|
||||
<profile version="1.0">
|
||||
<option name="myName" value="Project Default" />
|
||||
<inspection_tool class="JavaDoc" enabled="true" level="WARNING" enabled_by_default="true">
|
||||
<option name="TOP_LEVEL_CLASS_OPTIONS">
|
||||
<value>
|
||||
<option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
|
||||
<option name="REQUIRED_TAGS" value="" />
|
||||
</value>
|
||||
</option>
|
||||
<option name="INNER_CLASS_OPTIONS">
|
||||
<value>
|
||||
<option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
|
||||
<option name="REQUIRED_TAGS" value="" />
|
||||
</value>
|
||||
</option>
|
||||
<option name="METHOD_OPTIONS">
|
||||
<value>
|
||||
<option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
|
||||
<option name="REQUIRED_TAGS" value="@return@param@throws or @exception" />
|
||||
</value>
|
||||
</option>
|
||||
<option name="FIELD_OPTIONS">
|
||||
<value>
|
||||
<option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
|
||||
<option name="REQUIRED_TAGS" value="" />
|
||||
</value>
|
||||
</option>
|
||||
<option name="IGNORE_DEPRECATED" value="false" />
|
||||
<option name="IGNORE_JAVADOC_PERIOD" value="true" />
|
||||
<option name="IGNORE_DUPLICATED_THROWS" value="false" />
|
||||
<option name="IGNORE_POINT_TO_ITSELF" value="false" />
|
||||
<option name="myAdditionalJavadocTags" value="date" />
|
||||
</inspection_tool>
|
||||
</profile>
|
||||
</component>
|
||||
6
code/java/ThreadPoolExecutorDemo/.idea/misc.xml
generated
Normal file
6
code/java/ThreadPoolExecutorDemo/.idea/misc.xml
generated
Normal file
@ -0,0 +1,6 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
|
||||
<output url="file://$PROJECT_DIR$/out" />
|
||||
</component>
|
||||
</project>
|
||||
8
code/java/ThreadPoolExecutorDemo/.idea/modules.xml
generated
Normal file
8
code/java/ThreadPoolExecutorDemo/.idea/modules.xml
generated
Normal file
@ -0,0 +1,8 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="ProjectModuleManager">
|
||||
<modules>
|
||||
<module fileurl="file://$PROJECT_DIR$/ThreadPoolExecutorDemo.iml" filepath="$PROJECT_DIR$/ThreadPoolExecutorDemo.iml" />
|
||||
</modules>
|
||||
</component>
|
||||
</project>
|
||||
124
code/java/ThreadPoolExecutorDemo/.idea/uiDesigner.xml
generated
Normal file
124
code/java/ThreadPoolExecutorDemo/.idea/uiDesigner.xml
generated
Normal file
@ -0,0 +1,124 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="Palette2">
|
||||
<group name="Swing">
|
||||
<item class="com.intellij.uiDesigner.HSpacer" tooltip-text="Horizontal Spacer" icon="/com/intellij/uiDesigner/icons/hspacer.png" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="1" hsize-policy="6" anchor="0" fill="1" />
|
||||
</item>
|
||||
<item class="com.intellij.uiDesigner.VSpacer" tooltip-text="Vertical Spacer" icon="/com/intellij/uiDesigner/icons/vspacer.png" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="6" hsize-policy="1" anchor="0" fill="2" />
|
||||
</item>
|
||||
<item class="javax.swing.JPanel" icon="/com/intellij/uiDesigner/icons/panel.png" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3" />
|
||||
</item>
|
||||
<item class="javax.swing.JScrollPane" icon="/com/intellij/uiDesigner/icons/scrollPane.png" removable="false" auto-create-binding="false" can-attach-label="true">
|
||||
<default-constraints vsize-policy="7" hsize-policy="7" anchor="0" fill="3" />
|
||||
</item>
|
||||
<item class="javax.swing.JButton" icon="/com/intellij/uiDesigner/icons/button.png" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="3" anchor="0" fill="1" />
|
||||
<initial-values>
|
||||
<property name="text" value="Button" />
|
||||
</initial-values>
|
||||
</item>
|
||||
<item class="javax.swing.JRadioButton" icon="/com/intellij/uiDesigner/icons/radioButton.png" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
|
||||
<initial-values>
|
||||
<property name="text" value="RadioButton" />
|
||||
</initial-values>
|
||||
</item>
|
||||
<item class="javax.swing.JCheckBox" icon="/com/intellij/uiDesigner/icons/checkBox.png" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="3" anchor="8" fill="0" />
|
||||
<initial-values>
|
||||
<property name="text" value="CheckBox" />
|
||||
</initial-values>
|
||||
</item>
|
||||
<item class="javax.swing.JLabel" icon="/com/intellij/uiDesigner/icons/label.png" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="0" anchor="8" fill="0" />
|
||||
<initial-values>
|
||||
<property name="text" value="Label" />
|
||||
</initial-values>
|
||||
</item>
|
||||
<item class="javax.swing.JTextField" icon="/com/intellij/uiDesigner/icons/textField.png" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
|
||||
<preferred-size width="150" height="-1" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JPasswordField" icon="/com/intellij/uiDesigner/icons/passwordField.png" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
|
||||
<preferred-size width="150" height="-1" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JFormattedTextField" icon="/com/intellij/uiDesigner/icons/formattedTextField.png" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1">
|
||||
<preferred-size width="150" height="-1" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JTextArea" icon="/com/intellij/uiDesigner/icons/textArea.png" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
|
||||
<preferred-size width="150" height="50" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JTextPane" icon="/com/intellij/uiDesigner/icons/textPane.png" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
|
||||
<preferred-size width="150" height="50" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JEditorPane" icon="/com/intellij/uiDesigner/icons/editorPane.png" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
|
||||
<preferred-size width="150" height="50" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JComboBox" icon="/com/intellij/uiDesigner/icons/comboBox.png" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="0" hsize-policy="2" anchor="8" fill="1" />
|
||||
</item>
|
||||
<item class="javax.swing.JTable" icon="/com/intellij/uiDesigner/icons/table.png" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
|
||||
<preferred-size width="150" height="50" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JList" icon="/com/intellij/uiDesigner/icons/list.png" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="6" hsize-policy="2" anchor="0" fill="3">
|
||||
<preferred-size width="150" height="50" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JTree" icon="/com/intellij/uiDesigner/icons/tree.png" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3">
|
||||
<preferred-size width="150" height="50" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JTabbedPane" icon="/com/intellij/uiDesigner/icons/tabbedPane.png" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
|
||||
<preferred-size width="200" height="200" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JSplitPane" icon="/com/intellij/uiDesigner/icons/splitPane.png" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="3" hsize-policy="3" anchor="0" fill="3">
|
||||
<preferred-size width="200" height="200" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JSpinner" icon="/com/intellij/uiDesigner/icons/spinner.png" removable="false" auto-create-binding="true" can-attach-label="true">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
|
||||
</item>
|
||||
<item class="javax.swing.JSlider" icon="/com/intellij/uiDesigner/icons/slider.png" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="8" fill="1" />
|
||||
</item>
|
||||
<item class="javax.swing.JSeparator" icon="/com/intellij/uiDesigner/icons/separator.png" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="6" hsize-policy="6" anchor="0" fill="3" />
|
||||
</item>
|
||||
<item class="javax.swing.JProgressBar" icon="/com/intellij/uiDesigner/icons/progressbar.png" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1" />
|
||||
</item>
|
||||
<item class="javax.swing.JToolBar" icon="/com/intellij/uiDesigner/icons/toolbar.png" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="6" anchor="0" fill="1">
|
||||
<preferred-size width="-1" height="20" />
|
||||
</default-constraints>
|
||||
</item>
|
||||
<item class="javax.swing.JToolBar$Separator" icon="/com/intellij/uiDesigner/icons/toolbarSeparator.png" removable="false" auto-create-binding="false" can-attach-label="false">
|
||||
<default-constraints vsize-policy="0" hsize-policy="0" anchor="0" fill="1" />
|
||||
</item>
|
||||
<item class="javax.swing.JScrollBar" icon="/com/intellij/uiDesigner/icons/scrollbar.png" removable="false" auto-create-binding="true" can-attach-label="false">
|
||||
<default-constraints vsize-policy="6" hsize-policy="0" anchor="0" fill="2" />
|
||||
</item>
|
||||
</group>
|
||||
</component>
|
||||
</project>
|
||||
6
code/java/ThreadPoolExecutorDemo/.idea/vcs.xml
generated
Normal file
6
code/java/ThreadPoolExecutorDemo/.idea/vcs.xml
generated
Normal file
@ -0,0 +1,6 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="VcsDirectoryMappings">
|
||||
<mapping directory="$PROJECT_DIR$/../../.." vcs="Git" />
|
||||
</component>
|
||||
</project>
|
||||
11
code/java/ThreadPoolExecutorDemo/ThreadPoolExecutorDemo.iml
Normal file
11
code/java/ThreadPoolExecutorDemo/ThreadPoolExecutorDemo.iml
Normal file
@ -0,0 +1,11 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<module type="JAVA_MODULE" version="4">
|
||||
<component name="NewModuleRootManager" inherit-compiler-output="true">
|
||||
<exclude-output />
|
||||
<content url="file://$MODULE_DIR$">
|
||||
<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
|
||||
</content>
|
||||
<orderEntry type="inheritedJdk" />
|
||||
<orderEntry type="sourceFolder" forTests="false" />
|
||||
</component>
|
||||
</module>
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -0,0 +1,49 @@
|
||||
package callable;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Date;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.ArrayBlockingQueue;
|
||||
import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.ExecutionException;
|
||||
import java.util.concurrent.Future;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import static common.ThreadPoolConstants.CORE_POOL_SIZE;
|
||||
import static common.ThreadPoolConstants.KEEP_ALIVE_TIME;
|
||||
import static common.ThreadPoolConstants.MAX_POOL_SIZE;
|
||||
import static common.ThreadPoolConstants.QUEUE_CAPACITY;
|
||||
|
||||
public class CallableDemo {
|
||||
public static void main(String[] args) {
|
||||
//使用阿里巴巴推荐的创建线程池的方式
|
||||
//通过ThreadPoolExecutor构造函数自定义参数创建
|
||||
ThreadPoolExecutor executor = new ThreadPoolExecutor(
|
||||
CORE_POOL_SIZE,
|
||||
MAX_POOL_SIZE,
|
||||
KEEP_ALIVE_TIME,
|
||||
TimeUnit.SECONDS,
|
||||
new ArrayBlockingQueue<>(QUEUE_CAPACITY),
|
||||
new ThreadPoolExecutor.CallerRunsPolicy());
|
||||
|
||||
List<Future<String>> futureList = new ArrayList<>();
|
||||
Callable<String> callable = new MyCallable();
|
||||
for (int i = 0; i < 10; i++) {
|
||||
//提交任务到线程池
|
||||
Future<String> future = executor.submit(callable);
|
||||
//将返回值 future 添加到 list，我们可以通过 future 获得 执行 Callable 得到的返回值
|
||||
futureList.add(future);
|
||||
}
|
||||
for (Future<String> fut : futureList) {
|
||||
try {
|
||||
System.out.println(new Date() + "::" + fut.get());
|
||||
} catch (InterruptedException | ExecutionException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
//关闭线程池
|
||||
executor.shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,13 @@
|
||||
package callable;
|
||||
|
||||
import java.util.concurrent.Callable;
|
||||
|
||||
public class MyCallable implements Callable<String> {
|
||||
|
||||
@Override
|
||||
public String call() throws Exception {
|
||||
Thread.sleep(1000);
|
||||
//返回执行当前 Callable 的线程名字
|
||||
return Thread.currentThread().getName();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
package common;
|
||||
|
||||
public class ThreadPoolConstants {
|
||||
public static final int CORE_POOL_SIZE = 5;
|
||||
public static final int MAX_POOL_SIZE = 10;
|
||||
public static final int QUEUE_CAPACITY = 100;
|
||||
public static final Long KEEP_ALIVE_TIME = 1L;
|
||||
private ThreadPoolConstants(){
|
||||
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,36 @@
|
||||
package threadPoolExecutor;
|
||||
|
||||
import java.util.Date;
|
||||
|
||||
/**
|
||||
* 这是一个简单的Runnable类，需要大约5秒钟来执行其任务。
|
||||
* @author shuang.kou
|
||||
*/
|
||||
public class MyRunnable implements Runnable {
|
||||
|
||||
private String command;
|
||||
|
||||
public MyRunnable(String s) {
|
||||
this.command = s;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
|
||||
processCommand();
|
||||
System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
|
||||
}
|
||||
|
||||
private void processCommand() {
|
||||
try {
|
||||
Thread.sleep(5000);
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return this.command;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,39 @@
|
||||
package threadPoolExecutor;
|
||||
|
||||
import java.util.concurrent.ArrayBlockingQueue;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import static common.ThreadPoolConstants.CORE_POOL_SIZE;
|
||||
import static common.ThreadPoolConstants.KEEP_ALIVE_TIME;
|
||||
import static common.ThreadPoolConstants.MAX_POOL_SIZE;
|
||||
import static common.ThreadPoolConstants.QUEUE_CAPACITY;
|
||||
|
||||
|
||||
public class ThreadPoolExecutorDemo {
|
||||
|
||||
public static void main(String[] args) {
|
||||
|
||||
//使用阿里巴巴推荐的创建线程池的方式
|
||||
//通过ThreadPoolExecutor构造函数自定义参数创建
|
||||
ThreadPoolExecutor executor = new ThreadPoolExecutor(
|
||||
CORE_POOL_SIZE,
|
||||
MAX_POOL_SIZE,
|
||||
KEEP_ALIVE_TIME,
|
||||
TimeUnit.SECONDS,
|
||||
new ArrayBlockingQueue<>(QUEUE_CAPACITY),
|
||||
new ThreadPoolExecutor.CallerRunsPolicy());
|
||||
|
||||
for (int i = 0; i < 10; i++) {
|
||||
//创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
|
||||
Runnable worker = new MyRunnable("" + i);
|
||||
//执行Runnable
|
||||
executor.execute(worker);
|
||||
}
|
||||
//终止线程池
|
||||
executor.shutdown();
|
||||
while (!executor.isTerminated()) {
|
||||
}
|
||||
System.out.println("Finished all threads");
|
||||
}
|
||||
}
|
||||
119
docs/data/java-recommended-books.md
Normal file
119
docs/data/java-recommended-books.md
Normal file
@ -0,0 +1,119 @@
|
||||
|
||||
<!-- TOC -->
|
||||
|
||||
- [Java](#java)
|
||||
- [基础](#基础)
|
||||
- [并发](#并发)
|
||||
- [JVM](#jvm)
|
||||
- [Java8 新特性](#java8-新特性)
|
||||
- [代码优化](#代码优化)
|
||||
- [网络](#网络)
|
||||
- [操作系统](#操作系统)
|
||||
- [数据结构与算法](#数据结构与算法)
|
||||
- [数据库](#数据库)
|
||||
- [系统设计](#系统设计)
|
||||
- [设计模式](#设计模式)
|
||||
- [常用框架](#常用框架)
|
||||
- [网站架构](#网站架构)
|
||||
- [软件底层](#软件底层)
|
||||
- [其他](#其他)
|
||||
|
||||
<!-- /TOC -->
|
||||
## Java
|
||||
|
||||
### 基础
|
||||
|
||||
- [《Head First Java》](https://book.douban.com/subject/2000732/)(推荐，豆瓣评分 8.7，1.0K+人评价)： 可以说是我的 Java 启蒙书籍了，特别适合新手读当然也适合我们用来温故 Java 知识点。
|
||||
- [《Java 核心技术卷 1+卷 2》](https://book.douban.com/subject/25762168/)（推荐）: 很棒的两本书，建议有点 Java 基础之后再读，介绍的还是比较深入的，非常推荐。这两本书我一般也会用来巩固知识点，是两本适合放在自己身边的好书。
|
||||
- [《JAVA 网络编程 第 4 版》](https://book.douban.com/subject/26259017/)： 可以系统的学习一下网络的一些概念以及网络编程在 Java 中的使用。
|
||||
- [《Java 编程思想 (第 4 版)》](https://book.douban.com/subject/2130190/)（推荐，豆瓣评分 9.1，3.2K+人评价）：大部分人称之为Java领域的圣经，但我不推荐初学者阅读，有点劝退的味道。稍微有点基础后阅读更好。
|
||||
- [《Java性能权威指南》](https://book.douban.com/subject/26740520/)（推荐，豆瓣评分 8.2，0.1K+人评价）：O'Reilly 家族书，性能调优的入门书，我个人觉得性能调优是每个 Java 从业者必备知识，这本书的缺点就是太老了，但是这本书可以作为一个实战书，尤其是 JVM 调优！不适合初学者。前置书籍：《深入理解 Java 虚拟机》
|
||||
|
||||
### 并发
|
||||
|
||||
- [《Java 并发编程之美》](<https://book.douban.com/subject/30351286/>) （推荐）：2018 年 10 月出版的一本书，个人感觉非常不错，对每个知识点的讲解都很棒。
|
||||
- [《Java 并发编程的艺术》](https://book.douban.com/subject/26591326/)（推荐，豆瓣评分 7.2，0.2K+人评价）： 这本书不是很适合作为 Java 并发入门书籍，需要具备一定的 JVM 基础。我感觉有些东西讲的还是挺深入的，推荐阅读。
|
||||
- [《实战 Java 高并发程序设计》](https://book.douban.com/subject/26663605/)（推荐,豆瓣评分 8.3）： 书的质量没的说，推荐大家好好看一下。
|
||||
- [《Java 高并发编程详解》](https://book.douban.com/subject/30255689/)（豆瓣评分 7.6）： 2018 年 6 月出版的一本书，内容很详细，但可能又有点过于啰嗦，不过这只是我的感觉。
|
||||
|
||||
### JVM
|
||||
|
||||
- [《深入理解 Java 虚拟机（第 2 版）周志明》](https://book.douban.com/subject/24722612/)（推荐，豆瓣评分 8.9，1.0K+人评价）：建议多刷几遍，书中的所有知识点可以通过 JAVA 运行时区域和 JAVA 的内存模型与线程两个大模块罗列完全。
|
||||
- [《实战 JAVA 虚拟机》](https://book.douban.com/subject/26354292/)（推荐，豆瓣评分 8.0，1.0K+人评价）：作为入门的了解 Java 虚拟机的知识还是不错的。
|
||||
|
||||
### Java8 新特性
|
||||
|
||||
- [《Java 8 实战》](https://book.douban.com/subject/26772632/) （推荐，豆瓣评分 9.2 ）：面向 Java 8 的技能升级，包括 Lambdas、流和函数式编程特性。实战系列的一贯风格让自己快速上手应用起来。Java 8 支持的 Lambda 是精简表达在语法上提供的支持。Java 8 提供了 Stream，学习和使用可以建立流式编程的认知。
|
||||
- [《Java 8 编程参考官方教程》](https://book.douban.com/subject/26556574/) （推荐，豆瓣评分 9.2）：也还不错吧。
|
||||
|
||||
### 代码优化
|
||||
|
||||
- [《重构_改善既有代码的设计》](https://book.douban.com/subject/4262627/)（推荐）：豆瓣 9.1 分，重构书籍的开山鼻祖。
|
||||
- [《Effective java 》](https://book.douban.com/subject/3360807/)（推荐，豆瓣评分 9.0，1.4K+人评价）：本书介绍了在 Java 编程中 78 条极具实用价值的经验规则，这些经验规则涵盖了大多数开发人员每天所面临的问题的解决方案。通过对 Java 平台设计专家所使用的技术的全面描述，揭示了应该做什么，不应该做什么才能产生清晰、健壮和高效的代码。本书中的每条规则都以简短、独立的小文章形式出现，并通过例子代码加以进一步说明。本书内容全面，结构清晰，讲解详细。可作为技术人员的参考用书。
|
||||
- [《代码整洁之道》](https://book.douban.com/subject/5442024/)（推荐，豆瓣评分 9.1）：虽然是用 Java 语言作为例子，全篇都是在阐述 Java 面向对象的思想，但是其中大部分内容其它语言也能应用到。
|
||||
- **阿里巴巴 Java 开发手册（详尽版）** [https://github.com/alibaba/p3c/blob/master/阿里巴巴 Java 开发手册（详尽版）.pdf](https://github.com/alibaba/p3c/blob/master/%E9%98%BF%E9%87%8C%E5%B7%B4%E5%B7%B4Java%E5%BC%80%E5%8F%91%E6%89%8B%E5%86%8C%EF%BC%88%E8%AF%A6%E5%B0%BD%E7%89%88%EF%BC%89.pdf)
|
||||
- **Google Java 编程风格指南：** <http://www.hawstein.com/posts/google-java-style.html>
|
||||
|
||||
|
||||
## 网络
|
||||
|
||||
- [《图解 HTTP》](https://book.douban.com/subject/25863515/)（推荐,豆瓣评分 8.1 , 1.6K+人评价）： 讲漫画一样的讲 HTTP，很有意思，不会觉得枯燥，大概也涵盖也 HTTP 常见的知识点。因为篇幅问题，内容可能不太全面。不过，如果不是专门做网络方向研究的小伙伴想研究 HTTP 相关知识的话，读这本书的话应该来说就差不多了。
|
||||
- [《HTTP 权威指南》](https://book.douban.com/subject/10746113/) （推荐,豆瓣评分 8.6）:如果要全面了解 HTTP 非此书不可！
|
||||
|
||||
## 操作系统
|
||||
|
||||
- [《鸟哥的 Linux 私房菜》](https://book.douban.com/subject/4889838/)（推荐，，豆瓣评分 9.1，0.3K+人评价）：本书是最具知名度的 Linux 入门书《鸟哥的 Linux 私房菜基础学习篇》的最新版，全面而详细地介绍了 Linux 操作系统。全书分为 5 个部分：第一部分着重说明 Linux 的起源及功能，如何规划和安装 Linux 主机；第二部分介绍 Linux 的文件系统、文件、目录与磁盘的管理；第三部分介绍文字模式接口 shell 和管理系统的好帮手 shell 脚本，另外还介绍了文字编辑器 vi 和 vim 的使用方法；第四部分介绍了对于系统安全非常重要的 Linux 账号的管理，以及主机系统与程序的管理，如查看进程、任务分配和作业管理；第五部分介绍了系统管理员 (root) 的管理事项，如了解系统运行状况、系统服务，针对登录文件进行解析，对系统进行备份以及核心的管理等。
|
||||
|
||||
## 数据结构与算法
|
||||
|
||||
- [《大话数据结构》](https://book.douban.com/subject/6424904/)（推荐，豆瓣评分 7.9 , 1K+人评价）：入门类型的书籍，读起来比较浅显易懂，适合没有数据结构基础或者说数据结构没学好的小伙伴用来入门数据结构。
|
||||
- [《数据结构与算法分析：C 语言描述》](https://book.douban.com/subject/1139426/)（推荐，豆瓣评分 8.9，1.6K+人评价）:本书是《Data Structures and Algorithm Analysis in C》一书第 2 版的简体中译本。原书曾被评为 20 世纪顶尖的 30 部计算机著作之一，作者 Mark Allen Weiss 在数据结构和算法分析方面卓有建树，他的数据结构和算法分析的著作尤其畅销，并受到广泛好评．已被世界 500 余所大学用作教材。
|
||||
- [《算法图解》](https://book.douban.com/subject/26979890/)（推荐，豆瓣评分 8.4，0.6K+人评价）：入门类型的书籍，读起来比较浅显易懂，适合没有算法基础或者说算法没学好的小伙伴用来入门。示例丰富，图文并茂，以让人容易理解的方式阐释了算法.读起来比较快，内容不枯燥！
|
||||
- [《算法 第四版》](https://book.douban.com/subject/10432347/)（推荐，豆瓣评分 9.3，0.4K+人评价）：Java 语言描述，算法领域经典的参考书，全面介绍了关于算法和数据结构的必备知识，并特别针对排序、搜索、图处理和字符串处理进行了论述。书的内容非常多，可以说是 Java 程序员的必备书籍之一了。
|
||||
|
||||
## 数据库
|
||||
|
||||
- [《高性能 MySQL》](https://book.douban.com/subject/23008813/)（推荐，豆瓣评分 9.3，0.4K+人评价）：mysql 领域的经典之作，拥有广泛的影响力。不但适合数据库管理员（dba）阅读，也适合开发人员参考学习。不管是数据库新手还是专家，相信都能从本书有所收获。
|
||||
- [《Redis 实战》](https://book.douban.com/subject/26612779/)：如果你想了解 Redis 的一些概念性知识的话，这本书真的非常不错。
|
||||
- [《Redis 设计与实现》](https://book.douban.com/subject/25900156/)（推荐，豆瓣评分 8.5，0.5K+人评价）：也还行吧！
|
||||
- [《MySQL 技术内幕-InnoDB 存储引擎》](<https://book.douban.com/subject/24708143/>)（推荐，豆瓣评分 8.7）：了解 InnoDB 存储引擎底层原理必备的一本书，比较深入。
|
||||
|
||||
## 系统设计
|
||||
|
||||
### 设计模式
|
||||
|
||||
- [《设计模式 : 可复用面向对象软件的基础》](https://book.douban.com/subject/1052241/) （推荐，豆瓣评分 9.1）：设计模式的经典！
|
||||
- [《Head First 设计模式（中文版）》](https://book.douban.com/subject/2243615/) （推荐，豆瓣评分 9.2）：相当赞的一本设计模式入门书籍。用实际的编程案例讲解算法设计中会遇到的各种问题和需求变更（对的，连需求变更都考虑到了！），并以此逐步推导出良好的设计模式解决办法。
|
||||
- [《大话设计模式》](https://book.douban.com/subject/2334288/) （推荐，豆瓣评分 8.3）：本书通篇都是以情景对话的形式，用多个小故事或编程示例来组织讲解GOF(即《设计模式 : 可复用面向对象软件的基础》这本书))，但是不像《设计模式 : 可复用面向对象软件的基础》难懂。但是设计模式只看书是不够的，还是需要在实际项目中运用，结合[设计模式](docs/system-design/设计模式.md)更佳！
|
||||
|
||||
### 常用框架
|
||||
|
||||
- [《深入分析 Java Web 技术内幕》](https://book.douban.com/subject/25953851/)： 感觉还行，涉及的东西也蛮多。
|
||||
- [《Netty 实战》](https://book.douban.com/subject/27038538/)（推荐，豆瓣评分 7.8，92 人评价）：内容很细，如果想学 Netty 的话，推荐阅读这本书！
|
||||
- [《从 Paxos 到 Zookeeper》](https://book.douban.com/subject/26292004/)（推荐，豆瓣评分 7.8，0.3K 人评价）：简要介绍几种典型的分布式一致性协议，以及解决分布式一致性问题的思路，其中重点讲解了 Paxos 和 ZAB 协议。同时，本书深入介绍了分布式一致性问题的工业解决方案——ZooKeeper，并着重向读者展示这一分布式协调框架的使用方法、内部实现及运维技巧，旨在帮助读者全面了解 ZooKeeper，并更好地使用和运维 ZooKeeper。
|
||||
- [《Spring 实战（第 4 版）》](https://book.douban.com/subject/26767354/)（推荐，豆瓣评分 8.3，0.3K+人评价）：不建议当做入门书籍读，入门的话可以找点国人的书或者视频看。这本定位就相当于是关于 Spring 的新华字典，只有一些基本概念的介绍和示例，涵盖了 Spring 的各个方面，但都不够深入。就像作者在最后一页写的那样：“学习 Spring，这才刚刚开始”。
|
||||
- [《RabbitMQ 实战指南》](https://book.douban.com/subject/27591386/)：《RabbitMQ 实战指南》从消息中间件的概念和 RabbitMQ 的历史切入，主要阐述 RabbitMQ 的安装、使用、配置、管理、运维、原理、扩展等方面的细节。如果你想浅尝 RabbitMQ 的使用，这本书是你最好的选择；如果你想深入 RabbitMQ 的原理，这本书也是你最好的选择；总之，如果你想玩转 RabbitMQ，这本书一定是最值得看的书之一
|
||||
- [《Spring Cloud 微服务实战》](https://book.douban.com/subject/27025912/)：从时下流行的微服务架构概念出发，详细介绍了 Spring Cloud 针对微服务架构中几大核心要素的解决方案和基础组件。对于各个组件的介绍，《Spring Cloud 微服务实战》主要以示例与源码结合的方式来帮助读者更好地理解这些组件的使用方法以及运行原理。同时，在介绍的过程中，还包含了作者在实践中所遇到的一些问题和解决思路，可供读者在实践中作为参考。
|
||||
- [《第一本 Docker 书》](https://book.douban.com/subject/26780404/)：Docker 入门书籍！
|
||||
- [《Spring Boot编程思想（核心篇）》](https://book.douban.com/subject/33390560/)（推荐，豆瓣评分 6.2）：SpringBoot深入书，不适合初学者。书尤其的厚，评分低的的理由是书某些知识过于拖沓，评分高的理由是书中对SpringBoot内部原理讲解很清楚。作者小马哥：Apache Dubbo PMC、Spring Cloud Alibaba项目架构师。B站作者地址：https://space.bilibili.com/327910845?from=search&seid=17095917016893398636。
|
||||
|
||||
### 网站架构
|
||||
|
||||
- [《大型网站技术架构：核心原理与案例分析+李智慧》](https://book.douban.com/subject/25723064/)（推荐）:这本书我读过，基本不需要你有什么基础啊~读起来特别轻松，但是却可以学到很多东西，非常推荐了。另外我写过这本书的思维导图，关注我的微信公众号：“Java 面试通关手册”回复“大型网站技术架构”即可领取思维导图。
|
||||
- [《亿级流量网站架构核心技术》](https://book.douban.com/subject/26999243/)（推荐）：一书总结并梳理了亿级流量网站高可用和高并发原则，通过实例详细介绍了如何落地这些原则。本书分为四部分：概述、高可用原则、高并发原则、案例实战。从负载均衡、限流、降级、隔离、超时与重试、回滚机制、压测与预案、缓存、池化、异步化、扩容、队列等多方面详细介绍了亿级流量网站的架构核心技术，让读者看后能快速运用到实践项目中。
|
||||
|
||||
### 软件底层
|
||||
|
||||
- [《深入剖析 Tomcat》](https://book.douban.com/subject/10426640/)（推荐，豆瓣评分 8.4，0.2K+人评价）：本书深入剖析 Tomcat 4 和 Tomcat 5 中的每个组件，并揭示其内部工作原理。通过学习本书，你将可以自行开发 Tomcat 组件，或者扩展已有的组件。 读完这本书，基本可以摆脱背诵面试题的尴尬。
|
||||
- [《深入理解 Nginx（第 2 版）》](https://book.douban.com/subject/26745255/)：作者讲的非常细致，注释都写的都很工整，对于 Nginx 的开发人员非常有帮助。优点是细致，缺点是过于细致，到处都是代码片段，缺少一些抽象。
|
||||
|
||||
## 其他
|
||||
|
||||
- [《黑客与画家》](https://read.douban.com/ebook/387525/?dcs=subject-rec&dcm=douban&dct=2243615)：这本书是硅谷创业之父，Y Combinator 创始人 Paul Graham 的文集。之所以叫这个名字，是因为作者认为黑客（并非负面的那个意思）与画家有着极大的相似性，他们都是在创造，而不是完成某个任务。
|
||||
- [《图解密码技术》](https://book.douban.com/subject/26265544/)（推荐，豆瓣评分 9.1，0.3K+人评价）：本书以**图配文**的形式，第一部分讲述了密码技术的历史沿革、对称密码、分组密码模式（包括ECB、CBC、CFB、OFB、CTR）、公钥、混合密码系统。第二部分重点介绍了认证方面的内容，涉及单向散列函数、消息认证码、数字签名、证书等。第三部分讲述了密钥、随机数、PGP、SSL/TLS 以及密码技术在现实生活中的应用。关键字：JWT 前置知识、区块链密码技术前置知识。属于密码知识入门书籍。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
66
docs/data/spring-boot-practical-projects.md
Normal file
66
docs/data/spring-boot-practical-projects.md
Normal file
@ -0,0 +1,66 @@
|
||||
最近经常被读者问到有没有 Spring Boot 实战项目可以学习，于是，我就去 Github 上找了 10 个我觉得还不错的实战项目。对于这些实战项目，有部分是比较适合 Spring Boot 刚入门的朋友学习的，还有一部分可能要求你对 Spring Boot 相关技术比较熟悉。需要的朋友可以根据个人实际情况进行选择。如果你对 Spring Boot 不太熟悉的话，可以看我最近开源的 springboot-guide：https://github.com/Snailclimb/springboot-guide 入门（还在持续更新中）。
|
||||
|
||||
### mall
|
||||
|
||||
- **Github地址**： [https://github.com/macrozheng/mall](https://github.com/macrozheng/mall)
|
||||
- **star**: 22.9k
|
||||
- **介绍**: mall项目是一套电商系统，包括前台商城系统及后台管理系统，基于SpringBoot+MyBatis实现。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。
|
||||
|
||||
### jeecg-boot
|
||||
|
||||
- **Github地址**：[https://github.com/zhangdaiscott/jeecg-boot](https://github.com/zhangdaiscott/jeecg-boot)
|
||||
- **star**: 6.4k
|
||||
- **介绍**: 一款基于代码生成器的JAVA快速开发平台！采用最新技术，前后端分离架构：SpringBoot 2.x，Ant Design&Vue，Mybatis，Shiro，JWT。强大的代码生成器让前后端代码一键生成，无需写任何代码，绝对是全栈开发福音！！ JeecgBoot的宗旨是提高UI能力的同时,降低前后分离的开发成本，JeecgBoot还独创在线开发模式，No代码概念，一系列在线智能开发：在线配置表单、在线配置报表、在线设计流程等等。
|
||||
|
||||
### eladmin
|
||||
|
||||
- **Github地址**：[https://github.com/elunez/eladmin](https://github.com/elunez/eladmin)
|
||||
- **star**: 3.9k
|
||||
- **介绍**: 项目基于 Spring Boot 2.1.0 、 Jpa、 Spring Security、redis、Vue的前后端分离的后台管理系统，项目采用分模块开发方式， 权限控制采用 RBAC，支持数据字典与数据权限管理，支持一键生成前后端代码，支持动态路由。
|
||||
|
||||
### paascloud-master
|
||||
|
||||
- **Github地址**：[https://github.com/paascloud/paascloud-master](https://github.com/paascloud/paascloud-master)
|
||||
- **star**: 5.9k
|
||||
- **介绍**: spring cloud + vue + oAuth2.0全家桶实战，前后端分离模拟商城，完整的购物流程、后端运营平台，可以实现快速搭建企业级微服务项目。支持微信登录等三方登录。
|
||||
|
||||
### vhr
|
||||
|
||||
- **Github地址**：[https://github.com/lenve/vhr](https://github.com/lenve/vhr)
|
||||
- **star**: 10.6k
|
||||
- **介绍**: 微人事是一个前后端分离的人力资源管理系统，项目采用SpringBoot+Vue开发。
|
||||
|
||||
### One mall
|
||||
|
||||
- **Github地址**：[https://github.com/YunaiV/onemall](https://github.com/YunaiV/onemall)
|
||||
- **star**: 1.2k
|
||||
- **介绍**: mall 商城，基于微服务的思想，构建在 B2C 电商场景下的项目实战。核心技术栈，是 Spring Boot + Dubbo 。未来，会重构成 Spring Cloud Alibaba 。
|
||||
|
||||
### Guns
|
||||
|
||||
- **Github地址**：[https://github.com/stylefeng/Guns](https://github.com/stylefeng/Guns)
|
||||
- **star**: 2.3k
|
||||
- **介绍**: Guns基于SpringBoot 2，致力于做更简洁的后台管理系统，完美整合springmvc + shiro + mybatis-plus + beetl!Guns项目代码简洁，注释丰富，上手容易，同时Guns包含许多基础模块(用户管理，角色管理，部门管理，字典管理等10个模块)，可以直接作为一个后台管理系统的脚手架!
|
||||
|
||||
### SpringCloud
|
||||
|
||||
- **Github地址**：[https://github.com/YunaiV/onemall](https://github.com/YunaiV/onemall)
|
||||
- **star**: 1.2k
|
||||
- **介绍**: mall 商城，基于微服务的思想，构建在 B2C 电商场景下的项目实战。核心技术栈，是 Spring Boot + Dubbo 。未来，会重构成 Spring Cloud Alibaba 。
|
||||
|
||||
### SpringBoot-Shiro-Vue
|
||||
|
||||
- **Github地址**：[https://github.com/Heeexy/SpringBoot-Shiro-Vue](https://github.com/Heeexy/SpringBoot-Shiro-Vue)
|
||||
- **star**: 1.8k
|
||||
- **介绍**: 提供一套基于Spring Boot-Shiro-Vue的权限管理思路.前后端都加以控制,做到按钮/接口级别的权限。
|
||||
|
||||
### newbee-mall
|
||||
|
||||
最近开源的一个商城项目。
|
||||
|
||||
- **Github地址**：[https://github.com/newbee-ltd/newbee-mall](https://github.com/newbee-ltd/newbee-mall)
|
||||
- **star**: 50
|
||||
- **介绍**: newbee-mall 项目是一套电商系统，包括 newbee-mall 商城系统及 newbee-mall-admin 商城后台管理系统，基于 Spring Boot 2.X 及相关技术栈开发。 前台商城系统包含首页门户、商品分类、新品上线、首页轮播、商品推荐、商品搜索、商品展示、购物车、订单结算、订单流程、个人订单管理、会员中心、帮助中心等模块。 后台管理系统包含数据面板、轮播图管理、商品管理、订单管理、会员管理、分类管理、设置等模块。
|
||||
|
||||
|
||||
|
||||
145
docs/dataStructures-algorithms/Backtracking-NQueens.md
Normal file
145
docs/dataStructures-algorithms/Backtracking-NQueens.md
Normal file
@ -0,0 +1,145 @@
|
||||
# N皇后
|
||||
[51. N皇后](https://leetcode-cn.com/problems/n-queens/)
|
||||
### 题目描述
|
||||
> n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
|
||||
>
|
||||
|
||||
>
|
||||
上图为 8 皇后问题的一种解法。
|
||||
>
|
||||
给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。
|
||||
>
|
||||
每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。
|
||||
|
||||
示例：
|
||||
|
||||
```
|
||||
输入: 4
|
||||
输出: [
|
||||
[".Q..", // 解法 1
|
||||
"...Q",
|
||||
"Q...",
|
||||
"..Q."],
|
||||
|
||||
["..Q.", // 解法 2
|
||||
"Q...",
|
||||
"...Q",
|
||||
".Q.."]
|
||||
]
|
||||
解释: 4 皇后问题存在两个不同的解法。
|
||||
```
|
||||
|
||||
### 问题分析
|
||||
约束条件为每个棋子所在的行、列、对角线都不能有另一个棋子。
|
||||
|
||||
使用一维数组表示一种解法，下标（index）表示行，值（value）表示该行的Q（皇后）在哪一列。
|
||||
每行只存储一个元素，然后递归到下一行，这样就不用判断行了，只需要判断列和对角线。
|
||||
### Solution1
|
||||
当result[row] = column时，即row行的棋子在column列。
|
||||
|
||||
对于[0, row-1]的任意一行（i 行），若 row 行的棋子和 i 行的棋子在同一列，则有result[i] == column;
|
||||
若 row 行的棋子和 i 行的棋子在同一对角线，等腰直角三角形两直角边相等，即 row - i == Math.abs(result[i] - column)
|
||||
|
||||
布尔类型变量 isValid 的作用是剪枝，减少不必要的递归。
|
||||
```
|
||||
public List<List<String>> solveNQueens(int n) {
|
||||
// 下标代表行，值代表列。如result[0] = 3 表示第1行的Q在第3列
|
||||
int[] result = new int[n];
|
||||
List<List<String>> resultList = new LinkedList<>();
|
||||
dfs(resultList, result, 0, n);
|
||||
return resultList;
|
||||
}
|
||||
|
||||
void dfs(List<List<String>> resultList, int[] result, int row, int n) {
|
||||
// 递归终止条件
|
||||
if (row == n) {
|
||||
List<String> list = new LinkedList<>();
|
||||
for (int x = 0; x < n; ++x) {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (int y = 0; y < n; ++y)
|
||||
sb.append(result[x] == y ? "Q" : ".");
|
||||
list.add(sb.toString());
|
||||
}
|
||||
resultList.add(list);
|
||||
return;
|
||||
}
|
||||
for (int column = 0; column < n; ++column) {
|
||||
boolean isValid = true;
|
||||
result[row] = column;
|
||||
/*
|
||||
* 逐行往下考察每一行。同列，result[i] == column
|
||||
* 同对角线，row - i == Math.abs(result[i] - column)
|
||||
*/
|
||||
for (int i = row - 1; i >= 0; --i) {
|
||||
if (result[i] == column || row - i == Math.abs(result[i] - column)) {
|
||||
isValid = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (isValid) dfs(resultList, result, row + 1, n);
|
||||
}
|
||||
}
|
||||
```
|
||||
### Solution2
|
||||
使用LinkedList表示一种解法，下标（index）表示行，值（value）表示该行的Q（皇后）在哪一列。
|
||||
|
||||
解法二和解法一的不同在于，相同列以及相同对角线的校验。
|
||||
将对角线抽象成【一次函数】这个简单的数学模型，根据一次函数的截距是常量这一特性进行校验。
|
||||
|
||||
这里，我将右上-左下对角线，简称为“\”对角线；左上-右下对角线简称为“/”对角线。
|
||||
|
||||
“/”对角线斜率为1，对应方程为y = x + b，其中b为截距。
|
||||
对于线上任意一点，均有y - x = b，即row - i = b;
|
||||
定义一个布尔类型数组anti_diag，将b作为下标，当anti_diag[b] = true时，表示相应对角线上已经放置棋子。
|
||||
但row - i有可能为负数，负数不能作为数组下标，row - i 的最小值为-n（当row = 0，i = n时），可以加上n作为数组下标，即将row -i + n 作为数组下标。
|
||||
row - i + n 的最大值为 2n（当row = n，i = 0时），故anti_diag的容量设置为 2n 即可。
|
||||
|
||||
|
||||
|
||||
“\”对角线斜率为-1，对应方程为y = -x + b，其中b为截距。
|
||||
对于线上任意一点，均有y + x = b，即row + i = b;
|
||||
同理，定义数组main_diag，将b作为下标，当main_diag[row + i] = true时，表示相应对角线上已经放置棋子。
|
||||
|
||||
有了两个校验对角线的数组，再来定义一个用于校验列的数组cols，这个太简单啦，不解释。
|
||||
|
||||
**解法二时间复杂度为O(n!)，在校验相同列和相同对角线时，引入三个布尔类型数组进行判断。相比解法一，少了一层循环，用空间换时间。**
|
||||
|
||||
```
|
||||
List<List<String>> resultList = new LinkedList<>();
|
||||
|
||||
public List<List<String>> solveNQueens(int n) {
|
||||
boolean[] cols = new boolean[n];
|
||||
boolean[] main_diag = new boolean[2 * n];
|
||||
boolean[] anti_diag = new boolean[2 * n];
|
||||
LinkedList<Integer> result = new LinkedList<>();
|
||||
dfs(result, 0, cols, main_diag, anti_diag, n);
|
||||
return resultList;
|
||||
}
|
||||
|
||||
void dfs(LinkedList<Integer> result, int row, boolean[] cols, boolean[] main_diag, boolean[] anti_diag, int n) {
|
||||
if (row == n) {
|
||||
List<String> list = new LinkedList<>();
|
||||
for (int x = 0; x < n; ++x) {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (int y = 0; y < n; ++y)
|
||||
sb.append(result.get(x) == y ? "Q" : ".");
|
||||
list.add(sb.toString());
|
||||
}
|
||||
resultList.add(list);
|
||||
return;
|
||||
}
|
||||
for (int i = 0; i < n; ++i) {
|
||||
if (cols[i] || main_diag[row + i] || anti_diag[row - i + n])
|
||||
continue;
|
||||
result.add(i);
|
||||
cols[i] = true;
|
||||
main_diag[row + i] = true;
|
||||
anti_diag[row - i + n] = true;
|
||||
dfs(result, row + 1, cols, main_diag, anti_diag, n);
|
||||
result.removeLast();
|
||||
cols[i] = false;
|
||||
main_diag[row + i] = false;
|
||||
anti_diag[row - i + n] = false;
|
||||
}
|
||||
}
|
||||
```
|
||||
297
docs/dataStructures-algorithms/data-structure/bloom-filter.md
Normal file
297
docs/dataStructures-algorithms/data-structure/bloom-filter.md
Normal file
@ -0,0 +1,297 @@
|
||||
海量数据处理以及缓存穿透这两个场景让我认识了 布隆过滤器 ，我查阅了一些资料来了解它，但是很多现成资料并不满足我的需求，所以就决定自己总结一篇关于布隆过滤器的文章。希望通过这篇文章让更多人了解布隆过滤器，并且会实际去使用它！
|
||||
|
||||
下面我们将分为几个方面来介绍布隆过滤器：
|
||||
|
||||
1. 什么是布隆过滤器？
|
||||
2. 布隆过滤器的原理介绍。
|
||||
3. 布隆过滤器使用场景。
|
||||
4. 通过 Java 编程手动实现布隆过滤器。
|
||||
5. 利用Google开源的Guava中自带的布隆过滤器。
|
||||
6. Redis 中的布隆过滤器。
|
||||
|
||||
### 1.什么是布隆过滤器？
|
||||
|
||||
首先，我们需要了解布隆过滤器的概念。
|
||||
|
||||
布隆过滤器（Bloom Filter）是一个叫做 Bloom 的老哥于1970年提出的。我们可以把它看作由二进制向量（或者说位数组）和一系列随机映射函数（哈希函数）两部分组成的数据结构。相比于我们平时常用的的 List、Map 、Set 等数据结构，它占用空间更少并且效率更高，但是缺点是其返回的结果是概率性的，而不是非常准确的。理论情况下添加到集合中的元素越多，误报的可能性就越大。并且，存放在布隆过滤器的数据不容易删除。
|
||||
|
||||
|
||||
|
||||
位数组中的每个元素都只占用 1 bit ，并且每个元素只能是 0 或者 1。这样申请一个 100w 个元素的位数组只占用 1000000Bit / 8 = 125000 Byte = 125000/1024 kb ≈ 122kb 的空间。
|
||||
|
||||
总结：**一个名叫 Bloom 的人提出了一种来检索元素是否在给定大集合中的数据结构，这种数据结构是高效且性能很好的，但缺点是具有一定的错误识别率和删除难度。并且，理论情况下，添加到集合中的元素越多，误报的可能性就越大。**
|
||||
|
||||
### 2.布隆过滤器的原理介绍
|
||||
|
||||
**当一个元素加入布隆过滤器中的时候，会进行如下操作：**
|
||||
|
||||
1. 使用布隆过滤器中的哈希函数对元素值进行计算，得到哈希值（有几个哈希函数得到几个哈希值）。
|
||||
2. 根据得到的哈希值，在位数组中把对应下标的值置为 1。
|
||||
|
||||
**当我们需要判断一个元素是否存在于布隆过滤器的时候，会进行如下操作：**
|
||||
|
||||
1. 对给定元素再次进行相同的哈希计算；
|
||||
2. 得到值之后判断位数组中的每个元素是否都为 1，如果值都为 1，那么说明这个值在布隆过滤器中，如果存在一个值不为 1，说明该元素不在布隆过滤器中。
|
||||
|
||||
举个简单的例子：
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
如图所示，当字符串存储要加入到布隆过滤器中时，该字符串首先由多个哈希函数生成不同的哈希值，然后在对应的位数组的下表的元素设置为 1（当位数组初始化时 ，所有位置均为0）。当第二次存储相同字符串时，因为先前的对应位置已设置为1，所以很容易知道此值已经存在（去重非常方便）。
|
||||
|
||||
如果我们需要判断某个字符串是否在布隆过滤器中时，只需要对给定字符串再次进行相同的哈希计算，得到值之后判断位数组中的每个元素是否都为 1，如果值都为 1，那么说明这个值在布隆过滤器中，如果存在一个值不为 1，说明该元素不在布隆过滤器中。
|
||||
|
||||
**不同的字符串可能哈希出来的位置相同，这种情况我们可以适当增加位数组大小或者调整我们的哈希函数。**
|
||||
|
||||
综上，我们可以得出：**布隆过滤器说某个元素存在，小概率会误判。布隆过滤器说某个元素不在，那么这个元素一定不在。**
|
||||
|
||||
### 3.布隆过滤器使用场景
|
||||
|
||||
1. 判断给定数据是否存在：比如判断一个数字是否在于包含大量数字的数字集中（数字集很大，5亿以上！）、 防止缓存穿透（判断请求的数据是否有效避免直接绕过缓存请求数据库）等等、邮箱的垃圾邮件过滤、黑名单功能等等。
|
||||
2. 去重：比如爬给定网址的时候对已经爬取过的 URL 去重。
|
||||
|
||||
### 4.通过 Java 编程手动实现布隆过滤器
|
||||
|
||||
我们上面已经说了布隆过滤器的原理，知道了布隆过滤器的原理之后就可以自己手动实现一个了。
|
||||
|
||||
如果你想要手动实现一个的话，你需要：
|
||||
|
||||
1. 一个合适大小的位数组保存数据
|
||||
2. 几个不同的哈希函数
|
||||
3. 添加元素到位数组（布隆过滤器）的方法实现
|
||||
4. 判断给定元素是否存在于位数组（布隆过滤器）的方法实现。
|
||||
|
||||
下面给出一个我觉得写的还算不错的代码（参考网上已有代码改进得到，对于所有类型对象皆适用）：
|
||||
|
||||
```java
|
||||
import java.util.BitSet;
|
||||
|
||||
public class MyBloomFilter {
|
||||
|
||||
/**
|
||||
* 位数组的大小
|
||||
*/
|
||||
private static final int DEFAULT_SIZE = 2 << 24;
|
||||
/**
|
||||
* 通过这个数组可以创建 6 个不同的哈希函数
|
||||
*/
|
||||
private static final int[] SEEDS = new int[]{3, 13, 46, 71, 91, 134};
|
||||
|
||||
/**
|
||||
* 位数组。数组中的元素只能是 0 或者 1
|
||||
*/
|
||||
private BitSet bits = new BitSet(DEFAULT_SIZE);
|
||||
|
||||
/**
|
||||
* 存放包含 hash 函数的类的数组
|
||||
*/
|
||||
private SimpleHash[] func = new SimpleHash[SEEDS.length];
|
||||
|
||||
/**
|
||||
* 初始化多个包含 hash 函数的类的数组，每个类中的 hash 函数都不一样
|
||||
*/
|
||||
public MyBloomFilter() {
|
||||
// 初始化多个不同的 Hash 函数
|
||||
for (int i = 0; i < SEEDS.length; i++) {
|
||||
func[i] = new SimpleHash(DEFAULT_SIZE, SEEDS[i]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 添加元素到位数组
|
||||
*/
|
||||
public void add(Object value) {
|
||||
for (SimpleHash f : func) {
|
||||
bits.set(f.hash(value), true);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 判断指定元素是否存在于位数组
|
||||
*/
|
||||
public boolean contains(Object value) {
|
||||
boolean ret = true;
|
||||
for (SimpleHash f : func) {
|
||||
ret = ret && bits.get(f.hash(value));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* 静态内部类。用于 hash 操作！
|
||||
*/
|
||||
public static class SimpleHash {
|
||||
|
||||
private int cap;
|
||||
private int seed;
|
||||
|
||||
public SimpleHash(int cap, int seed) {
|
||||
this.cap = cap;
|
||||
this.seed = seed;
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算 hash 值
|
||||
*/
|
||||
public int hash(Object value) {
|
||||
int h;
|
||||
return (value == null) ? 0 : Math.abs(seed * (cap - 1) & ((h = value.hashCode()) ^ (h >>> 16)));
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
测试：
|
||||
|
||||
```java
|
||||
String value1 = "https://javaguide.cn/";
|
||||
String value2 = "https://github.com/Snailclimb";
|
||||
MyBloomFilter filter = new MyBloomFilter();
|
||||
System.out.println(filter.contains(value1));
|
||||
System.out.println(filter.contains(value2));
|
||||
filter.add(value1);
|
||||
filter.add(value2);
|
||||
System.out.println(filter.contains(value1));
|
||||
System.out.println(filter.contains(value2));
|
||||
```
|
||||
|
||||
Output:
|
||||
|
||||
```
|
||||
false
|
||||
false
|
||||
true
|
||||
true
|
||||
```
|
||||
|
||||
测试：
|
||||
|
||||
```java
|
||||
Integer value1 = 13423;
|
||||
Integer value2 = 22131;
|
||||
MyBloomFilter filter = new MyBloomFilter();
|
||||
System.out.println(filter.contains(value1));
|
||||
System.out.println(filter.contains(value2));
|
||||
filter.add(value1);
|
||||
filter.add(value2);
|
||||
System.out.println(filter.contains(value1));
|
||||
System.out.println(filter.contains(value2));
|
||||
```
|
||||
|
||||
Output:
|
||||
|
||||
```java
|
||||
false
|
||||
false
|
||||
true
|
||||
true
|
||||
```
|
||||
|
||||
### 5.利用Google开源的 Guava中自带的布隆过滤器
|
||||
|
||||
自己实现的目的主要是为了让自己搞懂布隆过滤器的原理，Guava 中布隆过滤器的实现算是比较权威的，所以实际项目中我们不需要手动实现一个布隆过滤器。
|
||||
|
||||
首先我们需要在项目中引入 Guava 的依赖：
|
||||
|
||||
```java
|
||||
<dependency>
|
||||
<groupId>com.google.guava</groupId>
|
||||
<artifactId>guava</artifactId>
|
||||
<version>28.0-jre</version>
|
||||
</dependency>
|
||||
```
|
||||
|
||||
实际使用如下：
|
||||
|
||||
我们创建了一个最多存放 最多 1500个整数的布隆过滤器，并且我们可以容忍误判的概率为百分之（0.01）
|
||||
|
||||
```java
|
||||
// 创建布隆过滤器对象
|
||||
BloomFilter<Integer> filter = BloomFilter.create(
|
||||
Funnels.integerFunnel(),
|
||||
1500,
|
||||
0.01);
|
||||
// 判断指定元素是否存在
|
||||
System.out.println(filter.mightContain(1));
|
||||
System.out.println(filter.mightContain(2));
|
||||
// 将元素添加进布隆过滤器
|
||||
filter.put(1);
|
||||
filter.put(2);
|
||||
System.out.println(filter.mightContain(1));
|
||||
System.out.println(filter.mightContain(2));
|
||||
```
|
||||
|
||||
在我们的示例中，当`mightContain（）` 方法返回*true*时，我们可以99％确定该元素在过滤器中，当过滤器返回*false*时，我们可以100％确定该元素不存在于过滤器中。
|
||||
|
||||
**Guava 提供的布隆过滤器的实现还是很不错的（想要详细了解的可以看一下它的源码实现），但是它有一个重大的缺陷就是只能单机使用（另外，容量扩展也不容易），而现在互联网一般都是分布式的场景。为了解决这个问题，我们就需要用到 Redis 中的布隆过滤器了。**
|
||||
|
||||
### 6.Redis 中的布隆过滤器
|
||||
|
||||
#### 6.1介绍
|
||||
|
||||
Redis v4.0 之后有了 Module（模块/插件） 功能，Redis Modules 让 Redis 可以使用外部模块扩展其功能 。布隆过滤器就是其中的 Module。详情可以查看 Redis 官方对 Redis Modules 的介绍 ：https://redis.io/modules。
|
||||
|
||||
另外，官网推荐了一个 RedisBloom 作为 Redis 布隆过滤器的 Module,地址：https://github.com/RedisBloom/RedisBloom。其他还有：
|
||||
|
||||
- redis-lua-scaling-bloom-filter （lua 脚本实现）：https://github.com/erikdubbelboer/redis-lua-scaling-bloom-filter
|
||||
- pyreBloom（Python中的快速Redis 布隆过滤器） ：https://github.com/seomoz/pyreBloom
|
||||
- ......
|
||||
|
||||
RedisBloom 提供了多种语言的客户端支持，包括：Python、Java、JavaScript 和 PHP。
|
||||
|
||||
#### 6.2使用Docker安装
|
||||
|
||||
如果我们需要体验 Redis 中的布隆过滤器非常简单，通过 Docker 就可以了！我们直接在 Google 搜索**docker redis bloomfilter** 然后在排除广告的第一条搜素结果就找到了我们想要的答案（这是我平常解决问题的一种方式，分享一下），具体地址：https://hub.docker.com/r/redislabs/rebloom/ （介绍的很详细 ）。
|
||||
|
||||
**具体操作如下：**
|
||||
|
||||
```
|
||||
➜ ~ docker run -p 6379:6379 --name redis-redisbloom redislabs/rebloom:latest
|
||||
➜ ~ docker exec -it redis-redisbloom bash
|
||||
root@21396d02c252:/data# redis-cli
|
||||
127.0.0.1:6379>
|
||||
```
|
||||
|
||||
#### 6.3常用命令一览
|
||||
|
||||
> 注意： key:布隆过滤器的名称，item : 添加的元素。
|
||||
|
||||
1. **`BF.ADD `**：将元素添加到布隆过滤器中，如果该过滤器尚不存在，则创建该过滤器。格式：`BF.ADD {key} {item}`。
|
||||
2. **`BF.MADD `** : 将一个或多个元素添加到“布隆过滤器”中，并创建一个尚不存在的过滤器。该命令的操作方式`BF.ADD`与之相同，只不过它允许多个输入并返回多个值。格式：`BF.MADD {key} {item} [item ...]` 。
|
||||
3. **`BF.EXISTS` ** : 确定元素是否在布隆过滤器中存在。格式：`BF.EXISTS {key} {item}`。
|
||||
4. **`BF.MEXISTS`** ： 确定一个或者多个元素是否在布隆过滤器中存在格式：`BF.MEXISTS {key} {item} [item ...]`。
|
||||
|
||||
另外，`BF.RESERVE` 命令需要单独介绍一下：
|
||||
|
||||
这个命令的格式如下：
|
||||
|
||||
`BF.RESERVE {key} {error_rate} {capacity} [EXPANSION expansion] `。
|
||||
|
||||
下面简单介绍一下每个参数的具体含义：
|
||||
|
||||
1. key：布隆过滤器的名称
|
||||
2. error_rate :误报的期望概率。这应该是介于0到1之间的十进制值。例如，对于期望的误报率0.1％（1000中为1），error_rate应该设置为0.001。该数字越接近零，则每个项目的内存消耗越大，并且每个操作的CPU使用率越高。
|
||||
3. capacity: 过滤器的容量。当实际存储的元素个数超过这个值之后，性能将开始下降。实际的降级将取决于超出限制的程度。随着过滤器元素数量呈指数增长，性能将线性下降。
|
||||
|
||||
可选参数：
|
||||
|
||||
- expansion：如果创建了一个新的子过滤器，则其大小将是当前过滤器的大小乘以`expansion`。默认扩展值为2。这意味着每个后续子过滤器将是前一个子过滤器的两倍。
|
||||
|
||||
#### 6.4实际使用
|
||||
|
||||
```shell
|
||||
127.0.0.1:6379> BF.ADD myFilter java
|
||||
(integer) 1
|
||||
127.0.0.1:6379> BF.ADD myFilter javaguide
|
||||
(integer) 1
|
||||
127.0.0.1:6379> BF.EXISTS myFilter java
|
||||
(integer) 1
|
||||
127.0.0.1:6379> BF.EXISTS myFilter javaguide
|
||||
(integer) 1
|
||||
127.0.0.1:6379> BF.EXISTS myFilter github
|
||||
(integer) 0
|
||||
```
|
||||
|
||||
@ -1,9 +1,10 @@
|
||||
# 网易 2018
|
||||
|
||||
下面三道编程题来自网易2018校招编程题，这三道应该来说是非常简单的编程题了，这些题目大家稍微有点编程和数学基础的话应该没什么问题。看答案之前一定要自己先想一下如果是自己做的话会怎么去做，然后再对照这我的答案看看，和你自己想的有什么区别？那一种方法更好？
|
||||
|
||||
|
||||
> # 问题
|
||||
## 问题
|
||||
|
||||
## 一 获得特定数量硬币问题
|
||||
### 一 获得特定数量硬币问题
|
||||
|
||||
小易准备去魔法王国采购魔法神器,购买魔法神器需要使用魔法币,但是小易现在一枚魔法币都没有,但是小易有两台魔法机器可以通过投入x(x可以为0)个魔法币产生更多的魔法币。
|
||||
|
||||
@ -15,33 +16,30 @@
|
||||
|
||||
**输入描述:** 输入包括一行,包括一个正整数n(1 ≤ n ≤ 10^9),表示小易需要的魔法币数量。
|
||||
|
||||
|
||||
**输出描述:** 输出一个字符串,每个字符表示该次小易选取投入的魔法机器。其中只包含字符'1'和'2'。
|
||||
|
||||
**输入例子1:** 10
|
||||
|
||||
**输出例子1:** 122
|
||||
|
||||
## 二 求“相反数”问题
|
||||
### 二 求“相反数”问题
|
||||
|
||||
为了得到一个数的"相反数",我们将这个数的数字顺序颠倒,然后再加上原先的数得到"相反数"。例如,为了得到1325的"相反数",首先我们将该数的数字顺序颠倒,我们得到5231,之后再加上原先的数,我们得到5231+1325=6556.如果颠倒之后的数字有前缀零,前缀零将会被忽略。例如n = 100, 颠倒之后是1.
|
||||
|
||||
**输入描述:** 输入包括一个整数n,(1 ≤ n ≤ 10^5)
|
||||
|
||||
|
||||
**输出描述:** 输出一个整数,表示n的相反数
|
||||
|
||||
**输入例子1:** 1325
|
||||
|
||||
**输出例子1:** 6556
|
||||
|
||||
## 三 字符串碎片的平均长度
|
||||
### 三 字符串碎片的平均长度
|
||||
|
||||
一个由小写字母组成的字符串可以看成一些同一字母的最大碎片组成的。例如,"aaabbaaac"是由下面碎片组成的:'aaa','bb','c'。牛牛现在给定一个字符串,请你帮助计算这个字符串的所有碎片的平均长度是多少。
|
||||
|
||||
**输入描述:** 输入包括一个字符串s,字符串s的长度length(1 ≤ length ≤ 50),s只含小写字母('a'-'z')
|
||||
|
||||
|
||||
**输出描述:** 输出一个整数,表示所有碎片的平均长度,四舍五入保留两位小数。
|
||||
|
||||
**如样例所示:** s = "aaabbaaac"
|
||||
@ -51,19 +49,18 @@
|
||||
|
||||
**输出例子1:** 2.25
|
||||
|
||||
|
||||
## 答案
|
||||
|
||||
> # 答案
|
||||
### 一 获得特定数量硬币问题
|
||||
|
||||
## 一 获得特定数量硬币问题
|
||||
|
||||
### 分析：
|
||||
#### 分析：
|
||||
|
||||
作为该试卷的第一题，这道题应该只要思路正确就很简单了。
|
||||
|
||||
解题关键：明确魔法机器1只能产生奇数，魔法机器2只能产生偶数即可。我们从后往前一步一步推回去即可。
|
||||
|
||||
### 示例代码
|
||||
#### 示例代码
|
||||
|
||||
注意：由于用户的输入不确定性，一般是为了程序高可用性使需要将捕获用户输入异常然后友好提示用户输入类型错误并重新输入的。所以下面我给了两个版本，这两个版本都是正确的。这里只是给大家演示如何捕获输入类型异常，后面的题目中我给的代码没有异常处理的部分，参照下面两个示例代码，应该很容易添加。（PS：企业面试中没有明确就不用添加异常处理，当然你有的话也更好）
|
||||
|
||||
**不带输入异常处理判断的版本：**
|
||||
@ -141,32 +138,33 @@ public class Main {
|
||||
|
||||
```
|
||||
|
||||
### 二 求“相反数”问题
|
||||
|
||||
## 二 求“相反数”问题
|
||||
|
||||
### 分析：
|
||||
#### 分析：
|
||||
|
||||
解决本道题有几种不同的方法，但是最快速的方法就是利用reverse()方法反转字符串然后再将字符串转换成int类型的整数，这个方法是快速解决本题关键。我们先来回顾一下下面两个知识点：
|
||||
|
||||
**1)String转int；**
|
||||
|
||||
在 Java 中要将 String 类型转化为 int 类型时,需要使用 Integer 类中的 parseInt() 方法或者 valueOf() 方法进行转换.
|
||||
|
||||
```java
|
||||
String str = "123";
|
||||
int a = Integer.parseInt(str);
|
||||
```
|
||||
|
||||
或
|
||||
|
||||
```java
|
||||
String str = "123";
|
||||
int a = Integer.valueOf(str).intValue()；
|
||||
```
|
||||
|
||||
|
||||
**2)next()和nextLine()的区别**
|
||||
|
||||
在Java中输入字符串有两种方法，就是next()和nextLine().两者的区别就是：nextLine()的输入是碰到回车就终止输入，而next()方法是碰到空格，回车，Tab键都会被视为终止符。所以next()不会得到带空格的字符串，而nextLine()可以得到带空格的字符串。
|
||||
|
||||
### 示例代码：
|
||||
#### 示例代码：
|
||||
|
||||
```java
|
||||
import java.util.Scanner;
|
||||
@ -192,15 +190,15 @@ public class Main {
|
||||
}
|
||||
```
|
||||
|
||||
## 三 字符串碎片的平均长度
|
||||
### 三 字符串碎片的平均长度
|
||||
|
||||
### 分析：
|
||||
#### 分析：
|
||||
|
||||
这道题的意思也就是要求：(字符串的总长度)/(相同字母团构成的字符串的个数)。
|
||||
|
||||
这样就很简单了，就变成了字符串的字符之间的比较。如果需要比较字符串的字符的话，我们可以利用charAt(i)方法：取出特定位置的字符与后一个字符比较，或者利用toCharArray()方法将字符串转换成字符数组采用同样的方法做比较。
|
||||
|
||||
### 示例代码
|
||||
#### 示例代码
|
||||
|
||||
**利用charAt(i)方法：**
|
||||
|
||||
@ -108,38 +108,57 @@ public class Solution {
|
||||
思路很简单！先利用Arrays.sort(strs)为数组排序，再将数组第一个元素和最后一个元素的字符从前往后对比即可！
|
||||
|
||||
```java
|
||||
//https://leetcode-cn.com/problems/longest-common-prefix/description/
|
||||
public class Main {
|
||||
public static String replaceSpace(String[] strs) {
|
||||
public static String replaceSpace(String[] strs) {
|
||||
|
||||
// 数组长度
|
||||
int len = strs.length;
|
||||
// 用于保存结果
|
||||
StringBuffer res = new StringBuffer();
|
||||
// 注意：=是赋值，==是判断
|
||||
if (strs == null || strs.length == 0) {
|
||||
return "";
|
||||
}
|
||||
// 给字符串数组的元素按照升序排序(包含数字的话，数字会排在前面)
|
||||
Arrays.sort(strs);
|
||||
int m = strs[0].length();
|
||||
int n = strs[len - 1].length();
|
||||
int num = Math.min(m, n);
|
||||
for (int i = 0; i < num; i++) {
|
||||
if (strs[0].charAt(i) == strs[len - 1].charAt(i)) {
|
||||
res.append(strs[0].charAt(i));
|
||||
} else
|
||||
break;
|
||||
// 如果检查值不合法及就返回空串
|
||||
if (!checkStrs(strs)) {
|
||||
return "";
|
||||
}
|
||||
// 数组长度
|
||||
int len = strs.length;
|
||||
// 用于保存结果
|
||||
StringBuilder res = new StringBuilder();
|
||||
// 给字符串数组的元素按照升序排序(包含数字的话，数字会排在前面)
|
||||
Arrays.sort(strs);
|
||||
int m = strs[0].length();
|
||||
int n = strs[len - 1].length();
|
||||
int num = Math.min(m, n);
|
||||
for (int i = 0; i < num; i++) {
|
||||
if (strs[0].charAt(i) == strs[len - 1].charAt(i)) {
|
||||
res.append(strs[0].charAt(i));
|
||||
} else
|
||||
break;
|
||||
|
||||
}
|
||||
return res.toString();
|
||||
}
|
||||
return res.toString();
|
||||
|
||||
}
|
||||
//测试
|
||||
public static void main(String[] args) {
|
||||
String[] strs = { "customer", "car", "cat" };
|
||||
System.out.println(Main.replaceSpace(strs));//c
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean chechStrs(String[] strs) {
|
||||
boolean flag = false;
|
||||
if (strs != null) {
|
||||
// 遍历strs检查元素值
|
||||
for (int i = 0; i < strs.length; i++) {
|
||||
if (strs[i] != null && strs[i].length() != 0) {
|
||||
flag = true;
|
||||
} else {
|
||||
flag = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return flag;
|
||||
}
|
||||
|
||||
// 测试
|
||||
public static void main(String[] args) {
|
||||
String[] strs = { "customer", "car", "cat" };
|
||||
// String[] strs = { "customer", "car", null };//空串
|
||||
// String[] strs = {};//空串
|
||||
// String[] strs = null;//空串
|
||||
System.out.println(Main.replaceSpace(strs));// c
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
@ -444,7 +463,7 @@ public class Main {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return flag == 1 ? res : -res;
|
||||
return flag != 2 ? res : -res;
|
||||
|
||||
}
|
||||
|
||||
@ -225,7 +225,7 @@ public class Solution {
|
||||
while (node1 != null) {
|
||||
node1 = node1.next;
|
||||
count++;
|
||||
if (k < 1 && node1 != null) {
|
||||
if (k < 1) {
|
||||
node2 = node2.next;
|
||||
}
|
||||
k--;
|
||||
686
docs/dataStructures-algorithms/剑指offer部分编程题.md
Normal file
686
docs/dataStructures-algorithms/剑指offer部分编程题.md
Normal file
@ -0,0 +1,686 @@
|
||||
### 一 斐波那契数列
|
||||
|
||||
#### **题目描述：**
|
||||
|
||||
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。
|
||||
n<=39
|
||||
|
||||
#### **问题分析：**
|
||||
|
||||
可以肯定的是这一题通过递归的方式是肯定能做出来，但是这样会有一个很大的问题，那就是递归大量的重复计算会导致内存溢出。另外可以使用迭代法，用fn1和fn2保存计算过程中的结果，并复用起来。下面我会把两个方法示例代码都给出来并给出两个方法的运行时间对比。
|
||||
|
||||
#### **示例代码：**
|
||||
|
||||
**采用迭代法：**
|
||||
|
||||
```java
|
||||
int Fibonacci(int number) {
|
||||
if (number <= 0) {
|
||||
return 0;
|
||||
}
|
||||
if (number == 1 || number == 2) {
|
||||
return 1;
|
||||
}
|
||||
int first = 1, second = 1, third = 0;
|
||||
for (int i = 3; i <= number; i++) {
|
||||
third = first + second;
|
||||
first = second;
|
||||
second = third;
|
||||
}
|
||||
return third;
|
||||
}
|
||||
```
|
||||
|
||||
**采用递归：**
|
||||
|
||||
```java
|
||||
public int Fibonacci(int n) {
|
||||
|
||||
if (n <= 0) {
|
||||
return 0;
|
||||
}
|
||||
if (n == 1||n==2) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
return Fibonacci(n - 2) + Fibonacci(n - 1);
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
#### **运行时间对比：**
|
||||
|
||||
假设n为40我们分别使用迭代法和递归法计算，计算结果如下：
|
||||
|
||||
1. 迭代法
|
||||
|
||||
2. 递归法
|
||||
|
||||
|
||||
### 二 跳台阶问题
|
||||
|
||||
#### **题目描述：**
|
||||
|
||||
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
|
||||
|
||||
#### **问题分析：**
|
||||
|
||||
**正常分析法：**
|
||||
a.如果两种跳法，1阶或者2阶，那么假定第一次跳的是一阶，那么剩下的是n-1个台阶，跳法是f(n-1);
|
||||
b.假定第一次跳的是2阶，那么剩下的是n-2个台阶，跳法是f(n-2)
|
||||
c.由a，b假设可以得出总跳法为: f(n) = f(n-1) + f(n-2)
|
||||
d.然后通过实际的情况可以得出：只有一阶的时候 f(1) = 1 ,只有两阶的时候可以有 f(2) = 2
|
||||
**找规律分析法：**
|
||||
f(1) = 1, f(2) = 2, f(3) = 3, f(4) = 5， 可以总结出f(n) = f(n-1) + f(n-2)的规律。
|
||||
但是为什么会出现这样的规律呢？假设现在6个台阶，我们可以从第5跳一步到6，这样的话有多少种方案跳到5就有多少种方案跳到6，另外我们也可以从4跳两步跳到6，跳到4有多少种方案的话，就有多少种方案跳到6，其他的不能从3跳到6什么的啦，所以最后就是f(6) = f(5) + f(4)；这样子也很好理解变态跳台阶的问题了。
|
||||
|
||||
**所以这道题其实就是斐波那契数列的问题。**
|
||||
代码只需要在上一题的代码稍做修改即可。和上一题唯一不同的就是这一题的初始元素变为 1 2 3 5 8.....而上一题为1 1 2 3 5 .......。另外这一题也可以用递归做，但是递归效率太低，所以我这里只给出了迭代方式的代码。
|
||||
|
||||
#### **示例代码：**
|
||||
|
||||
```java
|
||||
int jumpFloor(int number) {
|
||||
if (number <= 0) {
|
||||
return 0;
|
||||
}
|
||||
if (number == 1) {
|
||||
return 1;
|
||||
}
|
||||
if (number == 2) {
|
||||
return 2;
|
||||
}
|
||||
int first = 1, second = 2, third = 0;
|
||||
for (int i = 3; i <= number; i++) {
|
||||
third = first + second;
|
||||
first = second;
|
||||
second = third;
|
||||
}
|
||||
return third;
|
||||
}
|
||||
```
|
||||
|
||||
### 三 变态跳台阶问题
|
||||
|
||||
#### **题目描述：**
|
||||
|
||||
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
|
||||
|
||||
#### **问题分析：**
|
||||
|
||||
假设n>=2，第一步有n种跳法：跳1级、跳2级、到跳n级
|
||||
跳1级，剩下n-1级，则剩下跳法是f(n-1)
|
||||
跳2级，剩下n-2级，则剩下跳法是f(n-2)
|
||||
......
|
||||
跳n-1级，剩下1级，则剩下跳法是f(1)
|
||||
跳n级，剩下0级，则剩下跳法是f(0)
|
||||
所以在n>=2的情况下：
|
||||
f(n)=f(n-1)+f(n-2)+...+f(1)
|
||||
因为f(n-1)=f(n-2)+f(n-3)+...+f(1)
|
||||
所以f(n)=2*f(n-1) 又f(1)=1,所以可得**f(n)=2^(number-1)**
|
||||
|
||||
#### **示例代码：**
|
||||
|
||||
```java
|
||||
int JumpFloorII(int number) {
|
||||
return 1 << --number;//2^(number-1)用位移操作进行，更快
|
||||
}
|
||||
```
|
||||
|
||||
#### **补充：**
|
||||
|
||||
**java中有三种移位运算符：**
|
||||
|
||||
1. “<<” : **左移运算符**，等同于乘2的n次方
|
||||
2. “>>”: **右移运算符**，等同于除2的n次方
|
||||
3. “>>>” **无符号右移运算符**，不管移动前最高位是0还是1，右移后左侧产生的空位部分都以0来填充。与>>类似。
|
||||
例：
|
||||
int a = 16;
|
||||
int b = a << 2;//左移2，等同于16 * 2的2次方，也就是16 * 4
|
||||
int c = a >> 2;//右移2，等同于16 / 2的2次方，也就是16 / 4
|
||||
|
||||
### 四 二维数组查找
|
||||
|
||||
#### **题目描述：**
|
||||
|
||||
在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
|
||||
|
||||
#### **问题解析：**
|
||||
|
||||
这一道题还是比较简单的，我们需要考虑的是如何做，效率最快。这里有一种很好理解的思路：
|
||||
|
||||
> 矩阵是有序的，从左下角来看，向上数字递减，向右数字递增，
|
||||
> 因此从左下角开始查找，当要查找数字比左下角数字大时。右移
|
||||
> 要查找数字比左下角数字小时，上移。这样找的速度最快。
|
||||
|
||||
#### **示例代码：**
|
||||
|
||||
```java
|
||||
public boolean Find(int target, int [][] array) {
|
||||
//基本思路从左下角开始找，这样速度最快
|
||||
int row = array.length-1;//行
|
||||
int column = 0;//列
|
||||
//当行数大于0，当前列数小于总列数时循环条件成立
|
||||
while((row >= 0)&& (column< array[0].length)){
|
||||
if(array[row][column] > target){
|
||||
row--;
|
||||
}else if(array[row][column] < target){
|
||||
column++;
|
||||
}else{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
```
|
||||
|
||||
### 五 替换空格
|
||||
|
||||
#### **题目描述：**
|
||||
|
||||
请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
|
||||
|
||||
#### **问题分析：**
|
||||
|
||||
这道题不难，我们可以通过循环判断字符串的字符是否为空格，是的话就利用append()方法添加追加“%20”，否则还是追加原字符。
|
||||
|
||||
或者最简单的方法就是利用： replaceAll(String regex,String replacement)方法了，一行代码就可以解决。
|
||||
|
||||
#### **示例代码：**
|
||||
|
||||
**常规做法：**
|
||||
|
||||
```java
|
||||
public String replaceSpace(StringBuffer str) {
|
||||
StringBuffer out=new StringBuffer();
|
||||
for (int i = 0; i < str.toString().length(); i++) {
|
||||
char b=str.charAt(i);
|
||||
if(String.valueOf(b).equals(" ")){
|
||||
out.append("%20");
|
||||
}else{
|
||||
out.append(b);
|
||||
}
|
||||
}
|
||||
return out.toString();
|
||||
}
|
||||
```
|
||||
|
||||
**一行代码解决：**
|
||||
|
||||
```java
|
||||
public String replaceSpace(StringBuffer str) {
|
||||
//return str.toString().replaceAll(" ", "%20");
|
||||
//public String replaceAll(String regex,String replacement)
|
||||
//用给定的替换替换与给定的regular expression匹配的此字符串的每个子字符串。
|
||||
//\ 转义字符. 如果你要使用 "\" 本身, 则应该使用 "\\". String类型中的空格用“\s”表示，所以我这里猜测"\\s"就是代表空格的意思
|
||||
return str.toString().replaceAll("\\s", "%20");
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
### 六 数值的整数次方
|
||||
|
||||
#### **题目描述：**
|
||||
|
||||
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
|
||||
|
||||
#### **问题解析：**
|
||||
|
||||
这道题算是比较麻烦和难一点的一个了。我这里采用的是**二分幂**思想，当然也可以采用**快速幂**。
|
||||
更具剑指offer书中细节，该题的解题思路如下：
|
||||
1.当底数为0且指数<0时，会出现对0求倒数的情况，需进行错误处理，设置一个全局变量；
|
||||
2.判断底数是否等于0，由于base为double型，所以不能直接用==判断
|
||||
3.优化求幂函数（二分幂）。
|
||||
当n为偶数，a^n =（a^n/2）*（a^n/2）；
|
||||
当n为奇数，a^n = a^[(n-1)/2] * a^[(n-1)/2] * a。时间复杂度O(logn)
|
||||
|
||||
**时间复杂度**：O(logn)
|
||||
|
||||
#### **示例代码：**
|
||||
|
||||
```java
|
||||
public class Solution {
|
||||
boolean invalidInput=false;
|
||||
public double Power(double base, int exponent) {
|
||||
//如果底数等于0并且指数小于0
|
||||
//由于base为double型，不能直接用==判断
|
||||
if(equal(base,0.0)&&exponent<0){
|
||||
invalidInput=true;
|
||||
return 0.0;
|
||||
}
|
||||
int absexponent=exponent;
|
||||
//如果指数小于0，将指数转正
|
||||
if(exponent<0)
|
||||
absexponent=-exponent;
|
||||
//getPower方法求出base的exponent次方。
|
||||
double res=getPower(base,absexponent);
|
||||
//如果指数小于0，所得结果为上面求的结果的倒数
|
||||
if(exponent<0)
|
||||
res=1.0/res;
|
||||
return res;
|
||||
}
|
||||
//比较两个double型变量是否相等的方法
|
||||
boolean equal(double num1,double num2){
|
||||
if(num1-num2>-0.000001&&num1-num2<0.000001)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
//求出b的e次方的方法
|
||||
double getPower(double b,int e){
|
||||
//如果指数为0，返回1
|
||||
if(e==0)
|
||||
return 1.0;
|
||||
//如果指数为1，返回b
|
||||
if(e==1)
|
||||
return b;
|
||||
//e>>1相等于e/2，这里就是求a^n =（a^n/2）*（a^n/2）
|
||||
double result=getPower(b,e>>1);
|
||||
result*=result;
|
||||
//如果指数n为奇数，则要再乘一次底数base
|
||||
if((e&1)==1)
|
||||
result*=b;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
当然这一题也可以采用笨方法：累乘。不过这种方法的时间复杂度为O（n），这样没有前一种方法效率高。
|
||||
|
||||
```java
|
||||
// 使用累乘
|
||||
public double powerAnother(double base, int exponent) {
|
||||
double result = 1.0;
|
||||
for (int i = 0; i < Math.abs(exponent); i++) {
|
||||
result *= base;
|
||||
}
|
||||
if (exponent >= 0)
|
||||
return result;
|
||||
else
|
||||
return 1 / result;
|
||||
}
|
||||
```
|
||||
|
||||
### 七 调整数组顺序使奇数位于偶数前面
|
||||
|
||||
#### **题目描述：**
|
||||
|
||||
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
|
||||
|
||||
#### **问题解析：**
|
||||
|
||||
这道题有挺多种解法的，给大家介绍一种我觉得挺好理解的方法：
|
||||
我们首先统计奇数的个数假设为n,然后新建一个等长数组，然后通过循环判断原数组中的元素为偶数还是奇数。如果是则从数组下标0的元素开始，把该奇数添加到新数组；如果是偶数则从数组下标为n的元素开始把该偶数添加到新数组中。
|
||||
|
||||
#### **示例代码：**
|
||||
|
||||
时间复杂度为O（n），空间复杂度为O（n）的算法
|
||||
|
||||
```java
|
||||
public class Solution {
|
||||
public void reOrderArray(int [] array) {
|
||||
//如果数组长度等于0或者等于1，什么都不做直接返回
|
||||
if(array.length==0||array.length==1)
|
||||
return;
|
||||
//oddCount：保存奇数个数
|
||||
//oddBegin：奇数从数组头部开始添加
|
||||
int oddCount=0,oddBegin=0;
|
||||
//新建一个数组
|
||||
int[] newArray=new int[array.length];
|
||||
//计算出（数组中的奇数个数）开始添加元素
|
||||
for(int i=0;i<array.length;i++){
|
||||
if((array[i]&1)==1) oddCount++;
|
||||
}
|
||||
for(int i=0;i<array.length;i++){
|
||||
//如果数为基数新数组从头开始添加元素
|
||||
//如果为偶数就从oddCount（数组中的奇数个数）开始添加元素
|
||||
if((array[i]&1)==1)
|
||||
newArray[oddBegin++]=array[i];
|
||||
else newArray[oddCount++]=array[i];
|
||||
}
|
||||
for(int i=0;i<array.length;i++){
|
||||
array[i]=newArray[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 八 链表中倒数第k个节点
|
||||
|
||||
#### **题目描述：**
|
||||
|
||||
输入一个链表，输出该链表中倒数第k个结点
|
||||
|
||||
#### **问题分析：**
|
||||
|
||||
**一句话概括：**
|
||||
两个指针一个指针p1先开始跑，指针p1跑到k-1个节点后，另一个节点p2开始跑，当p1跑到最后时，p2所指的指针就是倒数第k个节点。
|
||||
|
||||
**思想的简单理解：**
|
||||
前提假设：链表的结点个数(长度)为n。
|
||||
规律一：要找到倒数第k个结点，需要向前走多少步呢？比如倒数第一个结点，需要走n步，那倒数第二个结点呢？很明显是向前走了n-1步，所以可以找到规律是找到倒数第k个结点，需要向前走n-k+1步。
|
||||
**算法开始：**
|
||||
|
||||
1. 设两个都指向head的指针p1和p2，当p1走了k-1步的时候，停下来。p2之前一直不动。
|
||||
2. p1的下一步是走第k步，这个时候，p2开始一起动了。至于为什么p2这个时候动呢？看下面的分析。
|
||||
3. 当p1走到链表的尾部时，即p1走了n步。由于我们知道p2是在p1走了k-1步才开始动的，也就是说p1和p2永远差k-1步。所以当p1走了n步时，p2走的应该是在n-(k-1)步。即p2走了n-k+1步，此时巧妙的是p2正好指向的是规律一的倒数第k个结点处。
|
||||
这样是不是很好理解了呢？
|
||||
|
||||
#### **考察内容：**
|
||||
|
||||
链表+代码的鲁棒性
|
||||
|
||||
#### **示例代码：**
|
||||
|
||||
```java
|
||||
/*
|
||||
//链表类
|
||||
public class ListNode {
|
||||
int val;
|
||||
ListNode next = null;
|
||||
|
||||
ListNode(int val) {
|
||||
this.val = val;
|
||||
}
|
||||
}*/
|
||||
|
||||
//时间复杂度O(n),一次遍历即可
|
||||
public class Solution {
|
||||
public ListNode FindKthToTail(ListNode head,int k) {
|
||||
ListNode pre=null,p=null;
|
||||
//两个指针都指向头结点
|
||||
p=head;
|
||||
pre=head;
|
||||
//记录k值
|
||||
int a=k;
|
||||
//记录节点的个数
|
||||
int count=0;
|
||||
//p指针先跑，并且记录节点数，当p指针跑了k-1个节点后，pre指针开始跑，
|
||||
//当p指针跑到最后时，pre所指指针就是倒数第k个节点
|
||||
while(p!=null){
|
||||
p=p.next;
|
||||
count++;
|
||||
if(k<1){
|
||||
pre=pre.next;
|
||||
}
|
||||
k--;
|
||||
}
|
||||
//如果节点个数小于所求的倒数第k个节点，则返回空
|
||||
if(count<a) return null;
|
||||
return pre;
|
||||
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 九 反转链表
|
||||
|
||||
#### **题目描述：**
|
||||
|
||||
输入一个链表，反转链表后，输出链表的所有元素。
|
||||
|
||||
#### **问题分析：**
|
||||
|
||||
链表的很常规的一道题，这一道题思路不算难，但自己实现起来真的可能会感觉无从下手，我是参考了别人的代码。
|
||||
思路就是我们根据链表的特点，前一个节点指向下一个节点的特点，把后面的节点移到前面来。
|
||||
就比如下图：我们把1节点和2节点互换位置，然后再将3节点指向2节点，4节点指向3节点，这样以来下面的链表就被反转了。
|
||||
|
||||
|
||||
#### **考察内容：**
|
||||
|
||||
链表+代码的鲁棒性
|
||||
|
||||
#### **示例代码：**
|
||||
|
||||
```java
|
||||
/*
|
||||
public class ListNode {
|
||||
int val;
|
||||
ListNode next = null;
|
||||
|
||||
ListNode(int val) {
|
||||
this.val = val;
|
||||
}
|
||||
}*/
|
||||
public class Solution {
|
||||
public ListNode ReverseList(ListNode head) {
|
||||
ListNode next = null;
|
||||
ListNode pre = null;
|
||||
while (head != null) {
|
||||
//保存要反转到头来的那个节点
|
||||
next = head.next;
|
||||
//要反转的那个节点指向已经反转的上一个节点
|
||||
head.next = pre;
|
||||
//上一个已经反转到头部的节点
|
||||
pre = head;
|
||||
//一直向链表尾走
|
||||
head = next;
|
||||
}
|
||||
return pre;
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
### 十 合并两个排序的链表
|
||||
|
||||
#### **题目描述：**
|
||||
|
||||
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
|
||||
|
||||
#### **问题分析：**
|
||||
|
||||
我们可以这样分析:
|
||||
|
||||
1. 假设我们有两个链表 A,B；
|
||||
2. A的头节点A1的值与B的头结点B1的值比较，假设A1小，则A1为头节点；
|
||||
3. A2再和B1比较，假设B1小,则，A1指向B1；
|
||||
4. A2再和B2比较。。。。。。。
|
||||
就这样循环往复就行了，应该还算好理解。
|
||||
|
||||
#### **考察内容：**
|
||||
|
||||
链表+代码的鲁棒性
|
||||
|
||||
#### **示例代码：**
|
||||
|
||||
**非递归版本：**
|
||||
|
||||
```java
|
||||
/*
|
||||
public class ListNode {
|
||||
int val;
|
||||
ListNode next = null;
|
||||
|
||||
ListNode(int val) {
|
||||
this.val = val;
|
||||
}
|
||||
}*/
|
||||
public class Solution {
|
||||
public ListNode Merge(ListNode list1,ListNode list2) {
|
||||
//list1为空，直接返回list2
|
||||
if(list1 == null){
|
||||
return list2;
|
||||
}
|
||||
//list2为空，直接返回list1
|
||||
if(list2 == null){
|
||||
return list1;
|
||||
}
|
||||
ListNode mergeHead = null;
|
||||
ListNode current = null;
|
||||
//当list1和list2不为空时
|
||||
while(list1!=null && list2!=null){
|
||||
//取较小值作头结点
|
||||
if(list1.val <= list2.val){
|
||||
if(mergeHead == null){
|
||||
mergeHead = current = list1;
|
||||
}else{
|
||||
current.next = list1;
|
||||
//current节点保存list1节点的值因为下一次还要用
|
||||
current = list1;
|
||||
}
|
||||
//list1指向下一个节点
|
||||
list1 = list1.next;
|
||||
}else{
|
||||
if(mergeHead == null){
|
||||
mergeHead = current = list2;
|
||||
}else{
|
||||
current.next = list2;
|
||||
//current节点保存list2节点的值因为下一次还要用
|
||||
current = list2;
|
||||
}
|
||||
//list2指向下一个节点
|
||||
list2 = list2.next;
|
||||
}
|
||||
}
|
||||
if(list1 == null){
|
||||
current.next = list2;
|
||||
}else{
|
||||
current.next = list1;
|
||||
}
|
||||
return mergeHead;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**递归版本：**
|
||||
|
||||
```java
|
||||
public ListNode Merge(ListNode list1,ListNode list2) {
|
||||
if(list1 == null){
|
||||
return list2;
|
||||
}
|
||||
if(list2 == null){
|
||||
return list1;
|
||||
}
|
||||
if(list1.val <= list2.val){
|
||||
list1.next = Merge(list1.next, list2);
|
||||
return list1;
|
||||
}else{
|
||||
list2.next = Merge(list1, list2.next);
|
||||
return list2;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 十一 用两个栈实现队列
|
||||
|
||||
#### **题目描述：**
|
||||
|
||||
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
|
||||
|
||||
#### 问题分析：
|
||||
|
||||
先来回顾一下栈和队列的基本特点：
|
||||
**栈：**后进先出（LIFO）
|
||||
**队列：** 先进先出
|
||||
很明显我们需要根据JDK给我们提供的栈的一些基本方法来实现。先来看一下Stack类的一些基本方法：
|
||||
|
||||
|
||||
既然题目给了我们两个栈，我们可以这样考虑当push的时候将元素push进stack1，pop的时候我们先把stack1的元素pop到stack2，然后再对stack2执行pop操作，这样就可以保证是先进先出的。（负[pop]负[pop]得正[先进先出]）
|
||||
|
||||
#### 考察内容：
|
||||
|
||||
队列+栈
|
||||
|
||||
#### 示例代码：
|
||||
|
||||
```java
|
||||
//左程云的《程序员代码面试指南》的答案
|
||||
import java.util.Stack;
|
||||
|
||||
public class Solution {
|
||||
Stack<Integer> stack1 = new Stack<Integer>();
|
||||
Stack<Integer> stack2 = new Stack<Integer>();
|
||||
|
||||
//当执行push操作时，将元素添加到stack1
|
||||
public void push(int node) {
|
||||
stack1.push(node);
|
||||
}
|
||||
|
||||
public int pop() {
|
||||
//如果两个队列都为空则抛出异常,说明用户没有push进任何元素
|
||||
if(stack1.empty()&&stack2.empty()){
|
||||
throw new RuntimeException("Queue is empty!");
|
||||
}
|
||||
//如果stack2不为空直接对stack2执行pop操作，
|
||||
if(stack2.empty()){
|
||||
while(!stack1.empty()){
|
||||
//将stack1的元素按后进先出push进stack2里面
|
||||
stack2.push(stack1.pop());
|
||||
}
|
||||
}
|
||||
return stack2.pop();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 十二 栈的压入,弹出序列
|
||||
|
||||
#### **题目描述：**
|
||||
|
||||
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
|
||||
|
||||
#### **题目分析：**
|
||||
|
||||
这道题想了半天没有思路，参考了Alias的答案，他的思路写的也很详细应该很容易看懂。
|
||||
作者：Alias
|
||||
https://www.nowcoder.com/questionTerminal/d77d11405cc7470d82554cb392585106
|
||||
来源：牛客网
|
||||
|
||||
【思路】借用一个辅助的栈，遍历压栈顺序，先讲第一个放入栈中，这里是1，然后判断栈顶元素是不是出栈顺序的第一个元素，这里是4，很显然1≠4，所以我们继续压栈，直到相等以后开始出栈，出栈一个元素，则将出栈顺序向后移动一位，直到不相等，这样循环等压栈顺序遍历完成，如果辅助栈还不为空，说明弹出序列不是该栈的弹出顺序。
|
||||
|
||||
举例：
|
||||
|
||||
入栈1,2,3,4,5
|
||||
|
||||
出栈4,5,3,2,1
|
||||
|
||||
首先1入辅助栈，此时栈顶1≠4，继续入栈2
|
||||
|
||||
此时栈顶2≠4，继续入栈3
|
||||
|
||||
此时栈顶3≠4，继续入栈4
|
||||
|
||||
此时栈顶4＝4，出栈4，弹出序列向后一位，此时为5，,辅助栈里面是1,2,3
|
||||
|
||||
此时栈顶3≠5，继续入栈5
|
||||
|
||||
此时栈顶5=5，出栈5,弹出序列向后一位，此时为3，,辅助栈里面是1,2,3
|
||||
|
||||
….
|
||||
依次执行，最后辅助栈为空。如果不为空说明弹出序列不是该栈的弹出顺序。
|
||||
|
||||
|
||||
|
||||
#### **考察内容：**
|
||||
|
||||
栈
|
||||
|
||||
#### **示例代码：**
|
||||
|
||||
```java
|
||||
import java.util.ArrayList;
|
||||
import java.util.Stack;
|
||||
//这道题没想出来，参考了Alias同学的答案：https://www.nowcoder.com/questionTerminal/d77d11405cc7470d82554cb392585106
|
||||
public class Solution {
|
||||
public boolean IsPopOrder(int [] pushA,int [] popA) {
|
||||
if(pushA.length == 0 || popA.length == 0)
|
||||
return false;
|
||||
Stack<Integer> s = new Stack<Integer>();
|
||||
//用于标识弹出序列的位置
|
||||
int popIndex = 0;
|
||||
for(int i = 0; i< pushA.length;i++){
|
||||
s.push(pushA[i]);
|
||||
//如果栈不为空，且栈顶元素等于弹出序列
|
||||
while(!s.empty() &&s.peek() == popA[popIndex]){
|
||||
//出栈
|
||||
s.pop();
|
||||
//弹出序列向后一位
|
||||
popIndex++;
|
||||
}
|
||||
}
|
||||
return s.empty();
|
||||
}
|
||||
}
|
||||
```
|
||||
@ -1,3 +1,4 @@
|
||||
下面只是简单地总结，给了一些参考文章，后面会对这部分内容进行重构。
|
||||
<!-- MarkdownTOC -->
|
||||
|
||||
- [Queue](#queue)
|
||||
@ -46,7 +47,7 @@ Queue 用来存放 等待处理元素 的集合，这种场景一般用于缓冲
|
||||
### 什么是 Set
|
||||
Set 继承于 Collection 接口，是一个不允许出现重复元素，并且无序的集合，主要 HashSet 和 TreeSet 两大实现类。
|
||||
|
||||
在判断重复元素的时候，Set 集合会调用 hashCode()和 equal()方法来实现。
|
||||
在判断重复元素的时候，HashSet 集合会调用 hashCode()和 equal()方法来实现；TreeSet 集合会调用compareTo方法来实现。
|
||||
|
||||
### 补充：有序集合与无序集合说明
|
||||
- 有序集合：集合里的元素可以根据 key 或 index 访问 (List、Map)
|
||||
@ -81,8 +82,9 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且
|
||||
**Stack** 是栈，它继承于Vector。它的特性是：先进后出(FILO, First In Last Out)。相关阅读：[java数据结构与算法之栈（Stack）设计与实现](https://blog.csdn.net/javazejian/article/details/53362993)
|
||||
|
||||
### ArrayList 和 LinkedList 源码学习
|
||||
- [ArrayList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/ArrayList.md)
|
||||
- [LinkedList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/LinkedList.md)
|
||||
|
||||
- [ArrayList 源码学习](https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/collection/ArrayList.md)
|
||||
- [LinkedList 源码学习](https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/collection/LinkedList.md)
|
||||
|
||||
### 推荐阅读
|
||||
|
||||
@ -102,7 +104,7 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且
|
||||
|
||||
(1)[完全二叉树](https://baike.baidu.com/item/%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91)——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。
|
||||
|
||||
(2)[满二叉树](https://baike.baidu.com/item/%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91)——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。
|
||||
(2)[满二叉树](https://baike.baidu.com/item/%E6%BB%A1%E4%BA%8C%E5%8F%89%E6%A0%91)——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。
|
||||
|
||||
(3)[平衡二叉树](https://baike.baidu.com/item/%E5%B9%B3%E8%A1%A1%E4%BA%8C%E5%8F%89%E6%A0%91/10421057)——平衡二叉树又被称为AVL树（区别于AVL算法），它是一棵二叉排序树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
|
||||
|
||||
@ -110,9 +112,9 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且
|
||||
|
||||
[完全二叉树](https://baike.baidu.com/item/%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91)（百度百科）
|
||||
|
||||
完全二叉树：叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树
|
||||
完全二叉树：叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树。
|
||||
* ### 3 满二叉树
|
||||
|
||||
|
||||
[满二叉树](https://baike.baidu.com/item/%E6%BB%A1%E4%BA%8C%E5%8F%89%E6%A0%91)（百度百科，国内外的定义不同）
|
||||
|
||||
国内教程定义：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
|
||||
@ -120,7 +122,7 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且
|
||||
|
||||
[数据结构之堆的定义](https://blog.csdn.net/qq_33186366/article/details/51876191)
|
||||
|
||||
堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆
|
||||
堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。
|
||||
* ### 4 二叉查找树（BST）
|
||||
|
||||
[浅谈算法和数据结构: 七 二叉查找树](http://www.cnblogs.com/yangecnu/p/Introduce-Binary-Search-Tree.html)
|
||||
@ -129,7 +131,7 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且
|
||||
|
||||
1. 若任意节点的左子树不空，则左子树上所有结点的 值均小于它的根结点的值；
|
||||
2. 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
|
||||
3. 任意节点的左、右子树也分别为二叉查找树。
|
||||
3. 任意节点的左、右子树也分别为二叉查找树；
|
||||
4. 没有键值相等的节点（no duplicate nodes）。
|
||||
|
||||
* ### 5 平衡二叉树（Self-balancing binary search tree）
|
||||
@ -142,16 +144,16 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且
|
||||
2. 根节点总是黑色的；
|
||||
3. 每个叶子节点都是黑色的空节点（NIL节点）；
|
||||
4. 如果节点是红色的，则它的子节点必须是黑色的（反之不一定）；
|
||||
5. 从根节点到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点（即相同的黑色高度）
|
||||
5. 从根节点到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点（即相同的黑色高度）。
|
||||
|
||||
- 红黑树的应用：
|
||||
|
||||
|
||||
TreeMap、TreeSet以及JDK1.8之后的HashMap底层都用到了红黑树。
|
||||
|
||||
- 为什么要用红黑树
|
||||
|
||||
|
||||
简单来说红黑树就是为了解决二叉查找树的缺陷，因为二叉查找树在某些情况下会退化成一个线性结构。详细了解可以查看 [漫画：什么是红黑树？](https://juejin.im/post/5a27c6946fb9a04509096248#comment)（也介绍到了二叉查找树，非常推荐）
|
||||
|
||||
|
||||
- 推荐文章：
|
||||
- [漫画：什么是红黑树？](https://juejin.im/post/5a27c6946fb9a04509096248#comment)（也介绍到了二叉查找树，非常推荐）
|
||||
- [寻找红黑树的操作手册](http://dandanlove.com/2018/03/18/red-black-tree/)（文章排版以及思路真的不错）
|
||||
@ -163,19 +165,19 @@ Set 继承于 Collection 接口，是一个不允许出现重复元素，并且
|
||||
[《B-树，B+树，B*树详解》](https://blog.csdn.net/aqzwss/article/details/53074186)
|
||||
|
||||
[《B-树，B+树与B*树的优缺点比较》](https://blog.csdn.net/bigtree_3721/article/details/73632405)
|
||||
|
||||
B-树（或B树）是一种平衡的多路查找(又称排序)树，在文件系统中有所应用。主要用作文件的索引。其中的B就表示平衡(Balance)
|
||||
|
||||
B-树（或B树）是一种平衡的多路查找（又称排序）树，在文件系统中有所应用。主要用作文件的索引。其中的B就表示平衡(Balance)
|
||||
1. B+ 树的叶子节点链表结构相比于 B- 树便于扫库，和范围检索。
|
||||
2. B+树支持range-query(区间查询)非常方便，而B树不支持。这是数据库选用B+树的最主要原因。
|
||||
2. B+树支持range-query（区间查询）非常方便，而B树不支持。这是数据库选用B+树的最主要原因。
|
||||
3. B\*树 是B+树的变体，B\*树分配新结点的概率比B+树要低，空间使用率更高；
|
||||
* ### 8 LSM 树
|
||||
|
||||
[[HBase] LSM树 VS B+树](https://blog.csdn.net/dbanote/article/details/8897599)
|
||||
|
||||
|
||||
B+树最大的性能问题是会产生大量的随机IO
|
||||
|
||||
为了克服B+树的弱点，HBase引入了LSM树的概念，即Log-Structured Merge-Trees。
|
||||
|
||||
|
||||
[LSM树由来、设计思想以及应用到HBase的索引](http://www.cnblogs.com/yanghuahui/p/3483754.html)
|
||||
|
||||
|
||||
52
docs/dataStructures-algorithms/算法学习资源推荐.md
Normal file
52
docs/dataStructures-algorithms/算法学习资源推荐.md
Normal file
@ -0,0 +1,52 @@
|
||||
我比较推荐大家可以刷一下 Leetcode ，我自己平时没事也会刷一下，我觉得刷 Leetcode 不仅是为了能让你更从容地面对面试中的手撕算法问题，更可以提高你的编程思维能力、解决问题的能力以及你对某门编程语言 API 的熟练度。当然牛客网也有一些算法题，我下面也整理了一些。
|
||||
|
||||
## LeetCode
|
||||
|
||||
- [LeetCode（中国）官网](https://leetcode-cn.com/)
|
||||
|
||||
- [如何高效地使用 LeetCode](https://leetcode-cn.com/articles/%E5%A6%82%E4%BD%95%E9%AB%98%E6%95%88%E5%9C%B0%E4%BD%BF%E7%94%A8-leetcode/)
|
||||
|
||||
|
||||
## 牛客网
|
||||
|
||||
- [牛客网官网](https://www.nowcoder.com)
|
||||
- [剑指offer编程题](https://www.nowcoder.com/ta/coding-interviews)
|
||||
|
||||
- [2017校招真题](https://www.nowcoder.com/ta/2017test)
|
||||
- [华为机试题](https://www.nowcoder.com/ta/huawei)
|
||||
|
||||
|
||||
## 公司真题
|
||||
|
||||
- [ 网易2018校园招聘编程题真题集合](https://www.nowcoder.com/test/6910869/summary)
|
||||
- [ 网易2018校招内推编程题集合](https://www.nowcoder.com/test/6291726/summary)
|
||||
- [2017年校招全国统一模拟笔试(第五场)编程题集合](https://www.nowcoder.com/test/5986669/summary)
|
||||
- [2017年校招全国统一模拟笔试(第四场)编程题集合](https://www.nowcoder.com/test/5507925/summary)
|
||||
- [2017年校招全国统一模拟笔试(第三场)编程题集合](https://www.nowcoder.com/test/5217106/summary)
|
||||
- [2017年校招全国统一模拟笔试(第二场)编程题集合](https://www.nowcoder.com/test/4546329/summary)
|
||||
- [ 2017年校招全国统一模拟笔试(第一场)编程题集合](https://www.nowcoder.com/test/4236887/summary)
|
||||
- [百度2017春招笔试真题编程题集合](https://www.nowcoder.com/test/4998655/summary)
|
||||
- [网易2017春招笔试真题编程题集合](https://www.nowcoder.com/test/4575457/summary)
|
||||
- [网易2017秋招编程题集合](https://www.nowcoder.com/test/2811407/summary)
|
||||
- [网易有道2017内推编程题](https://www.nowcoder.com/test/2385858/summary)
|
||||
- [ 滴滴出行2017秋招笔试真题-编程题汇总](https://www.nowcoder.com/test/3701760/summary)
|
||||
- [腾讯2017暑期实习生编程题](https://www.nowcoder.com/test/1725829/summary)
|
||||
- [今日头条2017客户端工程师实习生笔试题](https://www.nowcoder.com/test/1649301/summary)
|
||||
- [今日头条2017后端工程师实习生笔试题](https://www.nowcoder.com/test/1649268/summary)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -28,8 +28,8 @@ MySQL的基本存储结构是页(记录都存在页里边)：
|
||||
|
||||
所以说，如果我们写select * from user where indexname = 'xxx'这样没有进行任何优化的sql语句，默认会这样做：
|
||||
|
||||
1. **定位到记录所在的页:需要遍历双向链表，找到所在的页**
|
||||
2. **从所在的页内中查找相应的记录:由于不是根据主键查询，只能遍历所在页的单链表了**
|
||||
1. **定位到记录所在的页：需要遍历双向链表，找到所在的页**
|
||||
2. **从所在的页内中查找相应的记录：由于不是根据主键查询，只能遍历所在页的单链表了**
|
||||
|
||||
很明显，在数据量很大的情况下这样查找会很慢！这样的时间复杂度为O（n）。
|
||||
|
||||
@ -55,22 +55,22 @@ MySQL的基本存储结构是页(记录都存在页里边)：
|
||||
|
||||
### 最左前缀原则
|
||||
|
||||
MySQL中的索引可以以一定顺序引用多列，这种索引叫作联合索引。如User表的name和city加联合索引就是(name,city)o而最左前缀原则指的是，如果查询的时候查询条件精确匹配索引的左边连续一列或几列，则此列就可以被用到。如下：
|
||||
MySQL中的索引可以以一定顺序引用多列，这种索引叫作联合索引。如User表的name和city加联合索引就是(name,city)，而最左前缀原则指的是，如果查询的时候查询条件精确匹配索引的左边连续一列或几列，则此列就可以被用到。如下：
|
||||
|
||||
```
|
||||
select * from user where name=xx and city=xx ; ／／可以命中索引
|
||||
select * from user where name=xx ; // 可以命中索引
|
||||
select * from user where city=xx; // 无法命中索引
|
||||
select * from user where city=xx ; // 无法命中索引
|
||||
```
|
||||
这里需要注意的是，查询的时候如果两个条件都用上了，但是顺序不同，如 `city= xx and name ＝xx`，那么现在的查询引擎会自动优化为匹配联合索引的顺序，这样是能够命中索引的.
|
||||
这里需要注意的是，查询的时候如果两个条件都用上了，但是顺序不同，如 `city= xx and name ＝xx`，那么现在的查询引擎会自动优化为匹配联合索引的顺序，这样是能够命中索引的。
|
||||
|
||||
由于最左前缀原则，在创建联合索引时，索引字段的顺序需要考虑字段值去重之后的个数，较多的放前面。ORDERBY子句也遵循此规则。
|
||||
由于最左前缀原则，在创建联合索引时，索引字段的顺序需要考虑字段值去重之后的个数，较多的放前面。ORDER BY子句也遵循此规则。
|
||||
|
||||
### 注意避免冗余索引
|
||||
|
||||
冗余索引指的是索引的功能相同，能够命中 就肯定能命中 ，那么 就是冗余索引如（name,city ）和（name ）这两个索引就是冗余索引，能够命中后者的查询肯定是能够命中前者的 在大多数情况下，都应该尽量扩展已有的索引而不是创建新索引。
|
||||
|
||||
MySQLS.7 版本后，可以通过查询 sys 库的 `schemal_r dundant_indexes` 表来查看冗余索引
|
||||
MySQL 5.7 版本后，可以通过查询 sys 库的 `schema_redundant_indexes` 表来查看冗余索引
|
||||
|
||||
### Mysql如何为表字段添加索引？？？
|
||||
|
||||
328
docs/database/MySQL.md
Normal file
328
docs/database/MySQL.md
Normal file
@ -0,0 +1,328 @@
|
||||
点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。
|
||||
|
||||
- [书籍推荐](#书籍推荐)
|
||||
- [文字教程推荐](#文字教程推荐)
|
||||
- [视频教程推荐](#视频教程推荐)
|
||||
- [常见问题总结](#常见问题总结)
|
||||
- [什么是MySQL?](#什么是mysql)
|
||||
- [存储引擎](#存储引擎)
|
||||
- [一些常用命令](#一些常用命令)
|
||||
- [MyISAM和InnoDB区别](#myisam和innodb区别)
|
||||
- [字符集及校对规则](#字符集及校对规则)
|
||||
- [索引](#索引)
|
||||
- [查询缓存的使用](#查询缓存的使用)
|
||||
- [什么是事务?](#什么是事务)
|
||||
- [事物的四大特性(ACID)](#事物的四大特性acid)
|
||||
- [并发事务带来哪些问题?](#并发事务带来哪些问题)
|
||||
- [事务隔离级别有哪些?MySQL的默认隔离级别是?](#事务隔离级别有哪些mysql的默认隔离级别是)
|
||||
- [锁机制与InnoDB锁算法](#锁机制与innodb锁算法)
|
||||
- [大表优化](#大表优化)
|
||||
- [1. 限定数据的范围](#1-限定数据的范围)
|
||||
- [2. 读/写分离](#2-读写分离)
|
||||
- [3. 垂直分区](#3-垂直分区)
|
||||
- [4. 水平分区](#4-水平分区)
|
||||
- [一条SQL语句在MySQL中如何执行的](#一条sql语句在mysql中如何执行的)
|
||||
- [MySQL高性能优化规范建议](#mysql高性能优化规范建议)
|
||||
- [一条SQL语句执行得很慢的原因有哪些？](#一条sql语句执行得很慢的原因有哪些)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
## 书籍推荐
|
||||
|
||||
- 《SQL基础教程（第2版）》 （入门级）
|
||||
- 《高性能MySQL : 第3版》 (进阶)
|
||||
|
||||
## 文字教程推荐
|
||||
|
||||
- [SQL Tutorial](https://www.w3schools.com/sql/default.asp) （SQL语句学习,英文）、[SQL Tutorial](https://www.w3school.com.cn/sql/index.asp)（SQL语句学习,中文）、[SQL语句在线练习](https://www.w3schools.com/sql/exercise.asp) （非常不错）
|
||||
- [Github-MySQL入门教程（MySQL tutorial book）](https://github.com/jaywcjlove/mysql-tutorial) （从零开始学习MySQL，主要是面向MySQL数据库管理系统初学者）
|
||||
- [官方教程](https://dev.mysql.com/doc/refman/5.7/)
|
||||
- [MySQL 教程（菜鸟教程）](http://www.runoob.com/MySQL/MySQL-tutorial.html)
|
||||
|
||||
## 相关资源推荐
|
||||
|
||||
- [中国5级行政区域mysql库](https://github.com/kakuilan/china_area_mysql)
|
||||
|
||||
## 视频教程推荐
|
||||
|
||||
**基础入门：** [与MySQL的零距离接触-慕课网](https://www.imooc.com/learn/122)
|
||||
|
||||
**MySQL开发技巧：** [MySQL开发技巧（一）](https://www.imooc.com/learn/398) [MySQL开发技巧（二）](https://www.imooc.com/learn/427) [MySQL开发技巧（三）](https://www.imooc.com/learn/449)
|
||||
|
||||
**MySQL5.7新特性及相关优化技巧：** [MySQL5.7版本新特性](https://www.imooc.com/learn/533) [性能优化之MySQL优化](https://www.imooc.com/learn/194)
|
||||
|
||||
[MySQL集群（PXC）入门](https://www.imooc.com/learn/993) [MyCAT入门及应用](https://www.imooc.com/learn/951)
|
||||
|
||||
## 常见问题总结
|
||||
|
||||
### 什么是MySQL?
|
||||
|
||||
MySQL 是一种关系型数据库，在Java企业级开发中非常常用，因为 MySQL 是开源免费的，并且方便扩展。阿里巴巴数据库系统也大量用到了 MySQL，因此它的稳定性是有保障的。MySQL是开放源代码的，因此任何人都可以在 GPL(General Public License) 的许可下下载并根据个性化的需要对其进行修改。MySQL的默认端口号是**3306**。
|
||||
|
||||
### 存储引擎
|
||||
|
||||
#### 一些常用命令
|
||||
|
||||
**查看MySQL提供的所有存储引擎**
|
||||
|
||||
```sql
|
||||
mysql> show engines;
|
||||
```
|
||||
|
||||
|
||||
|
||||
从上图我们可以查看出 MySQL 当前默认的存储引擎是InnoDB,并且在5.7版本所有的存储引擎中只有 InnoDB 是事务性存储引擎，也就是说只有 InnoDB 支持事务。
|
||||
|
||||
**查看MySQL当前默认的存储引擎**
|
||||
|
||||
我们也可以通过下面的命令查看默认的存储引擎。
|
||||
|
||||
```sql
|
||||
mysql> show variables like '%storage_engine%';
|
||||
```
|
||||
|
||||
**查看表的存储引擎**
|
||||
|
||||
```sql
|
||||
show table status like "table_name" ;
|
||||
```
|
||||
|
||||
|
||||
|
||||
#### MyISAM和InnoDB区别
|
||||
|
||||
MyISAM是MySQL的默认数据库引擎（5.5版之前）。虽然性能极佳，而且提供了大量的特性，包括全文索引、压缩、空间函数等，但MyISAM不支持事务和行级锁，而且最大的缺陷就是崩溃后无法安全恢复。不过，5.5版本之后，MySQL引入了InnoDB（事务性数据库引擎），MySQL 5.5版本后默认的存储引擎为InnoDB。
|
||||
|
||||
大多数时候我们使用的都是 InnoDB 存储引擎，但是在某些情况下使用 MyISAM 也是合适的比如读密集的情况下。（如果你不介意 MyISAM 崩溃恢复问题的话）。
|
||||
|
||||
**两者的对比：**
|
||||
|
||||
1. **是否支持行级锁** : MyISAM 只有表级锁(table-level locking)，而InnoDB 支持行级锁(row-level locking)和表级锁,默认为行级锁。
|
||||
2. **是否支持事务和崩溃后的安全恢复： MyISAM** 强调的是性能，每次查询具有原子性,其执行速度比InnoDB类型更快，但是不提供事务支持。但是**InnoDB** 提供事务支持事务，外部键等高级数据库功能。 具有事务(commit)、回滚(rollback)和崩溃修复能力(crash recovery capabilities)的事务安全(transaction-safe (ACID compliant))型表。
|
||||
3. **是否支持外键：** MyISAM不支持，而InnoDB支持。
|
||||
4. **是否支持MVCC** ：仅 InnoDB 支持。应对高并发事务, MVCC比单纯的加锁更高效;MVCC只在 `READ COMMITTED` 和 `REPEATABLE READ` 两个隔离级别下工作;MVCC可以使用 乐观(optimistic)锁 和 悲观(pessimistic)锁来实现;各数据库中MVCC实现并不统一。推荐阅读：[MySQL-InnoDB-MVCC多版本并发控制](https://segmentfault.com/a/1190000012650596)
|
||||
5. ......
|
||||
|
||||
《MySQL高性能》上面有一句话这样写到:
|
||||
|
||||
> 不要轻易相信“MyISAM比InnoDB快”之类的经验之谈，这个结论往往不是绝对的。在很多我们已知场景中，InnoDB的速度都可以让MyISAM望尘莫及，尤其是用到了聚簇索引，或者需要访问的数据都可以放入内存的应用。
|
||||
|
||||
一般情况下我们选择 InnoDB 都是没有问题的，但是某些情况下你并不在乎可扩展能力和并发能力，也不需要事务支持，也不在乎崩溃后的安全恢复问题的话，选择MyISAM也是一个不错的选择。但是一般情况下，我们都是需要考虑到这些问题的。
|
||||
|
||||
### 字符集及校对规则
|
||||
|
||||
字符集指的是一种从二进制编码到某类字符符号的映射。校对规则则是指某种字符集下的排序规则。MySQL中每一种字符集都会对应一系列的校对规则。
|
||||
|
||||
MySQL采用的是类似继承的方式指定字符集的默认值，每个数据库以及每张数据表都有自己的默认值，他们逐层继承。比如：某个库中所有表的默认字符集将是该数据库所指定的字符集（这些表在没有指定字符集的情况下，才会采用默认字符集） PS：整理自《Java工程师修炼之道》
|
||||
|
||||
详细内容可以参考： [MySQL字符集及校对规则的理解](https://www.cnblogs.com/geaozhang/p/6724393.html#MySQLyuzifuji)
|
||||
|
||||
### 索引
|
||||
|
||||
MySQL索引使用的数据结构主要有**BTree索引** 和 **哈希索引** 。对于哈希索引来说，底层的数据结构就是哈希表，因此在绝大多数需求为单条记录查询的时候，可以选择哈希索引，查询性能最快；其余大部分场景，建议选择BTree索引。
|
||||
|
||||
MySQL的BTree索引使用的是B树中的B+Tree，但对于主要的两种存储引擎的实现方式是不同的。
|
||||
|
||||
- **MyISAM:** B+Tree叶节点的data域存放的是数据记录的地址。在索引检索的时候，首先按照B+Tree搜索算法搜索索引，如果指定的Key存在，则取出其 data 域的值，然后以 data 域的值为地址读取相应的数据记录。这被称为“非聚簇索引”。
|
||||
- **InnoDB:** 其数据文件本身就是索引文件。相比MyISAM，索引文件和数据文件是分离的，其表数据文件本身就是按B+Tree组织的一个索引结构，树的叶节点data域保存了完整的数据记录。这个索引的key是数据表的主键，因此InnoDB表数据文件本身就是主索引。这被称为“聚簇索引（或聚集索引）”。而其余的索引都作为辅助索引，辅助索引的data域存储相应记录主键的值而不是地址，这也是和MyISAM不同的地方。**在根据主索引搜索时，直接找到key所在的节点即可取出数据；在根据辅助索引查找时，则需要先取出主键的值，再走一遍主索引。** **因此，在设计表的时候，不建议使用过长的字段作为主键，也不建议使用非单调的字段作为主键，这样会造成主索引频繁分裂。** PS：整理自《Java工程师修炼之道》
|
||||
|
||||
**更多关于索引的内容可以查看文档首页MySQL目录下关于索引的详细总结。**
|
||||
|
||||
### 查询缓存的使用
|
||||
|
||||
> 执行查询语句的时候，会先查询缓存。不过，MySQL 8.0 版本后移除，因为这个功能不太实用
|
||||
|
||||
my.cnf加入以下配置，重启MySQL开启查询缓存
|
||||
```properties
|
||||
query_cache_type=1
|
||||
query_cache_size=600000
|
||||
```
|
||||
|
||||
MySQL执行以下命令也可以开启查询缓存
|
||||
|
||||
```properties
|
||||
set global query_cache_type=1;
|
||||
set global query_cache_size=600000;
|
||||
```
|
||||
如上，**开启查询缓存后在同样的查询条件以及数据情况下，会直接在缓存中返回结果**。这里的查询条件包括查询本身、当前要查询的数据库、客户端协议版本号等一些可能影响结果的信息。因此任何两个查询在任何字符上的不同都会导致缓存不命中。此外，如果查询中包含任何用户自定义函数、存储函数、用户变量、临时表、MySQL库中的系统表，其查询结果也不会被缓存。
|
||||
|
||||
缓存建立之后，MySQL的查询缓存系统会跟踪查询中涉及的每张表，如果这些表（数据或结构）发生变化，那么和这张表相关的所有缓存数据都将失效。
|
||||
|
||||
**缓存虽然能够提升数据库的查询性能，但是缓存同时也带来了额外的开销，每次查询后都要做一次缓存操作，失效后还要销毁。** 因此，开启缓存查询要谨慎，尤其对于写密集的应用来说更是如此。如果开启，要注意合理控制缓存空间大小，一般来说其大小设置为几十MB比较合适。此外，**还可以通过sql_cache和sql_no_cache来控制某个查询语句是否需要缓存：**
|
||||
```sql
|
||||
select sql_no_cache count(*) from usr;
|
||||
```
|
||||
|
||||
### 什么是事务?
|
||||
|
||||
**事务是逻辑上的一组操作，要么都执行，要么都不执行。**
|
||||
|
||||
事务最经典也经常被拿出来说例子就是转账了。假如小明要给小红转账1000元，这个转账会涉及到两个关键操作就是：将小明的余额减少1000元，将小红的余额增加1000元。万一在这两个操作之间突然出现错误比如银行系统崩溃，导致小明余额减少而小红的余额没有增加，这样就不对了。事务就是保证这两个关键操作要么都成功，要么都要失败。
|
||||
|
||||
### 事物的四大特性(ACID)
|
||||
|
||||
|
||||
|
||||
1. **原子性（Atomicity）：** 事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用；
|
||||
2. **一致性（Consistency）：** 执行事务前后，数据保持一致，多个事务对同一个数据读取的结果是相同的；
|
||||
3. **隔离性（Isolation）：** 并发访问数据库时，一个用户的事务不被其他事务所干扰，各并发事务之间数据库是独立的；
|
||||
4. **持久性（Durability）：** 一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。
|
||||
|
||||
### 并发事务带来哪些问题?
|
||||
|
||||
在典型的应用程序中，多个事务并发运行，经常会操作相同的数据来完成各自的任务（多个用户对同一数据进行操作）。并发虽然是必须的，但可能会导致以下的问题。
|
||||
|
||||
- **脏读（Dirty read）:** 当一个事务正在访问数据并且对数据进行了修改，而这种修改还没有提交到数据库中，这时另外一个事务也访问了这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另外一个事务读到的这个数据是“脏数据”，依据“脏数据”所做的操作可能是不正确的。
|
||||
- **丢失修改（Lost to modify）:** 指在一个事务读取一个数据时，另外一个事务也访问了该数据，那么在第一个事务中修改了这个数据后，第二个事务也修改了这个数据。这样第一个事务内的修改结果就被丢失，因此称为丢失修改。 例如：事务1读取某表中的数据A=20，事务2也读取A=20，事务1修改A=A-1，事务2也修改A=A-1，最终结果A=19，事务1的修改被丢失。
|
||||
- **不可重复读（Unrepeatableread）:** 指在一个事务内多次读同一数据。在这个事务还没有结束时，另一个事务也访问该数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改导致第一个事务两次读取的数据可能不太一样。这就发生了在一个事务内两次读到的数据是不一样的情况，因此称为不可重复读。
|
||||
- **幻读（Phantom read）:** 幻读与不可重复读类似。它发生在一个事务（T1）读取了几行数据，接着另一个并发事务（T2）插入了一些数据时。在随后的查询中，第一个事务（T1）就会发现多了一些原本不存在的记录，就好像发生了幻觉一样，所以称为幻读。
|
||||
|
||||
**不可重复读和幻读区别：**
|
||||
|
||||
不可重复读的重点是修改比如多次读取一条记录发现其中某些列的值被修改，幻读的重点在于新增或者删除比如多次读取一条记录发现记录增多或减少了。
|
||||
|
||||
### 事务隔离级别有哪些?MySQL的默认隔离级别是?
|
||||
|
||||
**SQL 标准定义了四个隔离级别：**
|
||||
|
||||
- **READ-UNCOMMITTED(读取未提交)：** 最低的隔离级别，允许读取尚未提交的数据变更，**可能会导致脏读、幻读或不可重复读**。
|
||||
- **READ-COMMITTED(读取已提交)：** 允许读取并发事务已经提交的数据，**可以阻止脏读，但是幻读或不可重复读仍有可能发生**。
|
||||
- **REPEATABLE-READ(可重复读)：** 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，**可以阻止脏读和不可重复读，但幻读仍有可能发生**。
|
||||
- **SERIALIZABLE(可串行化)：** 最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，**该级别可以防止脏读、不可重复读以及幻读**。
|
||||
|
||||
------
|
||||
|
||||
| 隔离级别 | 脏读 | 不可重复读 | 幻影读 |
|
||||
| :--------------: | :--: | :--------: | :----: |
|
||||
| READ-UNCOMMITTED | √ | √ | √ |
|
||||
| READ-COMMITTED | × | √ | √ |
|
||||
| REPEATABLE-READ | × | × | √ |
|
||||
| SERIALIZABLE | × | × | × |
|
||||
|
||||
MySQL InnoDB 存储引擎的默认支持的隔离级别是 **REPEATABLE-READ（可重读）**。我们可以通过`SELECT @@tx_isolation;`命令来查看
|
||||
|
||||
```sql
|
||||
mysql> SELECT @@tx_isolation;
|
||||
+-----------------+
|
||||
| @@tx_isolation |
|
||||
+-----------------+
|
||||
| REPEATABLE-READ |
|
||||
+-----------------+
|
||||
```
|
||||
|
||||
这里需要注意的是：与 SQL 标准不同的地方在于 InnoDB 存储引擎在 **REPEATABLE-READ（可重读）**
|
||||
事务隔离级别下使用的是Next-Key Lock 锁算法，因此可以避免幻读的产生，这与其他数据库系统(如 SQL Server)
|
||||
是不同的。所以说InnoDB 存储引擎的默认支持的隔离级别是 **REPEATABLE-READ（可重读）** 已经可以完全保证事务的隔离性要求，即达到了
|
||||
SQL标准的 **SERIALIZABLE(可串行化)** 隔离级别。因为隔离级别越低，事务请求的锁越少，所以大部分数据库系统的隔离级别都是 **READ-COMMITTED(读取提交内容)** ，但是你要知道的是InnoDB 存储引擎默认使用 **REPEAaTABLE-READ（可重读）** 并不会有任何性能损失。
|
||||
|
||||
InnoDB 存储引擎在 **分布式事务** 的情况下一般会用到 **SERIALIZABLE(可串行化)** 隔离级别。
|
||||
|
||||
### 锁机制与InnoDB锁算法
|
||||
|
||||
**MyISAM和InnoDB存储引擎使用的锁：**
|
||||
|
||||
- MyISAM采用表级锁(table-level locking)。
|
||||
- InnoDB支持行级锁(row-level locking)和表级锁,默认为行级锁
|
||||
|
||||
**表级锁和行级锁对比：**
|
||||
|
||||
- **表级锁：** MySQL中锁定 **粒度最大** 的一种锁，对当前操作的整张表加锁，实现简单，资源消耗也比较少，加锁快，不会出现死锁。其锁定粒度最大，触发锁冲突的概率最高，并发度最低，MyISAM和 InnoDB引擎都支持表级锁。
|
||||
- **行级锁：** MySQL中锁定 **粒度最小** 的一种锁，只针对当前操作的行进行加锁。 行级锁能大大减少数据库操作的冲突。其加锁粒度最小，并发度高，但加锁的开销也最大，加锁慢，会出现死锁。
|
||||
|
||||
详细内容可以参考： MySQL锁机制简单了解一下：[https://blog.csdn.net/qq_34337272/article/details/80611486](https://blog.csdn.net/qq_34337272/article/details/80611486)
|
||||
|
||||
**InnoDB存储引擎的锁的算法有三种：**
|
||||
|
||||
- Record lock：单个行记录上的锁
|
||||
- Gap lock：间隙锁，锁定一个范围，不包括记录本身
|
||||
- Next-key lock：record+gap 锁定一个范围，包含记录本身
|
||||
|
||||
**相关知识点：**
|
||||
|
||||
1. innodb对于行的查询使用next-key lock
|
||||
2. Next-locking keying为了解决Phantom Problem幻读问题
|
||||
3. 当查询的索引含有唯一属性时，将next-key lock降级为record key
|
||||
4. Gap锁设计的目的是为了阻止多个事务将记录插入到同一范围内，而这会导致幻读问题的产生
|
||||
5. 有两种方式显式关闭gap锁：（除了外键约束和唯一性检查外，其余情况仅使用record lock） A. 将事务隔离级别设置为RC B. 将参数innodb_locks_unsafe_for_binlog设置为1
|
||||
|
||||
### 大表优化
|
||||
|
||||
当MySQL单表记录数过大时，数据库的CRUD性能会明显下降，一些常见的优化措施如下：
|
||||
|
||||
#### 1. 限定数据的范围
|
||||
|
||||
务必禁止不带任何限制数据范围条件的查询语句。比如：我们当用户在查询订单历史的时候，我们可以控制在一个月的范围内；
|
||||
|
||||
#### 2. 读/写分离
|
||||
|
||||
经典的数据库拆分方案，主库负责写，从库负责读；
|
||||
|
||||
#### 3. 垂直分区
|
||||
|
||||
**根据数据库里面数据表的相关性进行拆分。** 例如，用户表中既有用户的登录信息又有用户的基本信息，可以将用户表拆分成两个单独的表，甚至放到单独的库做分库。
|
||||
|
||||
**简单来说垂直拆分是指数据表列的拆分，把一张列比较多的表拆分为多张表。** 如下图所示，这样来说大家应该就更容易理解了。
|
||||
|
||||
|
||||
- **垂直拆分的优点：** 可以使得列数据变小，在查询时减少读取的Block数，减少I/O次数。此外，垂直分区可以简化表的结构，易于维护。
|
||||
- **垂直拆分的缺点：** 主键会出现冗余，需要管理冗余列，并会引起Join操作，可以通过在应用层进行Join来解决。此外，垂直分区会让事务变得更加复杂；
|
||||
|
||||
#### 4. 水平分区
|
||||
|
||||
**保持数据表结构不变，通过某种策略存储数据分片。这样每一片数据分散到不同的表或者库中，达到了分布式的目的。 水平拆分可以支撑非常大的数据量。**
|
||||
|
||||
水平拆分是指数据表行的拆分，表的行数超过200万行时，就会变慢，这时可以把一张的表的数据拆成多张表来存放。举个例子：我们可以将用户信息表拆分成多个用户信息表，这样就可以避免单一表数据量过大对性能造成影响。
|
||||
|
||||
|
||||
|
||||
水平拆分可以支持非常大的数据量。需要注意的一点是：分表仅仅是解决了单一表数据过大的问题，但由于表的数据还是在同一台机器上，其实对于提升MySQL并发能力没有什么意义，所以 **水平拆分最好分库** 。
|
||||
|
||||
水平拆分能够 **支持非常大的数据量存储，应用端改造也少**，但 **分片事务难以解决** ，跨节点Join性能较差，逻辑复杂。《Java工程师修炼之道》的作者推荐 **尽量不要对数据进行分片，因为拆分会带来逻辑、部署、运维的各种复杂度** ，一般的数据表在优化得当的情况下支撑千万以下的数据量是没有太大问题的。如果实在要分片，尽量选择客户端分片架构，这样可以减少一次和中间件的网络I/O。
|
||||
|
||||
**下面补充一下数据库分片的两种常见方案：**
|
||||
|
||||
- **客户端代理：** **分片逻辑在应用端，封装在jar包中，通过修改或者封装JDBC层来实现。** 当当网的 **Sharding-JDBC** 、阿里的TDDL是两种比较常用的实现。
|
||||
- **中间件代理：** **在应用和数据中间加了一个代理层。分片逻辑统一维护在中间件服务中。** 我们现在谈的 **Mycat** 、360的Atlas、网易的DDB等等都是这种架构的实现。
|
||||
|
||||
详细内容可以参考： MySQL大表优化方案: [https://segmentfault.com/a/1190000006158186](https://segmentfault.com/a/1190000006158186)
|
||||
|
||||
### 解释一下什么是池化设计思想。什么是数据库连接池?为什么需要数据库连接池?
|
||||
|
||||
池话设计应该不是一个新名词。我们常见的如java线程池、jdbc连接池、redis连接池等就是这类设计的代表实现。这种设计会初始预设资源，解决的问题就是抵消每次获取资源的消耗，如创建线程的开销，获取远程连接的开销等。就好比你去食堂打饭，打饭的大妈会先把饭盛好几份放那里，你来了就直接拿着饭盒加菜即可，不用再临时又盛饭又打菜，效率就高了。除了初始化资源，池化设计还包括如下这些特征：池子的初始值、池子的活跃值、池子的最大值等，这些特征可以直接映射到java线程池和数据库连接池的成员属性中。——这篇文章对[池化设计思想](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247485679&idx=1&sn=57dbca8c9ad49e1f3968ecff04a4f735&chksm=cea24724f9d5ce3212292fac291234a760c99c0960b5430d714269efe33554730b5f71208582&token=1141994790&lang=zh_CN#rd)介绍的还不错，直接复制过来，避免重复造轮子了。
|
||||
|
||||
数据库连接本质就是一个 socket 的连接。数据库服务端还要维护一些缓存和用户权限信息之类的 所以占用了一些内存。我们可以把数据库连接池是看做是维护的数据库连接的缓存，以便将来需要对数据库的请求时可以重用这些连接。为每个用户打开和维护数据库连接，尤其是对动态数据库驱动的网站应用程序的请求，既昂贵又浪费资源。**在连接池中，创建连接后，将其放置在池中，并再次使用它，因此不必建立新的连接。如果使用了所有连接，则会建立一个新连接并将其添加到池中。**连接池还减少了用户必须等待建立与数据库的连接的时间。
|
||||
|
||||
### 分库分表之后,id 主键如何处理？
|
||||
|
||||
因为要是分成多个表之后，每个表都是从 1 开始累加，这样是不对的，我们需要一个全局唯一的 id 来支持。
|
||||
|
||||
生成全局 id 有下面这几种方式：
|
||||
|
||||
- **UUID**：不适合作为主键，因为太长了，并且无序不可读，查询效率低。比较适合用于生成唯一的名字的标示比如文件的名字。
|
||||
- **数据库自增 id** : 两台数据库分别设置不同步长，生成不重复ID的策略来实现高可用。这种方式生成的 id 有序，但是需要独立部署数据库实例，成本高，还会有性能瓶颈。
|
||||
- **利用 redis 生成 id :** 性能比较好，灵活方便，不依赖于数据库。但是，引入了新的组件造成系统更加复杂，可用性降低，编码更加复杂，增加了系统成本。
|
||||
- **Twitter的snowflake算法** ：Github 地址：https://github.com/twitter-archive/snowflake。
|
||||
- **美团的[Leaf](https://tech.meituan.com/2017/04/21/mt-leaf.html)分布式ID生成系统** ：Leaf 是美团开源的分布式ID生成器，能保证全局唯一性、趋势递增、单调递增、信息安全，里面也提到了几种分布式方案的对比，但也需要依赖关系数据库、Zookeeper等中间件。感觉还不错。美团技术团队的一篇文章：https://tech.meituan.com/2017/04/21/mt-leaf.html 。
|
||||
- ......
|
||||
|
||||
### 一条SQL语句在MySQL中如何执行的
|
||||
|
||||
[一条SQL语句在MySQL中如何执行的](<https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247485097&idx=1&sn=84c89da477b1338bdf3e9fcd65514ac1&chksm=cea24962f9d5c074d8d3ff1ab04ee8f0d6486e3d015cfd783503685986485c11738ccb542ba7&token=79317275&lang=zh_CN#rd>)
|
||||
|
||||
### MySQL高性能优化规范建议
|
||||
|
||||
[MySQL高性能优化规范建议](<https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247485117&idx=1&sn=92361755b7c3de488b415ec4c5f46d73&chksm=cea24976f9d5c060babe50c3747616cce63df5d50947903a262704988143c2eeb4069ae45420&token=79317275&lang=zh_CN#rd>)
|
||||
|
||||
### 一条SQL语句执行得很慢的原因有哪些？
|
||||
|
||||
[腾讯面试：一条SQL语句执行得很慢的原因有哪些？---不看后悔系列](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247485185&idx=1&sn=66ef08b4ab6af5757792223a83fc0d45&chksm=cea248caf9d5c1dc72ec8a281ec16aa3ec3e8066dbb252e27362438a26c33fbe842b0e0adf47&token=79317275&lang=zh_CN#rd)
|
||||
|
||||
## 公众号
|
||||
|
||||
如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。
|
||||
|
||||
**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"Java面试突击"** 即可免费领取！
|
||||
|
||||
**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
|
||||
|
||||
|
||||
441
docs/database/MySQL高性能优化规范建议.md
Normal file
441
docs/database/MySQL高性能优化规范建议.md
Normal file
@ -0,0 +1,441 @@
|
||||
> 作者: 听风，原文地址: <https://www.cnblogs.com/huchong/p/10219318.html>。JavaGuide 已获得作者授权。
|
||||
|
||||
<!-- TOC -->
|
||||
|
||||
- [数据库命令规范](#数据库命令规范)
|
||||
- [数据库基本设计规范](#数据库基本设计规范)
|
||||
- [1. 所有表必须使用 Innodb 存储引擎](#1-所有表必须使用-innodb-存储引擎)
|
||||
- [2. 数据库和表的字符集统一使用 UTF8](#2-数据库和表的字符集统一使用-utf8)
|
||||
- [3. 所有表和字段都需要添加注释](#3-所有表和字段都需要添加注释)
|
||||
- [4. 尽量控制单表数据量的大小,建议控制在 500 万以内。](#4-尽量控制单表数据量的大小建议控制在-500-万以内)
|
||||
- [5. 谨慎使用 MySQL 分区表](#5-谨慎使用-mysql-分区表)
|
||||
- [6.尽量做到冷热数据分离,减小表的宽度](#6尽量做到冷热数据分离减小表的宽度)
|
||||
- [7. 禁止在表中建立预留字段](#7-禁止在表中建立预留字段)
|
||||
- [8. 禁止在数据库中存储图片,文件等大的二进制数据](#8-禁止在数据库中存储图片文件等大的二进制数据)
|
||||
- [9. 禁止在线上做数据库压力测试](#9-禁止在线上做数据库压力测试)
|
||||
- [10. 禁止从开发环境,测试环境直接连接生成环境数据库](#10-禁止从开发环境测试环境直接连接生成环境数据库)
|
||||
- [数据库字段设计规范](#数据库字段设计规范)
|
||||
- [1. 优先选择符合存储需要的最小的数据类型](#1-优先选择符合存储需要的最小的数据类型)
|
||||
- [2. 避免使用 TEXT,BLOB 数据类型，最常见的 TEXT 类型可以存储 64k 的数据](#2-避免使用-textblob-数据类型最常见的-text-类型可以存储-64k-的数据)
|
||||
- [3. 避免使用 ENUM 类型](#3-避免使用-enum-类型)
|
||||
- [4. 尽可能把所有列定义为 NOT NULL](#4-尽可能把所有列定义为-not-null)
|
||||
- [5. 使用 TIMESTAMP(4 个字节) 或 DATETIME 类型 (8 个字节) 存储时间](#5-使用-timestamp4-个字节-或-datetime-类型-8-个字节-存储时间)
|
||||
- [6. 同财务相关的金额类数据必须使用 decimal 类型](#6-同财务相关的金额类数据必须使用-decimal-类型)
|
||||
- [索引设计规范](#索引设计规范)
|
||||
- [1. 限制每张表上的索引数量,建议单张表索引不超过 5 个](#1-限制每张表上的索引数量建议单张表索引不超过-5-个)
|
||||
- [2. 禁止给表中的每一列都建立单独的索引](#2-禁止给表中的每一列都建立单独的索引)
|
||||
- [3. 每个 Innodb 表必须有个主键](#3-每个-innodb-表必须有个主键)
|
||||
- [4. 常见索引列建议](#4-常见索引列建议)
|
||||
- [5.如何选择索引列的顺序](#5如何选择索引列的顺序)
|
||||
- [6. 避免建立冗余索引和重复索引（增加了查询优化器生成执行计划的时间）](#6-避免建立冗余索引和重复索引增加了查询优化器生成执行计划的时间)
|
||||
- [7. 对于频繁的查询优先考虑使用覆盖索引](#7-对于频繁的查询优先考虑使用覆盖索引)
|
||||
- [8.索引 SET 规范](#8索引-set-规范)
|
||||
- [数据库 SQL 开发规范](#数据库-sql-开发规范)
|
||||
- [1. 建议使用预编译语句进行数据库操作](#1-建议使用预编译语句进行数据库操作)
|
||||
- [2. 避免数据类型的隐式转换](#2-避免数据类型的隐式转换)
|
||||
- [3. 充分利用表上已经存在的索引](#3-充分利用表上已经存在的索引)
|
||||
- [4. 数据库设计时，应该要对以后扩展进行考虑](#4-数据库设计时应该要对以后扩展进行考虑)
|
||||
- [5. 程序连接不同的数据库使用不同的账号，进制跨库查询](#5-程序连接不同的数据库使用不同的账号进制跨库查询)
|
||||
- [6. 禁止使用 SELECT * 必须使用 SELECT <字段列表> 查询](#6-禁止使用-select--必须使用-select-字段列表-查询)
|
||||
- [7. 禁止使用不含字段列表的 INSERT 语句](#7-禁止使用不含字段列表的-insert-语句)
|
||||
- [8. 避免使用子查询，可以把子查询优化为 join 操作](#8-避免使用子查询可以把子查询优化为-join-操作)
|
||||
- [9. 避免使用 JOIN 关联太多的表](#9-避免使用-join-关联太多的表)
|
||||
- [10. 减少同数据库的交互次数](#10-减少同数据库的交互次数)
|
||||
- [11. 对应同一列进行 or 判断时，使用 in 代替 or](#11-对应同一列进行-or-判断时使用-in-代替-or)
|
||||
- [12. 禁止使用 order by rand() 进行随机排序](#12-禁止使用-order-by-rand-进行随机排序)
|
||||
- [13. WHERE 从句中禁止对列进行函数转换和计算](#13-where-从句中禁止对列进行函数转换和计算)
|
||||
- [14. 在明显不会有重复值时使用 UNION ALL 而不是 UNION](#14-在明显不会有重复值时使用-union-all-而不是-union)
|
||||
- [15. 拆分复杂的大 SQL 为多个小 SQL](#15-拆分复杂的大-sql-为多个小-sql)
|
||||
- [数据库操作行为规范](#数据库操作行为规范)
|
||||
- [1. 超 100 万行的批量写 (UPDATE,DELETE,INSERT) 操作,要分批多次进行操作](#1-超-100-万行的批量写-updatedeleteinsert-操作要分批多次进行操作)
|
||||
- [2. 对于大表使用 pt-online-schema-change 修改表结构](#2-对于大表使用-pt-online-schema-change-修改表结构)
|
||||
- [3. 禁止为程序使用的账号赋予 super 权限](#3-禁止为程序使用的账号赋予-super-权限)
|
||||
- [4. 对于程序连接数据库账号,遵循权限最小原则](#4-对于程序连接数据库账号遵循权限最小原则)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
## 数据库命令规范
|
||||
|
||||
- 所有数据库对象名称必须使用小写字母并用下划线分割
|
||||
- 所有数据库对象名称禁止使用 MySQL 保留关键字（如果表名中包含关键字查询时，需要将其用单引号括起来）
|
||||
- 数据库对象的命名要能做到见名识意，并且最后不要超过 32 个字符
|
||||
- 临时库表必须以 tmp_为前缀并以日期为后缀，备份表必须以 bak_为前缀并以日期 (时间戳) 为后缀
|
||||
- 所有存储相同数据的列名和列类型必须一致（一般作为关联列，如果查询时关联列类型不一致会自动进行数据类型隐式转换，会造成列上的索引失效，导致查询效率降低）
|
||||
|
||||
------
|
||||
|
||||
## 数据库基本设计规范
|
||||
|
||||
### 1. 所有表必须使用 Innodb 存储引擎
|
||||
|
||||
没有特殊要求（即 Innodb 无法满足的功能如：列存储，存储空间数据等）的情况下，所有表必须使用 Innodb 存储引擎（MySQL5.5 之前默认使用 Myisam，5.6 以后默认的为 Innodb）。
|
||||
|
||||
Innodb 支持事务，支持行级锁，更好的恢复性，高并发下性能更好。
|
||||
|
||||
### 2. 数据库和表的字符集统一使用 UTF8
|
||||
|
||||
兼容性更好，统一字符集可以避免由于字符集转换产生的乱码，不同的字符集进行比较前需要进行转换会造成索引失效，如果数据库中有存储 emoji 表情的需要，字符集需要采用 utf8mb4 字符集。
|
||||
|
||||
### 3. 所有表和字段都需要添加注释
|
||||
|
||||
使用 comment 从句添加表和列的备注，从一开始就进行数据字典的维护
|
||||
|
||||
### 4. 尽量控制单表数据量的大小,建议控制在 500 万以内。
|
||||
|
||||
500 万并不是 MySQL 数据库的限制，过大会造成修改表结构，备份，恢复都会有很大的问题。
|
||||
|
||||
可以用历史数据归档（应用于日志数据），分库分表（应用于业务数据）等手段来控制数据量大小
|
||||
|
||||
### 5. 谨慎使用 MySQL 分区表
|
||||
|
||||
分区表在物理上表现为多个文件，在逻辑上表现为一个表；
|
||||
|
||||
谨慎选择分区键，跨分区查询效率可能更低；
|
||||
|
||||
建议采用物理分表的方式管理大数据。
|
||||
|
||||
### 6.尽量做到冷热数据分离,减小表的宽度
|
||||
|
||||
> MySQL 限制每个表最多存储 4096 列，并且每一行数据的大小不能超过 65535 字节。
|
||||
|
||||
减少磁盘 IO,保证热数据的内存缓存命中率（表越宽，把表装载进内存缓冲池时所占用的内存也就越大,也会消耗更多的 IO）；
|
||||
|
||||
更有效的利用缓存，避免读入无用的冷数据；
|
||||
|
||||
经常一起使用的列放到一个表中（避免更多的关联操作）。
|
||||
|
||||
### 7. 禁止在表中建立预留字段
|
||||
|
||||
预留字段的命名很难做到见名识义。
|
||||
|
||||
预留字段无法确认存储的数据类型，所以无法选择合适的类型。
|
||||
|
||||
对预留字段类型的修改，会对表进行锁定。
|
||||
|
||||
### 8. 禁止在数据库中存储图片,文件等大的二进制数据
|
||||
|
||||
通常文件很大，会短时间内造成数据量快速增长，数据库进行数据库读取时，通常会进行大量的随机 IO 操作，文件很大时，IO 操作很耗时。
|
||||
|
||||
通常存储于文件服务器，数据库只存储文件地址信息
|
||||
|
||||
### 9. 禁止在线上做数据库压力测试
|
||||
|
||||
### 10. 禁止从开发环境,测试环境直接连接生产环境数据库
|
||||
|
||||
------
|
||||
|
||||
## 数据库字段设计规范
|
||||
|
||||
### 1. 优先选择符合存储需要的最小的数据类型
|
||||
|
||||
**原因：**
|
||||
|
||||
列的字段越大，建立索引时所需要的空间也就越大，这样一页中所能存储的索引节点的数量也就越少也越少，在遍历时所需要的 IO 次数也就越多，索引的性能也就越差。
|
||||
|
||||
**方法：**
|
||||
|
||||
**a.将字符串转换成数字类型存储,如:将 IP 地址转换成整形数据**
|
||||
|
||||
MySQL 提供了两个方法来处理 ip 地址
|
||||
|
||||
- inet_aton 把 ip 转为无符号整型 (4-8 位)
|
||||
- inet_ntoa 把整型的 ip 转为地址
|
||||
|
||||
插入数据前，先用 inet_aton 把 ip 地址转为整型，可以节省空间，显示数据时，使用 inet_ntoa 把整型的 ip 地址转为地址显示即可。
|
||||
|
||||
**b.对于非负型的数据 (如自增 ID,整型 IP) 来说,要优先使用无符号整型来存储**
|
||||
|
||||
**原因：**
|
||||
|
||||
无符号相对于有符号可以多出一倍的存储空间
|
||||
|
||||
```
|
||||
SIGNED INT -2147483648~2147483647
|
||||
UNSIGNED INT 0~4294967295
|
||||
```
|
||||
|
||||
VARCHAR(N) 中的 N 代表的是字符数，而不是字节数，使用 UTF8 存储 255 个汉字 Varchar(255)=765 个字节。**过大的长度会消耗更多的内存。**
|
||||
|
||||
### 2. 避免使用 TEXT,BLOB 数据类型，最常见的 TEXT 类型可以存储 64k 的数据
|
||||
|
||||
**a. 建议把 BLOB 或是 TEXT 列分离到单独的扩展表中**
|
||||
|
||||
MySQL 内存临时表不支持 TEXT、BLOB 这样的大数据类型，如果查询中包含这样的数据，在排序等操作时，就不能使用内存临时表，必须使用磁盘临时表进行。而且对于这种数据，MySQL 还是要进行二次查询，会使 sql 性能变得很差，但是不是说一定不能使用这样的数据类型。
|
||||
|
||||
如果一定要使用，建议把 BLOB 或是 TEXT 列分离到单独的扩展表中，查询时一定不要使用 select * 而只需要取出必要的列，不需要 TEXT 列的数据时不要对该列进行查询。
|
||||
|
||||
**2、TEXT 或 BLOB 类型只能使用前缀索引**
|
||||
|
||||
因为[MySQL](http://mp.weixin.qq.com/s?__biz=MzI4Njc5NjM1NQ==&mid=2247487885&idx=1&sn=65b1bf5f7d4505502620179669a9c2df&chksm=ebd62ea1dca1a7b7bf884bcd9d538d78ba064ee03c09436ca8e57873b1d98a55afd6d7884cfc&scene=21#wechat_redirect) 对索引字段长度是有限制的，所以 TEXT 类型只能使用前缀索引，并且 TEXT 列上是不能有默认值的
|
||||
|
||||
### 3. 避免使用 ENUM 类型
|
||||
|
||||
修改 ENUM 值需要使用 ALTER 语句
|
||||
|
||||
ENUM 类型的 ORDER BY 操作效率低，需要额外操作
|
||||
|
||||
禁止使用数值作为 ENUM 的枚举值
|
||||
|
||||
### 4. 尽可能把所有列定义为 NOT NULL
|
||||
|
||||
**原因：**
|
||||
|
||||
索引 NULL 列需要额外的空间来保存，所以要占用更多的空间
|
||||
|
||||
进行比较和计算时要对 NULL 值做特别的处理
|
||||
|
||||
### 5. 使用 TIMESTAMP(4 个字节) 或 DATETIME 类型 (8 个字节) 存储时间
|
||||
|
||||
TIMESTAMP 存储的时间范围 1970-01-01 00:00:01 ~ 2038-01-19-03:14:07
|
||||
|
||||
TIMESTAMP 占用 4 字节和 INT 相同，但比 INT 可读性高
|
||||
|
||||
超出 TIMESTAMP 取值范围的使用 DATETIME 类型存储
|
||||
|
||||
**经常会有人用字符串存储日期型的数据（不正确的做法）**
|
||||
|
||||
- 缺点 1：无法用日期函数进行计算和比较
|
||||
- 缺点 2：用字符串存储日期要占用更多的空间
|
||||
|
||||
### 6. 同财务相关的金额类数据必须使用 decimal 类型
|
||||
|
||||
- 非精准浮点：float,double
|
||||
- 精准浮点：decimal
|
||||
|
||||
Decimal 类型为精准浮点数，在计算时不会丢失精度
|
||||
|
||||
占用空间由定义的宽度决定，每 4 个字节可以存储 9 位数字，并且小数点要占用一个字节
|
||||
|
||||
可用于存储比 bigint 更大的整型数据
|
||||
|
||||
------
|
||||
|
||||
## 索引设计规范
|
||||
|
||||
### 1. 限制每张表上的索引数量,建议单张表索引不超过 5 个
|
||||
|
||||
索引并不是越多越好！索引可以提高效率同样可以降低效率。
|
||||
|
||||
索引可以增加查询效率，但同样也会降低插入和更新的效率，甚至有些情况下会降低查询效率。
|
||||
|
||||
因为 MySQL 优化器在选择如何优化查询时，会根据统一信息，对每一个可以用到的索引来进行评估，以生成出一个最好的执行计划，如果同时有很多个索引都可以用于查询，就会增加 MySQL 优化器生成执行计划的时间，同样会降低查询性能。
|
||||
|
||||
### 2. 禁止给表中的每一列都建立单独的索引
|
||||
|
||||
5.6 版本之前，一个 sql 只能使用到一个表中的一个索引，5.6 以后，虽然有了合并索引的优化方式，但是还是远远没有使用一个联合索引的查询方式好。
|
||||
|
||||
### 3. 每个 Innodb 表必须有个主键
|
||||
|
||||
Innodb 是一种索引组织表：数据的存储的逻辑顺序和索引的顺序是相同的。每个表都可以有多个索引，但是表的存储顺序只能有一种。
|
||||
|
||||
Innodb 是按照主键索引的顺序来组织表的
|
||||
|
||||
- 不要使用更新频繁的列作为主键，不适用多列主键（相当于联合索引）
|
||||
- 不要使用 UUID,MD5,HASH,字符串列作为主键（无法保证数据的顺序增长）
|
||||
- 主键建议使用自增 ID 值
|
||||
|
||||
------
|
||||
|
||||
### 4. 常见索引列建议
|
||||
|
||||
- 出现在 SELECT、UPDATE、DELETE 语句的 WHERE 从句中的列
|
||||
- 包含在 ORDER BY、GROUP BY、DISTINCT 中的字段
|
||||
- 并不要将符合 1 和 2 中的字段的列都建立一个索引， 通常将 1、2 中的字段建立联合索引效果更好
|
||||
- 多表 join 的关联列
|
||||
|
||||
------
|
||||
|
||||
### 5.如何选择索引列的顺序
|
||||
|
||||
建立索引的目的是：希望通过索引进行数据查找，减少随机 IO，增加查询性能 ，索引能过滤出越少的数据，则从磁盘中读入的数据也就越少。
|
||||
|
||||
- 区分度最高的放在联合索引的最左侧（区分度=列中不同值的数量/列的总行数）
|
||||
- 尽量把字段长度小的列放在联合索引的最左侧（因为字段长度越小，一页能存储的数据量越大，IO 性能也就越好）
|
||||
- 使用最频繁的列放到联合索引的左侧（这样可以比较少的建立一些索引）
|
||||
|
||||
------
|
||||
|
||||
### 6. 避免建立冗余索引和重复索引（增加了查询优化器生成执行计划的时间）
|
||||
|
||||
- 重复索引示例：primary key(id)、index(id)、unique index(id)
|
||||
- 冗余索引示例：index(a,b,c)、index(a,b)、index(a)
|
||||
|
||||
------
|
||||
|
||||
### 7. 对于频繁的查询优先考虑使用覆盖索引
|
||||
|
||||
> 覆盖索引：就是包含了所有查询字段 (where,select,ordery by,group by 包含的字段) 的索引
|
||||
|
||||
**覆盖索引的好处：**
|
||||
|
||||
- **避免 Innodb 表进行索引的二次查询:** Innodb 是以聚集索引的顺序来存储的，对于 Innodb 来说，二级索引在叶子节点中所保存的是行的主键信息，如果是用二级索引查询数据的话，在查找到相应的键值后，还要通过主键进行二次查询才能获取我们真实所需要的数据。而在覆盖索引中，二级索引的键值中可以获取所有的数据，避免了对主键的二次查询 ，减少了 IO 操作，提升了查询效率。
|
||||
- **可以把随机 IO 变成顺序 IO 加快查询效率:** 由于覆盖索引是按键值的顺序存储的，对于 IO 密集型的范围查找来说，对比随机从磁盘读取每一行的数据 IO 要少的多，因此利用覆盖索引在访问时也可以把磁盘的随机读取的 IO 转变成索引查找的顺序 IO。
|
||||
|
||||
------
|
||||
|
||||
### 8.索引 SET 规范
|
||||
|
||||
**尽量避免使用外键约束**
|
||||
|
||||
- 不建议使用外键约束（foreign key），但一定要在表与表之间的关联键上建立索引
|
||||
- 外键可用于保证数据的参照完整性，但建议在业务端实现
|
||||
- 外键会影响父表和子表的写操作从而降低性能
|
||||
|
||||
------
|
||||
|
||||
## 数据库 SQL 开发规范
|
||||
|
||||
### 1. 建议使用预编译语句进行数据库操作
|
||||
|
||||
预编译语句可以重复使用这些计划，减少 SQL 编译所需要的时间，还可以解决动态 SQL 所带来的 SQL 注入的问题。
|
||||
|
||||
只传参数，比传递 SQL 语句更高效。
|
||||
|
||||
相同语句可以一次解析，多次使用，提高处理效率。
|
||||
|
||||
### 2. 避免数据类型的隐式转换
|
||||
|
||||
隐式转换会导致索引失效如:
|
||||
|
||||
```
|
||||
select name,phone from customer where id = '111';
|
||||
```
|
||||
|
||||
### 3. 充分利用表上已经存在的索引
|
||||
|
||||
避免使用双%号的查询条件。如：`a like '%123%'`，（如果无前置%,只有后置%，是可以用到列上的索引的）
|
||||
|
||||
一个 SQL 只能利用到复合索引中的一列进行范围查询。如：有 a,b,c 列的联合索引，在查询条件中有 a 列的范围查询，则在 b,c 列上的索引将不会被用到。
|
||||
|
||||
在定义联合索引时，如果 a 列要用到范围查找的话，就要把 a 列放到联合索引的右侧，使用 left join 或 not exists 来优化 not in 操作，因为 not in 也通常会使用索引失效。
|
||||
|
||||
### 4. 数据库设计时，应该要对以后扩展进行考虑
|
||||
|
||||
### 5. 程序连接不同的数据库使用不同的账号，禁止跨库查询
|
||||
|
||||
- 为数据库迁移和分库分表留出余地
|
||||
- 降低业务耦合度
|
||||
- 避免权限过大而产生的安全风险
|
||||
|
||||
### 6. 禁止使用 SELECT * 必须使用 SELECT <字段列表> 查询
|
||||
|
||||
**原因：**
|
||||
|
||||
- 消耗更多的 CPU 和 IO 以网络带宽资源
|
||||
- 无法使用覆盖索引
|
||||
- 可减少表结构变更带来的影响
|
||||
|
||||
### 7. 禁止使用不含字段列表的 INSERT 语句
|
||||
|
||||
如：
|
||||
|
||||
```
|
||||
insert into values ('a','b','c');
|
||||
```
|
||||
|
||||
应使用：
|
||||
|
||||
```
|
||||
insert into t(c1,c2,c3) values ('a','b','c');
|
||||
```
|
||||
|
||||
### 8. 避免使用子查询，可以把子查询优化为 join 操作
|
||||
|
||||
通常子查询在 in 子句中，且子查询中为简单 SQL(不包含 union、group by、order by、limit 从句) 时,才可以把子查询转化为关联查询进行优化。
|
||||
|
||||
**子查询性能差的原因：**
|
||||
|
||||
子查询的结果集无法使用索引，通常子查询的结果集会被存储到临时表中，不论是内存临时表还是磁盘临时表都不会存在索引，所以查询性能会受到一定的影响。特别是对于返回结果集比较大的子查询，其对查询性能的影响也就越大。
|
||||
|
||||
由于子查询会产生大量的临时表也没有索引，所以会消耗过多的 CPU 和 IO 资源，产生大量的慢查询。
|
||||
|
||||
### 9. 避免使用 JOIN 关联太多的表
|
||||
|
||||
对于 MySQL 来说，是存在关联缓存的，缓存的大小可以由 join_buffer_size 参数进行设置。
|
||||
|
||||
在 MySQL 中，对于同一个 SQL 多关联（join）一个表，就会多分配一个关联缓存，如果在一个 SQL 中关联的表越多，所占用的内存也就越大。
|
||||
|
||||
如果程序中大量的使用了多表关联的操作，同时 join_buffer_size 设置的也不合理的情况下，就容易造成服务器内存溢出的情况，就会影响到服务器数据库性能的稳定性。
|
||||
|
||||
同时对于关联操作来说，会产生临时表操作，影响查询效率，MySQL 最多允许关联 61 个表，建议不超过 5 个。
|
||||
|
||||
### 10. 减少同数据库的交互次数
|
||||
|
||||
数据库更适合处理批量操作，合并多个相同的操作到一起，可以提高处理效率。
|
||||
|
||||
### 11. 对应同一列进行 or 判断时，使用 in 代替 or
|
||||
|
||||
in 的值不要超过 500 个，in 操作可以更有效的利用索引，or 大多数情况下很少能利用到索引。
|
||||
|
||||
### 12. 禁止使用 order by rand() 进行随机排序
|
||||
|
||||
order by rand() 会把表中所有符合条件的数据装载到内存中，然后在内存中对所有数据根据随机生成的值进行排序，并且可能会对每一行都生成一个随机值，如果满足条件的数据集非常大，就会消耗大量的 CPU 和 IO 及内存资源。
|
||||
|
||||
推荐在程序中获取一个随机值，然后从数据库中获取数据的方式。
|
||||
|
||||
### 13. WHERE 从句中禁止对列进行函数转换和计算
|
||||
|
||||
对列进行函数转换或计算时会导致无法使用索引
|
||||
|
||||
**不推荐：**
|
||||
|
||||
```
|
||||
where date(create_time)='20190101'
|
||||
```
|
||||
|
||||
**推荐：**
|
||||
|
||||
```
|
||||
where create_time >= '20190101' and create_time < '20190102'
|
||||
```
|
||||
|
||||
### 14. 在明显不会有重复值时使用 UNION ALL 而不是 UNION
|
||||
|
||||
- UNION 会把两个结果集的所有数据放到临时表中后再进行去重操作
|
||||
- UNION ALL 不会再对结果集进行去重操作
|
||||
|
||||
### 15. 拆分复杂的大 SQL 为多个小 SQL
|
||||
|
||||
- 大 SQL 逻辑上比较复杂，需要占用大量 CPU 进行计算的 SQL
|
||||
- MySQL 中，一个 SQL 只能使用一个 CPU 进行计算
|
||||
- SQL 拆分后可以通过并行执行来提高处理效率
|
||||
|
||||
------
|
||||
|
||||
## 数据库操作行为规范
|
||||
|
||||
### 1. 超 100 万行的批量写 (UPDATE,DELETE,INSERT) 操作,要分批多次进行操作
|
||||
|
||||
**大批量操作可能会造成严重的主从延迟**
|
||||
|
||||
主从环境中,大批量操作可能会造成严重的主从延迟，大批量的写操作一般都需要执行一定长的时间，
|
||||
而只有当主库上执行完成后，才会在其他从库上执行，所以会造成主库与从库长时间的延迟情况
|
||||
|
||||
**binlog 日志为 row 格式时会产生大量的日志**
|
||||
|
||||
大批量写操作会产生大量日志，特别是对于 row 格式二进制数据而言，由于在 row 格式中会记录每一行数据的修改，我们一次修改的数据越多，产生的日志量也就会越多，日志的传输和恢复所需要的时间也就越长，这也是造成主从延迟的一个原因
|
||||
|
||||
**避免产生大事务操作**
|
||||
|
||||
大批量修改数据，一定是在一个事务中进行的，这就会造成表中大批量数据进行锁定，从而导致大量的阻塞，阻塞会对 MySQL 的性能产生非常大的影响。
|
||||
|
||||
特别是长时间的阻塞会占满所有数据库的可用连接，这会使生产环境中的其他应用无法连接到数据库，因此一定要注意大批量写操作要进行分批
|
||||
|
||||
### 2. 对于大表使用 pt-online-schema-change 修改表结构
|
||||
|
||||
- 避免大表修改产生的主从延迟
|
||||
- 避免在对表字段进行修改时进行锁表
|
||||
|
||||
对大表数据结构的修改一定要谨慎，会造成严重的锁表操作，尤其是生产环境，是不能容忍的。
|
||||
|
||||
pt-online-schema-change 它会首先建立一个与原表结构相同的新表，并且在新表上进行表结构的修改，然后再把原表中的数据复制到新表中，并在原表中增加一些触发器。把原表中新增的数据也复制到新表中，在行所有数据复制完成之后，把新表命名成原表，并把原来的表删除掉。把原来一个 DDL 操作，分解成多个小的批次进行。
|
||||
|
||||
### 3. 禁止为程序使用的账号赋予 super 权限
|
||||
|
||||
- 当达到最大连接数限制时，还运行 1 个有 super 权限的用户连接
|
||||
- super 权限只能留给 DBA 处理问题的账号使用
|
||||
|
||||
### 4. 对于程序连接数据库账号,遵循权限最小原则
|
||||
|
||||
- 程序使用数据库账号只能在一个 DB 下使用，不准跨库
|
||||
- 程序使用的账号原则上不准有 drop 权限
|
||||
@ -1,38 +1,38 @@
|
||||
<!-- MarkdownTOC -->
|
||||
点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。
|
||||
|
||||
<!-- TOC -->
|
||||
|
||||
- [redis 简介](#redis-简介)
|
||||
- [为什么要用 redis /为什么要用缓存](#为什么要用-redis-为什么要用缓存)
|
||||
- [为什么要用 redis/为什么要用缓存](#为什么要用-redis为什么要用缓存)
|
||||
- [为什么要用 redis 而不用 map/guava 做缓存?](#为什么要用-redis-而不用-mapguava-做缓存)
|
||||
- [redis 和 memcached 的区别](#redis-和-memcached-的区别)
|
||||
- [redis 常见数据结构以及使用场景分析](#redis-常见数据结构以及使用场景分析)
|
||||
- [1. String](#1-string)
|
||||
- [2.Hash](#2hash)
|
||||
- [3.List](#3list)
|
||||
- [4.Set](#4set)
|
||||
- [5.Sorted Set](#5sorted-set)
|
||||
- [1.String](#1string)
|
||||
- [2.Hash](#2hash)
|
||||
- [3.List](#3list)
|
||||
- [4.Set](#4set)
|
||||
- [5.Sorted Set](#5sorted-set)
|
||||
- [redis 设置过期时间](#redis-设置过期时间)
|
||||
- [redis 内存淘汰机制（MySQL里有2000w数据，Redis中只存20w的数据，如何保证Redis中的数据都是热点数据？）](#redis-内存淘汰机制（mysql里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据？）)
|
||||
- [redis 持久化机制（怎么保证 redis 挂掉之后再重启数据可以进行恢复）](#redis-持久化机制（怎么保证-redis-挂掉之后再重启数据可以进行恢复）)
|
||||
- [redis 内存淘汰机制(MySQL里有2000w数据，Redis中只存20w的数据，如何保证Redis中的数据都是热点数据?)](#redis-内存淘汰机制mysql里有2000w数据redis中只存20w的数据如何保证redis中的数据都是热点数据)
|
||||
- [redis 持久化机制(怎么保证 redis 挂掉之后再重启数据可以进行恢复)](#redis-持久化机制怎么保证-redis-挂掉之后再重启数据可以进行恢复)
|
||||
- [redis 事务](#redis-事务)
|
||||
- [缓存雪崩和缓存穿透问题解决方案](#缓存雪崩和缓存穿透问题解决方案)
|
||||
- [如何解决 Redis 的并发竞争 Key 问题](#如何解决-redis-的并发竞争-key-问题)
|
||||
- [如何保证缓存与数据库双写时的数据一致性？](#如何保证缓存与数据库双写时的数据一致性？)
|
||||
- [参考：](#参考：)
|
||||
|
||||
<!-- /MarkdownTOC -->
|
||||
- [如何保证缓存与数据库双写时的数据一致性?](#如何保证缓存与数据库双写时的数据一致性)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
### redis 简介
|
||||
|
||||
简单来说 redis 就是一个数据库，不过与传统数据库不同的是 redis 的数据是存在内存中的，所以存写速度非常快，因此 redis 被广泛应用于缓存方向。另外，redis 也经常用来做分布式锁。redis 提供了多种数据类型来支持不同的业务场景。除此之外，redis 支持事务 、持久化、LUA脚本、LRU驱动事件、多种集群方案。
|
||||
简单来说 redis 就是一个数据库，不过与传统数据库不同的是 redis 的数据是存在内存中的，所以读写速度非常快，因此 redis 被广泛应用于缓存方向。另外，redis 也经常用来做分布式锁。redis 提供了多种数据类型来支持不同的业务场景。除此之外，redis 支持事务 、持久化、LUA脚本、LRU驱动事件、多种集群方案。
|
||||
|
||||
### 为什么要用 redis /为什么要用缓存
|
||||
### 为什么要用 redis/为什么要用缓存
|
||||
|
||||
主要从“高性能”和“高并发”这两点来看待这个问题。
|
||||
|
||||
**高性能：**
|
||||
|
||||
假如用户第一次访问数据库中的某些数据。这个过程会比较慢，因为是从硬盘上读取的。将该用户访问的数据存在数缓存中，这样下一次再访问这些数据的时候就可以直接从缓存中获取了。操作缓存就是直接操作内存，所以速度相当快。如果数据库中的对应数据改变的之后，同步改变缓存中相应的数据即可！
|
||||
假如用户第一次访问数据库中的某些数据。这个过程会比较慢，因为是从硬盘上读取的。将该用户访问的数据存在缓存中，这样下一次再访问这些数据的时候就可以直接从缓存中获取了。操作缓存就是直接操作内存，所以速度相当快。如果数据库中的对应数据改变的之后，同步改变缓存中相应的数据即可！
|
||||
|
||||
|
||||
|
||||
@ -54,6 +54,21 @@
|
||||
|
||||
使用 redis 或 memcached 之类的称为分布式缓存，在多实例的情况下，各实例共用一份缓存数据，缓存具有一致性。缺点是需要保持 redis 或 memcached服务的高可用，整个程序架构上较为复杂。
|
||||
|
||||
### redis 的线程模型
|
||||
|
||||
> 参考地址:https://www.javazhiyin.com/22943.html
|
||||
|
||||
redis 内部使用文件事件处理器 `file event handler`，这个文件事件处理器是单线程的，所以 redis 才叫做单线程的模型。它采用 IO 多路复用机制同时监听多个 socket，根据 socket 上的事件来选择对应的事件处理器进行处理。
|
||||
|
||||
文件事件处理器的结构包含 4 个部分：
|
||||
|
||||
- 多个 socket
|
||||
- IO 多路复用程序
|
||||
- 文件事件分派器
|
||||
- 事件处理器（连接应答处理器、命令请求处理器、命令回复处理器）
|
||||
|
||||
多个 socket 可能会并发产生不同的操作，每个操作对应不同的文件事件，但是 IO 多路复用程序会监听多个 socket，会将 socket 产生的事件放入队列中排队，事件分派器每次从队列中取出一个事件，把该事件交给对应的事件处理器进行处理。
|
||||
|
||||
|
||||
### redis 和 memcached 的区别
|
||||
|
||||
@ -72,7 +87,7 @@
|
||||
|
||||
### redis 常见数据结构以及使用场景分析
|
||||
|
||||
#### 1. String
|
||||
#### 1.String
|
||||
|
||||
> **常用命令:** set,get,decr,incr,mget 等。
|
||||
|
||||
@ -84,7 +99,7 @@ String数据结构是简单的key-value类型，value其实不仅可以是String
|
||||
#### 2.Hash
|
||||
> **常用命令：** hget,hset,hgetall 等。
|
||||
|
||||
Hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象，后续操作的时候，你可以直接仅仅修改这个对象中的某个字段的值。 比如我们可以Hash数据结构来存储用户信息，商品信息等等。比如下面我就用 hash 类型存放了我本人的一些信息：
|
||||
hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象，后续操作的时候，你可以直接仅仅修改这个对象中的某个字段的值。 比如我们可以 hash 数据结构来存储用户信息，商品信息等等。比如下面我就用 hash 类型存放了我本人的一些信息：
|
||||
|
||||
```
|
||||
key=JavaUser293847
|
||||
@ -128,7 +143,7 @@ sinterstore key1 key2 key3 将交集存在key1内
|
||||
|
||||
和set相比，sorted set增加了一个权重参数score，使得集合中的元素能够按score进行有序排列。
|
||||
|
||||
**举例：** 在直播系统中，实时排行信息包含直播间在线用户列表，各种礼物排行榜，弹幕消息（可以理解为按消息维度的消息排行榜）等信息，适合使用 Redis 中的 SortedSet 结构进行存储。
|
||||
**举例：** 在直播系统中，实时排行信息包含直播间在线用户列表，各种礼物排行榜，弹幕消息（可以理解为按消息维度的消息排行榜）等信息，适合使用 Redis 中的 Sorted Set 结构进行存储。
|
||||
|
||||
|
||||
### redis 设置过期时间
|
||||
@ -147,11 +162,9 @@ Redis中有个设置时间过期的功能，即对存储在 redis 数据库中
|
||||
- **惰性删除** ：定期删除可能会导致很多过期 key 到了时间并没有被删除掉。所以就有了惰性删除。假如你的过期 key，靠定期删除没有被删除掉，还停留在内存里，除非你的系统去查一下那个 key，才会被redis给删除掉。这就是所谓的惰性删除，也是够懒的哈！
|
||||
|
||||
|
||||
但是仅仅通过设置过期时间还是有问题的。我们想一下：如果定期删除漏掉了很多过期 key，然后你也没及时去查，也就没走惰性删除，此时会怎么样？如果大量过期key堆积在内存里，导致redis内存块耗尽了。怎么解决这个问题呢？
|
||||
但是仅仅通过设置过期时间还是有问题的。我们想一下：如果定期删除漏掉了很多过期 key，然后你也没及时去查，也就没走惰性删除，此时会怎么样？如果大量过期key堆积在内存里，导致redis内存块耗尽了。怎么解决这个问题呢？ **redis 内存淘汰机制。**
|
||||
|
||||
**redis 内存淘汰机制。**
|
||||
|
||||
### redis 内存淘汰机制（MySQL里有2000w数据，Redis中只存20w的数据，如何保证Redis中的数据都是热点数据？）
|
||||
### redis 内存淘汰机制(MySQL里有2000w数据，Redis中只存20w的数据，如何保证Redis中的数据都是热点数据?)
|
||||
|
||||
redis 配置文件 redis.conf 中有相关注释，我这里就不贴了，大家可以自行查阅或者通过这个网址查看： [http://download.redis.io/redis-stable/redis.conf](http://download.redis.io/redis-stable/redis.conf)
|
||||
|
||||
@ -160,19 +173,23 @@ redis 配置文件 redis.conf 中有相关注释，我这里就不贴了，大
|
||||
1. **volatile-lru**：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰
|
||||
2. **volatile-ttl**：从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰
|
||||
3. **volatile-random**：从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰
|
||||
4. **allkeys-lru**：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的key（这个是最常用的）.
|
||||
4. **allkeys-lru**：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的key（这个是最常用的）
|
||||
5. **allkeys-random**：从数据集（server.db[i].dict）中任意选择数据淘汰
|
||||
6. **no-eviction**：禁止驱逐数据，也就是说当内存不足以容纳新写入数据时，新写入操作会报错。这个应该没人使用吧！
|
||||
|
||||
4.0版本后增加以下两种：
|
||||
|
||||
7. **volatile-lfu**：从已设置过期时间的数据集(server.db[i].expires)中挑选最不经常使用的数据淘汰
|
||||
8. **allkeys-lfu**：当内存不足以容纳新写入数据时，在键空间中，移除最不经常使用的key
|
||||
|
||||
**备注： 关于 redis 设置过期时间以及内存淘汰机制，我这里只是简单的总结一下，后面会专门写一篇文章来总结！**
|
||||
|
||||
|
||||
### redis 持久化机制（怎么保证 redis 挂掉之后再重启数据可以进行恢复）
|
||||
### redis 持久化机制(怎么保证 redis 挂掉之后再重启数据可以进行恢复)
|
||||
|
||||
很多时候我们需要持久化数据也就是将内存中的数据写入到硬盘里面，大部分原因是为了之后重用数据（比如重启机器、机器故障之后回复数据），或者是为了防止系统故障而将数据备份到一个远程位置。
|
||||
很多时候我们需要持久化数据也就是将内存中的数据写入到硬盘里面，大部分原因是为了之后重用数据（比如重启机器、机器故障之后恢复数据），或者是为了防止系统故障而将数据备份到一个远程位置。
|
||||
|
||||
Redis不同于Memcached的很重一点就是，Redis支持持久化，而且支持两种不同的持久化操作。**Redis的一种持久化方式叫快照（snapshotting，RDB）,另一种方式是只追加文件（append-only file,AOF）**.这两种方法各有千秋，下面我会详细这两种持久化方法是什么，怎么用，如何选择适合自己的持久化方法。
|
||||
Redis不同于Memcached的很重一点就是，Redis支持持久化，而且支持两种不同的持久化操作。**Redis的一种持久化方式叫快照（snapshotting，RDB），另一种方式是只追加文件（append-only file,AOF）**。这两种方法各有千秋，下面我会详细这两种持久化方法是什么，怎么用，如何选择适合自己的持久化方法。
|
||||
|
||||
**快照（snapshotting）持久化（RDB）**
|
||||
|
||||
@ -182,14 +199,13 @@ Redis可以通过创建快照来获得存储在内存里面的数据在某个时
|
||||
|
||||
```conf
|
||||
|
||||
save 900 1 #在900秒(15分钟)之后，如果至少有1个key发生变化，Redis就会自动触发BGSAVE命令创建快照。
|
||||
save 900 1 #在900秒(15分钟)之后，如果至少有1个key发生变化，Redis就会自动触发BGSAVE命令创建快照。
|
||||
|
||||
save 300 10 #在300秒(5分钟)之后，如果至少有10个key发生变化，Redis就会自动触发BGSAVE命令创建快照。
|
||||
save 300 10 #在300秒(5分钟)之后，如果至少有10个key发生变化，Redis就会自动触发BGSAVE命令创建快照。
|
||||
|
||||
save 60 10000 #在60秒(1分钟)之后，如果至少有10000个key发生变化，Redis就会自动触发BGSAVE命令创建快照。
|
||||
```
|
||||
|
||||
|
||||
**AOF（append-only file）持久化**
|
||||
|
||||
与快照持久化相比，AOF持久化 的实时性更好，因此已成为主流的持久化方案。默认情况下Redis没有开启AOF（append only file）方式的持久化，可以通过appendonly参数开启：
|
||||
@ -203,49 +219,53 @@ appendonly yes
|
||||
在Redis的配置文件中存在三种不同的 AOF 持久化方式，它们分别是：
|
||||
|
||||
```conf
|
||||
appendfsync always #每次有数据修改发生时都会写入AOF文件,这样会严重降低Redis的速度
|
||||
appendfsync always #每次有数据修改发生时都会写入AOF文件,这样会严重降低Redis的速度
|
||||
appendfsync everysec #每秒钟同步一次，显示地将多个写命令同步到硬盘
|
||||
appendfsync no #让操作系统决定何时进行同步
|
||||
appendfsync no #让操作系统决定何时进行同步
|
||||
```
|
||||
|
||||
为了兼顾数据和写入性能，用户可以考虑 appendfsync everysec选项 ，让Redis每秒同步一次AOF文件，Redis性能几乎没受到任何影响。而且这样即使出现系统崩溃，用户最多只会丢失一秒之内产生的数据。当硬盘忙于执行写入操作的时候，Redis还会优雅的放慢自己的速度以便适应硬盘的最大写入速度。
|
||||
|
||||
|
||||
**Redis 4.0 对于持久化机制的优化**
|
||||
|
||||
Redis 4.0 开始支持 RDB 和 AOF 的混合持久化（默认关闭，可以通过配置项 `aof-use-rdb-preamble` 开启）。
|
||||
|
||||
如果把混合持久化打开，AOF 重写的时候就直接把 RDB 的内容写到 AOF 文件开头。这样做的好处是可以结合 RDB 和 AOF 的优点, 快速加载同时避免丢失过多的数据。当然缺点也是有的， AOF 里面的 RDB 部分是压缩格式不再是 AOF 格式，可读性较差。
|
||||
|
||||
|
||||
|
||||
**补充内容：AOF 重写**
|
||||
|
||||
AOF重写可以产生一个新的AOF文件，这个新的AOF文件和原有的AOF文件所保存的数据库状态一样，但体积更小。
|
||||
|
||||
AOF重写是一个有歧义的名字，该功能是通过读取数据库中的键值对来实现的，程序无须对现有AOF文件进行任伺读入、分析或者写入操作。
|
||||
AOF重写是一个有歧义的名字，该功能是通过读取数据库中的键值对来实现的，程序无须对现有AOF文件进行任何读入、分析或者写入操作。
|
||||
|
||||
在执行 BGREWRITEAOF 命令时，Redis 服务器会维护一个 AOF 重写缓冲区，该缓冲区会在子进程创建新AOF文件期间，记录服务器执行的所有写命令。当子进程完成创建新AOF文件的工作之后，服务器会将重写缓冲区中的所有内容追加到新AOF文件的末尾，使得新旧两个AOF文件所保存的数据库状态一致。最后，服务器用新的AOF文件替换旧的AOF文件，以此来完成AOF文件重写操作
|
||||
|
||||
|
||||
**更多内容可以查看我的这篇文章：**
|
||||
|
||||
- [https://github.com/Snailclimb/JavaGuide/blob/master/数据存储/Redis/Redis持久化.md](https://github.com/Snailclimb/JavaGuide/blob/master/数据存储/Redis/Redis持久化.md)
|
||||
- [Redis持久化](Redis持久化.md)
|
||||
|
||||
|
||||
### redis 事务
|
||||
|
||||
Redis 通过 MULTI、EXEC、WATCH 等命令来实现事务(transaction)功能。事务提供了一种将多个命令请求打包，然后一次性、按顺序地执行多个命令的机制，并且在事务执行期间，服务器不会中断事务而改去执行其他客户端的命令请求，它会将事务中的所有命令都执行完毕，然后才去处理其他客户端的命令请求。
|
||||
|
||||
在传统的关系式数据库中，常常用 ACID 性质来检验事务功能的可靠性和安全性。在 Redis 中，事务总是具有原子性（Atomicity)、一致性(Consistency)和隔离性（Isolation），并且当 Redis 运行在某种特定的持久化模式下时，事务也具有持久性（Durability）。
|
||||
在传统的关系式数据库中，常常用 ACID 性质来检验事务功能的可靠性和安全性。在 Redis 中，事务总是具有原子性（Atomicity）、一致性（Consistency）和隔离性（Isolation），并且当 Redis 运行在某种特定的持久化模式下时，事务也具有持久性（Durability）。
|
||||
|
||||
补充内容：
|
||||
|
||||
> 1. redis同一个事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚。（来自[issue:关于Redis事务不是原子性问题](https://github.com/Snailclimb/JavaGuide/issues/452) ）
|
||||
|
||||
### 缓存雪崩和缓存穿透问题解决方案
|
||||
|
||||
**缓存雪崩**
|
||||
#### **缓存雪崩**
|
||||
|
||||
**什么是缓存雪崩？**
|
||||
|
||||
简介：缓存同一时间大面积的失效，所以，后面的请求都会落到数据库上，造成数据库短时间内承受大量请求而崩掉。
|
||||
|
||||
解决办法（中华石杉老师在他的视频中提到过，视频地址在最后一个问题中有提到）：
|
||||
**有哪些解决办法？**
|
||||
|
||||
（中华石杉老师在他的视频中提到过，视频地址在最后一个问题中有提到）：
|
||||
|
||||
- 事前：尽量保证整个 redis 集群的高可用性，发现机器宕机尽快补上。选择合适的内存淘汰策略。
|
||||
- 事中：本地ehcache缓存 + hystrix限流&降级，避免MySQL崩掉
|
||||
@ -253,16 +273,58 @@ Redis 通过 MULTI、EXEC、WATCH 等命令来实现事务(transaction)功能。
|
||||
|
||||
|
||||
|
||||
#### **缓存穿透**
|
||||
|
||||
**缓存穿透**
|
||||
**什么是缓存穿透？**
|
||||
|
||||
简介：一般是黑客故意去请求缓存中不存在的数据，导致所有的请求都落到数据库上，造成数据库短时间内承受大量请求而崩掉。
|
||||
缓存穿透说简单点就是大量请求的 key 根本不存在于缓存中，导致请求直接到了数据库上，根本没有经过缓存这一层。举个例子：某个黑客故意制造我们缓存中不存在的 key 发起大量请求，导致大量请求落到数据库。下面用图片展示一下(这两张图片不是我画的，为了省事直接在网上找的，这里说明一下)：
|
||||
|
||||
解决办法： 有很多种方法可以有效地解决缓存穿透问题，最常见的则是采用布隆过滤器，将所有可能存在的数据哈希到一个足够大的bitmap中，一个一定不存在的数据会被 这个bitmap拦截掉，从而避免了对底层存储系统的查询压力。另外也有一个更为简单粗暴的方法（我们采用的就是这种），如果一个查询返回的数据为空（不管是数 据不存在，还是系统故障），我们仍然把这个空结果进行缓存，但它的过期时间会很短，最长不超过五分钟。
|
||||
**正常缓存处理流程：**
|
||||
|
||||
参考：
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-11/正常缓存处理流程-redis.png" style="zoom:50%;" />
|
||||
|
||||
- https://blog.csdn.net/zeb_perfect/article/details/54135506[enter link description here](https://blog.csdn.net/zeb_perfect/article/details/54135506)
|
||||
**缓存穿透情况处理流程：**
|
||||
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-11/缓存穿透处理流程-redis.png" style="zoom:50%;" />
|
||||
|
||||
一般MySQL 默认的最大连接数在 150 左右，这个可以通过 `show variables like '%max_connections%'; `命令来查看。最大连接数一个还只是一个指标，cpu，内存，磁盘，网络等无力条件都是其运行指标，这些指标都会限制其并发能力！所以，一般 3000 个并发请求就能打死大部分数据库了。
|
||||
|
||||
**有哪些解决办法？**
|
||||
|
||||
最基本的就是首先做好参数校验，一些不合法的参数请求直接抛出异常信息返回给客户端。比如查询的数据库 id 不能小于 0、传入的邮箱格式不对的时候直接返回错误消息给客户端等等。
|
||||
|
||||
**1）缓存无效 key** : 如果缓存和数据库都查不到某个 key 的数据就写一个到 redis 中去并设置过期时间，具体命令如下：`SET key value EX 10086`。这种方式可以解决请求的 key 变化不频繁的情况，如果黑客恶意攻击，每次构建不同的请求key，会导致 redis 中缓存大量无效的 key 。很明显，这种方案并不能从根本上解决此问题。如果非要用这种方式来解决穿透问题的话，尽量将无效的 key 的过期时间设置短一点比如 1 分钟。
|
||||
|
||||
另外，这里多说一嘴，一般情况下我们是这样设计 key 的： `表名:列名:主键名:主键值`。
|
||||
|
||||
如果用 Java 代码展示的话，差不多是下面这样的：
|
||||
|
||||
```java
|
||||
public Object getObjectInclNullById(Integer id) {
|
||||
// 从缓存中获取数据
|
||||
Object cacheValue = cache.get(id);
|
||||
// 缓存为空
|
||||
if (cacheValue == null) {
|
||||
// 从数据库中获取
|
||||
Object storageValue = storage.get(key);
|
||||
// 缓存空对象
|
||||
cache.set(key, storageValue);
|
||||
// 如果存储数据为空，需要设置一个过期时间(300秒)
|
||||
if (storageValue == null) {
|
||||
// 必须设置过期时间，否则有被攻击的风险
|
||||
cache.expire(key, 60 * 5);
|
||||
}
|
||||
return storageValue;
|
||||
}
|
||||
return cacheValue;
|
||||
}
|
||||
```
|
||||
|
||||
**2）布隆过滤器：**布隆过滤器是一个非常神奇的数据结构，通过它我们可以非常方便地判断一个给定数据是否存在与海量数据中。我们需要的就是判断 key 是否合法，有没有感觉布隆过滤器就是我们想要找的那个“人”。具体是这样做的：把所有可能存在的请求的值都存放在布隆过滤器中，当用户请求过来，我会先判断用户发来的请求的值是否存在于布隆过滤器中。不存在的话，直接返回请求参数错误信息给客户端，存在的话才会走下面的流程。总结一下就是下面这张图(这张图片不是我画的，为了省事直接在网上找的)：
|
||||
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-11/布隆过滤器-缓存穿透-redis.png" style="zoom:50%;" />
|
||||
|
||||
更多关于布隆过滤器的内容可以看我的这篇原创：[《不了解布隆过滤器？一文给你整的明明白白！》](https://github.com/Snailclimb/JavaGuide/blob/master/docs/dataStructures-algorithms/data-structure/bloom-filter.md) ，强烈推荐，个人感觉网上应该找不到总结的这么明明白白的文章了。
|
||||
|
||||
### 如何解决 Redis 的并发竞争 Key 问题
|
||||
|
||||
@ -278,9 +340,9 @@ Redis 通过 MULTI、EXEC、WATCH 等命令来实现事务(transaction)功能。
|
||||
|
||||
- https://www.jianshu.com/p/8bddd381de06
|
||||
|
||||
### 如何保证缓存与数据库双写时的数据一致性?
|
||||
|
||||
### 如何保证缓存与数据库双写时的数据一致性？
|
||||
|
||||
> 一般情况下我们都是这样使用缓存的：先读缓存，缓存没有的话，就读数据库，然后取出数据后放入缓存，同时返回响应。这种方式很明显会存在缓存和数据库的数据不一致的情况。
|
||||
|
||||
你只要用缓存，就可能会涉及到缓存与数据库双存储双写，你只要是双写，就一定会有数据一致性的问题，那么你如何解决一致性问题？
|
||||
|
||||
@ -288,13 +350,21 @@ Redis 通过 MULTI、EXEC、WATCH 等命令来实现事务(transaction)功能。
|
||||
|
||||
串行化之后，就会导致系统的吞吐量会大幅度的降低，用比正常情况下多几倍的机器去支撑线上的一个请求。
|
||||
|
||||
**参考：**
|
||||
更多内容可以查看：https://github.com/doocs/advanced-java/blob/master/docs/high-concurrency/redis-consistence.md
|
||||
|
||||
- Java工程师面试突击第1季（可能是史上最好的Java面试突击课程）-中华石杉老师。视频地址见下面！
|
||||
- 链接： https://pan.baidu.com/s/18pp6g1xKVGCfUATf_nMrOA
|
||||
- 密码：5i58
|
||||
**参考：** Java工程师面试突击第1季（可能是史上最好的Java面试突击课程）-中华石杉老师！公众号后台回复关键字“1”即可获取该视频内容。
|
||||
|
||||
### 参考：
|
||||
### 参考
|
||||
|
||||
- redis设计与实现(第二版)
|
||||
- 《Redis开发与运维》
|
||||
- Redis 命令总结：http://redisdoc.com/string/set.html
|
||||
|
||||
## 公众号
|
||||
|
||||
如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。
|
||||
|
||||
**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"Java面试突击"** 即可免费领取！
|
||||
|
||||
**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
|
||||
|
||||
|
||||
@ -28,7 +28,7 @@ end
|
||||
|
||||
算法很易懂，起 5 个 master 节点，分布在不同的机房尽量保证可用性。为了获得锁，client 会进行如下操作：
|
||||
|
||||
1. 得到当前的时间，微妙单位
|
||||
1. 得到当前的时间，微秒单位
|
||||
2. 尝试顺序地在 5 个实例上申请锁，当然需要使用相同的 key 和 random value，这里一个 client 需要合理设置与 master 节点沟通的 timeout 大小，避免长时间和一个 fail 了的节点浪费时间
|
||||
3. 当 client 在大于等于 3 个 master 上成功申请到锁的时候，且它会计算申请锁消耗了多少时间，这部分消耗的时间采用获得锁的当下时间减去第一步获得的时间戳得到，如果锁的持续时长（lock validity time）比流逝的时间多的话，那么锁就真正获取到了。
|
||||
4. 如果锁申请到了，那么锁真正的 lock validity time 应该是 origin（lock validity time） - 申请锁期间流逝的时间
|
||||
269
docs/database/Redis/redis集群以及应用场景.md
Normal file
269
docs/database/Redis/redis集群以及应用场景.md
Normal file
@ -0,0 +1,269 @@
|
||||
相关阅读：
|
||||
|
||||
- [史上最全Redis高可用技术解决方案大全](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247484850&idx=1&sn=3238360bfa8105cf758dcf7354af2814&chksm=cea24a79f9d5c36fb2399aafa91d7fb2699b5006d8d037fe8aaf2e5577ff20ae322868b04a87&token=1082669959&lang=zh_CN&scene=21#wechat_redirect)
|
||||
- [Raft协议实战之Redis Sentinel的选举Leader源码解析](http://weizijun.cn/2015/04/30/Raft%E5%8D%8F%E8%AE%AE%E5%AE%9E%E6%88%98%E4%B9%8BRedis%20Sentinel%E7%9A%84%E9%80%89%E4%B8%BELeader%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90/)
|
||||
|
||||
目录：
|
||||
|
||||
<!-- TOC -->
|
||||
|
||||
- [Redis 集群以及应用](#redis-集群以及应用)
|
||||
- [集群](#集群)
|
||||
- [主从复制](#主从复制)
|
||||
- [主从链(拓扑结构)](#主从链拓扑结构)
|
||||
- [复制模式](#复制模式)
|
||||
- [问题点](#问题点)
|
||||
- [哨兵机制](#哨兵机制)
|
||||
- [拓扑图](#拓扑图)
|
||||
- [节点下线](#节点下线)
|
||||
- [Leader选举](#Leader选举)
|
||||
- [故障转移](#故障转移)
|
||||
- [读写分离](#读写分离)
|
||||
- [定时任务](#定时任务)
|
||||
- [分布式集群(Cluster)](#分布式集群cluster)
|
||||
- [拓扑图](#拓扑图)
|
||||
- [通讯](#通讯)
|
||||
- [集中式](#集中式)
|
||||
- [Gossip](#gossip)
|
||||
- [寻址分片](#寻址分片)
|
||||
- [hash取模](#hash取模)
|
||||
- [一致性hash](#一致性hash)
|
||||
- [hash槽](#hash槽)
|
||||
- [使用场景](#使用场景)
|
||||
- [热点数据](#热点数据)
|
||||
- [会话维持 Session](#会话维持-session)
|
||||
- [分布式锁 SETNX](#分布式锁-setnx)
|
||||
- [表缓存](#表缓存)
|
||||
- [消息队列 list](#消息队列-list)
|
||||
- [计数器 string](#计数器-string)
|
||||
- [缓存设计](#缓存设计)
|
||||
- [更新策略](#更新策略)
|
||||
- [更新一致性](#更新一致性)
|
||||
- [缓存粒度](#缓存粒度)
|
||||
- [缓存穿透](#缓存穿透)
|
||||
- [解决方案](#解决方案)
|
||||
- [缓存雪崩](#缓存雪崩)
|
||||
- [出现后应对](#出现后应对)
|
||||
- [请求过程](#请求过程)
|
||||
|
||||
<!-- /MarkdownTOC -->
|
||||
|
||||
# Redis 集群以及应用
|
||||
|
||||
## 集群
|
||||
|
||||
### 主从复制
|
||||
|
||||
#### 主从链(拓扑结构)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#### 复制模式
|
||||
- 全量复制：Master 全部同步到 Slave
|
||||
- 部分复制：Slave 数据丢失进行备份
|
||||
|
||||
#### 问题点
|
||||
- 同步故障
|
||||
- 复制数据延迟(不一致)
|
||||
- 读取过期数据(Slave 不能删除数据)
|
||||
- 从节点故障
|
||||
- 主节点故障
|
||||
- 配置不一致
|
||||
- maxmemory 不一致:丢失数据
|
||||
- 优化参数不一致:内存不一致.
|
||||
- 避免全量复制
|
||||
- 选择小主节点(分片)、低峰期间操作.
|
||||
- 如果节点运行 id 不匹配(如主节点重启、运行 id 发送变化)，此时要执行全量复制，应该配合哨兵和集群解决.
|
||||
- 主从复制挤压缓冲区不足产生的问题(网络中断，部分复制无法满足)，可增大复制缓冲区( rel_backlog_size 参数).
|
||||
- 复制风暴
|
||||
|
||||
### 哨兵机制
|
||||
|
||||
#### 拓扑图
|
||||
|
||||
|
||||
|
||||
#### 节点下线
|
||||
|
||||
- 主观下线
|
||||
- 即 Sentinel 节点对 Redis 节点失败的偏见，超出超时时间认为 Master 已经宕机。
|
||||
- Sentinel 集群的每一个 Sentinel 节点会定时对 Redis 集群的所有节点发心跳包检测节点是否正常。如果一个节点在 `down-after-milliseconds` 时间内没有回复 Sentinel 节点的心跳包，则该 Redis 节点被该 Sentinel 节点主观下线。
|
||||
- 客观下线
|
||||
- 所有 Sentinel 节点对 Redis 节点失败要达成共识，即超过 quorum 个统一。
|
||||
- 当节点被一个 Sentinel 节点记为主观下线时，并不意味着该节点肯定故障了，还需要 Sentinel 集群的其他 Sentinel 节点共同判断为主观下线才行。
|
||||
- 该 Sentinel 节点会询问其它 Sentinel 节点，如果 Sentinel 集群中超过 quorum 数量的 Sentinel 节点认为该 Redis 节点主观下线，则该 Redis 客观下线。
|
||||
|
||||
#### Leader选举
|
||||
|
||||
- 选举出一个 Sentinel 作为 Leader：集群中至少有三个 Sentinel 节点，但只有其中一个节点可完成故障转移.通过以下命令可以进行失败判定或领导者选举。
|
||||
- 选举流程
|
||||
1. 每个主观下线的 Sentinel 节点向其他 Sentinel 节点发送命令，要求设置它为领导者.
|
||||
2. 收到命令的 Sentinel 节点如果没有同意通过其他 Sentinel 节点发送的命令，则同意该请求，否则拒绝。
|
||||
3. 如果该 Sentinel 节点发现自己的票数已经超过 Sentinel 集合半数且超过 quorum，则它成为领导者。
|
||||
4. 如果此过程有多个 Sentinel 节点成为领导者，则等待一段时间再重新进行选举。
|
||||
|
||||
#### 故障转移
|
||||
|
||||
- 转移流程
|
||||
1. Sentinel 选出一个合适的 Slave 作为新的 Master(slaveof no one 命令)。
|
||||
2. 向其余 Slave 发出通知，让它们成为新 Master 的 Slave( parallel-syncs 参数)。
|
||||
3. 等待旧 Master 复活，并使之称为新 Master 的 Slave。
|
||||
4. 向客户端通知 Master 变化。
|
||||
- 从 Slave 中选择新 Master 节点的规则(slave 升级成 master 之后)
|
||||
1. 选择 slave-priority 最高的节点。
|
||||
2. 选择复制偏移量最大的节点(同步数据最多)。
|
||||
3. 选择 runId 最小的节点。
|
||||
|
||||
>Sentinel 集群运行过程中故障转移完成，所有 Sentinel 又会恢复平等。Leader 仅仅是故障转移操作出现的角色。
|
||||
|
||||
#### 读写分离
|
||||
|
||||
#### 定时任务
|
||||
|
||||
- 每 1s 每个 Sentinel 对其他 Sentinel 和 Redis 执行 ping，进行心跳检测。
|
||||
- 每 2s 每个 Sentinel 通过 Master 的 Channel 交换信息(pub - sub)。
|
||||
- 每 10s 每个 Sentinel 对 Master 和 Slave 执行 info，目的是发现 Slave 节点、确定主从关系。
|
||||
|
||||
### 分布式集群(Cluster)
|
||||
|
||||
#### 拓扑图
|
||||
|
||||
|
||||
|
||||
#### 通讯
|
||||
|
||||
##### 集中式
|
||||
|
||||
> 将集群元数据(节点信息、故障等等)几种存储在某个节点上。
|
||||
- 优势
|
||||
1. 元数据的更新读取具有很强的时效性，元数据修改立即更新
|
||||
- 劣势
|
||||
1. 数据集中存储
|
||||
|
||||
##### Gossip
|
||||
|
||||
|
||||
|
||||
- [Gossip 协议](https://www.jianshu.com/p/8279d6fd65bb)
|
||||
|
||||
#### 寻址分片
|
||||
|
||||
##### hash取模
|
||||
|
||||
- hash(key)%机器数量
|
||||
- 问题
|
||||
1. 机器宕机，造成数据丢失，数据读取失败
|
||||
1. 伸缩性
|
||||
|
||||
##### 一致性hash
|
||||
|
||||
- 
|
||||
|
||||
- 问题
|
||||
1. 一致性哈希算法在节点太少时，容易因为节点分布不均匀而造成缓存热点的问题。
|
||||
- 解决方案
|
||||
- 可以通过引入虚拟节点机制解决：即对每一个节点计算多个 hash，每个计算结果位置都放置一个虚拟节点。这样就实现了数据的均匀分布，负载均衡。
|
||||
|
||||
##### hash槽
|
||||
|
||||
- CRC16(key)%16384
|
||||
-
|
||||
|
||||
|
||||
## 使用场景
|
||||
|
||||
### 热点数据
|
||||
|
||||
存取数据优先从 Redis 操作，如果不存在再从文件（例如 MySQL）中操作，从文件操作完后将数据存储到 Redis 中并返回。同时有个定时任务后台定时扫描 Redis 的 key，根据业务规则进行淘汰，防止某些只访问一两次的数据一直存在 Redis 中。
|
||||
>例如使用 Zset 数据结构，存储 Key 的访问次数/最后访问时间作为 Score，最后做排序，来淘汰那些最少访问的 Key。
|
||||
|
||||
如果企业级应用，可以参考：[阿里云的 Redis 混合存储版][1]
|
||||
|
||||
### 会话维持 Session
|
||||
|
||||
会话维持 Session 场景，即使用 Redis 作为分布式场景下的登录中心存储应用。每次不同的服务在登录的时候，都会去统一的 Redis 去验证 Session 是否正确。但是在微服务场景，一般会考虑 Redis + JWT 做 Oauth2 模块。
|
||||
>其中 Redis 存储 JWT 的相关信息主要是留出口子，方便以后做统一的防刷接口，或者做登录设备限制等。
|
||||
|
||||
### 分布式锁 SETNX
|
||||
|
||||
命令格式：`SETNX key value`：当且仅当 key 不存在，将 key 的值设为 value。若给定的 key 已经存在，则 SETNX 不做任何动作。
|
||||
|
||||
1. 超时时间设置：获取锁的同时，启动守护线程，使用 expire 进行定时更新超时时间。如果该业务机器宕机，守护线程也挂掉，这样也会自动过期。如果该业务不是宕机，而是真的需要这么久的操作时间，那么增加超时时间在业务上也是可以接受的，但是肯定有个最大的阈值。
|
||||
2. 但是为了增加高可用，需要使用多台 Redis，就增加了复杂性，就可以参考 Redlock：[Redlock分布式锁](Redlock分布式锁.md#怎么在单节点上实现分布式锁)
|
||||
|
||||
### 表缓存
|
||||
|
||||
Redis 缓存表的场景有黑名单、禁言表等。访问频率较高，即读高。根据业务需求，可以使用后台定时任务定时刷新 Redis 的缓存表数据。
|
||||
|
||||
### 消息队列 list
|
||||
|
||||
主要使用了 List 数据结构。
|
||||
List 支持在头部和尾部操作，因此可以实现简单的消息队列。
|
||||
1. 发消息：在 List 尾部塞入数据。
|
||||
2. 消费消息：在 List 头部拿出数据。
|
||||
|
||||
同时可以使用多个 List，来实现多个队列，根据不同的业务消息，塞入不同的 List，来增加吞吐量。
|
||||
|
||||
### 计数器 string
|
||||
|
||||
主要使用了 INCR、DECR、INCRBY、DECRBY 方法。
|
||||
|
||||
INCR key：给 key 的 value 值增加一
|
||||
DECR key：给 key 的 value 值减去一
|
||||
|
||||
## 缓存设计
|
||||
|
||||
### 更新策略
|
||||
|
||||
- LRU、LFU、FIFO 算法自动清除：一致性最差，维护成本低。
|
||||
- 超时自动清除(key expire)：一致性较差，维护成本低。
|
||||
- 主动更新：代码层面控制生命周期，一致性最好，维护成本高。
|
||||
|
||||
在 Redis 根据在 redis.conf 的参数 `maxmemory` 来做更新淘汰策略：
|
||||
1. noeviction: 不删除策略, 达到最大内存限制时, 如果需要更多内存, 直接返回错误信息。大多数写命令都会导致占用更多的内存(有极少数会例外, 如 DEL 命令)。
|
||||
2. allkeys-lru: 所有 key 通用; 优先删除最近最少使用(less recently used ,LRU) 的 key。
|
||||
3. volatile-lru: 只限于设置了 expire 的部分; 优先删除最近最少使用(less recently used ,LRU) 的 key。
|
||||
4. allkeys-random: 所有key通用; 随机删除一部分 key。
|
||||
5. volatile-random: 只限于设置了 expire 的部分; 随机删除一部分 key。
|
||||
6. volatile-ttl: 只限于设置了 expire 的部分; 优先删除剩余时间(time to live,TTL) 短的key。
|
||||
|
||||
### 更新一致性
|
||||
|
||||
- 读请求：先读缓存，缓存没有的话，就读数据库，然后取出数据后放入缓存，同时返回响应。
|
||||
- 写请求：先删除缓存，然后再更新数据库(避免大量地写、却又不经常读的数据导致缓存频繁更新)。
|
||||
|
||||
### 缓存粒度
|
||||
|
||||
- 通用性：全量属性更好。
|
||||
- 占用空间：部分属性更好。
|
||||
- 代码维护成本。
|
||||
|
||||
### 缓存穿透
|
||||
|
||||
> 当大量的请求无命中缓存、直接请求到后端数据库(业务代码的 bug、或恶意攻击)，同时后端数据库也没有查询到相应的记录、无法添加缓存。
|
||||
> 这种状态会一直维持，流量一直打到存储层上，无法利用缓存、还会给存储层带来巨大压力。
|
||||
|
||||
#### 解决方案
|
||||
|
||||
1. 请求无法命中缓存、同时数据库记录为空时在缓存添加该 key 的空对象(设置过期时间)，缺点是可能会在缓存中添加大量的空值键(比如遭到恶意攻击或爬虫)，而且缓存层和存储层数据短期内不一致；
|
||||
2. 使用布隆过滤器在缓存层前拦截非法请求、自动为空值添加黑名单(同时可能要为误判的记录添加白名单).但需要考虑布隆过滤器的维护(离线生成/ 实时生成)。
|
||||
|
||||
### 缓存雪崩
|
||||
|
||||
> 缓存崩溃时请求会直接落到数据库上，很可能由于无法承受大量的并发请求而崩溃，此时如果只重启数据库，或因为缓存重启后没有数据，新的流量进来很快又会把数据库击倒。
|
||||
|
||||
#### 出现后应对
|
||||
|
||||
- 事前：Redis 高可用，主从 + 哨兵，Redis Cluster，避免全盘崩溃。
|
||||
- 事中：本地 ehcache 缓存 + hystrix 限流 & 降级，避免数据库承受太多压力。
|
||||
- 事后：Redis 持久化，一旦重启，自动从磁盘上加载数据，快速恢复缓存数据。
|
||||
|
||||
#### 请求过程
|
||||
|
||||
1. 用户请求先访问本地缓存，无命中后再访问 Redis，如果本地缓存和 Redis 都没有再查数据库，并把数据添加到本地缓存和 Redis；
|
||||
2. 由于设置了限流，一段时间范围内超出的请求走降级处理(返回默认值，或给出友情提示)。
|
||||
|
||||
973
docs/database/一千行MySQL命令.md
Normal file
973
docs/database/一千行MySQL命令.md
Normal file
@ -0,0 +1,973 @@
|
||||
> 原文地址：https://shockerli.net/post/1000-line-mysql-note/ ，JavaGuide 对本文进行了简答排版，新增了目录。
|
||||
> 作者：格物
|
||||
|
||||
非常不错的总结，强烈建议保存下来，需要的时候看一看。
|
||||
|
||||
<!-- TOC -->
|
||||
- [基本操作](#基本操作)
|
||||
- [数据库操作](#数据库操作)
|
||||
- [表的操作](#表的操作)
|
||||
- [数据操作](#数据操作)
|
||||
- [字符集编码](#字符集编码)
|
||||
- [数据类型(列类型)](#数据类型列类型)
|
||||
- [列属性(列约束)](#列属性列约束)
|
||||
- [建表规范](#建表规范)
|
||||
- [SELECT](#select)
|
||||
- [UNION](#union)
|
||||
- [子查询](#子查询)
|
||||
- [连接查询(join)](#连接查询join)
|
||||
- [TRUNCATE](#truncate)
|
||||
- [备份与还原](#备份与还原)
|
||||
- [视图](#视图)
|
||||
- [事务(transaction)](#事务transaction)
|
||||
- [锁表](#锁表)
|
||||
- [触发器](#触发器)
|
||||
- [SQL编程](#sql编程)
|
||||
- [存储过程](#存储过程)
|
||||
- [用户和权限管理](#用户和权限管理)
|
||||
- [表维护](#表维护)
|
||||
- [杂项](#杂项)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
### 基本操作
|
||||
|
||||
```mysql
|
||||
/* Windows服务 */
|
||||
-- 启动MySQL
|
||||
net start mysql
|
||||
-- 创建Windows服务
|
||||
sc create mysql binPath= mysqld_bin_path(注意：等号与值之间有空格)
|
||||
/* 连接与断开服务器 */
|
||||
mysql -h 地址 -P 端口 -u 用户名 -p 密码
|
||||
SHOW PROCESSLIST -- 显示哪些线程正在运行
|
||||
SHOW VARIABLES -- 显示系统变量信息
|
||||
```
|
||||
|
||||
### 数据库操作
|
||||
|
||||
```mysql
|
||||
/* 数据库操作 */ ------------------
|
||||
-- 查看当前数据库
|
||||
SELECT DATABASE();
|
||||
-- 显示当前时间、用户名、数据库版本
|
||||
SELECT now(), user(), version();
|
||||
-- 创建库
|
||||
CREATE DATABASE[ IF NOT EXISTS] 数据库名 数据库选项
|
||||
数据库选项：
|
||||
CHARACTER SET charset_name
|
||||
COLLATE collation_name
|
||||
-- 查看已有库
|
||||
SHOW DATABASES[ LIKE 'PATTERN']
|
||||
-- 查看当前库信息
|
||||
SHOW CREATE DATABASE 数据库名
|
||||
-- 修改库的选项信息
|
||||
ALTER DATABASE 库名 选项信息
|
||||
-- 删除库
|
||||
DROP DATABASE[ IF EXISTS] 数据库名
|
||||
同时删除该数据库相关的目录及其目录内容
|
||||
```
|
||||
|
||||
### 表的操作
|
||||
|
||||
```mysql
|
||||
-- 创建表
|
||||
CREATE [TEMPORARY] TABLE[ IF NOT EXISTS] [库名.]表名 ( 表的结构定义 )[ 表选项]
|
||||
每个字段必须有数据类型
|
||||
最后一个字段后不能有逗号
|
||||
TEMPORARY 临时表，会话结束时表自动消失
|
||||
对于字段的定义：
|
||||
字段名 数据类型 [NOT NULL | NULL] [DEFAULT default_value] [AUTO_INCREMENT] [UNIQUE [KEY] | [PRIMARY] KEY] [COMMENT 'string']
|
||||
-- 表选项
|
||||
-- 字符集
|
||||
CHARSET = charset_name
|
||||
如果表没有设定，则使用数据库字符集
|
||||
-- 存储引擎
|
||||
ENGINE = engine_name
|
||||
表在管理数据时采用的不同的数据结构，结构不同会导致处理方式、提供的特性操作等不同
|
||||
常见的引擎：InnoDB MyISAM Memory/Heap BDB Merge Example CSV MaxDB Archive
|
||||
不同的引擎在保存表的结构和数据时采用不同的方式
|
||||
MyISAM表文件含义：.frm表定义，.MYD表数据，.MYI表索引
|
||||
InnoDB表文件含义：.frm表定义，表空间数据和日志文件
|
||||
SHOW ENGINES -- 显示存储引擎的状态信息
|
||||
SHOW ENGINE 引擎名 {LOGS|STATUS} -- 显示存储引擎的日志或状态信息
|
||||
-- 自增起始数
|
||||
AUTO_INCREMENT = 行数
|
||||
-- 数据文件目录
|
||||
DATA DIRECTORY = '目录'
|
||||
-- 索引文件目录
|
||||
INDEX DIRECTORY = '目录'
|
||||
-- 表注释
|
||||
COMMENT = 'string'
|
||||
-- 分区选项
|
||||
PARTITION BY ... (详细见手册)
|
||||
-- 查看所有表
|
||||
SHOW TABLES[ LIKE 'pattern']
|
||||
SHOW TABLES FROM 库名
|
||||
-- 查看表结构
|
||||
SHOW CREATE TABLE 表名 （信息更详细）
|
||||
DESC 表名 / DESCRIBE 表名 / EXPLAIN 表名 / SHOW COLUMNS FROM 表名 [LIKE 'PATTERN']
|
||||
SHOW TABLE STATUS [FROM db_name] [LIKE 'pattern']
|
||||
-- 修改表
|
||||
-- 修改表本身的选项
|
||||
ALTER TABLE 表名 表的选项
|
||||
eg: ALTER TABLE 表名 ENGINE=MYISAM;
|
||||
-- 对表进行重命名
|
||||
RENAME TABLE 原表名 TO 新表名
|
||||
RENAME TABLE 原表名 TO 库名.表名 （可将表移动到另一个数据库）
|
||||
-- RENAME可以交换两个表名
|
||||
-- 修改表的字段机构（13.1.2. ALTER TABLE语法）
|
||||
ALTER TABLE 表名 操作名
|
||||
-- 操作名
|
||||
ADD[ COLUMN] 字段定义 -- 增加字段
|
||||
AFTER 字段名 -- 表示增加在该字段名后面
|
||||
FIRST -- 表示增加在第一个
|
||||
ADD PRIMARY KEY(字段名) -- 创建主键
|
||||
ADD UNIQUE [索引名] (字段名)-- 创建唯一索引
|
||||
ADD INDEX [索引名] (字段名) -- 创建普通索引
|
||||
DROP[ COLUMN] 字段名 -- 删除字段
|
||||
MODIFY[ COLUMN] 字段名 字段属性 -- 支持对字段属性进行修改，不能修改字段名(所有原有属性也需写上)
|
||||
CHANGE[ COLUMN] 原字段名 新字段名 字段属性 -- 支持对字段名修改
|
||||
DROP PRIMARY KEY -- 删除主键(删除主键前需删除其AUTO_INCREMENT属性)
|
||||
DROP INDEX 索引名 -- 删除索引
|
||||
DROP FOREIGN KEY 外键 -- 删除外键
|
||||
-- 删除表
|
||||
DROP TABLE[ IF EXISTS] 表名 ...
|
||||
-- 清空表数据
|
||||
TRUNCATE [TABLE] 表名
|
||||
-- 复制表结构
|
||||
CREATE TABLE 表名 LIKE 要复制的表名
|
||||
-- 复制表结构和数据
|
||||
CREATE TABLE 表名 [AS] SELECT * FROM 要复制的表名
|
||||
-- 检查表是否有错误
|
||||
CHECK TABLE tbl_name [, tbl_name] ... [option] ...
|
||||
-- 优化表
|
||||
OPTIMIZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ...
|
||||
-- 修复表
|
||||
REPAIR [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ... [QUICK] [EXTENDED] [USE_FRM]
|
||||
-- 分析表
|
||||
ANALYZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ...
|
||||
```
|
||||
|
||||
### 数据操作
|
||||
|
||||
```mysql
|
||||
/* 数据操作 */ ------------------
|
||||
-- 增
|
||||
INSERT [INTO] 表名 [(字段列表)] VALUES (值列表)[, (值列表), ...]
|
||||
-- 如果要插入的值列表包含所有字段并且顺序一致，则可以省略字段列表。
|
||||
-- 可同时插入多条数据记录！
|
||||
REPLACE 与 INSERT 完全一样，可互换。
|
||||
INSERT [INTO] 表名 SET 字段名=值[, 字段名=值, ...]
|
||||
-- 查
|
||||
SELECT 字段列表 FROM 表名[ 其他子句]
|
||||
-- 可来自多个表的多个字段
|
||||
-- 其他子句可以不使用
|
||||
-- 字段列表可以用*代替，表示所有字段
|
||||
-- 删
|
||||
DELETE FROM 表名[ 删除条件子句]
|
||||
没有条件子句，则会删除全部
|
||||
-- 改
|
||||
UPDATE 表名 SET 字段名=新值[, 字段名=新值] [更新条件]
|
||||
```
|
||||
|
||||
### 字符集编码
|
||||
|
||||
```mysql
|
||||
/* 字符集编码 */ ------------------
|
||||
-- MySQL、数据库、表、字段均可设置编码
|
||||
-- 数据编码与客户端编码不需一致
|
||||
SHOW VARIABLES LIKE 'character_set_%' -- 查看所有字符集编码项
|
||||
character_set_client 客户端向服务器发送数据时使用的编码
|
||||
character_set_results 服务器端将结果返回给客户端所使用的编码
|
||||
character_set_connection 连接层编码
|
||||
SET 变量名 = 变量值
|
||||
SET character_set_client = gbk;
|
||||
SET character_set_results = gbk;
|
||||
SET character_set_connection = gbk;
|
||||
SET NAMES GBK; -- 相当于完成以上三个设置
|
||||
-- 校对集
|
||||
校对集用以排序
|
||||
SHOW CHARACTER SET [LIKE 'pattern']/SHOW CHARSET [LIKE 'pattern'] 查看所有字符集
|
||||
SHOW COLLATION [LIKE 'pattern'] 查看所有校对集
|
||||
CHARSET 字符集编码 设置字符集编码
|
||||
COLLATE 校对集编码 设置校对集编码
|
||||
```
|
||||
|
||||
### 数据类型(列类型)
|
||||
|
||||
```mysql
|
||||
/* 数据类型（列类型） */ ------------------
|
||||
1. 数值类型
|
||||
-- a. 整型 ----------
|
||||
类型 字节 范围（有符号位）
|
||||
tinyint 1字节 -128 ~ 127 无符号位：0 ~ 255
|
||||
smallint 2字节 -32768 ~ 32767
|
||||
mediumint 3字节 -8388608 ~ 8388607
|
||||
int 4字节
|
||||
bigint 8字节
|
||||
int(M) M表示总位数
|
||||
- 默认存在符号位，unsigned 属性修改
|
||||
- 显示宽度，如果某个数不够定义字段时设置的位数，则前面以0补填，zerofill 属性修改
|
||||
例：int(5) 插入一个数'123'，补填后为'00123'
|
||||
- 在满足要求的情况下，越小越好。
|
||||
- 1表示bool值真，0表示bool值假。MySQL没有布尔类型，通过整型0和1表示。常用tinyint(1)表示布尔型。
|
||||
-- b. 浮点型 ----------
|
||||
类型 字节 范围
|
||||
float(单精度) 4字节
|
||||
double(双精度) 8字节
|
||||
浮点型既支持符号位 unsigned 属性，也支持显示宽度 zerofill 属性。
|
||||
不同于整型，前后均会补填0.
|
||||
定义浮点型时，需指定总位数和小数位数。
|
||||
float(M, D) double(M, D)
|
||||
M表示总位数，D表示小数位数。
|
||||
M和D的大小会决定浮点数的范围。不同于整型的固定范围。
|
||||
M既表示总位数（不包括小数点和正负号），也表示显示宽度（所有显示符号均包括）。
|
||||
支持科学计数法表示。
|
||||
浮点数表示近似值。
|
||||
-- c. 定点数 ----------
|
||||
decimal -- 可变长度
|
||||
decimal(M, D) M也表示总位数，D表示小数位数。
|
||||
保存一个精确的数值，不会发生数据的改变，不同于浮点数的四舍五入。
|
||||
将浮点数转换为字符串来保存，每9位数字保存为4个字节。
|
||||
2. 字符串类型
|
||||
-- a. char, varchar ----------
|
||||
char 定长字符串，速度快，但浪费空间
|
||||
varchar 变长字符串，速度慢，但节省空间
|
||||
M表示能存储的最大长度，此长度是字符数，非字节数。
|
||||
不同的编码，所占用的空间不同。
|
||||
char,最多255个字符，与编码无关。
|
||||
varchar,最多65535字符，与编码有关。
|
||||
一条有效记录最大不能超过65535个字节。
|
||||
utf8 最大为21844个字符，gbk 最大为32766个字符，latin1 最大为65532个字符
|
||||
varchar 是变长的，需要利用存储空间保存 varchar 的长度，如果数据小于255个字节，则采用一个字节来保存长度，反之需要两个字节来保存。
|
||||
varchar 的最大有效长度由最大行大小和使用的字符集确定。
|
||||
最大有效长度是65532字节，因为在varchar存字符串时，第一个字节是空的，不存在任何数据，然后还需两个字节来存放字符串的长度，所以有效长度是64432-1-2=65532字节。
|
||||
例：若一个表定义为 CREATE TABLE tb(c1 int, c2 char(30), c3 varchar(N)) charset=utf8; 问N的最大值是多少？ 答：(65535-1-2-4-30*3)/3
|
||||
-- b. blob, text ----------
|
||||
blob 二进制字符串（字节字符串）
|
||||
tinyblob, blob, mediumblob, longblob
|
||||
text 非二进制字符串（字符字符串）
|
||||
tinytext, text, mediumtext, longtext
|
||||
text 在定义时，不需要定义长度，也不会计算总长度。
|
||||
text 类型在定义时，不可给default值
|
||||
-- c. binary, varbinary ----------
|
||||
类似于char和varchar，用于保存二进制字符串，也就是保存字节字符串而非字符字符串。
|
||||
char, varchar, text 对应 binary, varbinary, blob.
|
||||
3. 日期时间类型
|
||||
一般用整型保存时间戳，因为PHP可以很方便的将时间戳进行格式化。
|
||||
datetime 8字节 日期及时间 1000-01-01 00:00:00 到 9999-12-31 23:59:59
|
||||
date 3字节 日期 1000-01-01 到 9999-12-31
|
||||
timestamp 4字节 时间戳 19700101000000 到 2038-01-19 03:14:07
|
||||
time 3字节 时间 -838:59:59 到 838:59:59
|
||||
year 1字节 年份 1901 - 2155
|
||||
datetime YYYY-MM-DD hh:mm:ss
|
||||
timestamp YY-MM-DD hh:mm:ss
|
||||
YYYYMMDDhhmmss
|
||||
YYMMDDhhmmss
|
||||
YYYYMMDDhhmmss
|
||||
YYMMDDhhmmss
|
||||
date YYYY-MM-DD
|
||||
YY-MM-DD
|
||||
YYYYMMDD
|
||||
YYMMDD
|
||||
YYYYMMDD
|
||||
YYMMDD
|
||||
time hh:mm:ss
|
||||
hhmmss
|
||||
hhmmss
|
||||
year YYYY
|
||||
YY
|
||||
YYYY
|
||||
YY
|
||||
4. 枚举和集合
|
||||
-- 枚举(enum) ----------
|
||||
enum(val1, val2, val3...)
|
||||
在已知的值中进行单选。最大数量为65535.
|
||||
枚举值在保存时，以2个字节的整型(smallint)保存。每个枚举值，按保存的位置顺序，从1开始逐一递增。
|
||||
表现为字符串类型，存储却是整型。
|
||||
NULL值的索引是NULL。
|
||||
空字符串错误值的索引值是0。
|
||||
-- 集合（set） ----------
|
||||
set(val1, val2, val3...)
|
||||
create table tab ( gender set('男', '女', '无') );
|
||||
insert into tab values ('男, 女');
|
||||
最多可以有64个不同的成员。以bigint存储，共8个字节。采取位运算的形式。
|
||||
当创建表时，SET成员值的尾部空格将自动被删除。
|
||||
```
|
||||
|
||||
### 列属性(列约束)
|
||||
|
||||
```mysql
|
||||
/* 列属性（列约束） */ ------------------
|
||||
1. PRIMARY 主键
|
||||
- 能唯一标识记录的字段，可以作为主键。
|
||||
- 一个表只能有一个主键。
|
||||
- 主键具有唯一性。
|
||||
- 声明字段时，用 primary key 标识。
|
||||
也可以在字段列表之后声明
|
||||
例：create table tab ( id int, stu varchar(10), primary key (id));
|
||||
- 主键字段的值不能为null。
|
||||
- 主键可以由多个字段共同组成。此时需要在字段列表后声明的方法。
|
||||
例：create table tab ( id int, stu varchar(10), age int, primary key (stu, age));
|
||||
2. UNIQUE 唯一索引（唯一约束）
|
||||
使得某字段的值也不能重复。
|
||||
3. NULL 约束
|
||||
null不是数据类型，是列的一个属性。
|
||||
表示当前列是否可以为null，表示什么都没有。
|
||||
null, 允许为空。默认。
|
||||
not null, 不允许为空。
|
||||
insert into tab values (null, 'val');
|
||||
-- 此时表示将第一个字段的值设为null, 取决于该字段是否允许为null
|
||||
4. DEFAULT 默认值属性
|
||||
当前字段的默认值。
|
||||
insert into tab values (default, 'val'); -- 此时表示强制使用默认值。
|
||||
create table tab ( add_time timestamp default current_timestamp );
|
||||
-- 表示将当前时间的时间戳设为默认值。
|
||||
current_date, current_time
|
||||
5. AUTO_INCREMENT 自动增长约束
|
||||
自动增长必须为索引（主键或unique）
|
||||
只能存在一个字段为自动增长。
|
||||
默认为1开始自动增长。可以通过表属性 auto_increment = x进行设置，或 alter table tbl auto_increment = x;
|
||||
6. COMMENT 注释
|
||||
例：create table tab ( id int ) comment '注释内容';
|
||||
7. FOREIGN KEY 外键约束
|
||||
用于限制主表与从表数据完整性。
|
||||
alter table t1 add constraint `t1_t2_fk` foreign key (t1_id) references t2(id);
|
||||
-- 将表t1的t1_id外键关联到表t2的id字段。
|
||||
-- 每个外键都有一个名字，可以通过 constraint 指定
|
||||
存在外键的表，称之为从表（子表），外键指向的表，称之为主表（父表）。
|
||||
作用：保持数据一致性，完整性，主要目的是控制存储在外键表（从表）中的数据。
|
||||
MySQL中，可以对InnoDB引擎使用外键约束：
|
||||
语法：
|
||||
foreign key (外键字段） references 主表名 (关联字段) [主表记录删除时的动作] [主表记录更新时的动作]
|
||||
此时需要检测一个从表的外键需要约束为主表的已存在的值。外键在没有关联的情况下，可以设置为null.前提是该外键列，没有not null。
|
||||
可以不指定主表记录更改或更新时的动作，那么此时主表的操作被拒绝。
|
||||
如果指定了 on update 或 on delete：在删除或更新时，有如下几个操作可以选择：
|
||||
1. cascade，级联操作。主表数据被更新（主键值更新），从表也被更新（外键值更新）。主表记录被删除，从表相关记录也被删除。
|
||||
2. set null，设置为null。主表数据被更新（主键值更新），从表的外键被设置为null。主表记录被删除，从表相关记录外键被设置成null。但注意，要求该外键列，没有not null属性约束。
|
||||
3. restrict，拒绝父表删除和更新。
|
||||
注意，外键只被InnoDB存储引擎所支持。其他引擎是不支持的。
|
||||
|
||||
```
|
||||
|
||||
### 建表规范
|
||||
|
||||
```mysql
|
||||
/* 建表规范 */ ------------------
|
||||
-- Normal Format, NF
|
||||
- 每个表保存一个实体信息
|
||||
- 每个具有一个ID字段作为主键
|
||||
- ID主键 + 原子表
|
||||
-- 1NF, 第一范式
|
||||
字段不能再分，就满足第一范式。
|
||||
-- 2NF, 第二范式
|
||||
满足第一范式的前提下，不能出现部分依赖。
|
||||
消除复合主键就可以避免部分依赖。增加单列关键字。
|
||||
-- 3NF, 第三范式
|
||||
满足第二范式的前提下，不能出现传递依赖。
|
||||
某个字段依赖于主键，而有其他字段依赖于该字段。这就是传递依赖。
|
||||
将一个实体信息的数据放在一个表内实现。
|
||||
```
|
||||
|
||||
### SELECT
|
||||
|
||||
```mysql
|
||||
/* SELECT */ ------------------
|
||||
SELECT [ALL|DISTINCT] select_expr FROM -> WHERE -> GROUP BY [合计函数] -> HAVING -> ORDER BY -> LIMIT
|
||||
a. select_expr
|
||||
-- 可以用 * 表示所有字段。
|
||||
select * from tb;
|
||||
-- 可以使用表达式（计算公式、函数调用、字段也是个表达式）
|
||||
select stu, 29+25, now() from tb;
|
||||
-- 可以为每个列使用别名。适用于简化列标识，避免多个列标识符重复。
|
||||
- 使用 as 关键字，也可省略 as.
|
||||
select stu+10 as add10 from tb;
|
||||
b. FROM 子句
|
||||
用于标识查询来源。
|
||||
-- 可以为表起别名。使用as关键字。
|
||||
SELECT * FROM tb1 AS tt, tb2 AS bb;
|
||||
-- from子句后，可以同时出现多个表。
|
||||
-- 多个表会横向叠加到一起，而数据会形成一个笛卡尔积。
|
||||
SELECT * FROM tb1, tb2;
|
||||
-- 向优化符提示如何选择索引
|
||||
USE INDEX、IGNORE INDEX、FORCE INDEX
|
||||
SELECT * FROM table1 USE INDEX (key1,key2) WHERE key1=1 AND key2=2 AND key3=3;
|
||||
SELECT * FROM table1 IGNORE INDEX (key3) WHERE key1=1 AND key2=2 AND key3=3;
|
||||
c. WHERE 子句
|
||||
-- 从from获得的数据源中进行筛选。
|
||||
-- 整型1表示真，0表示假。
|
||||
-- 表达式由运算符和运算数组成。
|
||||
-- 运算数：变量（字段）、值、函数返回值
|
||||
-- 运算符：
|
||||
=, <=>, <>, !=, <=, <, >=, >, !, &&, ||,
|
||||
in (not) null, (not) like, (not) in, (not) between and, is (not), and, or, not, xor
|
||||
is/is not 加上ture/false/unknown，检验某个值的真假
|
||||
<=>与<>功能相同，<=>可用于null比较
|
||||
d. GROUP BY 子句, 分组子句
|
||||
GROUP BY 字段/别名 [排序方式]
|
||||
分组后会进行排序。升序：ASC，降序：DESC
|
||||
以下[合计函数]需配合 GROUP BY 使用：
|
||||
count 返回不同的非NULL值数目 count(*)、count(字段)
|
||||
sum 求和
|
||||
max 求最大值
|
||||
min 求最小值
|
||||
avg 求平均值
|
||||
group_concat 返回带有来自一个组的连接的非NULL值的字符串结果。组内字符串连接。
|
||||
e. HAVING 子句，条件子句
|
||||
与 where 功能、用法相同，执行时机不同。
|
||||
where 在开始时执行检测数据，对原数据进行过滤。
|
||||
having 对筛选出的结果再次进行过滤。
|
||||
having 字段必须是查询出来的，where 字段必须是数据表存在的。
|
||||
where 不可以使用字段的别名，having 可以。因为执行WHERE代码时，可能尚未确定列值。
|
||||
where 不可以使用合计函数。一般需用合计函数才会用 having
|
||||
SQL标准要求HAVING必须引用GROUP BY子句中的列或用于合计函数中的列。
|
||||
f. ORDER BY 子句，排序子句
|
||||
order by 排序字段/别名 排序方式 [,排序字段/别名 排序方式]...
|
||||
升序：ASC，降序：DESC
|
||||
支持多个字段的排序。
|
||||
g. LIMIT 子句，限制结果数量子句
|
||||
仅对处理好的结果进行数量限制。将处理好的结果的看作是一个集合，按照记录出现的顺序，索引从0开始。
|
||||
limit 起始位置, 获取条数
|
||||
省略第一个参数，表示从索引0开始。limit 获取条数
|
||||
h. DISTINCT, ALL 选项
|
||||
distinct 去除重复记录
|
||||
默认为 all, 全部记录
|
||||
```
|
||||
|
||||
### UNION
|
||||
|
||||
```mysql
|
||||
/* UNION */ ------------------
|
||||
将多个select查询的结果组合成一个结果集合。
|
||||
SELECT ... UNION [ALL|DISTINCT] SELECT ...
|
||||
默认 DISTINCT 方式，即所有返回的行都是唯一的
|
||||
建议，对每个SELECT查询加上小括号包裹。
|
||||
ORDER BY 排序时，需加上 LIMIT 进行结合。
|
||||
需要各select查询的字段数量一样。
|
||||
每个select查询的字段列表(数量、类型)应一致，因为结果中的字段名以第一条select语句为准。
|
||||
```
|
||||
|
||||
### 子查询
|
||||
|
||||
```mysql
|
||||
/* 子查询 */ ------------------
|
||||
- 子查询需用括号包裹。
|
||||
-- from型
|
||||
from后要求是一个表，必须给子查询结果取个别名。
|
||||
- 简化每个查询内的条件。
|
||||
- from型需将结果生成一个临时表格，可用以原表的锁定的释放。
|
||||
- 子查询返回一个表，表型子查询。
|
||||
select * from (select * from tb where id>0) as subfrom where id>1;
|
||||
-- where型
|
||||
- 子查询返回一个值，标量子查询。
|
||||
- 不需要给子查询取别名。
|
||||
- where子查询内的表，不能直接用以更新。
|
||||
select * from tb where money = (select max(money) from tb);
|
||||
-- 列子查询
|
||||
如果子查询结果返回的是一列。
|
||||
使用 in 或 not in 完成查询
|
||||
exists 和 not exists 条件
|
||||
如果子查询返回数据，则返回1或0。常用于判断条件。
|
||||
select column1 from t1 where exists (select * from t2);
|
||||
-- 行子查询
|
||||
查询条件是一个行。
|
||||
select * from t1 where (id, gender) in (select id, gender from t2);
|
||||
行构造符：(col1, col2, ...) 或 ROW(col1, col2, ...)
|
||||
行构造符通常用于与对能返回两个或两个以上列的子查询进行比较。
|
||||
-- 特殊运算符
|
||||
!= all() 相当于 not in
|
||||
= some() 相当于 in。any 是 some 的别名
|
||||
!= some() 不等同于 not in，不等于其中某一个。
|
||||
all, some 可以配合其他运算符一起使用。
|
||||
```
|
||||
|
||||
### 连接查询(join)
|
||||
|
||||
```mysql
|
||||
/* 连接查询(join) */ ------------------
|
||||
将多个表的字段进行连接，可以指定连接条件。
|
||||
-- 内连接(inner join)
|
||||
- 默认就是内连接，可省略inner。
|
||||
- 只有数据存在时才能发送连接。即连接结果不能出现空行。
|
||||
on 表示连接条件。其条件表达式与where类似。也可以省略条件（表示条件永远为真）
|
||||
也可用where表示连接条件。
|
||||
还有 using, 但需字段名相同。 using(字段名)
|
||||
-- 交叉连接 cross join
|
||||
即，没有条件的内连接。
|
||||
select * from tb1 cross join tb2;
|
||||
-- 外连接(outer join)
|
||||
- 如果数据不存在，也会出现在连接结果中。
|
||||
-- 左外连接 left join
|
||||
如果数据不存在，左表记录会出现，而右表为null填充
|
||||
-- 右外连接 right join
|
||||
如果数据不存在，右表记录会出现，而左表为null填充
|
||||
-- 自然连接(natural join)
|
||||
自动判断连接条件完成连接。
|
||||
相当于省略了using，会自动查找相同字段名。
|
||||
natural join
|
||||
natural left join
|
||||
natural right join
|
||||
select info.id, info.name, info.stu_num, extra_info.hobby, extra_info.sex from info, extra_info where info.stu_num = extra_info.stu_id;
|
||||
```
|
||||
|
||||
### TRUNCATE
|
||||
|
||||
```mysql
|
||||
/* TRUNCATE */ ------------------
|
||||
TRUNCATE [TABLE] tbl_name
|
||||
清空数据
|
||||
删除重建表
|
||||
区别：
|
||||
1，truncate 是删除表再创建，delete 是逐条删除
|
||||
2，truncate 重置auto_increment的值。而delete不会
|
||||
3，truncate 不知道删除了几条，而delete知道。
|
||||
4，当被用于带分区的表时，truncate 会保留分区
|
||||
```
|
||||
|
||||
### 备份与还原
|
||||
|
||||
```mysql
|
||||
/* 备份与还原 */ ------------------
|
||||
备份，将数据的结构与表内数据保存起来。
|
||||
利用 mysqldump 指令完成。
|
||||
-- 导出
|
||||
mysqldump [options] db_name [tables]
|
||||
mysqldump [options] ---database DB1 [DB2 DB3...]
|
||||
mysqldump [options] --all--database
|
||||
1. 导出一张表
|
||||
mysqldump -u用户名 -p密码 库名 表名 > 文件名(D:/a.sql)
|
||||
2. 导出多张表
|
||||
mysqldump -u用户名 -p密码 库名 表1 表2 表3 > 文件名(D:/a.sql)
|
||||
3. 导出所有表
|
||||
mysqldump -u用户名 -p密码 库名 > 文件名(D:/a.sql)
|
||||
4. 导出一个库
|
||||
mysqldump -u用户名 -p密码 --lock-all-tables --database 库名 > 文件名(D:/a.sql)
|
||||
可以-w携带WHERE条件
|
||||
-- 导入
|
||||
1. 在登录mysql的情况下：
|
||||
source 备份文件
|
||||
2. 在不登录的情况下
|
||||
mysql -u用户名 -p密码 库名 < 备份文件
|
||||
```
|
||||
|
||||
### 视图
|
||||
|
||||
```mysql
|
||||
什么是视图：
|
||||
视图是一个虚拟表，其内容由查询定义。同真实的表一样，视图包含一系列带有名称的列和行数据。但是，视图并不在数据库中以存储的数据值集形式存在。行和列数据来自由定义视图的查询所引用的表，并且在引用视图时动态生成。
|
||||
视图具有表结构文件，但不存在数据文件。
|
||||
对其中所引用的基础表来说，视图的作用类似于筛选。定义视图的筛选可以来自当前或其它数据库的一个或多个表，或者其它视图。通过视图进行查询没有任何限制，通过它们进行数据修改时的限制也很少。
|
||||
视图是存储在数据库中的查询的sql语句，它主要出于两种原因：安全原因，视图可以隐藏一些数据，如：社会保险基金表，可以用视图只显示姓名，地址，而不显示社会保险号和工资数等，另一原因是可使复杂的查询易于理解和使用。
|
||||
-- 创建视图
|
||||
CREATE [OR REPLACE] [ALGORITHM = {UNDEFINED | MERGE | TEMPTABLE}] VIEW view_name [(column_list)] AS select_statement
|
||||
- 视图名必须唯一，同时不能与表重名。
|
||||
- 视图可以使用select语句查询到的列名，也可以自己指定相应的列名。
|
||||
- 可以指定视图执行的算法，通过ALGORITHM指定。
|
||||
- column_list如果存在，则数目必须等于SELECT语句检索的列数
|
||||
-- 查看结构
|
||||
SHOW CREATE VIEW view_name
|
||||
-- 删除视图
|
||||
- 删除视图后，数据依然存在。
|
||||
- 可同时删除多个视图。
|
||||
DROP VIEW [IF EXISTS] view_name ...
|
||||
-- 修改视图结构
|
||||
- 一般不修改视图，因为不是所有的更新视图都会映射到表上。
|
||||
ALTER VIEW view_name [(column_list)] AS select_statement
|
||||
-- 视图作用
|
||||
1. 简化业务逻辑
|
||||
2. 对客户端隐藏真实的表结构
|
||||
-- 视图算法(ALGORITHM)
|
||||
MERGE 合并
|
||||
将视图的查询语句，与外部查询需要先合并再执行！
|
||||
TEMPTABLE 临时表
|
||||
将视图执行完毕后，形成临时表，再做外层查询！
|
||||
UNDEFINED 未定义(默认)，指的是MySQL自主去选择相应的算法。
|
||||
```
|
||||
|
||||
### 事务(transaction)
|
||||
|
||||
```mysql
|
||||
事务是指逻辑上的一组操作，组成这组操作的各个单元，要不全成功要不全失败。
|
||||
- 支持连续SQL的集体成功或集体撤销。
|
||||
- 事务是数据库在数据完整性方面的一个功能。
|
||||
- 需要利用 InnoDB 或 BDB 存储引擎，对自动提交的特性支持完成。
|
||||
- InnoDB被称为事务安全型引擎。
|
||||
-- 事务开启
|
||||
START TRANSACTION; 或者 BEGIN;
|
||||
开启事务后，所有被执行的SQL语句均被认作当前事务内的SQL语句。
|
||||
-- 事务提交
|
||||
COMMIT;
|
||||
-- 事务回滚
|
||||
ROLLBACK;
|
||||
如果部分操作发生问题，映射到事务开启前。
|
||||
-- 事务的特性
|
||||
1. 原子性（Atomicity）
|
||||
事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
|
||||
2. 一致性（Consistency）
|
||||
事务前后数据的完整性必须保持一致。
|
||||
- 事务开始和结束时，外部数据一致
|
||||
- 在整个事务过程中，操作是连续的
|
||||
3. 隔离性（Isolation）
|
||||
多个用户并发访问数据库时，一个用户的事务不能被其它用户的事物所干扰，多个并发事务之间的数据要相互隔离。
|
||||
4. 持久性（Durability）
|
||||
一个事务一旦被提交，它对数据库中的数据改变就是永久性的。
|
||||
-- 事务的实现
|
||||
1. 要求是事务支持的表类型
|
||||
2. 执行一组相关的操作前开启事务
|
||||
3. 整组操作完成后，都成功，则提交；如果存在失败，选择回滚，则会回到事务开始的备份点。
|
||||
-- 事务的原理
|
||||
利用InnoDB的自动提交(autocommit)特性完成。
|
||||
普通的MySQL执行语句后，当前的数据提交操作均可被其他客户端可见。
|
||||
而事务是暂时关闭“自动提交”机制，需要commit提交持久化数据操作。
|
||||
-- 注意
|
||||
1. 数据定义语言（DDL）语句不能被回滚，比如创建或取消数据库的语句，和创建、取消或更改表或存储的子程序的语句。
|
||||
2. 事务不能被嵌套
|
||||
-- 保存点
|
||||
SAVEPOINT 保存点名称 -- 设置一个事务保存点
|
||||
ROLLBACK TO SAVEPOINT 保存点名称 -- 回滚到保存点
|
||||
RELEASE SAVEPOINT 保存点名称 -- 删除保存点
|
||||
-- InnoDB自动提交特性设置
|
||||
SET autocommit = 0|1; 0表示关闭自动提交，1表示开启自动提交。
|
||||
- 如果关闭了，那普通操作的结果对其他客户端也不可见，需要commit提交后才能持久化数据操作。
|
||||
- 也可以关闭自动提交来开启事务。但与START TRANSACTION不同的是，
|
||||
SET autocommit是永久改变服务器的设置，直到下次再次修改该设置。(针对当前连接)
|
||||
而START TRANSACTION记录开启前的状态，而一旦事务提交或回滚后就需要再次开启事务。(针对当前事务)
|
||||
|
||||
```
|
||||
|
||||
### 锁表
|
||||
|
||||
```mysql
|
||||
/* 锁表 */
|
||||
表锁定只用于防止其它客户端进行不正当地读取和写入
|
||||
MyISAM 支持表锁，InnoDB 支持行锁
|
||||
-- 锁定
|
||||
LOCK TABLES tbl_name [AS alias]
|
||||
-- 解锁
|
||||
UNLOCK TABLES
|
||||
```
|
||||
|
||||
### 触发器
|
||||
|
||||
```mysql
|
||||
/* 触发器 */ ------------------
|
||||
触发程序是与表有关的命名数据库对象，当该表出现特定事件时，将激活该对象
|
||||
监听：记录的增加、修改、删除。
|
||||
-- 创建触发器
|
||||
CREATE TRIGGER trigger_name trigger_time trigger_event ON tbl_name FOR EACH ROW trigger_stmt
|
||||
参数：
|
||||
trigger_time是触发程序的动作时间。它可以是 before 或 after，以指明触发程序是在激活它的语句之前或之后触发。
|
||||
trigger_event指明了激活触发程序的语句的类型
|
||||
INSERT：将新行插入表时激活触发程序
|
||||
UPDATE：更改某一行时激活触发程序
|
||||
DELETE：从表中删除某一行时激活触发程序
|
||||
tbl_name：监听的表，必须是永久性的表，不能将触发程序与TEMPORARY表或视图关联起来。
|
||||
trigger_stmt：当触发程序激活时执行的语句。执行多个语句，可使用BEGIN...END复合语句结构
|
||||
-- 删除
|
||||
DROP TRIGGER [schema_name.]trigger_name
|
||||
可以使用old和new代替旧的和新的数据
|
||||
更新操作，更新前是old，更新后是new.
|
||||
删除操作，只有old.
|
||||
增加操作，只有new.
|
||||
-- 注意
|
||||
1. 对于具有相同触发程序动作时间和事件的给定表，不能有两个触发程序。
|
||||
-- 字符连接函数
|
||||
concat(str1,str2,...])
|
||||
concat_ws(separator,str1,str2,...)
|
||||
-- 分支语句
|
||||
if 条件 then
|
||||
执行语句
|
||||
elseif 条件 then
|
||||
执行语句
|
||||
else
|
||||
执行语句
|
||||
end if;
|
||||
-- 修改最外层语句结束符
|
||||
delimiter 自定义结束符号
|
||||
SQL语句
|
||||
自定义结束符号
|
||||
delimiter ; -- 修改回原来的分号
|
||||
-- 语句块包裹
|
||||
begin
|
||||
语句块
|
||||
end
|
||||
-- 特殊的执行
|
||||
1. 只要添加记录，就会触发程序。
|
||||
2. Insert into on duplicate key update 语法会触发：
|
||||
如果没有重复记录，会触发 before insert, after insert;
|
||||
如果有重复记录并更新，会触发 before insert, before update, after update;
|
||||
如果有重复记录但是没有发生更新，则触发 before insert, before update
|
||||
3. Replace 语法 如果有记录，则执行 before insert, before delete, after delete, after insert
|
||||
```
|
||||
|
||||
### SQL编程
|
||||
|
||||
```mysql
|
||||
/* SQL编程 */ ------------------
|
||||
--// 局部变量 ----------
|
||||
-- 变量声明
|
||||
declare var_name[,...] type [default value]
|
||||
这个语句被用来声明局部变量。要给变量提供一个默认值，请包含一个default子句。值可以被指定为一个表达式，不需要为一个常数。如果没有default子句，初始值为null。
|
||||
-- 赋值
|
||||
使用 set 和 select into 语句为变量赋值。
|
||||
- 注意：在函数内是可以使用全局变量（用户自定义的变量）
|
||||
--// 全局变量 ----------
|
||||
-- 定义、赋值
|
||||
set 语句可以定义并为变量赋值。
|
||||
set @var = value;
|
||||
也可以使用select into语句为变量初始化并赋值。这样要求select语句只能返回一行，但是可以是多个字段，就意味着同时为多个变量进行赋值，变量的数量需要与查询的列数一致。
|
||||
还可以把赋值语句看作一个表达式，通过select执行完成。此时为了避免=被当作关系运算符看待，使用:=代替。（set语句可以使用= 和 :=）。
|
||||
select @var:=20;
|
||||
select @v1:=id, @v2=name from t1 limit 1;
|
||||
select * from tbl_name where @var:=30;
|
||||
select into 可以将表中查询获得的数据赋给变量。
|
||||
-| select max(height) into @max_height from tb;
|
||||
-- 自定义变量名
|
||||
为了避免select语句中，用户自定义的变量与系统标识符（通常是字段名）冲突，用户自定义变量在变量名前使用@作为开始符号。
|
||||
@var=10;
|
||||
- 变量被定义后，在整个会话周期都有效（登录到退出）
|
||||
--// 控制结构 ----------
|
||||
-- if语句
|
||||
if search_condition then
|
||||
statement_list
|
||||
[elseif search_condition then
|
||||
statement_list]
|
||||
...
|
||||
[else
|
||||
statement_list]
|
||||
end if;
|
||||
-- case语句
|
||||
CASE value WHEN [compare-value] THEN result
|
||||
[WHEN [compare-value] THEN result ...]
|
||||
[ELSE result]
|
||||
END
|
||||
-- while循环
|
||||
[begin_label:] while search_condition do
|
||||
statement_list
|
||||
end while [end_label];
|
||||
- 如果需要在循环内提前终止 while循环，则需要使用标签；标签需要成对出现。
|
||||
-- 退出循环
|
||||
退出整个循环 leave
|
||||
退出当前循环 iterate
|
||||
通过退出的标签决定退出哪个循环
|
||||
--// 内置函数 ----------
|
||||
-- 数值函数
|
||||
abs(x) -- 绝对值 abs(-10.9) = 10
|
||||
format(x, d) -- 格式化千分位数值 format(1234567.456, 2) = 1,234,567.46
|
||||
ceil(x) -- 向上取整 ceil(10.1) = 11
|
||||
floor(x) -- 向下取整 floor (10.1) = 10
|
||||
round(x) -- 四舍五入去整
|
||||
mod(m, n) -- m%n m mod n 求余 10%3=1
|
||||
pi() -- 获得圆周率
|
||||
pow(m, n) -- m^n
|
||||
sqrt(x) -- 算术平方根
|
||||
rand() -- 随机数
|
||||
truncate(x, d) -- 截取d位小数
|
||||
-- 时间日期函数
|
||||
now(), current_timestamp(); -- 当前日期时间
|
||||
current_date(); -- 当前日期
|
||||
current_time(); -- 当前时间
|
||||
date('yyyy-mm-dd hh:ii:ss'); -- 获取日期部分
|
||||
time('yyyy-mm-dd hh:ii:ss'); -- 获取时间部分
|
||||
date_format('yyyy-mm-dd hh:ii:ss', '%d %y %a %d %m %b %j'); -- 格式化时间
|
||||
unix_timestamp(); -- 获得unix时间戳
|
||||
from_unixtime(); -- 从时间戳获得时间
|
||||
-- 字符串函数
|
||||
length(string) -- string长度，字节
|
||||
char_length(string) -- string的字符个数
|
||||
substring(str, position [,length]) -- 从str的position开始,取length个字符
|
||||
replace(str ,search_str ,replace_str) -- 在str中用replace_str替换search_str
|
||||
instr(string ,substring) -- 返回substring首次在string中出现的位置
|
||||
concat(string [,...]) -- 连接字串
|
||||
charset(str) -- 返回字串字符集
|
||||
lcase(string) -- 转换成小写
|
||||
left(string, length) -- 从string2中的左边起取length个字符
|
||||
load_file(file_name) -- 从文件读取内容
|
||||
locate(substring, string [,start_position]) -- 同instr,但可指定开始位置
|
||||
lpad(string, length, pad) -- 重复用pad加在string开头,直到字串长度为length
|
||||
ltrim(string) -- 去除前端空格
|
||||
repeat(string, count) -- 重复count次
|
||||
rpad(string, length, pad) --在str后用pad补充,直到长度为length
|
||||
rtrim(string) -- 去除后端空格
|
||||
strcmp(string1 ,string2) -- 逐字符比较两字串大小
|
||||
-- 流程函数
|
||||
case when [condition] then result [when [condition] then result ...] [else result] end 多分支
|
||||
if(expr1,expr2,expr3) 双分支。
|
||||
-- 聚合函数
|
||||
count()
|
||||
sum();
|
||||
max();
|
||||
min();
|
||||
avg();
|
||||
group_concat()
|
||||
-- 其他常用函数
|
||||
md5();
|
||||
default();
|
||||
--// 存储函数，自定义函数 ----------
|
||||
-- 新建
|
||||
CREATE FUNCTION function_name (参数列表) RETURNS 返回值类型
|
||||
函数体
|
||||
- 函数名，应该合法的标识符，并且不应该与已有的关键字冲突。
|
||||
- 一个函数应该属于某个数据库，可以使用db_name.funciton_name的形式执行当前函数所属数据库，否则为当前数据库。
|
||||
- 参数部分，由"参数名"和"参数类型"组成。多个参数用逗号隔开。
|
||||
- 函数体由多条可用的mysql语句，流程控制，变量声明等语句构成。
|
||||
- 多条语句应该使用 begin...end 语句块包含。
|
||||
- 一定要有 return 返回值语句。
|
||||
-- 删除
|
||||
DROP FUNCTION [IF EXISTS] function_name;
|
||||
-- 查看
|
||||
SHOW FUNCTION STATUS LIKE 'partten'
|
||||
SHOW CREATE FUNCTION function_name;
|
||||
-- 修改
|
||||
ALTER FUNCTION function_name 函数选项
|
||||
--// 存储过程，自定义功能 ----------
|
||||
-- 定义
|
||||
存储存储过程 是一段代码（过程），存储在数据库中的sql组成。
|
||||
一个存储过程通常用于完成一段业务逻辑，例如报名，交班费，订单入库等。
|
||||
而一个函数通常专注与某个功能，视为其他程序服务的，需要在其他语句中调用函数才可以，而存储过程不能被其他调用，是自己执行 通过call执行。
|
||||
-- 创建
|
||||
CREATE PROCEDURE sp_name (参数列表)
|
||||
过程体
|
||||
参数列表：不同于函数的参数列表，需要指明参数类型
|
||||
IN，表示输入型
|
||||
OUT，表示输出型
|
||||
INOUT，表示混合型
|
||||
注意，没有返回值。
|
||||
```
|
||||
|
||||
### 存储过程
|
||||
|
||||
```mysql
|
||||
/* 存储过程 */ ------------------
|
||||
存储过程是一段可执行性代码的集合。相比函数，更偏向于业务逻辑。
|
||||
调用：CALL 过程名
|
||||
-- 注意
|
||||
- 没有返回值。
|
||||
- 只能单独调用，不可夹杂在其他语句中
|
||||
-- 参数
|
||||
IN|OUT|INOUT 参数名 数据类型
|
||||
IN 输入：在调用过程中，将数据输入到过程体内部的参数
|
||||
OUT 输出：在调用过程中，将过程体处理完的结果返回到客户端
|
||||
INOUT 输入输出：既可输入，也可输出
|
||||
-- 语法
|
||||
CREATE PROCEDURE 过程名 (参数列表)
|
||||
BEGIN
|
||||
过程体
|
||||
END
|
||||
```
|
||||
|
||||
### 用户和权限管理
|
||||
|
||||
```mysql
|
||||
/* 用户和权限管理 */ ------------------
|
||||
-- root密码重置
|
||||
1. 停止MySQL服务
|
||||
2. [Linux] /usr/local/mysql/bin/safe_mysqld --skip-grant-tables &
|
||||
[Windows] mysqld --skip-grant-tables
|
||||
3. use mysql;
|
||||
4. UPDATE `user` SET PASSWORD=PASSWORD("密码") WHERE `user` = "root";
|
||||
5. FLUSH PRIVILEGES;
|
||||
用户信息表：mysql.user
|
||||
-- 刷新权限
|
||||
FLUSH PRIVILEGES;
|
||||
-- 增加用户
|
||||
CREATE USER 用户名 IDENTIFIED BY [PASSWORD] 密码(字符串)
|
||||
- 必须拥有mysql数据库的全局CREATE USER权限，或拥有INSERT权限。
|
||||
- 只能创建用户，不能赋予权限。
|
||||
- 用户名，注意引号：如 'user_name'@'192.168.1.1'
|
||||
- 密码也需引号，纯数字密码也要加引号
|
||||
- 要在纯文本中指定密码，需忽略PASSWORD关键词。要把密码指定为由PASSWORD()函数返回的混编值，需包含关键字PASSWORD
|
||||
-- 重命名用户
|
||||
RENAME USER old_user TO new_user
|
||||
-- 设置密码
|
||||
SET PASSWORD = PASSWORD('密码') -- 为当前用户设置密码
|
||||
SET PASSWORD FOR 用户名 = PASSWORD('密码') -- 为指定用户设置密码
|
||||
-- 删除用户
|
||||
DROP USER 用户名
|
||||
-- 分配权限/添加用户
|
||||
GRANT 权限列表 ON 表名 TO 用户名 [IDENTIFIED BY [PASSWORD] 'password']
|
||||
- all privileges 表示所有权限
|
||||
- *.* 表示所有库的所有表
|
||||
- 库名.表名 表示某库下面的某表
|
||||
GRANT ALL PRIVILEGES ON `pms`.* TO 'pms'@'%' IDENTIFIED BY 'pms0817';
|
||||
-- 查看权限
|
||||
SHOW GRANTS FOR 用户名
|
||||
-- 查看当前用户权限
|
||||
SHOW GRANTS; 或 SHOW GRANTS FOR CURRENT_USER; 或 SHOW GRANTS FOR CURRENT_USER();
|
||||
-- 撤消权限
|
||||
REVOKE 权限列表 ON 表名 FROM 用户名
|
||||
REVOKE ALL PRIVILEGES, GRANT OPTION FROM 用户名 -- 撤销所有权限
|
||||
-- 权限层级
|
||||
-- 要使用GRANT或REVOKE，您必须拥有GRANT OPTION权限，并且您必须用于您正在授予或撤销的权限。
|
||||
全局层级：全局权限适用于一个给定服务器中的所有数据库，mysql.user
|
||||
GRANT ALL ON *.*和 REVOKE ALL ON *.*只授予和撤销全局权限。
|
||||
数据库层级：数据库权限适用于一个给定数据库中的所有目标，mysql.db, mysql.host
|
||||
GRANT ALL ON db_name.*和REVOKE ALL ON db_name.*只授予和撤销数据库权限。
|
||||
表层级：表权限适用于一个给定表中的所有列，mysql.talbes_priv
|
||||
GRANT ALL ON db_name.tbl_name和REVOKE ALL ON db_name.tbl_name只授予和撤销表权限。
|
||||
列层级：列权限适用于一个给定表中的单一列，mysql.columns_priv
|
||||
当使用REVOKE时，您必须指定与被授权列相同的列。
|
||||
-- 权限列表
|
||||
ALL [PRIVILEGES] -- 设置除GRANT OPTION之外的所有简单权限
|
||||
ALTER -- 允许使用ALTER TABLE
|
||||
ALTER ROUTINE -- 更改或取消已存储的子程序
|
||||
CREATE -- 允许使用CREATE TABLE
|
||||
CREATE ROUTINE -- 创建已存储的子程序
|
||||
CREATE TEMPORARY TABLES -- 允许使用CREATE TEMPORARY TABLE
|
||||
CREATE USER -- 允许使用CREATE USER, DROP USER, RENAME USER和REVOKE ALL PRIVILEGES。
|
||||
CREATE VIEW -- 允许使用CREATE VIEW
|
||||
DELETE -- 允许使用DELETE
|
||||
DROP -- 允许使用DROP TABLE
|
||||
EXECUTE -- 允许用户运行已存储的子程序
|
||||
FILE -- 允许使用SELECT...INTO OUTFILE和LOAD DATA INFILE
|
||||
INDEX -- 允许使用CREATE INDEX和DROP INDEX
|
||||
INSERT -- 允许使用INSERT
|
||||
LOCK TABLES -- 允许对您拥有SELECT权限的表使用LOCK TABLES
|
||||
PROCESS -- 允许使用SHOW FULL PROCESSLIST
|
||||
REFERENCES -- 未被实施
|
||||
RELOAD -- 允许使用FLUSH
|
||||
REPLICATION CLIENT -- 允许用户询问从属服务器或主服务器的地址
|
||||
REPLICATION SLAVE -- 用于复制型从属服务器（从主服务器中读取二进制日志事件）
|
||||
SELECT -- 允许使用SELECT
|
||||
SHOW DATABASES -- 显示所有数据库
|
||||
SHOW VIEW -- 允许使用SHOW CREATE VIEW
|
||||
SHUTDOWN -- 允许使用mysqladmin shutdown
|
||||
SUPER -- 允许使用CHANGE MASTER, KILL, PURGE MASTER LOGS和SET GLOBAL语句，mysqladmin debug命令；允许您连接（一次），即使已达到max_connections。
|
||||
UPDATE -- 允许使用UPDATE
|
||||
USAGE -- “无权限”的同义词
|
||||
GRANT OPTION -- 允许授予权限
|
||||
```
|
||||
|
||||
### 表维护
|
||||
|
||||
```mysql
|
||||
/* 表维护 */
|
||||
-- 分析和存储表的关键字分布
|
||||
ANALYZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE 表名 ...
|
||||
-- 检查一个或多个表是否有错误
|
||||
CHECK TABLE tbl_name [, tbl_name] ... [option] ...
|
||||
option = {QUICK | FAST | MEDIUM | EXTENDED | CHANGED}
|
||||
-- 整理数据文件的碎片
|
||||
OPTIMIZE [LOCAL | NO_WRITE_TO_BINLOG] TABLE tbl_name [, tbl_name] ...
|
||||
```
|
||||
|
||||
### 杂项
|
||||
|
||||
```mysql
|
||||
/* 杂项 */ ------------------
|
||||
1. 可用反引号（`）为标识符（库名、表名、字段名、索引、别名）包裹，以避免与关键字重名！中文也可以作为标识符！
|
||||
2. 每个库目录存在一个保存当前数据库的选项文件db.opt。
|
||||
3. 注释：
|
||||
单行注释 # 注释内容
|
||||
多行注释 /* 注释内容 */
|
||||
单行注释 -- 注释内容 (标准SQL注释风格，要求双破折号后加一空格符（空格、TAB、换行等）)
|
||||
4. 模式通配符：
|
||||
_ 任意单个字符
|
||||
% 任意多个字符，甚至包括零字符
|
||||
单引号需要进行转义 \'
|
||||
5. CMD命令行内的语句结束符可以为 ";", "\G", "\g"，仅影响显示结果。其他地方还是用分号结束。delimiter 可修改当前对话的语句结束符。
|
||||
6. SQL对大小写不敏感
|
||||
7. 清除已有语句：\c
|
||||
```
|
||||
|
||||
149
docs/database/一条sql语句在mysql中如何执行的.md
Normal file
149
docs/database/一条sql语句在mysql中如何执行的.md
Normal file
@ -0,0 +1,149 @@
|
||||
本文来自[木木匠](https://github.com/kinglaw1204)投稿。
|
||||
|
||||
<!-- TOC -->
|
||||
|
||||
- [一 MySQL 基础架构分析](#一-mysql-基础架构分析)
|
||||
- [1.1 MySQL 基本架构概览](#11-mysql-基本架构概览)
|
||||
- [1.2 Server 层基本组件介绍](#12-server-层基本组件介绍)
|
||||
- [1) 连接器](#1-连接器)
|
||||
- [2) 查询缓存(MySQL 8.0 版本后移除)](#2-查询缓存mysql-80-版本后移除)
|
||||
- [3) 分析器](#3-分析器)
|
||||
- [4) 优化器](#4-优化器)
|
||||
- [5) 执行器](#5-执行器)
|
||||
- [二 语句分析](#二-语句分析)
|
||||
- [2.1 查询语句](#21-查询语句)
|
||||
- [2.2 更新语句](#22-更新语句)
|
||||
- [三 总结](#三-总结)
|
||||
- [四 参考](#四-参考)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
本篇文章会分析下一个 sql 语句在 MySQL 中的执行流程，包括 sql 的查询在 MySQL 内部会怎么流转，sql 语句的更新是怎么完成的。
|
||||
|
||||
在分析之前我会先带着你看看 MySQL 的基础架构，知道了 MySQL 由那些组件组成已经这些组件的作用是什么，可以帮助我们理解和解决这些问题。
|
||||
|
||||
## 一 MySQL 基础架构分析
|
||||
|
||||
### 1.1 MySQL 基本架构概览
|
||||
|
||||
下图是 MySQL 的一个简要架构图，从下图你可以很清晰的看到用户的 SQL 语句在 MySQL 内部是如何执行的。
|
||||
|
||||
先简单介绍一下下图涉及的一些组件的基本作用帮助大家理解这幅图，在 1.2 节中会详细介绍到这些组件的作用。
|
||||
|
||||
- **连接器：** 身份认证和权限相关(登录 MySQL 的时候)。
|
||||
- **查询缓存:** 执行查询语句的时候，会先查询缓存（MySQL 8.0 版本后移除，因为这个功能不太实用）。
|
||||
- **分析器:** 没有命中缓存的话，SQL 语句就会经过分析器，分析器说白了就是要先看你的 SQL 语句要干嘛，再检查你的 SQL 语句语法是否正确。
|
||||
- **优化器：** 按照 MySQL 认为最优的方案去执行。
|
||||
- **执行器:** 执行语句，然后从存储引擎返回数据。
|
||||
|
||||
|
||||
|
||||
简单来说 MySQL 主要分为 Server 层和存储引擎层：
|
||||
|
||||
- **Server 层**：主要包括连接器、查询缓存、分析器、优化器、执行器等，所有跨存储引擎的功能都在这一层实现，比如存储过程、触发器、视图，函数等，还有一个通用的日志模块 binglog 日志模块。
|
||||
- **存储引擎**： 主要负责数据的存储和读取，采用可以替换的插件式架构，支持 InnoDB、MyISAM、Memory 等多个存储引擎，其中 InnoDB 引擎有自有的日志模块 redolog 模块。**现在最常用的存储引擎是 InnoDB，它从 MySQL 5.5.5 版本开始就被当做默认存储引擎了。**
|
||||
|
||||
### 1.2 Server 层基本组件介绍
|
||||
|
||||
#### 1) 连接器
|
||||
|
||||
连接器主要和身份认证和权限相关的功能相关，就好比一个级别很高的门卫一样。
|
||||
|
||||
主要负责用户登录数据库，进行用户的身份认证，包括校验账户密码，权限等操作，如果用户账户密码已通过，连接器会到权限表中查询该用户的所有权限，之后在这个连接里的权限逻辑判断都是会依赖此时读取到的权限数据，也就是说，后续只要这个连接不断开，即时管理员修改了该用户的权限，该用户也是不受影响的。
|
||||
|
||||
#### 2) 查询缓存(MySQL 8.0 版本后移除)
|
||||
|
||||
查询缓存主要用来缓存我们所执行的 SELECT 语句以及该语句的结果集。
|
||||
|
||||
连接建立后，执行查询语句的时候，会先查询缓存，MySQL 会先校验这个 sql 是否执行过，以 Key-Value 的形式缓存在内存中，Key 是查询预计，Value 是结果集。如果缓存 key 被命中，就会直接返回给客户端，如果没有命中，就会执行后续的操作，完成后也会把结果缓存起来，方便下一次调用。当然在真正执行缓存查询的时候还是会校验用户的权限，是否有该表的查询条件。
|
||||
|
||||
MySQL 查询不建议使用缓存，因为查询缓存失效在实际业务场景中可能会非常频繁，假如你对一个表更新的话，这个表上的所有的查询缓存都会被清空。对于不经常更新的数据来说，使用缓存还是可以的。
|
||||
|
||||
所以，一般在大多数情况下我们都是不推荐去使用查询缓存的。
|
||||
|
||||
MySQL 8.0 版本后删除了缓存的功能，官方也是认为该功能在实际的应用场景比较少，所以干脆直接删掉了。
|
||||
|
||||
#### 3) 分析器
|
||||
|
||||
MySQL 没有命中缓存，那么就会进入分析器，分析器主要是用来分析 SQL 语句是来干嘛的，分析器也会分为几步：
|
||||
|
||||
**第一步，词法分析**，一条 SQL 语句有多个字符串组成，首先要提取关键字，比如 select，提出查询的表，提出字段名，提出查询条件等等。做完这些操作后，就会进入第二步。
|
||||
|
||||
**第二步，语法分析**，主要就是判断你输入的 sql 是否正确，是否符合 MySQL 的语法。
|
||||
|
||||
完成这 2 步之后，MySQL 就准备开始执行了，但是如何执行，怎么执行是最好的结果呢？这个时候就需要优化器上场了。
|
||||
|
||||
#### 4) 优化器
|
||||
|
||||
优化器的作用就是它认为的最优的执行方案去执行（有时候可能也不是最优，这篇文章涉及对这部分知识的深入讲解），比如多个索引的时候该如何选择索引，多表查询的时候如何选择关联顺序等。
|
||||
|
||||
可以说，经过了优化器之后可以说这个语句具体该如何执行就已经定下来。
|
||||
|
||||
#### 5) 执行器
|
||||
|
||||
当选择了执行方案后，MySQL 就准备开始执行了，首先执行前会校验该用户有没有权限，如果没有权限，就会返回错误信息，如果有权限，就会去调用引擎的接口，返回接口执行的结果。
|
||||
|
||||
## 二 语句分析
|
||||
|
||||
### 2.1 查询语句
|
||||
|
||||
说了以上这么多，那么究竟一条 sql 语句是如何执行的呢？其实我们的 sql 可以分为两种，一种是查询，一种是更新（增加，更新，删除）。我们先分析下查询语句，语句如下：
|
||||
|
||||
```sql
|
||||
select * from tb_student A where A.age='18' and A.name=' 张三 ';
|
||||
```
|
||||
|
||||
结合上面的说明，我们分析下这个语句的执行流程：
|
||||
|
||||
* 先检查该语句是否有权限，如果没有权限，直接返回错误信息，如果有权限，在 MySQL8.0 版本以前，会先查询缓存，以这条 sql 语句为 key 在内存中查询是否有结果，如果有直接缓存，如果没有，执行下一步。
|
||||
* 通过分析器进行词法分析，提取 sql 语句的关键元素，比如提取上面这个语句是查询 select，提取需要查询的表名为 tb_student,需要查询所有的列，查询条件是这个表的 id='1'。然后判断这个 sql 语句是否有语法错误，比如关键词是否正确等等，如果检查没问题就执行下一步。
|
||||
* 接下来就是优化器进行确定执行方案，上面的 sql 语句，可以有两种执行方案：
|
||||
|
||||
a.先查询学生表中姓名为“张三”的学生，然后判断是否年龄是 18。
|
||||
b.先找出学生中年龄 18 岁的学生，然后再查询姓名为“张三”的学生。
|
||||
那么优化器根据自己的优化算法进行选择执行效率最好的一个方案（优化器认为，有时候不一定最好）。那么确认了执行计划后就准备开始执行了。
|
||||
|
||||
* 进行权限校验，如果没有权限就会返回错误信息，如果有权限就会调用数据库引擎接口，返回引擎的执行结果。
|
||||
|
||||
### 2.2 更新语句
|
||||
|
||||
以上就是一条查询 sql 的执行流程，那么接下来我们看看一条更新语句如何执行的呢？sql 语句如下：
|
||||
|
||||
```
|
||||
update tb_student A set A.age='19' where A.name=' 张三 ';
|
||||
```
|
||||
我们来给张三修改下年龄，在实际数据库肯定不会设置年龄这个字段的，不然要被技术负责人打的。其实条语句也基本上会沿着上一个查询的流程走，只不过执行更新的时候肯定要记录日志啦，这就会引入日志模块了，MySQL 自带的日志模块式 **binlog（归档日志）** ，所有的存储引擎都可以使用，我们常用的 InnoDB 引擎还自带了一个日志模块 **redo log（重做日志）**，我们就以 InnoDB 模式下来探讨这个语句的执行流程。流程如下：
|
||||
|
||||
* 先查询到张三这一条数据，如果有缓存，也是会用到缓存。
|
||||
* 然后拿到查询的语句，把 age 改为 19，然后调用引擎 API 接口，写入这一行数据，InnoDB 引擎把数据保存在内存中，同时记录 redo log，此时 redo log 进入 prepare 状态，然后告诉执行器，执行完成了，随时可以提交。
|
||||
* 执行器收到通知后记录 binlog，然后调用引擎接口，提交 redo log 为提交状态。
|
||||
* 更新完成。
|
||||
|
||||
**这里肯定有同学会问，为什么要用两个日志模块，用一个日志模块不行吗?**
|
||||
|
||||
这是因为最开始 MySQL 并没与 InnoDB 引擎( InnoDB 引擎是其他公司以插件形式插入 MySQL 的) ，MySQL 自带的引擎是 MyISAM，但是我们知道 redo log 是 InnoDB 引擎特有的，其他存储引擎都没有，这就导致会没有 crash-safe 的能力(crash-safe 的能力即使数据库发生异常重启，之前提交的记录都不会丢失)，binlog 日志只能用来归档。
|
||||
|
||||
并不是说只用一个日志模块不可以，只是 InnoDB 引擎就是通过 redo log 来支持事务的。那么，又会有同学问，我用两个日志模块，但是不要这么复杂行不行，为什么 redo log 要引入 prepare 预提交状态？这里我们用反证法来说明下为什么要这么做？
|
||||
|
||||
* **先写 redo log 直接提交，然后写 binlog**，假设写完 redo log 后，机器挂了，binlog 日志没有被写入，那么机器重启后，这台机器会通过 redo log 恢复数据，但是这个时候 bingog 并没有记录该数据，后续进行机器备份的时候，就会丢失这一条数据，同时主从同步也会丢失这一条数据。
|
||||
* **先写 binlog，然后写 redo log**，假设写完了 binlog，机器异常重启了，由于没有 redo log，本机是无法恢复这一条记录的，但是 binlog 又有记录，那么和上面同样的道理，就会产生数据不一致的情况。
|
||||
|
||||
如果采用 redo log 两阶段提交的方式就不一样了，写完 binglog 后，然后再提交 redo log 就会防止出现上述的问题，从而保证了数据的一致性。那么问题来了，有没有一个极端的情况呢？假设 redo log 处于预提交状态，binglog 也已经写完了，这个时候发生了异常重启会怎么样呢？
|
||||
这个就要依赖于 MySQL 的处理机制了，MySQL 的处理过程如下：
|
||||
|
||||
* 判断 redo log 是否完整，如果判断是完整的，就立即提交。
|
||||
* 如果 redo log 只是预提交但不是 commit 状态，这个时候就会去判断 binlog 是否完整，如果完整就提交 redo log, 不完整就回滚事务。
|
||||
|
||||
这样就解决了数据一致性的问题。
|
||||
|
||||
## 三 总结
|
||||
|
||||
* MySQL 主要分为 Server 层和引擎层，Server 层主要包括连接器、查询缓存、分析器、优化器、执行器，同时还有一个日志模块（binlog），这个日志模块所有执行引擎都可以共用,redolog 只有 InnoDB 有。
|
||||
* 引擎层是插件式的，目前主要包括，MyISAM,InnoDB,Memory 等。
|
||||
* 查询语句的执行流程如下：权限校验（如果命中缓存）---》查询缓存---》分析器---》优化器---》权限校验---》执行器---》引擎
|
||||
* 更新语句执行流程如下：分析器----》权限校验----》执行器---》引擎---redo log(prepare 状态---》binlog---》redo log(commit状态)
|
||||
|
||||
## 四 参考
|
||||
|
||||
* 《MySQL 实战45讲》
|
||||
* MySQL 5.6参考手册:<https://dev.MySQL.com/doc/refman/5.6/en/>
|
||||
148
docs/database/事务隔离级别(图文详解).md
Normal file
148
docs/database/事务隔离级别(图文详解).md
Normal file
@ -0,0 +1,148 @@
|
||||
> 本文由 [SnailClimb](https://github.com/Snailclimb) 和 [BugSpeak](https://github.com/BugSpeak) 共同完成。
|
||||
<!-- TOC -->
|
||||
|
||||
- [事务隔离级别(图文详解)](#事务隔离级别图文详解)
|
||||
- [什么是事务?](#什么是事务)
|
||||
- [事务的特性(ACID)](#事务的特性acid)
|
||||
- [并发事务带来的问题](#并发事务带来的问题)
|
||||
- [事务隔离级别](#事务隔离级别)
|
||||
- [实际情况演示](#实际情况演示)
|
||||
- [脏读(读未提交)](#脏读读未提交)
|
||||
- [避免脏读(读已提交)](#避免脏读读已提交)
|
||||
- [不可重复读](#不可重复读)
|
||||
- [可重复读](#可重复读)
|
||||
- [防止幻读(可重复读)](#防止幻读可重复读)
|
||||
- [参考](#参考)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
## 事务隔离级别(图文详解)
|
||||
|
||||
### 什么是事务?
|
||||
|
||||
事务是逻辑上的一组操作，要么都执行，要么都不执行。
|
||||
|
||||
事务最经典也经常被拿出来说例子就是转账了。假如小明要给小红转账1000元，这个转账会涉及到两个关键操作就是：将小明的余额减少1000元，将小红的余额增加1000元。万一在这两个操作之间突然出现错误比如银行系统崩溃，导致小明余额减少而小红的余额没有增加，这样就不对了。事务就是保证这两个关键操作要么都成功，要么都要失败。
|
||||
|
||||
### 事务的特性(ACID)
|
||||
|
||||
|
||||
|
||||
|
||||
1. **原子性：** 事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用；
|
||||
2. **一致性：** 执行事务前后，数据保持一致，例如转账业务中，无论事务是否成功，转账者和收款人的总额应该是不变的；
|
||||
3. **隔离性：** 并发访问数据库时，一个用户的事务不被其他事务所干扰，各并发事务之间数据库是独立的；
|
||||
4. **持久性：** 一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。
|
||||
|
||||
### 并发事务带来的问题
|
||||
|
||||
在典型的应用程序中，多个事务并发运行，经常会操作相同的数据来完成各自的任务（多个用户对统一数据进行操作）。并发虽然是必须的，但可能会导致以下的问题。
|
||||
|
||||
- **脏读（Dirty read）:** 当一个事务正在访问数据并且对数据进行了修改，而这种修改还没有提交到数据库中，这时另外一个事务也访问了这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另外一个事务读到的这个数据是“脏数据”，依据“脏数据”所做的操作可能是不正确的。
|
||||
- **丢失修改（Lost to modify）:** 指在一个事务读取一个数据时，另外一个事务也访问了该数据，那么在第一个事务中修改了这个数据后，第二个事务也修改了这个数据。这样第一个事务内的修改结果就被丢失，因此称为丢失修改。 例如：事务1读取某表中的数据A=20，事务2也读取A=20，事务1修改A=A-1，事务2也修改A=A-1，最终结果A=19，事务1的修改被丢失。
|
||||
- **不可重复读（Unrepeatableread）:** 指在一个事务内多次读同一数据。在这个事务还没有结束时，另一个事务也访问该数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改导致第一个事务两次读取的数据可能不太一样。这就发生了在一个事务内两次读到的数据是不一样的情况，因此称为不可重复读。
|
||||
- **幻读（Phantom read）:** 幻读与不可重复读类似。它发生在一个事务（T1）读取了几行数据，接着另一个并发事务（T2）插入了一些数据时。在随后的查询中，第一个事务（T1）就会发现多了一些原本不存在的记录，就好像发生了幻觉一样，所以称为幻读。
|
||||
|
||||
**不可重复度和幻读区别：**
|
||||
|
||||
不可重复读的重点是修改，幻读的重点在于新增或者删除。
|
||||
|
||||
例1（同样的条件, 你读取过的数据, 再次读取出来发现值不一样了 ）：事务1中的A先生读取自己的工资为 1000的操作还没完成，事务2中的B先生就修改了A的工资为2000，导 致A再读自己的工资时工资变为 2000；这就是不可重复读。
|
||||
|
||||
例2（同样的条件, 第1次和第2次读出来的记录数不一样 ）：假某工资单表中工资大于3000的有4人，事务1读取了所有工资大于3000的人，共查到4条记录，这时事务2 又插入了一条工资大于3000的记录，事务1再次读取时查到的记录就变为了5条，这样就导致了幻读。
|
||||
|
||||
### 事务隔离级别
|
||||
|
||||
**SQL 标准定义了四个隔离级别：**
|
||||
|
||||
- **READ-UNCOMMITTED(读取未提交)：** 最低的隔离级别，允许读取尚未提交的数据变更，**可能会导致脏读、幻读或不可重复读**。
|
||||
- **READ-COMMITTED(读取已提交)：** 允许读取并发事务已经提交的数据，**可以阻止脏读，但是幻读或不可重复读仍有可能发生**。
|
||||
- **REPEATABLE-READ(可重复读)：** 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，**可以阻止脏读和不可重复读，但幻读仍有可能发生**。
|
||||
- **SERIALIZABLE(可串行化)：** 最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，**该级别可以防止脏读、不可重复读以及幻读**。
|
||||
|
||||
----
|
||||
|
||||
| 隔离级别 | 脏读 | 不可重复读 | 幻影读 |
|
||||
| :---: | :---: | :---:| :---: |
|
||||
| READ-UNCOMMITTED | √ | √ | √ |
|
||||
| READ-COMMITTED | × | √ | √ |
|
||||
| REPEATABLE-READ | × | × | √ |
|
||||
| SERIALIZABLE | × | × | × |
|
||||
|
||||
MySQL InnoDB 存储引擎的默认支持的隔离级别是 **REPEATABLE-READ（可重读）**。我们可以通过`SELECT @@tx_isolation;`命令来查看,MySQL 8.0 该命令改为`SELECT @@transaction_isolation;`
|
||||
|
||||
```sql
|
||||
mysql> SELECT @@tx_isolation;
|
||||
+-----------------+
|
||||
| @@tx_isolation |
|
||||
+-----------------+
|
||||
| REPEATABLE-READ |
|
||||
+-----------------+
|
||||
```
|
||||
|
||||
这里需要注意的是：与 SQL 标准不同的地方在于InnoDB 存储引擎在 **REPEATABLE-READ（可重读）**事务隔离级别下使用的是Next-Key Lock 锁算法，因此可以避免幻读的产生，这与其他数据库系统(如 SQL Server)是不同的。所以说InnoDB 存储引擎的默认支持的隔离级别是 **REPEATABLE-READ（可重读）** 已经可以完全保证事务的隔离性要求，即达到了 SQL标准的**SERIALIZABLE(可串行化)**隔离级别。
|
||||
|
||||
因为隔离级别越低，事务请求的锁越少，所以大部分数据库系统的隔离级别都是**READ-COMMITTED(读取提交内容):**，但是你要知道的是InnoDB 存储引擎默认使用 **REPEATABLE-READ（可重读）**并不会有任何性能损失。
|
||||
|
||||
InnoDB 存储引擎在 **分布式事务** 的情况下一般会用到**SERIALIZABLE(可串行化)**隔离级别。
|
||||
|
||||
### 实际情况演示
|
||||
|
||||
在下面我会使用 2 个命令行mysql ，模拟多线程（多事务）对同一份数据的脏读问题。
|
||||
|
||||
MySQL 命令行的默认配置中事务都是自动提交的，即执行SQL语句后就会马上执行 COMMIT 操作。如果要显式地开启一个事务需要使用命令：`START TARNSACTION`。
|
||||
|
||||
我们可以通过下面的命令来设置隔离级别。
|
||||
|
||||
```sql
|
||||
SET [SESSION|GLOBAL] TRANSACTION ISOLATION LEVEL [READ UNCOMMITTED|READ COMMITTED|REPEATABLE READ|SERIALIZABLE]
|
||||
```
|
||||
|
||||
我们再来看一下我们在下面实际操作中使用到的一些并发控制语句:
|
||||
|
||||
- `START TARNSACTION` |`BEGIN`：显式地开启一个事务。
|
||||
- `COMMIT`：提交事务，使得对数据库做的所有修改成为永久性。
|
||||
- `ROLLBACK`：回滚会结束用户的事务，并撤销正在进行的所有未提交的修改。
|
||||
|
||||
#### 脏读(读未提交)
|
||||
|
||||
<div align="center">
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-31-1脏读(读未提交)实例.jpg" width="800px"/>
|
||||
</div>
|
||||
|
||||
#### 避免脏读(读已提交)
|
||||
|
||||
<div align="center">
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-31-2读已提交实例.jpg" width="800px"/>
|
||||
</div>
|
||||
|
||||
#### 不可重复读
|
||||
|
||||
还是刚才上面的读已提交的图，虽然避免了读未提交，但是却出现了，一个事务还没有结束，就发生了 不可重复读问题。
|
||||
|
||||
<div align="center">
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-32-1不可重复读实例.jpg"/>
|
||||
</div>
|
||||
|
||||
#### 可重复读
|
||||
|
||||
<div align="center">
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-33-2可重复读.jpg"/>
|
||||
</div>
|
||||
|
||||
#### 防止幻读(可重复读)
|
||||
|
||||
<div align="center">
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-33防止幻读(使用可重复读).jpg"/>
|
||||
</div>
|
||||
|
||||
一个事务对数据库进行操作，这种操作的范围是数据库的全部行，然后第二个事务也在对这个数据库操作，这种操作可以是插入一行记录或删除一行记录，那么第一个是事务就会觉得自己出现了幻觉，怎么还有没有处理的记录呢? 或者 怎么多处理了一行记录呢?
|
||||
|
||||
幻读和不可重复读有些相似之处 ，但是不可重复读的重点是修改，幻读的重点在于新增或者删除。
|
||||
|
||||
### 参考
|
||||
|
||||
- 《MySQL技术内幕：InnoDB存储引擎》
|
||||
- <https://dev.mysql.com/doc/refman/5.7/en/>
|
||||
- [Mysql 锁：灵魂七拷问](https://tech.youzan.com/seven-questions-about-the-lock-of-mysql/)
|
||||
- [Innodb 中的事务隔离级别和锁的关系](https://tech.meituan.com/2014/08/20/innodb-lock.html)
|
||||
21
docs/database/数据库连接池.md
Normal file
21
docs/database/数据库连接池.md
Normal file
@ -0,0 +1,21 @@
|
||||
- 公众号和Github待发文章：[数据库：数据库连接池原理详解与自定义连接池实现](https://www.fangzhipeng.com/javainterview/2019/07/15/mysql-connector-pool.html)
|
||||
- [基于JDBC的数据库连接池技术研究与应用](http://blog.itpub.net/9403012/viewspace-111794/)
|
||||
- [数据库连接池技术详解](https://juejin.im/post/5b7944c6e51d4538c86cf195)
|
||||
|
||||
数据库连接本质就是一个 socket 的连接。数据库服务端还要维护一些缓存和用户权限信息之类的 所以占用了一些内存
|
||||
|
||||
连接池是维护的数据库连接的缓存，以便将来需要对数据库的请求时可以重用这些连接。为每个用户打开和维护数据库连接，尤其是对动态数据库驱动的网站应用程序的请求，既昂贵又浪费资源。**在连接池中，创建连接后，将其放置在池中，并再次使用它，因此不必建立新的连接。如果使用了所有连接，则会建立一个新连接并将其添加到池中。**连接池还减少了用户必须等待建立与数据库的连接的时间。
|
||||
|
||||
操作过数据库的朋友应该都知道数据库连接池这个概念，它几乎每天都在和我们打交道，但是你真的了解 **数据库连接池** 吗？
|
||||
|
||||
### 没有数据库连接池之前
|
||||
|
||||
我相信你一定听过这样一句话：**Java语言中，JDBC（Java DataBase Connection）是应用程序与数据库沟通的桥梁**。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
41
docs/database/阿里巴巴开发手册数据库部分的一些最佳实践.md
Normal file
41
docs/database/阿里巴巴开发手册数据库部分的一些最佳实践.md
Normal file
@ -0,0 +1,41 @@
|
||||
# 阿里巴巴Java开发手册数据库部分的一些最佳实践总结
|
||||
|
||||
## 模糊查询
|
||||
|
||||
对于模糊查询阿里巴巴开发手册这样说到：
|
||||
|
||||
> 【强制】页面搜索严禁左模糊或者全模糊，如果需要请走搜索引擎来解决。
|
||||
>
|
||||
> 说明:索引文件具有 B-Tree 的最左前缀匹配特性，如果左边的值未确定，那么无法使用此索引。
|
||||
|
||||
## 外键和级联
|
||||
|
||||
对于外键和级联，阿里巴巴开发手册这样说到：
|
||||
|
||||
>【强制】不得使用外键与级联，一切外键概念必须在应用层解决。
|
||||
>
|
||||
>说明:以学生和成绩的关系为例，学生表中的 student_id 是主键，那么成绩表中的 student_id 则为外键。如果更新学生表中的 student_id，同时触发成绩表中的 student_id 更新，即为级联更新。外键与级联更新适用于单机低并发，不适合分布式、高并发集群;级联更新是强阻塞，存在数据库更新风暴的风 险;外键影响数据库的插入速度
|
||||
|
||||
为什么不要用外键呢？大部分人可能会这样回答：
|
||||
|
||||
> 1. **增加了复杂性：** a.每次做DELETE 或者UPDATE都必须考虑外键约束，会导致开发的时候很痛苦,测试数据极为不方便;b.外键的主从关系是定的，假如那天需求有变化，数据库中的这个字段根本不需要和其他表有关联的话就会增加很多麻烦。
|
||||
> 2. **增加了额外工作**： 数据库需要增加维护外键的工作，比如当我们做一些涉及外键字段的增，删，更新操作之后，需要触发相关操作去检查，保证数据的的一致性和正确性，这样会不得不消耗资源；（个人觉得这个不是不用外键的原因，因为即使你不使用外键，你在应用层面也还是要保证的。所以，我觉得这个影响可以忽略不计。）
|
||||
> 3. 外键还会因为需要请求对其他表内部加锁而容易出现死锁情况；
|
||||
> 4. **对分不分表不友好** ：因为分库分表下外键是无法生效的。
|
||||
> 5. ......
|
||||
|
||||
我个人觉得上面这种回答不是特别的全面，只是说了外键存在的一个常见的问题。实际上，我们知道外键也是有很多好处的，比如：
|
||||
|
||||
1. 保证了数据库数据的一致性和完整性；
|
||||
2. 级联操作方便，减轻了程序代码量；
|
||||
3. ......
|
||||
|
||||
所以说，不要一股脑的就抛弃了外键这个概念，既然它存在就有它存在的道理，如果系统不涉及分不分表，并发量不是很高的情况还是可以考虑使用外键的。
|
||||
|
||||
我个人是不太喜欢外键约束，比较喜欢在应用层去进行相关操作。
|
||||
|
||||
## 关于@Transactional注解
|
||||
|
||||
对于`@Transactional`事务注解，阿里巴巴开发手册这样说到：
|
||||
|
||||
>【参考】@Transactional事务不要滥用。事务会影响数据库的QPS，另外使用事务的地方需要考虑各方面的回滚方案，包括缓存回滚、搜索引擎回滚、消息补偿、统计修正等。
|
||||
@ -0,0 +1,294 @@
|
||||
作者： rhwayfun,原文地址：https://mp.weixin.qq.com/s/msYty4vjjC0PvrwasRH5Bw ,JavaGuide 已经获得作者授权并对原文进行了重新排版。
|
||||
<!-- TOC -->
|
||||
|
||||
- [写在2019年后的蚂蚁、头条、拼多多的面试总结](#写在2019年后的蚂蚁头条拼多多的面试总结)
|
||||
- [准备过程](#准备过程)
|
||||
- [蚂蚁金服](#蚂蚁金服)
|
||||
- [一面](#一面)
|
||||
- [二面](#二面)
|
||||
- [三面](#三面)
|
||||
- [四面](#四面)
|
||||
- [五面](#五面)
|
||||
- [小结](#小结)
|
||||
- [拼多多](#拼多多)
|
||||
- [面试前](#面试前)
|
||||
- [一面](#一面-1)
|
||||
- [二面](#二面-1)
|
||||
- [三面](#三面-1)
|
||||
- [小结](#小结-1)
|
||||
- [字节跳动](#字节跳动)
|
||||
- [面试前](#面试前-1)
|
||||
- [一面](#一面-2)
|
||||
- [二面](#二面-2)
|
||||
- [小结](#小结-2)
|
||||
- [总结](#总结)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
# 2019年蚂蚁金服、头条、拼多多的面试总结
|
||||
|
||||
文章有点长，请耐心看完，绝对有收获！不想听我BB直接进入面试分享：
|
||||
|
||||
- 准备过程
|
||||
- 蚂蚁金服面试分享
|
||||
- 拼多多面试分享
|
||||
- 字节跳动面试分享
|
||||
- 总结
|
||||
|
||||
说起来开始进行面试是年前倒数第二周，上午9点，我还在去公司的公交上，突然收到蚂蚁的面试电话，其实算不上真正的面试。面试官只是和我聊了下他们在做的事情（主要是做双十一这里大促的稳定性保障，偏中间件吧），说的很详细，然后和我沟通了下是否有兴趣，我表示有兴趣，后面就收到正式面试的通知，最后没选择去蚂蚁表示抱歉。
|
||||
|
||||
当时我自己也准备出去看看机会，顺便看看自己的实力。当时我其实挺纠结的，一方面现在部门也正需要我，还是可以有一番作为的，另一方面觉得近一年来进步缓慢，没有以前飞速进步的成就感了，而且业务和技术偏于稳定，加上自己也属于那种比较懒散的人，骨子里还是希望能够突破现状，持续在技术上有所精进。
|
||||
|
||||
在开始正式的总结之前，还是希望各位同仁能否听我继续发泄一会，抱拳！
|
||||
|
||||
我翻开自己2018年初立的flag，觉得甚是惭愧。其中就有一条是保持一周写一篇博客，奈何中间因为各种原因没能坚持下去。细细想来，主要是自己没能真正静下来心认真投入到技术的研究和学习，那么为什么会这样？说白了还是因为没有确定目标或者目标不明确，没有目标或者目标不明确都可能导致行动的失败。
|
||||
|
||||
那么问题来了，目标是啥？就我而言，短期目标是深入研究某一项技术，比如最近在研究mysql，那么深入研究一定要动手实践并且有所产出，这就够了么？还需要我们能够举一反三，结合实际开发场景想一想日常开发要注意什么，这中间有没有什么坑？可以看出，要进步真的不是一件简单的事，这种反人类的行为需要我们克服自我的弱点，逐渐形成习惯。真正牛逼的人，从不觉得认真学习是一件多么难的事，因为这已经形成了他的习惯，就喝早上起床刷牙洗脸那么自然简单。
|
||||
|
||||
扯了那么多，开始进入正题，先后进行了蚂蚁、拼多多和字节跳动的面试。
|
||||
|
||||
## 准备过程
|
||||
|
||||
先说说我自己的情况，我2016先在蚂蚁实习了将近三个月，然后去了我现在的老东家，2.5年工作经验，可以说毕业后就一直老老实实在老东家打怪升级，虽说有蚂蚁的实习经历，但是因为时间太短，还是有点虚的。所以面试官看到我简历第一个问题绝对是这样的。
|
||||
|
||||
“哇，你在蚂蚁待过，不错啊”，面试官笑嘻嘻地问到。“是的，还好”，我说。“为啥才三个月？”，面试官脸色一沉问到。“哗啦啦解释一通。。。”，我解释道。“哦，原来如此，那我们开始面试吧”，面试官一本正经说到。
|
||||
|
||||
尼玛，早知道不写蚂蚁的实习经历了，后面仔细一想，当初写上蚂蚁不就给简历加点料嘛。
|
||||
|
||||
言归正传，准备过程其实很早开始了（当然这不是说我工作时老想着跳槽，因为我明白现在的老东家并不是终点，我还需要不断提升），具体可追溯到从蚂蚁离职的时候，当时出来也面了很多公司，没啥大公司，面了大概5家公司，都拿到offer了。
|
||||
|
||||
工作之余常常会去额外研究自己感兴趣的技术以及工作用到的技术，力求把原理搞明白，并且会自己实践一把。此外，买了N多书，基本有时间就会去看，补补基础，什么操作系统、数据结构与算法、MySQL、JDK之类的源码，基本都好好温习了（文末会列一下自己看过的书和一些好的资料）。**我深知基础就像“木桶效应”的短板，决定了能装多少水。**
|
||||
|
||||
此外，在正式决定看机会之前，我给自己列了一个提纲，主要包括Java要掌握的核心要点，有不懂的就查资料搞懂。我给自己定位还是Java工程师，所以Java体系是一定要做到心中有数的，很多东西没有常年的积累面试的时候很容易露馅，学习要对得起自己，不要骗人。
|
||||
|
||||
剩下的就是找平台和内推了，除了蚂蚁，头条和拼多多都是找人内推的，感谢蚂蚁面试官对我的欣赏，以后说不定会去蚂蚁咯😄。
|
||||
|
||||
平台：脉脉、GitHub、v2
|
||||
|
||||
## 蚂蚁金服
|
||||
|
||||
|
||||
|
||||
- 一面
|
||||
- 二面
|
||||
- 三面
|
||||
- 四面
|
||||
- 五面
|
||||
- 小结
|
||||
|
||||
### 一面
|
||||
|
||||
一面就做了一道算法题，要求两小时内完成，给了长度为N的有重复元素的数组，要求输出第10大的数。典型的TopK问题，快排算法搞定。
|
||||
|
||||
算法题要注意的是合法性校验、边界条件以及异常的处理。另外，如果要写测试用例，一定要保证测试覆盖场景尽可能全。加上平时刷刷算法题，这种考核应该没问题的。
|
||||
|
||||
### 二面
|
||||
|
||||
- 自我介绍下呗
|
||||
- 开源项目贡献过代码么？（Dubbo提过一个打印accesslog的bug算么）
|
||||
- 目前在部门做什么，业务简单介绍下，内部有哪些系统，作用和交互过程说下
|
||||
- Dubbo踩过哪些坑，分别是怎么解决的？（说了异常处理时业务异常捕获的问题，自定义了一个异常拦截器）
|
||||
- 开始进入正题，说下你对线程安全的理解（多线程访问同一个对象，如果不需要考虑额外的同步，调用对象的行为就可以获得正确的结果就是线程安全）
|
||||
- 事务有哪些特性？（ACID）
|
||||
- 怎么理解原子性？（同一个事务下，多个操作要么成功要么失败，不存在部分成功或者部分失败的情况）
|
||||
- 乐观锁和悲观锁的区别？（悲观锁假定会发生冲突，访问的时候都要先获得锁，保证同一个时刻只有线程获得锁，读读也会阻塞；乐观锁假设不会发生冲突，只有在提交操作的时候检查是否有冲突）这两种锁在Java和MySQL分别是怎么实现的？（Java乐观锁通过CAS实现，悲观锁通过synchronize实现。mysql乐观锁通过MVCC，也就是版本实现，悲观锁可以通过select... for update加上排它锁）
|
||||
- HashMap为什么不是线程安全的？（多线程操作无并发控制，顺便说了在扩容的时候多线程访问时会造成死锁，会形成一个环，不过扩容时多线程操作形成环的问题再JDK1.8已经解决，但多线程下使用HashMap还会有一些其他问题比如数据丢失，所以多线程下不应该使用HashMap，而应该使用ConcurrentHashMap）怎么让HashMap变得线程安全？(Collections的synchronize方法包装一个线程安全的Map，或者直接用ConcurrentHashMap)两者的区别是什么？（前者直接在put和get方法加了synchronize同步，后者采用了分段锁以及CAS支持更高的并发）
|
||||
- jdk1.8对ConcurrentHashMap做了哪些优化？（插入的时候如果数组元素使用了红黑树，取消了分段锁设计，synchronize替代了Lock锁）为什么这样优化？（避免冲突严重时链表多长，提高查询效率，时间复杂度从O(N)提高到O(logN)）
|
||||
- redis主从机制了解么？怎么实现的？
|
||||
- 有过GC调优的经历么？（有点虚，答得不是很好）
|
||||
- 有什么想问的么？
|
||||
|
||||
### 三面
|
||||
|
||||
- 简单自我介绍下
|
||||
- 监控系统怎么做的，分为哪些模块，模块之间怎么交互的？用的什么数据库？（MySQL）使用什么存储引擎，为什么使用InnnoDB？(支持事务、聚簇索引、MVCC)
|
||||
- 订单表有做拆分么，怎么拆的？(垂直拆分和水平拆分)
|
||||
- 水平拆分后查询过程描述下
|
||||
- 如果落到某个分片的数据很大怎么办？(按照某种规则，比如哈希取模、range，将单张表拆分为多张表)
|
||||
- 哈希取模会有什么问题么？(有的，数据分布不均，扩容缩容相对复杂 )
|
||||
- 分库分表后怎么解决读写压力？(一主多从、多主多从)
|
||||
- 拆分后主键怎么保证惟一？(UUID、Snowflake算法)
|
||||
- Snowflake生成的ID是全局递增唯一么？(不是，只是全局唯一，单机递增)
|
||||
- 怎么实现全局递增的唯一ID？(讲了TDDL的一次取一批ID，然后再本地慢慢分配的做法)
|
||||
- Mysql的索引结构说下(说了B+树，B+树可以对叶子结点顺序查找，因为叶子结点存放了数据结点且有序)
|
||||
- 主键索引和普通索引的区别(主键索引的叶子结点存放了整行记录，普通索引的叶子结点存放了主键ID，查询的时候需要做一次回表查询)一定要回表查询么？(不一定，当查询的字段刚好是索引的字段或者索引的一部分，就可以不用回表，这也是索引覆盖的原理)
|
||||
- 你们系统目前的瓶颈在哪里？
|
||||
- 你打算怎么优化？简要说下你的优化思路
|
||||
- 有什么想问我么？
|
||||
|
||||
### 四面
|
||||
|
||||
- 介绍下自己
|
||||
- 为什么要做逆向？
|
||||
- 怎么理解微服务？
|
||||
- 服务治理怎么实现的？(说了限流、压测、监控等模块的实现)
|
||||
- 这个不是中间件做的事么，为什么你们部门做？(当时没有单独的中间件团队，微服务刚搞不久，需要进行监控和性能优化)
|
||||
- 说说Spring的生命周期吧
|
||||
- 说说GC的过程(说了young gc和full gc的触发条件和回收过程以及对象创建的过程)
|
||||
- CMS GC有什么问题？(并发清除算法，浮动垃圾，短暂停顿)
|
||||
- 怎么避免产生浮动垃圾？(记得有个VM参数设置可以让扫描新生代之前进行一次young gc，但是因为gc是虚拟机自动调度的，所以不保证一定执行。但是还有参数可以让虚拟机强制执行一次young gc)
|
||||
- 强制young gc会有什么问题？(STW停顿时间变长)
|
||||
- 知道G1么？(了解一点 )
|
||||
- 回收过程是怎么样的？(young gc、并发阶段、混合阶段、full gc，说了Remember Set)
|
||||
- 你提到的Remember Set底层是怎么实现的？
|
||||
- 有什么想问的么？
|
||||
|
||||
### 五面
|
||||
|
||||
五面是HRBP面的，和我提前预约了时间，主要聊了之前在蚂蚁的实习经历、部门在做的事情、职业发展、福利待遇等。阿里面试官确实是具有一票否决权的，很看重你的价值观是否match，一般都比较喜欢皮实的候选人。HR面一定要诚实，不要说谎，只要你说谎HR都会去证实，直接cut了。
|
||||
|
||||
- 之前蚂蚁实习三个月怎么不留下来？
|
||||
- 实习的时候主管是谁？
|
||||
- 实习做了哪些事情？（尼玛这种也问？）
|
||||
- 你对技术怎么看？平时使用什么技术栈？（阿里HR真的是既当爹又当妈，😂）
|
||||
- 最近有在研究什么东西么
|
||||
- 你对SRE怎么看
|
||||
- 对待遇有什么预期么
|
||||
|
||||
最后HR还对我说目前稳定性保障部挺缺人的，希望我尽快回复。
|
||||
|
||||
### 小结
|
||||
|
||||
蚂蚁面试比较重视基础，所以Java那些基本功一定要扎实。蚂蚁的工作环境还是挺赞的，因为我面的是稳定性保障部门，还有许多单独的小组，什么三年1班，很有青春的感觉。面试官基本水平都比较高，基本都P7以上，除了基础还问了不少架构设计方面的问题，收获还是挺大的。
|
||||
|
||||
## 拼多多
|
||||
|
||||
|
||||
|
||||
- 面试前
|
||||
- 一面
|
||||
- 二面
|
||||
- 三面
|
||||
- 小结
|
||||
|
||||
### 面试前
|
||||
|
||||
面完蚂蚁后，早就听闻拼多多这个独角兽，决定也去面一把。首先我在脉脉找了一个拼多多的HR，加了微信聊了下，发了简历便开始我的拼多多面试之旅。这里要非常感谢拼多多HR小姐姐，从面试内推到offer确认一直都在帮我，人真的很nice。
|
||||
|
||||
### 一面
|
||||
|
||||
- 为啥蚂蚁只待了三个月？没转正？(转正了，解释了一通。。。)
|
||||
- Java中的HashMap、TreeMap解释下？(TreeMap红黑树，有序，HashMap无序，数组+链表)
|
||||
- TreeMap查询写入的时间复杂度多少？(O(logN))
|
||||
- HashMap多线程有什么问题？(线程安全，死锁)怎么解决？( jdk1.8用了synchronize + CAS，扩容的时候通过CAS检查是否有修改，是则重试)重试会有什么问题么？(CAS（Compare And Swap）是比较和交换，不会导致线程阻塞，但是因为重试是通过自旋实现的，所以仍然会占用CPU时间，还有ABA的问题)怎么解决？(超时，限定自旋的次数，ABA可以通过原理变量AtomicStampedReference解决，原理利用版本号进行比较)超过重试次数如果仍然失败怎么办？(synchronize互斥锁)
|
||||
- CAS和synchronize有什么区别？都用synchronize不行么？(CAS是乐观锁，不需要阻塞，硬件级别实现的原子性；synchronize会阻塞，JVM级别实现的原子性。使用场景不同，线程冲突严重时CAS会造成CPU压力过大，导致吞吐量下降，synchronize的原理是先自旋然后阻塞，线程冲突严重仍然有较高的吞吐量，因为线程都被阻塞了，不会占用CPU
|
||||
)
|
||||
- 如果要保证线程安全怎么办？(ConcurrentHashMap)
|
||||
- ConcurrentHashMap怎么实现线程安全的？(分段锁)
|
||||
- get需要加锁么，为什么？(不用，volatile关键字)
|
||||
- volatile的作用是什么？(保证内存可见性)
|
||||
- 底层怎么实现的？(说了主内存和工作内存，读写内存屏障，happen-before，并在纸上画了线程交互图)
|
||||
- 在多核CPU下，可见性怎么保证？(思考了一会，总线嗅探技术)
|
||||
- 聊项目，系统之间是怎么交互的？
|
||||
- 系统并发多少，怎么优化？
|
||||
- 给我一张纸，画了一个九方格，都填了数字，给一个M*N矩阵，从1开始逆时针打印这M*N个数，要求时间复杂度尽可能低（内心OS：之前貌似碰到过这题，最优解是怎么实现来着）思考中。。。
|
||||
- 可以先说下你的思路(想起来了，说了什么时候要变换方向的条件，向右、向下、向左、向上，依此循环)
|
||||
- 有什么想问我的？
|
||||
|
||||
### 二面
|
||||
|
||||
- 自我介绍下
|
||||
- 手上还有其他offer么？(拿了蚂蚁的offer)
|
||||
- 部门组织结构是怎样的？(这轮不是技术面么，不过还是老老实实说了)
|
||||
- 系统有哪些模块，每个模块用了哪些技术，数据怎么流转的？（面试官有点秃顶，一看级别就很高）给了我一张纸，我在上面简单画了下系统之间的流转情况
|
||||
- 链路追踪的信息是怎么传递的？(RpcContext的attachment，说了Span的结构:parentSpanId + curSpanId)
|
||||
- SpanId怎么保证唯一性？(UUID，说了下内部的定制改动)
|
||||
- RpcContext是在什么维度传递的？(线程)
|
||||
- Dubbo的远程调用怎么实现的？(讲了读取配置、拼装url、创建Invoker、服务导出、服务注册以及消费者通过动态代理、filter、获取Invoker列表、负载均衡等过程（哗啦啦讲了10多分钟），我可以喝口水么)
|
||||
- Spring的单例是怎么实现的？(单例注册表)
|
||||
- 为什么要单独实现一个服务治理框架？(说了下内部刚搞微服务不久，主要对服务进行一些监控和性能优化)
|
||||
- 谁主导的？内部还在使用么？
|
||||
- 逆向有想过怎么做成通用么？
|
||||
- 有什么想问的么？
|
||||
|
||||
### 三面
|
||||
|
||||
二面老大面完后就直接HR面了，主要问了些职业发展、是否有其他offer、以及入职意向等问题，顺便说了下公司的福利待遇等，都比较常规啦。不过要说的是手上有其他offer或者大厂经历会有一定加分。
|
||||
|
||||
### 小结
|
||||
|
||||
拼多多的面试流程就简单许多，毕竟是一个成立三年多的公司。面试难度中规中矩，只要基础扎实应该不是问题。但不得不说工作强度很大，开始面试前HR就提前和我确认能否接受这样强度的工作，想来的老铁还是要做好准备
|
||||
|
||||
## 字节跳动
|
||||
|
||||
|
||||
|
||||
- 面试前
|
||||
- 一面
|
||||
- 二面
|
||||
- 小结
|
||||
|
||||
### 面试前
|
||||
|
||||
头条的面试是三家里最专业的，每次面试前有专门的HR和你约时间，确定OK后再进行面试。每次都是通过视频面试，因为都是之前都是电话面或现场面，所以视频面试还是有点不自然。也有人觉得视频面试体验很赞，当然萝卜青菜各有所爱。最坑的二面的时候对方面试官的网络老是掉线，最后很冤枉的挂了（当然有一些点答得不好也是原因之一）。所以还是有点遗憾的。
|
||||
|
||||
### 一面
|
||||
|
||||
- 先自我介绍下
|
||||
- 聊项目，逆向系统是什么意思
|
||||
- 聊项目，逆向系统用了哪些技术
|
||||
- 线程池的线程数怎么确定？
|
||||
- 如果是IO操作为主怎么确定？
|
||||
- 如果计算型操作又怎么确定？
|
||||
- Redis熟悉么，了解哪些数据结构?(说了zset) zset底层怎么实现的?(跳表)
|
||||
- 跳表的查询过程是怎么样的，查询和插入的时间复杂度?(说了先从第一层查找，不满足就下沉到第二层找，因为每一层都是有序的，写入和插入的时间复杂度都是O(logN))
|
||||
- 红黑树了解么，时间复杂度?(说了是N叉平衡树，O(logN))
|
||||
- 既然两个数据结构时间复杂度都是O(logN)，zset为什么不用红黑树(跳表实现简单，踩坑成本低，红黑树每次插入都要通过旋转以维持平衡，实现复杂)
|
||||
- 点了点头，说下Dubbo的原理?(说了服务注册与发布以及消费者调用的过程)踩过什么坑没有？（说了dubbo异常处理的和打印accesslog的问题）
|
||||
- CAS了解么？（说了CAS的实现）还了解其他同步机制么？（说了synchronize以及两者的区别，一个乐观锁，一个悲观锁）
|
||||
- 那我们做一道题吧，数组A，2*n个元素，n个奇数、n个偶数，设计一个算法，使得数组奇数下标位置放置的都是奇数，偶数下标位置放置的都是偶数
|
||||
- 先说下你的思路（从0下标开始遍历，如果是奇数下标判断该元素是否奇数，是则跳过，否则从该位置寻找下一个奇数）
|
||||
- 下一个奇数？怎么找？（有点懵逼，思考中。。）
|
||||
- 有思路么？（仍然是先遍历一次数组，并对下标进行判断，如果下标属性和该位置元素不匹配从当前下标的下一个遍历数组元素，然后替换）
|
||||
- 你这样时间复杂度有点高，如果要求O(N)要怎么做（思考一会，答道“定义两个指针，分别从下标0和1开始遍历，遇见奇数位是是偶数和偶数位是奇数就停下，交换内容”）
|
||||
- 时间差不多了，先到这吧。你有什么想问我的？
|
||||
|
||||
### 二面
|
||||
|
||||
- 面试官和蔼很多，你先介绍下自己吧
|
||||
- 你对服务治理怎么理解的？
|
||||
- 项目中的限流怎么实现的？（Guava ratelimiter，令牌桶算法）
|
||||
- 具体怎么实现的？（要点是固定速率且令牌数有限）
|
||||
- 如果突然很多线程同时请求令牌，有什么问题？（导致很多请求积压，线程阻塞）
|
||||
- 怎么解决呢？（可以把积压的请求放到消息队列，然后异步处理）
|
||||
- 如果不用消息队列怎么解决？（说了RateLimiter预消费的策略）
|
||||
- 分布式追踪的上下文是怎么存储和传递的？（ThreadLocal + spanId，当前节点的spanId作为下个节点的父spanId）
|
||||
- Dubbo的RpcContext是怎么传递的？（ThreadLocal）主线程的ThreadLocal怎么传递到线程池？（说了先在主线程通过ThreadLocal的get方法拿到上下文信息，在线程池创建新的ThreadLocal并把之前获取的上下文信息设置到ThreadLocal中。这里要注意的线程池创建的ThreadLocal要在finally中手动remove，不然会有内存泄漏的问题）
|
||||
- 你说的内存泄漏具体是怎么产生的？（说了ThreadLocal的结构，主要分两种场景：主线程仍然对ThreadLocal有引用和主线程不存在对ThreadLocal的引用。第一种场景因为主线程仍然在运行，所以还是有对ThreadLocal的引用，那么ThreadLocal变量的引用和value是不会被回收的。第二种场景虽然主线程不存在对ThreadLocal的引用，且该引用是弱引用，所以会在gc的时候被回收，但是对用的value不是弱引用，不会被内存回收，仍然会造成内存泄漏）
|
||||
- 线程池的线程是不是必须手动remove才可以回收value？（是的，因为线程池的核心线程是一直存在的，如果不清理，那么核心线程的threadLocals变量会一直持有ThreadLocal变量）
|
||||
- 那你说的内存泄漏是指主线程还是线程池？（主线程 ）
|
||||
- 可是主线程不是都退出了，引用的对象不应该会主动回收么？（面试官和内存泄漏杠上了），沉默了一会。。。
|
||||
- 那你说下SpringMVC不同用户登录的信息怎么保证线程安全的？（刚才解释的有点懵逼，一下没反应过来，居然回答成锁了。大脑有点晕了，此时已经一个小时过去了，感觉情况不妙。。。）
|
||||
- 这个直接用ThreadLocal不就可以么，你见过SpringMVC有锁实现的代码么？（有点晕菜。。。）
|
||||
- 我们聊聊mysql吧，说下索引结构（说了B+树）
|
||||
- 为什么使用B+树？（ 说了查询效率高，O(logN)，可以充分利用磁盘预读的特性，多叉树，深度小，叶子结点有序且存储数据）
|
||||
- 什么是索引覆盖？（忘记了。。。 ）
|
||||
- Java为什么要设计双亲委派模型？
|
||||
- 什么时候需要自定义类加载器？
|
||||
- 我们做一道题吧，手写一个对象池
|
||||
- 有什么想问我的么？（感觉我很多点都没答好，是不是挂了（结果真的是） ）
|
||||
|
||||
### 小结
|
||||
|
||||
头条的面试确实很专业，每次面试官会提前给你发一个视频链接，然后准点开始面试，而且考察的点都比较全。
|
||||
|
||||
面试官都有一个特点，会抓住一个值得深入的点或者你没说清楚的点深入下去直到你把这个点讲清楚，不然面试官会觉得你并没有真正理解。二面面试官给了我一点建议，研究技术的时候一定要去研究产生的背景，弄明白在什么场景解决什么特定的问题，其实很多技术内部都是相通的。很诚恳，还是很感谢这位面试官大大。
|
||||
|
||||
## 总结
|
||||
|
||||
从年前开始面试到头条面完大概一个多月的时间，真的有点身心俱疲的感觉。最后拿到了拼多多、蚂蚁的offer，还是蛮幸运的。头条的面试对我帮助很大，再次感谢面试官对我的诚恳建议，以及拼多多的HR对我的啰嗦的问题详细解答。
|
||||
|
||||
这里要说的是面试前要做好两件事：简历和自我介绍，简历要好好回顾下自己做的一些项目，然后挑几个亮点项目。自我介绍基本每轮面试都有，所以最好提前自己练习下，想好要讲哪些东西，分别怎么讲。此外，简历提到的技术一定是自己深入研究过的，没有深入研究也最好找点资料预热下，不打无准备的仗。
|
||||
|
||||
**这些年看过的书**：
|
||||
|
||||
《Effective Java》、《现代操作系统》、《TCP/IP详解：卷一》、《代码整洁之道》、《重构》、《Java程序性能优化》、《Spring实战》、《Zookeeper》、《高性能MySQL》、《亿级网站架构核心技术》、《可伸缩服务架构》、《Java编程思想》
|
||||
|
||||
说实话这些书很多只看了一部分，我通常会带着问题看书，不然看着看着就睡着了，简直是催眠良药😅。
|
||||
|
||||
|
||||
最后，附一张自己面试前准备的脑图：
|
||||
|
||||
链接:https://pan.baidu.com/s/1o2l1tuRakBEP0InKEh4Hzw 密码:300d
|
||||
|
||||
全文完。
|
||||
@ -0,0 +1,96 @@
|
||||
> 作者：ppxyn。本文来自读者投稿，同时也欢迎各位投稿，**对于不错的原创文章我根据你的选择给予现金(50-200)、付费专栏或者任选书籍进行奖励！所以，快提 pr 或者邮件的方式（邮件地址在主页）给我投稿吧！** 当然，我觉得奖励是次要的，最重要的是你可以从自己整理知识点的过程中学习到很多知识。
|
||||
|
||||
**目录**
|
||||
|
||||
<!-- MarkdownTOC -->
|
||||
|
||||
- [前言](#前言)
|
||||
- [一面\(技术面\)](#一面技术面)
|
||||
- [二面\(技术面\)](#二面技术面)
|
||||
- [三面\(技术面\)](#三面技术面)
|
||||
- [四面\(半个技术面\)](#四面半个技术面)
|
||||
- [五面\(HR面\)](#五面hr面)
|
||||
- [总结](#总结)
|
||||
|
||||
<!-- /MarkdownTOC -->
|
||||
|
||||
### 前言
|
||||
|
||||
在接触 Java 之前我接触的比较多的是硬件方面，用的比较多的语言就是C和C++。到了大三我才正式选择 Java 方向，到目前为止使用Java到现在大概有一年多的时间，所以Java算不上很好。刚开始投递的时候，实习刚辞职，也没准备笔试面试，很多东西都忘记了。所以，刚开始我并没有直接就投递阿里，毕竟心里还是有一点点小害怕的。于是，我就先投递了几个不算大的公司来练手，就是想着刷刷经验而已或者说是练练手（ps：还是挺对不起那些公司的）。面了一个月其他公司后，我找了我实验室的学长内推我，后面就有了这5次面试。
|
||||
|
||||
下面简单的说一下我的这5次面试：4次技术面+1次HR面，希望我的经历能对你有所帮助。
|
||||
|
||||
### 一面(技术面)
|
||||
|
||||
1. 自我介绍（主要讲自己会的技术细节，项目经验，经历那些就一语带过，后面面试官会问你的）。
|
||||
2. 聊聊项目（就是一个很普通的分布式商城，自己做了一些改进），让我画了整个项目的架构图，然后针对项目抛了一系列的提高性能的问题，还问了我做项目的过程中遇到了那些问题，如何解决的，差不读就这些吧。
|
||||
3. 可能是我前面说了我会数据库优化，然后面试官就开始问索引、事务隔离级别、悲观锁和乐观锁、索引、ACID、MVVC这些问题。
|
||||
4. 浏览器输入URL发生了什么? TCP和UDP区别? TCP如何保证传输可靠性?
|
||||
5. 讲下跳表怎么实现的?哈夫曼编码是怎么回事？非递归且不用额外空间（不用栈），如何遍历二叉树
|
||||
6. 后面又问了很多JVM方面的问题，比如Java内存模型、常见的垃圾回收器、双亲委派模型这些
|
||||
7. 你有什么问题要问吗？
|
||||
|
||||
### 二面(技术面)
|
||||
|
||||
1. 自我介绍（主要讲自己会的技术细节，项目经验，经历那些就一语带过，后面面试官会问你的）。
|
||||
2. 操作系统的内存管理机制
|
||||
3. 进程和线程的区别
|
||||
4. 说下你对线程安全的理解
|
||||
5. volatile 有什么作用 ，sychronized和lock有什么区别
|
||||
6. ReentrantLock实现原理
|
||||
7. 用过CountDownLatch么？什么场景下用的？
|
||||
8. AQS底层原理。
|
||||
9. 造成死锁的原因有哪些，如何预防？
|
||||
10. 加锁会带来哪些性能问题。如何解决？
|
||||
11. HashMap、ConcurrentHashMap源码。HashMap是线程安全的吗？Hashtable呢？ConcurrentHashMap有了解吗？
|
||||
12. 是否可以实习？
|
||||
13. 你有什么问题要问吗？
|
||||
|
||||
### 三面(技术面)
|
||||
|
||||
1. 有没有参加过 ACM 或者他竞赛，有没有拿过什么奖？（ 我说我没参加过ACM，本科参加过数学建模竞赛，名次并不好，没拿过什么奖。面试官好像有点失望，然后我又赶紧补充说我和老师一起做过一个项目，目前已经投入使用。面试官还比较感兴趣，后面又和他聊了一下这个项目。）
|
||||
2. 研究生期间，做过什么项目，发过论文吗？有什么成果吗？
|
||||
3. 你觉得你有什么优点和缺点？你觉得你相比于那些比你更优秀的人欠缺什么？
|
||||
4. 有读过什么源码吗？（我说我读过 Java 集合框架和 Netty 的，面试官说 Java 集合前几面一定问的差不多，就不问了，然后就问我 Netty的，我当时很慌啊！）
|
||||
5. 介绍一下自己对 Netty 的认识，为什么要用。说说业务中，Netty 的使用场景。什么是TCP 粘包/拆包,解决办法。Netty线程模型。Dubbo 在使用 Netty 作为网络通讯时候是如何避免粘包与半包问题？讲讲Netty的零拷贝？巴拉巴拉问了好多，我记得有好几个我都没回答上来，心里想着凉凉了啊。
|
||||
6. 用到了那些开源技术、在开源领域做过贡献吗？
|
||||
7. 常见的排序算法及其复杂度，现场写了快排。
|
||||
8. 红黑树，B树的一些问题。
|
||||
9. 讲讲算法及数据结构在实习项目中的用处。
|
||||
10. 自己的未来规划（就简单描述了一下自己未来的设想啊，说的还挺诚恳，面试官好像还挺满意的）
|
||||
11. 你有什么问题要问吗？
|
||||
|
||||
### 四面(半个技术面)
|
||||
|
||||
三面面完当天，晚上9点接到面试电话，感觉像是部门或者项目主管。 这个和之前的面试不大相同，感觉面试官主要考察的是你解决问题的能力、学习能力和团队协作能力。
|
||||
|
||||
1. 让我讲一个自己觉得最不错的项目。然后就巴拉巴拉的聊，我记得主要是问了项目是如何进行协作的、遇到问题是如何解决的、与他人发生冲突是如何解决的这些。感觉聊了挺久。
|
||||
2. 出现 OOM 后你会怎么排查问题？
|
||||
3. 自己平时是如何学习新技术的？除了 Java 还回去了解其他技术吗?
|
||||
4. 上一段实习经历的收获。
|
||||
5. NginX如何做负载均衡、常见的负载均衡算法有哪些、一致性哈希的一致性是什么意思、一致性哈希是如何做哈希的
|
||||
6. 你有什么问题问我吗？
|
||||
7. 还有一些其他的，想不起来了，感觉这一面不是偏向技术来问。
|
||||
|
||||
## 五面(HR面)
|
||||
|
||||
1. 自我介绍（主要讲能突出自己的经历，会的编程技术一语带过）。
|
||||
2. 你觉得你有什么优点和缺点？如何克服这些缺点？
|
||||
3. 说一件大学里你自己比较有成就感的一件事情，为此付出了那些努力。
|
||||
4. 你前面跟其他面试官讲过一些你做的项目吧？可以给我讲讲吗？你要考虑到我不是一个做技术的人，怎么让我也听得懂。项目中有什么问题，你怎么解决的？你最大的收获是什么？
|
||||
5. 你目前有面试过其他公司吗？如果让你选，这些公司和阿里，你选哪个？（送分题，回答不好可能送命）
|
||||
6. 你期望的工作地点是哪里？
|
||||
7. 你有什么问题吗？
|
||||
|
||||
### 总结
|
||||
|
||||
1. 可以看出面试官问我的很多问题都是比较常见的问题，所以记得一定要提前准备，还要深入准备，不要回答的太皮毛。很多时候一个问题可能会牵扯出很多问题，遇到不会的问题不要慌，冷静分析，如果你真的回答不上来，也不要担心自己是不是就要挂了，很可能这个问题本身就比较难。
|
||||
2. 表达能力和沟通能力太重要了，一定要提前练一下，我自身就是一个不太会说话的人，所以，面试前我对于自我介绍、项目介绍和一些常见问题都在脑子里练了好久，确保面试的时候能够很清晰和简洁的说出来。
|
||||
3. 等待面试的过程和面试的过程真的好熬人，那段时间我压力也比较大，好在我私下找到学长聊了很多，心情也好了很多。
|
||||
4. 面试之后及时总结，面的好的话，不要得意，尽快准备下一场面试吧！
|
||||
|
||||
我觉得我还算是比较幸运的，最后也祝大家都能获得心仪的Offer。
|
||||
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,251 @@
|
||||
本文来自 Anonymous 的投稿 ，JavaGuide 对原文进行了重新排版和一点完善。
|
||||
|
||||
<!-- TOC -->
|
||||
|
||||
- [一面 (37 分钟左右)](#一面-37-分钟左右)
|
||||
- [二面 (33 分钟左右)](#二面-33-分钟左右)
|
||||
- [三面 (46 分钟)](#三面-46-分钟)
|
||||
- [HR 面](#hr-面)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
### 一面 (37 分钟左右)
|
||||
|
||||
一面是上海的小哥打来的，3.12 号中午确认的内推，下午就打来约时间了，也是唯一一个约时间的面试官。约的晚上八点。紧张的一比，人生第一次面试就献给了阿里。
|
||||
|
||||
幸运的是一面的小哥特温柔。好像是个海归？口语中夹杂着英文。废话不多说，上干货：
|
||||
|
||||
**面试官：** 先自我介绍下吧！
|
||||
|
||||
**我：** 巴拉巴拉...。
|
||||
|
||||
> 关于自我介绍：从 HR 面、技术面到高管面/部门主管面，面试官一般会让你先自我介绍一下，所以好好准备自己的自我介绍真的非常重要。网上一般建议的是准备好两份自我介绍：一份对 HR 说的，主要讲能突出自己的经历，会的编程技术一语带过；另一份对技术面试官说的，主要讲自己会的技术细节，项目经验，经历那些就一语带过。
|
||||
|
||||
**面试官：** 我看你简历上写你做了个秒杀系统？我们就从这个项目开始吧，先介绍下你的项目。
|
||||
|
||||
> 关于项目介绍：如果有项目的话，技术面试第一步，面试官一般都是让你自己介绍一下你的项目。你可以从下面几个方向来考虑：
|
||||
>
|
||||
> 1. 对项目整体设计的一个感受（面试官可能会让你画系统的架构图）
|
||||
> 2. 在这个项目中你负责了什么、做了什么、担任了什么角色
|
||||
> 3. 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用
|
||||
> 4. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如:用 redis 做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。
|
||||
|
||||
**我：** 我说了我是如何考虑它的需求（秒杀地址隐藏，记录订单，减库存），一开始简单的用 synchronized 锁住方法，出现了问题，后来乐观锁改进，又有瓶颈，再上缓存，出现了缓存雪崩，于是缓存预热，错开缓存失效时间。最后，发现先记录订单再减库存会减少行级锁等待时间。
|
||||
|
||||
> 一面面试官很耐心地听，并给了我一些指导，问了我乐观锁是怎么实现的，我说是基于 sql 语句，在减库存操作的 where 条件里加剩余库存数>0，他说这应该不算是一种乐观锁，应该先查库存，在减库存的时候判断当前库存是否与读到的库存一样（可这样不是多一次查询操作吗？不是很理解，不过我没有反驳，只是说理解您的意思。事实证明千万别怼面试官，即使你觉得他说的不对）
|
||||
|
||||
**面试官:** 我缓存雪崩什么情况下会发生？如何避免？
|
||||
|
||||
**我：** 当多个商品缓存同时失效时会雪崩，导致大量查询数据库。还有就是秒杀刚开始的时候缓存里没有数据。解决方案：缓存预热，错开缓存失效时间
|
||||
|
||||
**面试官：** 问我更新数据库的同时为什么不马上更新缓存，而是删除缓存？
|
||||
|
||||
**我：** 因为考虑到更新数据库后更新缓存可能会因为多线程下导致写入脏数据（比如线程 A 先更新数据库成功，接下来要取更新缓存，接着线程 B 更新数据库，但 B 又更新了缓存，接着 B 的时间片用完了，线程 A 更新了缓存）
|
||||
|
||||
逼逼了将近 30 分钟，面试官居然用周杰伦的语气对我说：
|
||||
|
||||
|
||||
|
||||
我突然受宠若惊，连忙说谢谢，也正是因为第一次面试得到了面试官的肯定，才让我信心大增，二三面稳定发挥。
|
||||
|
||||
**面试官又曰：** 我看你还懂数据库是吧，答：略懂略懂。。。那我问个简单的吧！
|
||||
|
||||
**我：** 因为这个问题太简单了，所以我忘记它是什么了。
|
||||
|
||||
**面试官：** 你还会啥数据库知识？
|
||||
|
||||
**我：** 我一听，问的这么随意的吗。。。都让我选题了，我就说我了解索引，慢查询优化，巴拉巴拉
|
||||
|
||||
**面试官：** 等等，你说索引是吧，那你能说下索引的存储数据结构吗？
|
||||
|
||||
**我：** 我心想这简单啊，我就说 B+树，还说了为什么用 B+树
|
||||
|
||||
**面试官：** 你简历上写的这个 J.U.C 包是什么啊？（他居然不知道 JUC）
|
||||
|
||||
**我：** 就是 java 多线程的那个包啊。。。
|
||||
|
||||
**面试官：** 那你都了解里面的哪些东西呢？
|
||||
|
||||
**我：** 哈哈哈！这可是我的强项，从 ConcurrentHashMap，ConcurrentLinkedQueue 说到 CountDownLatch，CyclicBarrier，又说到线程池，分别说了底层实现和项目中的应用。
|
||||
|
||||
**面试官:** 我觉得差不多了，那我再问个与技术无关的问题哈，虽然这个问题可能不应该我问，就是你是如何考虑你的项目架构的呢？
|
||||
|
||||
**我：** 先用最简单的方式实现它，再去发掘系统的问题和瓶颈，于是查资料改进架构。。。
|
||||
|
||||
**面试官：** 好，那我给你介绍下我这边的情况吧
|
||||
|
||||
|
||||
|
||||
**总结：** 一面可能是简历面吧，问的比较简单，我在讲项目中说出了我做项目时的学习历程和思考，赢得了面试官的好感，感觉他应该给我的评价很好。
|
||||
|
||||
### 二面 (33 分钟左右)
|
||||
|
||||
然而开心了没一会，内推人问我面的怎么样啊？看我流程已经到大大 boss 那了。我一听二面不是主管吗？？？怎么直接跳了一面。于是瞬间慌了，赶紧（下床）学习准备二面。
|
||||
|
||||
隔了一天，3.14 的早上 10：56 分，杭州的大大 boss 给我打来了电话，卧槽我当时在上毛概课，万恶的毛概课每节课都点名，我还在最后一排不敢跑出去。于是接起电话来怂怂地说不好意思我在上课，晚上可以面试吗？大大 boss 看来很忙啊，跟我说晚上没时间啊，再说吧！
|
||||
|
||||
于是又隔了一天，3.16 中午我收到了北京的电话，当时心里小失望，我的大大 boss 呢？？？接起电话来，就是一番狂轰乱炸。。。
|
||||
|
||||
第一步还是先自我介绍，这个就不多说了，提前准备好要说的重点就没问题！
|
||||
|
||||
**面试官:** 我们还是从你的项目开始吧，说说你的秒杀系统。
|
||||
|
||||
**我:** 一面时的套路。。。我考虑到秒杀地址在开始前不应暴露给用户。。。
|
||||
|
||||
**面试官:** 等下啊，为什么要这样呢？暴露给用户会怎么样？
|
||||
|
||||
**我:** 用户提前知道秒杀地址就可以写脚本来抢购了，这样不公平
|
||||
|
||||
**面试官:** 那比如说啊，我现在是个黑客，我在秒杀开始时写好了脚本，运行一万个线程获取秒杀地址，这样是不是也不公平呢？
|
||||
|
||||
**我：** 我考虑到了这方面，于是我自己写了个 LRU 缓存（划重点，这么多好用的缓存我为啥不用偏要自己写？就是为了让面试官上钩问我是怎么写的，这样我就可以逼逼准备好的内容了！），用这个缓存存储请求的 ip 和用户名，一个 ip 和用户名只能同时透过 3 个请求。
|
||||
|
||||
**面试官:** 那我可不可以创建一个 ip 代理池和很多用户来抢购呢？假设我有很多手机号的账户。
|
||||
|
||||
**我：** 这就是在为难我胖虎啊，我说这种情况跟真实用户操作太像了。。。我没法区别，不过我觉得可以通过地理位置信息或者机器学习算法来做吧。。。
|
||||
|
||||
**面试官:** 好的这个问题就到这吧，你接着说
|
||||
|
||||
**我：** 我把生成订单和减库存两条 sql 语句放在一个事务里，都操作成功了则认为秒杀成功。
|
||||
|
||||
**面试官:** 等等，你这个订单表和商品库存表是在一个数据库的吧，那如果在不同的数据库中呢？
|
||||
|
||||
**我:** 这面试官好变态啊，我只是个本科生？！？！我觉得应该要用分布式锁来实现吧。。。
|
||||
|
||||
**面试官:** 有没有更轻量级的做法？
|
||||
|
||||
**我:** 不知道了。后来查资料发现可以用消息队列来实现。使用消息队列主要能带来两个好处：(1) 通过异步处理提高系统性能（削峰、减少响应所需时间）;(2) 降低系统耦合性。关于消息队列的更多内容可以查看这篇文章：<https://snailclimb.gitee.io/javaguide/#/./system-design/data-communication/message-queue>
|
||||
|
||||
后来发现消息队列作用好大，于是现在在学手写一个消息队列。
|
||||
|
||||
**面试官:** 好的你接着说项目吧。
|
||||
|
||||
**我:** 我考虑到了缓存雪崩问题，于是。。。
|
||||
|
||||
**面试官:** 等等，你有没有考虑到一种情况，假如说你的缓存刚刚失效，大量流量就来查缓存，你的数据库会不会炸？
|
||||
|
||||
**我:** 我不知道数据库会不会炸，反正我快炸了。当时说没考虑这么高的并发量，后来发现也是可以用消息队列来解决，对流量削峰填谷。
|
||||
|
||||
**面试官:** 好项目聊（怼）完了，我们来说说别的，操作系统了解吧，你能说说 NIO 吗？
|
||||
|
||||
**我:** NIO 是。。。
|
||||
|
||||
**面试官:** 那你知道 NIO 的系统调用有哪些吗，具体是怎么实现的？
|
||||
|
||||
**我：** 当时复习 NIO 的时候就知道是咋回事，不知道咋实现。最近在补这方面的知识，可见 NIO 还是很重要的！
|
||||
|
||||
**面试官:** 说说进程切换时操作系统都会发生什么？
|
||||
|
||||
**我:** 不如杀了我，我最讨厌操作系统了。简单说了下，可能不对，需要答案自行百度。
|
||||
|
||||
**面试官:** 说说线程池？
|
||||
|
||||
**答：** 卧槽这我熟啊，把 Java 并发编程的艺术里讲的都说出来了，说了得有十分钟，自夸一波，毕竟这本书我看了五遍😂
|
||||
|
||||
**面试官:** 好问问计网吧如果设计一个聊天系统，应该用 TCP 还是 UDP？为什么
|
||||
|
||||
**我:** 当然是 TCP！原因如下：
|
||||
|
||||
|
||||
|
||||
**面试官:** 好的，你有什么要问我的吗？
|
||||
|
||||
**我:** 我还有下一次面试吗?
|
||||
|
||||
**面试官：** 应该。应该有的，一周内吧。还告诉我居然转正前要实习三个月？wtf，一个大三满课的本科生让我如何在八月底前实习三个月？
|
||||
|
||||
**我：** 面试官再见
|
||||
|
||||
|
||||
|
||||
### 三面 (46 分钟)
|
||||
|
||||
3.18 号，三面来了，这次又是那个大大 boss！
|
||||
|
||||
第一步还是先自我介绍，这个就不多说了，提前准备好要说的重点就没问题！
|
||||
|
||||
**面试官:** 聊聊你的项目？
|
||||
|
||||
**我:** 经过二面的教训，我迅速学习了一下分布式的理论知识，并应用到了我的项目（吹牛逼）中。
|
||||
|
||||
**面试官:** 看你用到了 Spring 的事务机制，你能说下 Spring 的事务传播吗？
|
||||
|
||||
**我：** 完了这个问题好像没准备，虽然之前刷知乎看到过。。。我就只说出来一条，面试官说其实这个有很多机制的，比如事务嵌套，内事务回滚外事务回滚都会有不同情况，你可以回去看看。
|
||||
|
||||
**面试官:** 说说你的分布式事务解决方案？
|
||||
|
||||
**我:** 我叭叭的照着资料查到的解决方案说了一通，面试官怎么好像没大听懂？？？
|
||||
|
||||
> 阿里巴巴之前开源了一个分布式 Fescar（一种易于使用，高性能，基于 Java 的开源分布式事务解决方案），后来，Ant Financial 加入 Fescar，使其成为一个更加中立和开放的分布式交易社区，Fescar 重命名为 Seata。Github 地址：<https://github.com/seata/seata>
|
||||
|
||||
**面试官:** 好，我们聊聊其他项目，说说你这个 MapReduce 项目？MapReduce 原理了解过吗？
|
||||
|
||||
**我:** 我叭叭地说了一通，面试官好像觉得这个项目太简单了。要不是没项目，我会把我的实验写上吗？？？
|
||||
|
||||
**面试官:** 你这个手写 BP 神经网络是干了啥？
|
||||
|
||||
**我:** 这是我选修机器学习课程时的一个作业，我又对它进行了扩展。
|
||||
|
||||
**面试官:** 你能说说为什么调整权值时要沿着梯度下降的方向？
|
||||
|
||||
**我:** 老大，你太厉害了，怎么什么都懂。我压根没准备这个项目。。。没想到会问，做过去好几个月了，加上当时一紧张就忘了，后来想起来大概是....。
|
||||
|
||||
**面试官:** 好我们问问基础知识吧，说说什么叫 xisuo？
|
||||
|
||||
**我：**？？？xisuo，您说什么，不好意思我没听清。（这面试官有点口音。。。）就是 xisuo 啊！xisuo 你不知道吗？。。。尴尬了十几秒后我终于意识到，他在说死锁！！！
|
||||
|
||||
**面试官:** 假如 A 账户给 B 账户转钱，会发生 xisuo 吗？能具体说说吗？
|
||||
|
||||
**我:** 当时答的不好，后来发现面试官又是想问分布式，具体答案参考这个：<https://blog.csdn.net/taylorchan2016/article/details/51039362>
|
||||
|
||||
**面试官:** 为什么不考研？
|
||||
|
||||
**我：** 不喜欢学术氛围，巴拉巴拉。
|
||||
|
||||
**面试官:** 你有什么问题吗？
|
||||
|
||||
**我:** 我还有下一面吗。。。面试官说让我等，一周内答复。
|
||||
|
||||
------
|
||||
|
||||
等了十天，一度以为我凉了，内推人说我流程到 HR 了，让我等着吧可能 HR 太忙了，3.28 号 HR 打来了电话，当时在教室，我直接飞了出去。
|
||||
|
||||
### HR 面
|
||||
|
||||
**面试官:** 你好啊，先自我介绍下吧
|
||||
|
||||
**我：** 巴拉巴拉....HR 面的技术面试和技术面的还是有所区别的！
|
||||
|
||||
面试官人特别好，一听就是很会说话的小姐姐！说我这里给你悄悄透露下，你的评级是 A 哦！
|
||||
|
||||
|
||||
|
||||
接下来就是几个经典 HR 面挂人的问题，什么难给我来什么，我看别人的 HR 面怎么都是聊聊天。。。
|
||||
|
||||
**面试官:** 你为什么选择支付宝呢，你怎么看待支付宝？
|
||||
|
||||
**我:** 我从个人情怀，公司理念，环境氛围，市场价值，趋势导向分析了一波（说白了就是疯狂夸支付宝，不过说实话我说的那些一点都没撒谎，阿里确实做到了。比如我举了个雷军和格力打赌 5 年 2000 亿销售额，大部分企业家关注的是利益，而马云更关注的是真的为人类为世界做一些事情，利益不是第一位的。）
|
||||
|
||||
**面试官:** 明白了解，那你的优点我们都很明了了，你能说说你的缺点吗？
|
||||
|
||||
> 缺点肯定不能是目标岗位需要的关键能力！！！
|
||||
>
|
||||
> 总之，记住一点，面试官问你这个问题的话，你可以说一些不影响你这个职位工作需要的一些缺点。比如你面试后端工程师，面试官问你的缺点是什么的话，你可以这样说：自己比较内向，平时不太爱与人交流，但是考虑到以后可能要和客户沟通，自己正在努力改。
|
||||
|
||||
**我:** 据说这是 HR 面最难的一个问题。。。我当时翻了好几天的知乎才找到一个合适的，也符合我的答案：我有时候会表现的不太自信，比如阿里的内推二月份就开始了，其实我当时已经复习了很久了，但是老是觉得自己还不行，不敢投简历，于是又把书看了一遍才投的，当时也是舍友怂恿一波才投的，面了之后发现其实自己也没有很差。（划重点，一定要把自己的缺点圆回来）。
|
||||
|
||||
**面试官:** HR 好像不太满意我的答案，继续问我还有缺点吗？
|
||||
|
||||
**我:** 我说比较容易紧张吧，举了自己大一面实验室因为紧张没进去的例子，后来不断调整心态，现在已经好很多了。
|
||||
|
||||
接下来又是个好难的问题。
|
||||
|
||||
**面试官：** BAT 都给你 offer 了，你怎么选？
|
||||
|
||||
其实我当时好想说，BT 是什么？不好意思我只知道阿里。
|
||||
|
||||
**我 :** 哈哈哈哈开玩笑，就说了阿里的文化，支付宝给我们带来很多便利，想加入支付宝为人类做贡献！
|
||||
|
||||
最后 HR 问了我实习时间，现在大几之类的问题，说肯定会给我发 offer 的，让我等着就好了，希望过两天能收到好的结果。
|
||||
|
||||
|
||||
@ -0,0 +1,89 @@
|
||||
昨天我整理了公众号历史所有和面试相关的我觉得还不错的文章：[整理了一些有助于你拿Offer的文章](<https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247485434&idx=1&sn=f6bdf19d2594bf719e149e48d1384340&chksm=cea24831f9d5c1278617d347238f65f0481f36291675f05fabb382b69ea0ff3adae7ee6e6524&token=1452779379&lang=zh_CN#rd>) 。今天分享一下最近逛Github看到了一些我觉得对于Java面试以及学习有帮助的仓库，这些仓库涉及Java核心知识点整理、Java常见面试题、算法、基础知识点比如网络和操作系统等等。
|
||||
|
||||
## 知识点相关
|
||||
|
||||
### 1.JavaGuide
|
||||
|
||||
- Github地址： [https://github.com/Snailclimb/JavaGuide](https://github.com/Snailclimb/JavaGuide)
|
||||
- star: 64.0k
|
||||
- 介绍: 【Java学习+面试指南】 一份涵盖大部分Java程序员所需要掌握的核心知识。
|
||||
|
||||
### 2.CS-Notes
|
||||
|
||||
- Github 地址：<https://github.com/CyC2018/CS-Notes>
|
||||
- Star: 68.3k
|
||||
- 介绍: 技术面试必备基础知识、Leetcode 题解、后端面试、Java 面试、春招、秋招、操作系统、计算机网络、系统设计。
|
||||
|
||||
### 3. advanced-java
|
||||
|
||||
- Github地址：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java)
|
||||
- star: 23.4k
|
||||
- 介绍: 互联网 Java 工程师进阶知识完全扫盲：涵盖高并发、分布式、高可用、微服务等领域知识，后端同学必看，前端同学也可学习。
|
||||
|
||||
### 4.JCSprout
|
||||
|
||||
- Github地址：[https://github.com/crossoverJie/JCSprout](https://github.com/crossoverJie/JCSprout)
|
||||
- star: 21.2k
|
||||
- 介绍: Java Core Sprout：处于萌芽阶段的 Java 核心知识库。
|
||||
|
||||
### 5.toBeTopJavaer
|
||||
|
||||
- Github地址：[https://github.com/hollischuang/toBeTopJavaer](https://github.com/hollischuang/toBeTopJavaer)
|
||||
- star: 4.0 k
|
||||
- 介绍: Java工程师成神之路。
|
||||
|
||||
### 6.architect-awesome
|
||||
|
||||
- Github地址：[https://github.com/xingshaocheng/architect-awesome](https://github.com/xingshaocheng/architect-awesome)
|
||||
- star: 34.4 k
|
||||
- 介绍:后端架构师技术图谱。
|
||||
|
||||
### 7.technology-talk
|
||||
|
||||
- Github地址： [https://github.com/aalansehaiyang/technology-talk](https://github.com/aalansehaiyang/technology-talk)
|
||||
- star: 6.1k
|
||||
- 介绍: 汇总java生态圈常用技术框架、开源中间件，系统架构、项目管理、经典架构案例、数据库、常用三方库、线上运维等知识。
|
||||
|
||||
### 8.fullstack-tutorial
|
||||
|
||||
- Github地址： [https://github.com/frank-lam/fullstack-tutorial](https://github.com/frank-lam/fullstack-tutorial)
|
||||
- star: 4.0k
|
||||
- 介绍: fullstack tutorial 2019，后台技术栈/架构师之路/全栈开发社区，春招/秋招/校招/面试。
|
||||
|
||||
### 9.3y
|
||||
|
||||
- Github地址：[https://github.com/ZhongFuCheng3y/3y](https://github.com/ZhongFuCheng3y/3y)
|
||||
- star: 1.9 k
|
||||
- 介绍: Java 知识整合。
|
||||
|
||||
### 10.java-bible
|
||||
|
||||
- Github地址：[https://github.com/biezhi/java-bible](https://github.com/biezhi/java-bible)
|
||||
- star: 2.3k
|
||||
- 介绍: 这里记录了一些技术摘要，部分文章来自网络，本项目的目的力求分享精品技术干货，以Java为主。
|
||||
|
||||
### 11.interviews
|
||||
|
||||
- Github地址: [https://github.com/kdn251/interviews/blob/master/README-zh-cn.md](https://github.com/kdn251/interviews/blob/master/README-zh-cn.md)
|
||||
- star: 35.3k
|
||||
- 介绍: 软件工程技术面试个人指南（国外的一个项目，虽然有翻译版，但是不太推荐，因为很多内容并不适用于国内）。
|
||||
|
||||
## 算法相关
|
||||
|
||||
### 1.LeetCodeAnimation
|
||||
|
||||
- Github 地址： <https://github.com/MisterBooo/LeetCodeAnimation>
|
||||
- Star: 33.4k
|
||||
- 介绍: Demonstrate all the questions on LeetCode in the form of animation.（用动画的形式呈现解LeetCode题目的思路）。
|
||||
|
||||
### 2.awesome-java-leetcode
|
||||
|
||||
- Github地址：[https://github.com/Blankj/awesome-java-leetcode](https://github.com/Blankj/awesome-java-leetcode)
|
||||
- star: 6.1k
|
||||
- 介绍: LeetCode 上 Facebook 的面试题目。
|
||||
|
||||
### 3.leetcode
|
||||
|
||||
- Github地址：[https://github.com/azl397985856/leetcode](https://github.com/azl397985856/leetcode)
|
||||
- star: 12.0k
|
||||
- 介绍: LeetCode Solutions: A Record of My Problem Solving Journey.( leetcode题解，记录自己的leetcode解题之路。)
|
||||
@ -1,4 +1,4 @@
|
||||
身边的朋友或者公众号的粉丝很多人都向我询问过:“我是双非/三本/专科学校的，我有机会进入大厂吗？”、“非计算机专业的学生能学好吗？”、“如何学习Java？”、“Java学习该学那些东西？”、“我该如何准备Java面试？”......这些方面的问题。我会根据自己的一点经验对大部分人关心的这些问题进行答疑解惑。现在又刚好赶上考研结束，这篇文章也算是给考研结束准备往Java后端方向发展的朋友们指名一条学习之路。道理懂了如果没有实际行动，那这篇文章对你或许没有任何意义。
|
||||
身边的朋友或者公众号的粉丝很多人都向我询问过：“我是双非/三本/专科学校的，我有机会进入大厂吗？”、“非计算机专业的学生能学好吗？”、“如何学习Java？”、“Java学习该学哪些东西？”、“我该如何准备Java面试？”......这些方面的问题。我会根据自己的一点经验对大部分人关心的这些问题进行答疑解惑。现在又刚好赶上考研结束，这篇文章也算是给考研结束准备往Java后端方向发展的朋友们指明一条学习之路。道理懂了如果没有实际行动，那这篇文章对你或许没有任何意义。
|
||||
|
||||
### Question1:我是双非/三本/专科学校的，我有机会进入大厂吗？
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
首先，我觉得学校歧视很正常，真的太正常了，如果要抱怨的话，你只能抱怨自己没有进入名校。但是，千万不要动不动说自己学校差，动不动拿自己学校当做自己进不了大厂的借口，学历只是筛选简历的很多标准中的一个而已，如果你够优秀，简历够丰富，你也一样可以和名校同学一起同台竞争。
|
||||
|
||||
企业HR肯定是更喜欢高学历的人，毕竟985，211优秀人才比例肯定比普通学校高很多，HR团队肯定会优先在这些学校里选。这就好比相亲，你是愿意在很多优秀的人中选一个优秀的，还是愿意在很多普通的人中选一个优秀的呢？
|
||||
企业HR肯定是更喜欢高学历的人，毕竟985、211优秀人才比例肯定比普通学校高很多，HR团队肯定会优先在这些学校里选。这就好比相亲，你是愿意在很多优秀的人中选一个优秀的，还是愿意在很多普通的人中选一个优秀的呢？
|
||||
|
||||
双非本科甚至是二本、三本甚至是专科的同学也有很多进入大厂的，不过比率相比于名校的低很多而已。从大厂招聘的结果上看，高学历人才的数量占据大头，那些成功进入BAT、美团，京东，网易等大厂的双非本科甚至是二本、三本甚至是专科的同学往往是因为具备丰富的项目经历或者在某个含金量比较高的竞赛比如ACM中取得了不错的成绩。**一部分学历不突出但能力出众的面试者能够进入大厂并不是说明学历不重要，而是学历的软肋能够通过其他的优势来弥补。** 所以，如果你的学校不够好而你自己又想去大厂的话，建议你可以从这几点来做：**①尽量在面试前最好有一个可以拿的出手的项目；②有实习条件的话，尽早出去实习，实习经历也会是你的简历的一个亮点（有能力在大厂实习最佳！）；③参加一些含金量比较高的比赛，拿不拿得到名次没关系，重在锻炼。**
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
|
||||
我觉得我们不应该因为自己的专业给自己划界限或者贴标签，说实话，很多科班的同学可能并不如你，你以为科班的同学就会认真听讲吗？还不是几乎全靠自己课下自学！不过如果你是非科班的话，你想要学好，那么注定就要舍弃自己本专业的一些学习时间，这是无可厚非的。
|
||||
|
||||
建议非科班的同学，首先要打好计算机基础知识基础：①计算机网络、②操作系统、③数据机构与算法，我个人觉得这3个对你最重要。这些东西就像是内功，对你以后的长远发展非常有用。当然，如果你想要进大厂的话，这些知识也是一定会被问到的。另外，“一定学好数据机构与算法！一定学好数据机构与算法！一定学好数据机构与算法！”，重要的东西说3遍。
|
||||
建议非科班的同学，首先要打好计算机基础知识基础：①计算机网络、②操作系统、③数据机构与算法，我个人觉得这3个对你最重要。这些东西就像是内功，对你以后的长远发展非常有用。当然，如果你想要进大厂的话，这些知识也是一定会被问到的。另外，“一定学好数据结构与算法！一定学好数据结构与算法！一定学好数据结构与算法！”，重要的东西说3遍。
|
||||
|
||||
|
||||
|
||||
@ -31,12 +31,12 @@
|
||||
|
||||
下面是我总结的一些准备面试的Tips以及面试必备的注意事项：
|
||||
|
||||
1. **准备一份自己的自我介绍，面试的时候根据面试对象适当进行修改**（突出重点，突出自己的优势在哪里，切忌流水账）；
|
||||
1. **准备一份自己的自我介绍，面试的时候根据面试对象适当进行修改**（突出重点，突出自己的优势在哪里，切忌流水账）；
|
||||
2. **注意随身带上自己的成绩单和简历复印件；** （有的公司在面试前都会让你交一份成绩单和简历当做面试中的参考。）
|
||||
3. **如果需要笔试就提前刷一些笔试题，大部分在线笔试的类型是选择题+编程题，有的还会有简答题。**（平时空闲时间多的可以刷一下笔试题目（牛客网上有很多），但是不要只刷面试题，不动手code，程序员不是为了考试而存在的。）另外，注意抓重点，因为题目太多了，但是有很多题目几乎次次遇到，像这样的题目一定要搞定。
|
||||
4. **提前准备技术面试。** 搞清楚自己面试中可能涉及哪些知识点、那些知识点是重点。面试中哪些问题会被经常问到、自己改如何回答。(强烈不推荐背题，第一：通过背这种方式你能记住多少？能记住多久？第二：背题的方式的学习很难坚持下去！)
|
||||
4. **提前准备技术面试。** 搞清楚自己面试中可能涉及哪些知识点、哪些知识点是重点。面试中哪些问题会被经常问到、自己该如何回答。(强烈不推荐背题，第一：通过背这种方式你能记住多少？能记住多久？第二：背题的方式的学习很难坚持下去！)
|
||||
5. **面试之前做好定向复习。** 也就是专门针对你要面试的公司来复习。比如你在面试之前可以在网上找找有没有你要面试的公司的面经。
|
||||
6. **准备好自己的项目介绍。** 如果有项目的话，技术面试第一步，面试官一般都是让你自己介绍一下你的项目。你可以从下面几个方向来考虑：①对项目整体设计的一个感受（面试官可能会让你画系统的架构图；②在这个项目中你负责了什么、做了什么、担任了什么角色；③ 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用；④项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如:用redis做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。
|
||||
6. **准备好自己的项目介绍。** 如果有项目的话，技术面试第一步，面试官一般都是让你自己介绍一下你的项目。你可以从下面几个方向来考虑：①对项目整体设计的一个感受（面试官可能会让你画系统的架构图）；②在这个项目中你负责了什么、做了什么、担任了什么角色；③ 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用；④项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如：用 redis 做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。
|
||||
7. **面试之后记得复盘。** 面试遭遇失败是很正常的事情，所以善于总结自己的失败原因才是最重要的。如果失败，不要灰心；如果通过，切勿狂喜。
|
||||
|
||||
|
||||
@ -1,8 +1,22 @@
|
||||
这是【备战春招/秋招系列】的第二篇文章，主要是简单地介绍如何去准备面试。
|
||||
|
||||
不论是校招还是社招都避免不了各种面试、笔试，如何去准备这些东西就显得格外重要。不论是笔试还是面试都是有章可循的，我这个“有章可循”说的意思只是说应对技术面试是可以提前准备。 我其实特别不喜欢那种临近考试就提前背啊记啊各种题的行为，非常反对！我觉得这种方法特别极端，而且在稍有一点经验的面试官面前是根本没有用的。建议大家还是一步一个脚印踏踏实实地走。
|
||||
|
||||
### 1 如何获取大厂面试机会？
|
||||
<!-- TOC -->
|
||||
|
||||
- [1 如何获取大厂面试机会？](#1-如何获取大厂面试机会)
|
||||
- [2 面试前的准备](#2--面试前的准备)
|
||||
- [2.1 准备自己的自我介绍](#21-准备自己的自我介绍)
|
||||
- [2.2 关于着装](#22-关于着装)
|
||||
- [2.3 随身带上自己的成绩单和简历](#23-随身带上自己的成绩单和简历)
|
||||
- [2.4 如果需要笔试就提前刷一些笔试题](#24-如果需要笔试就提前刷一些笔试题)
|
||||
- [2.5 花时间一些逻辑题](#25-花时间一些逻辑题)
|
||||
- [2.6 准备好自己的项目介绍](#26-准备好自己的项目介绍)
|
||||
- [2.7 提前准备技术面试](#27-提前准备技术面试)
|
||||
- [2.7 面试之前做好定向复习](#27-面试之前做好定向复习)
|
||||
- [3 面试之后复盘](#3-面试之后复盘)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
## 1 如何获取大厂面试机会？
|
||||
|
||||
**在讲如何获取大厂面试机会之前，先来给大家科普/对比一下两个校招非常常见的概念——春招和秋招。**
|
||||
|
||||
@ -24,7 +38,7 @@
|
||||
|
||||
除了这些方法，我也遇到过这样的经历：有些大公司的一些部门可能暂时没招够人，然后如果你的亲戚或者朋友刚好在这个公司，而你正好又在寻求offer，那么面试机会基本上是有了，而且这种面试的难度好像一般还普遍比其他正规面试低很多。
|
||||
|
||||
### 2 面试前的准备
|
||||
## 2 面试前的准备
|
||||
|
||||
### 2.1 准备自己的自我介绍
|
||||
|
||||
@ -57,11 +71,11 @@
|
||||
1. 对项目整体设计的一个感受（面试官可能会让你画系统的架构图）
|
||||
2. 在这个项目中你负责了什么、做了什么、担任了什么角色
|
||||
3. 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用
|
||||
4. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如:用redis做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。
|
||||
4. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如：用redis做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。
|
||||
|
||||
### 2.7 提前准备技术面试
|
||||
|
||||
搞清楚自己面试中可能涉及哪些知识点、那些知识点是重点。面试中哪些问题会被经常问到、自己改如何回答。(强烈不推荐背题，第一：通过背这种方式你能记住多少？能记住多久？第二：背题的方式的学习很难坚持下去！)
|
||||
搞清楚自己面试中可能涉及哪些知识点、哪些知识点是重点。面试中哪些问题会被经常问到、自己该如何回答。(强烈不推荐背题，第一：通过背这种方式你能记住多少？能记住多久？第二：背题的方式的学习很难坚持下去！)
|
||||
|
||||
### 2.7 面试之前做好定向复习
|
||||
|
||||
@ -69,6 +83,6 @@
|
||||
|
||||
举个栗子：在我面试 ThoughtWorks 的前几天我就在网上找了一些关于 ThoughtWorks 的技术面的一些文章。然后知道了 ThoughtWorks 的技术面会让我们在之前做的作业的基础上增加一个或两个功能，所以我提前一天就把我之前做的程序重新重构了一下。然后在技术面的时候，简单的改了几行代码之后写个测试就完事了。如果没有提前准备，我觉得 20 分钟我很大几率会完不成这项任务。
|
||||
|
||||
# 3 面试之后复盘
|
||||
## 3 面试之后复盘
|
||||
|
||||
如果失败，不要灰心；如果通过，切勿狂喜。面试和工作实际上是两回事，可能很多面试未通过的人，工作能力比你强的多，反之亦然。我个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！
|
||||
如果失败，不要灰心；如果通过，切勿狂喜。面试和工作实际上是两回事，可能很多面试未通过的人，工作能力比你强的多，反之亦然。我个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！
|
||||
@ -0,0 +1,743 @@
|
||||
<!-- TOC -->
|
||||
|
||||
- [一 为什么 Java 中只有值传递？](#一-为什么-java-中只有值传递)
|
||||
- [二 ==与 equals(重要)](#二-与-equals重要)
|
||||
- [三 hashCode 与 equals（重要）](#三-hashcode-与-equals重要)
|
||||
- [3.1 hashCode（）介绍](#31-hashcode介绍)
|
||||
- [3.2 为什么要有 hashCode](#32-为什么要有-hashcode)
|
||||
- [3.3 hashCode（）与 equals（）的相关规定](#33-hashcode与-equals的相关规定)
|
||||
- [3.4 为什么两个对象有相同的 hashcode 值，它们也不一定是相等的？](#34-为什么两个对象有相同的-hashcode-值它们也不一定是相等的)
|
||||
- [四 String 和 StringBuffer、StringBuilder 的区别是什么？String 为什么是不可变的？](#四-string-和-stringbufferstringbuilder-的区别是什么string-为什么是不可变的)
|
||||
- [String 为什么是不可变的吗？](#string-为什么是不可变的吗)
|
||||
- [String 真的是不可变的吗？](#string-真的是不可变的吗)
|
||||
- [五 什么是反射机制？反射机制的应用场景有哪些？](#五-什么是反射机制反射机制的应用场景有哪些)
|
||||
- [5.1 反射机制介绍](#51-反射机制介绍)
|
||||
- [5.2 静态编译和动态编译](#52-静态编译和动态编译)
|
||||
- [5.3 反射机制优缺点](#53-反射机制优缺点)
|
||||
- [5.4 反射的应用场景](#54-反射的应用场景)
|
||||
- [六 什么是 JDK?什么是 JRE？什么是 JVM？三者之间的联系与区别](#六-什么是-jdk什么是-jre什么是-jvm三者之间的联系与区别)
|
||||
- [6.1 JVM](#61-jvm)
|
||||
- [6.2 JDK 和 JRE](#62-jdk-和-jre)
|
||||
- [七 什么是字节码？采用字节码的最大好处是什么？](#七-什么是字节码采用字节码的最大好处是什么)
|
||||
- [八 接口和抽象类的区别是什么?](#八-接口和抽象类的区别是什么)
|
||||
- [九 重载和重写的区别](#九-重载和重写的区别)
|
||||
- [重载](#重载)
|
||||
- [重写](#重写)
|
||||
- [十. Java 面向对象编程三大特性: 封装 继承 多态](#十-java-面向对象编程三大特性-封装-继承-多态)
|
||||
- [封装](#封装)
|
||||
- [继承](#继承)
|
||||
- [多态](#多态)
|
||||
- [十一. 什么是线程和进程?](#十一-什么是线程和进程)
|
||||
- [11.1 何为进程?](#111-何为进程)
|
||||
- [11.2 何为线程?](#112-何为线程)
|
||||
- [十二. 请简要描述线程与进程的关系,区别及优缺点？](#十二-请简要描述线程与进程的关系区别及优缺点)
|
||||
- [12.1 图解进程和线程的关系](#121-图解进程和线程的关系)
|
||||
- [12.2 程序计数器为什么是私有的?](#122-程序计数器为什么是私有的)
|
||||
- [12.3 虚拟机栈和本地方法栈为什么是私有的?](#123-虚拟机栈和本地方法栈为什么是私有的)
|
||||
- [12.4 一句话简单了解堆和方法区](#124-一句话简单了解堆和方法区)
|
||||
- [十三. 说说并发与并行的区别?](#十三-说说并发与并行的区别)
|
||||
- [十四. 什么是上下文切换?](#十四-什么是上下文切换)
|
||||
- [十五. 什么是线程死锁?如何避免死锁?](#十五-什么是线程死锁如何避免死锁)
|
||||
- [15.1. 认识线程死锁](#151-认识线程死锁)
|
||||
- [15.2 如何避免线程死锁?](#152-如何避免线程死锁)
|
||||
- [十六. 说说 sleep() 方法和 wait() 方法区别和共同点?](#十六-说说-sleep-方法和-wait-方法区别和共同点)
|
||||
- [十七. 为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？](#十七-为什么我们调用-start-方法时会执行-run-方法为什么我们不能直接调用-run-方法)
|
||||
- [参考](#参考)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
## 一 为什么 Java 中只有值传递？
|
||||
|
||||
首先回顾一下在程序设计语言中有关将参数传递给方法（或函数）的一些专业术语。**按值调用(call by value)表示方法接收的是调用者提供的值，而按引用调用（call by reference)表示方法接收的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。** 它用来描述各种程序设计语言（不只是 Java)中方法参数传递方式。
|
||||
|
||||
**Java 程序设计语言总是采用按值调用。也就是说，方法得到的是所有参数值的一个拷贝，也就是说，方法不能修改传递给它的任何参数变量的内容。**
|
||||
|
||||
**下面通过 3 个例子来给大家说明**
|
||||
|
||||
> **example 1**
|
||||
|
||||
```java
|
||||
public static void main(String[] args) {
|
||||
int num1 = 10;
|
||||
int num2 = 20;
|
||||
|
||||
swap(num1, num2);
|
||||
|
||||
System.out.println("num1 = " + num1);
|
||||
System.out.println("num2 = " + num2);
|
||||
}
|
||||
|
||||
public static void swap(int a, int b) {
|
||||
int temp = a;
|
||||
a = b;
|
||||
b = temp;
|
||||
|
||||
System.out.println("a = " + a);
|
||||
System.out.println("b = " + b);
|
||||
}
|
||||
```
|
||||
|
||||
**结果：**
|
||||
|
||||
```
|
||||
a = 20
|
||||
b = 10
|
||||
num1 = 10
|
||||
num2 = 20
|
||||
```
|
||||
|
||||
**解析：**
|
||||
|
||||
|
||||
|
||||
在 swap 方法中，a、b 的值进行交换，并不会影响到 num1、num2。因为，a、b 中的值，只是从 num1、num2 的复制过来的。也就是说，a、b 相当于 num1、num2 的副本，副本的内容无论怎么修改，都不会影响到原件本身。
|
||||
|
||||
**通过上面例子，我们已经知道了一个方法不能修改一个基本数据类型的参数，而对象引用作为参数就不一样，请看 example2.**
|
||||
|
||||
> **example 2**
|
||||
|
||||
```java
|
||||
public static void main(String[] args) {
|
||||
int[] arr = { 1, 2, 3, 4, 5 };
|
||||
System.out.println(arr[0]);
|
||||
change(arr);
|
||||
System.out.println(arr[0]);
|
||||
}
|
||||
|
||||
public static void change(int[] array) {
|
||||
// 将数组的第一个元素变为0
|
||||
array[0] = 0;
|
||||
}
|
||||
```
|
||||
|
||||
**结果：**
|
||||
|
||||
```
|
||||
1
|
||||
0
|
||||
```
|
||||
|
||||
**解析：**
|
||||
|
||||
|
||||
|
||||
array 被初始化 arr 的拷贝也就是一个对象的引用，也就是说 array 和 arr 指向的是同一个数组对象。 因此，外部对引用对象的改变会反映到所对应的对象上。
|
||||
|
||||
**通过 example2 我们已经看到，实现一个改变对象参数状态的方法并不是一件难事。理由很简单，方法得到的是对象引用的拷贝，对象引用及其他的拷贝同时引用同一个对象。**
|
||||
|
||||
**很多程序设计语言（特别是，C++和 Pascal)提供了两种参数传递的方式：值调用和引用调用。有些程序员（甚至本书的作者）认为 Java 程序设计语言对对象采用的是引用调用，实际上，这种理解是不对的。由于这种误解具有一定的普遍性，所以下面给出一个反例来详细地阐述一下这个问题。**
|
||||
|
||||
> **example 3**
|
||||
|
||||
```java
|
||||
public class Test {
|
||||
|
||||
public static void main(String[] args) {
|
||||
// TODO Auto-generated method stub
|
||||
Student s1 = new Student("小张");
|
||||
Student s2 = new Student("小李");
|
||||
Test.swap(s1, s2);
|
||||
System.out.println("s1:" + s1.getName());
|
||||
System.out.println("s2:" + s2.getName());
|
||||
}
|
||||
|
||||
public static void swap(Student x, Student y) {
|
||||
Student temp = x;
|
||||
x = y;
|
||||
y = temp;
|
||||
System.out.println("x:" + x.getName());
|
||||
System.out.println("y:" + y.getName());
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**结果：**
|
||||
|
||||
```
|
||||
x:小李
|
||||
y:小张
|
||||
s1:小张
|
||||
s2:小李
|
||||
```
|
||||
|
||||
**解析：**
|
||||
|
||||
交换之前：
|
||||
|
||||
|
||||
|
||||
交换之后：
|
||||
|
||||
|
||||
|
||||
通过上面两张图可以很清晰的看出： **方法并没有改变存储在变量 s1 和 s2 中的对象引用。swap 方法的参数 x 和 y 被初始化为两个对象引用的拷贝，这个方法交换的是这两个拷贝**
|
||||
|
||||
> **总结**
|
||||
|
||||
Java 程序设计语言对对象采用的不是引用调用，实际上，对象引用是按
|
||||
值传递的。
|
||||
|
||||
下面再总结一下 Java 中方法参数的使用情况：
|
||||
|
||||
- 一个方法不能修改一个基本数据类型的参数（即数值型或布尔型）。
|
||||
- 一个方法可以改变一个对象参数的状态。
|
||||
- 一个方法不能让对象参数引用一个新的对象。
|
||||
|
||||
**参考：**
|
||||
|
||||
《Java 核心技术卷 Ⅰ》基础知识第十版第四章 4.5 小节
|
||||
|
||||
## 二 ==与 equals(重要)
|
||||
|
||||
**==** : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。(基本数据类型==比较的是值，引用数据类型==比较的是内存地址)
|
||||
|
||||
**equals()** : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：
|
||||
|
||||
- 情况 1：类没有覆盖 equals()方法。则通过 equals()比较该类的两个对象时，等价于通过“==”比较这两个对象。
|
||||
- 情况 2：类覆盖了 equals()方法。一般，我们都覆盖 equals()方法来两个对象的内容相等；若它们的内容相等，则返回 true(即，认为这两个对象相等)。
|
||||
|
||||
**举个例子：**
|
||||
|
||||
```java
|
||||
public class test1 {
|
||||
public static void main(String[] args) {
|
||||
String a = new String("ab"); // a 为一个引用
|
||||
String b = new String("ab"); // b为另一个引用,对象的内容一样
|
||||
String aa = "ab"; // 放在常量池中
|
||||
String bb = "ab"; // 从常量池中查找
|
||||
if (aa == bb) // true
|
||||
System.out.println("aa==bb");
|
||||
if (a == b) // false，非同一对象
|
||||
System.out.println("a==b");
|
||||
if (a.equals(b)) // true
|
||||
System.out.println("aEQb");
|
||||
if (42 == 42.0) { // true
|
||||
System.out.println("true");
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**说明：**
|
||||
|
||||
- String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是对象的值。
|
||||
- 当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。
|
||||
|
||||
## 三 hashCode 与 equals（重要）
|
||||
|
||||
面试官可能会问你：“你重写过 hashcode 和 equals 么，为什么重写 equals 时必须重写 hashCode 方法？”
|
||||
|
||||
### 3.1 hashCode（）介绍
|
||||
|
||||
hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个 int 整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在 JDK 的 Object.java 中，这就意味着 Java 中的任何类都包含有 hashCode() 函数。另外需要注意的是： Object 的 hashcode 方法是本地方法，也就是用 c 语言或 c++ 实现的，该方法通常用来将对象的 内存地址 转换为整数之后返回。
|
||||
|
||||
```java
|
||||
/**
|
||||
* Returns a hash code value for the object. This method is
|
||||
* supported for the benefit of hash tables such as those provided by
|
||||
* {@link java.util.HashMap}.
|
||||
* <p>
|
||||
* As much as is reasonably practical, the hashCode method defined by
|
||||
* class {@code Object} does return distinct integers for distinct
|
||||
* objects. (This is typically implemented by converting the internal
|
||||
* address of the object into an integer, but this implementation
|
||||
* technique is not required by the
|
||||
* Java™ programming language.)
|
||||
*
|
||||
* @return a hash code value for this object.
|
||||
* @see java.lang.Object#equals(java.lang.Object)
|
||||
* @see java.lang.System#identityHashCode
|
||||
*/
|
||||
public native int hashCode();
|
||||
```
|
||||
|
||||
散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）
|
||||
|
||||
### 3.2 为什么要有 hashCode
|
||||
|
||||
**我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：**
|
||||
|
||||
当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的 hashcode，HashSet 会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals（）方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自我的 Java 启蒙书《Head fist java》第二版）。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。
|
||||
|
||||
### 3.3 hashCode（）与 equals（）的相关规定
|
||||
|
||||
1. 如果两个对象相等，则 hashcode 一定也是相同的
|
||||
2. 两个对象相等,对两个对象分别调用 equals 方法都返回 true
|
||||
3. 两个对象有相同的 hashcode 值，它们也不一定是相等的
|
||||
4. **因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖**
|
||||
5. hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）
|
||||
|
||||
### 3.4 为什么两个对象有相同的 hashcode 值，它们也不一定是相等的？
|
||||
|
||||
在这里解释一位小伙伴的问题。以下内容摘自《Head Fisrt Java》。
|
||||
|
||||
因为 hashCode() 所使用的杂凑算法也许刚好会让多个对象传回相同的杂凑值。越糟糕的杂凑算法越容易碰撞，但这也与数据值域分布的特性有关（所谓碰撞也就是指的是不同的对象得到相同的 hashCode）。
|
||||
|
||||
我们刚刚也提到了 HashSet,如果 HashSet 在对比的时候，同样的 hashcode 有多个对象，它会使用 equals() 来判断是否真的相同。也就是说 hashcode 只是用来缩小查找成本。
|
||||
|
||||
## 四 String 和 StringBuffer、StringBuilder 的区别是什么？String 为什么是不可变的？
|
||||
|
||||
**可变性**
|
||||
|
||||
简单的来说：String 类中使用 final 关键字修饰字符数组来保存字符串，`private final char value[]`，所以 String 对象是不可变的。而 StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串`char[]value` 但是没有用 final 关键字修饰，所以这两种对象都是可变的。
|
||||
|
||||
StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是 AbstractStringBuilder 实现的，大家可以自行查阅源码。
|
||||
|
||||
AbstractStringBuilder.java
|
||||
|
||||
```java
|
||||
abstract class AbstractStringBuilder implements Appendable, CharSequence {
|
||||
char[] value;
|
||||
int count;
|
||||
AbstractStringBuilder() {
|
||||
}
|
||||
AbstractStringBuilder(int capacity) {
|
||||
value = new char[capacity];
|
||||
}
|
||||
```
|
||||
|
||||
**线程安全性**
|
||||
|
||||
String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。
|
||||
|
||||
**性能**
|
||||
|
||||
每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
|
||||
|
||||
**对于三者使用的总结：**
|
||||
|
||||
1. 操作少量的数据: 适用 String
|
||||
2. 单线程操作字符串缓冲区下操作大量数据: 适用 StringBuilder
|
||||
3. 多线程操作字符串缓冲区下操作大量数据: 适用 StringBuffer
|
||||
|
||||
#### String 为什么是不可变的吗？
|
||||
|
||||
简单来说就是 String 类利用了 final 修饰的 char 类型数组存储字符，源码如下图所以：
|
||||
|
||||
```java
|
||||
/** The value is used for character storage. */
|
||||
private final char value[];
|
||||
```
|
||||
|
||||
#### String 真的是不可变的吗？
|
||||
|
||||
我觉得如果别人问这个问题的话，回答不可变就可以了。
|
||||
下面只是给大家看两个有代表性的例子：
|
||||
|
||||
**1) String 不可变但不代表引用不可以变**
|
||||
|
||||
```java
|
||||
String str = "Hello";
|
||||
str = str + " World";
|
||||
System.out.println("str=" + str);
|
||||
```
|
||||
|
||||
结果：
|
||||
|
||||
```
|
||||
str=Hello World
|
||||
```
|
||||
|
||||
解析：
|
||||
|
||||
实际上，原来 String 的内容是不变的，只是 str 由原来指向"Hello"的内存地址转为指向"Hello World"的内存地址而已，也就是说多开辟了一块内存区域给"Hello World"字符串。
|
||||
|
||||
**2) 通过反射是可以修改所谓的“不可变”对象**
|
||||
|
||||
```java
|
||||
// 创建字符串"Hello World"， 并赋给引用s
|
||||
String s = "Hello World";
|
||||
|
||||
System.out.println("s = " + s); // Hello World
|
||||
|
||||
// 获取String类中的value字段
|
||||
Field valueFieldOfString = String.class.getDeclaredField("value");
|
||||
|
||||
// 改变value属性的访问权限
|
||||
valueFieldOfString.setAccessible(true);
|
||||
|
||||
// 获取s对象上的value属性的值
|
||||
char[] value = (char[]) valueFieldOfString.get(s);
|
||||
|
||||
// 改变value所引用的数组中的第5个字符
|
||||
value[5] = '_';
|
||||
|
||||
System.out.println("s = " + s); // Hello_World
|
||||
```
|
||||
|
||||
结果：
|
||||
|
||||
```
|
||||
s = Hello World
|
||||
s = Hello_World
|
||||
```
|
||||
|
||||
解析：
|
||||
|
||||
用反射可以访问私有成员， 然后反射出 String 对象中的 value 属性， 进而改变通过获得的 value 引用改变数组的结构。但是一般我们不会这么做，这里只是简单提一下有这个东西。
|
||||
|
||||
## 五 什么是反射机制？反射机制的应用场景有哪些？
|
||||
|
||||
### 5.1 反射机制介绍
|
||||
|
||||
JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 java 语言的反射机制。
|
||||
|
||||
### 5.2 静态编译和动态编译
|
||||
|
||||
- **静态编译：**在编译时确定类型，绑定对象
|
||||
- **动态编译：**运行时确定类型，绑定对象
|
||||
|
||||
### 5.3 反射机制优缺点
|
||||
|
||||
- **优点：** 运行期类型的判断，动态加载类，提高代码灵活度。
|
||||
- **缺点：** 性能瓶颈：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的 java 代码要慢很多。
|
||||
|
||||
### 5.4 反射的应用场景
|
||||
|
||||
**反射是框架设计的灵魂。**
|
||||
|
||||
在我们平时的项目开发过程中，基本上很少会直接使用到反射机制，但这不能说明反射机制没有用，实际上有很多设计、开发都与反射机制有关，例如模块化的开发，通过反射去调用对应的字节码；动态代理设计模式也采用了反射机制，还有我们日常使用的 Spring／Hibernate 等框架也大量使用到了反射机制。
|
||||
|
||||
举例：① 我们在使用 JDBC 连接数据库时使用 `Class.forName()`通过反射加载数据库的驱动程序；②Spring 框架也用到很多反射机制，最经典的就是 xml 的配置模式。Spring 通过 XML 配置模式装载 Bean 的过程：1) 将程序内所有 XML 或 Properties 配置文件加载入内存中;
|
||||
2)Java 类里面解析 xml 或 properties 里面的内容，得到对应实体类的字节码字符串以及相关的属性信息; 3)使用反射机制，根据这个字符串获得某个类的 Class 实例; 4)动态配置实例的属性
|
||||
|
||||
**推荐阅读：**
|
||||
|
||||
- [Reflection：Java 反射机制的应用场景](https://segmentfault.com/a/1190000010162647?utm_source=tuicool&utm_medium=referral "Reflection：Java反射机制的应用场景")
|
||||
- [Java 基础之—反射（非常重要）](https://blog.csdn.net/sinat_38259539/article/details/71799078 "Java基础之—反射（非常重要）")
|
||||
|
||||
## 六 什么是 JDK?什么是 JRE？什么是 JVM？三者之间的联系与区别
|
||||
|
||||
### 6.1 JVM
|
||||
|
||||
Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。
|
||||
|
||||
**什么是字节码?采用字节码的好处是什么?**
|
||||
|
||||
> 在 Java 中，JVM 可以理解的代码就叫做`字节码`（即扩展名为 `.class` 的文件），它不面向任何特定的处理器，只面向虚拟机。Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比较高效，而且，由于字节码并不针对一种特定的机器，因此，Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。
|
||||
|
||||
**Java 程序从源代码到运行一般有下面 3 步：**
|
||||
|
||||
|
||||
|
||||
我们需要格外注意的是 .class->机器码 这一步。在这一步 JVM 类加载器首先加载字节码文件，然后通过解释器逐行解释执行，这种方式的执行速度会相对比较慢。而且，有些方法和代码块是经常需要被调用的(也就是所谓的热点代码)，所以后面引进了 JIT 编译器，而 JIT 属于运行时编译。当 JIT 编译器完成第一次编译后，其会将字节码对应的机器码保存下来，下次可以直接使用。而我们知道，机器码的运行效率肯定是高于 Java 解释器的。这也解释了我们为什么经常会说 Java 是编译与解释共存的语言。
|
||||
|
||||
> HotSpot 采用了惰性评估(Lazy Evaluation)的做法，根据二八定律，消耗大部分系统资源的只有那一小部分的代码（热点代码），而这也就是 JIT 所需要编译的部分。JVM 会根据代码每次被执行的情况收集信息并相应地做出一些优化，因此执行的次数越多，它的速度就越快。JDK 9 引入了一种新的编译模式 AOT(Ahead of Time Compilation)，它是直接将字节码编译成机器码，这样就避免了 JIT 预热等各方面的开销。JDK 支持分层编译和 AOT 协作使用。但是 ，AOT 编译器的编译质量是肯定比不上 JIT 编译器的。
|
||||
|
||||
**总结：**
|
||||
|
||||
Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。
|
||||
|
||||
### 6.2 JDK 和 JRE
|
||||
|
||||
JDK 是 Java Development Kit，它是功能齐全的 Java SDK。它拥有 JRE 所拥有的一切，还有编译器（javac）和工具（如 javadoc 和 jdb）。它能够创建和编译程序。
|
||||
|
||||
JRE 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有内容的集合，包括 Java 虚拟机（JVM），Java 类库，java 命令和其他的一些基础构件。但是，它不能用于创建新程序。
|
||||
|
||||
如果你只是为了运行一下 Java 程序的话，那么你只需要安装 JRE 就可以了。如果你需要进行一些 Java 编程方面的工作，那么你就需要安装 JDK 了。但是，这不是绝对的。有时，即使您不打算在计算机上进行任何 Java 开发，仍然需要安装 JDK。例如，如果要使用 JSP 部署 Web 应用程序，那么从技术上讲，您只是在应用程序服务器中运行 Java 程序。那你为什么需要 JDK 呢？因为应用程序服务器会将 JSP 转换为 Java servlet，并且需要使用 JDK 来编译 servlet。
|
||||
|
||||
## 七 什么是字节码？采用字节码的最大好处是什么？
|
||||
|
||||
**先看下 java 中的编译器和解释器：**
|
||||
|
||||
Java 中引入了虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由解释器来将虚拟机代码转换为特定系统的机器码执行。在 Java 中，这种供虚拟机理解的代码叫做`字节码`（即扩展名为`.class`的文件），它不面向任何特定的处理器，只面向虚拟机。每一种平台的解释器是不同的，但是实现的虚拟机是相同的。Java 源程序经过编译器编译后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码，然后在特定的机器上运行。这也就是解释了 Java 的编译与解释并存的特点。
|
||||
|
||||
Java 源代码---->编译器---->jvm 可执行的 Java 字节码(即虚拟指令)---->jvm---->jvm 中解释器----->机器可执行的二进制机器码---->程序运行。
|
||||
|
||||
**采用字节码的好处：**
|
||||
|
||||
Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比较高效，而且，由于字节码并不专对一种特定的机器，因此，Java 程序无须重新编译便可在多种不同的计算机上运行。
|
||||
|
||||
## 八 接口和抽象类的区别是什么?
|
||||
|
||||
1. 接口的方法默认是 public，所有方法在接口中不能有实现，抽象类可以有非抽象的方法
|
||||
2. 接口中的实例变量默认是 final 类型的，而抽象类中则不一定
|
||||
3. 一个类可以实现多个接口，但最多只能实现一个抽象类
|
||||
4. 一个类实现接口的话要实现接口的所有方法，而抽象类不一定
|
||||
5. 接口不能用 new 实例化，但可以声明，但是必须引用一个实现该接口的对象 从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。
|
||||
|
||||
注意：Java8 后接口可以有默认实现( default )。
|
||||
|
||||
## 九 重载和重写的区别
|
||||
|
||||
### 重载
|
||||
|
||||
发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同。
|
||||
|
||||
下面是《Java 核心技术》对重载这个概念的介绍：
|
||||
|
||||
|
||||
|
||||
### 重写
|
||||
|
||||
重写是子类对父类的允许访问的方法的实现过程进行重新编写,发生在子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。另外，如果父类方法访问修饰符为 private 则子类就不能重写该方法。**也就是说方法提供的行为改变，而方法的外貌并没有改变。**
|
||||
|
||||
## 十. Java 面向对象编程三大特性: 封装 继承 多态
|
||||
|
||||
### 封装
|
||||
|
||||
封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。
|
||||
|
||||
### 继承
|
||||
|
||||
继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码。
|
||||
|
||||
**关于继承如下 3 点请记住：**
|
||||
|
||||
1. 子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，**只是拥有**。
|
||||
2. 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
|
||||
3. 子类可以用自己的方式实现父类的方法。（以后介绍）。
|
||||
|
||||
### 多态
|
||||
|
||||
所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
|
||||
|
||||
在 Java 中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）。
|
||||
|
||||
## 十一. 什么是线程和进程?
|
||||
|
||||
### 11.1 何为进程?
|
||||
|
||||
进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。
|
||||
|
||||
在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。
|
||||
|
||||
如下图所示，在 windows 中通过查看任务管理器的方式，我们就可以清楚看到 window 当前运行的进程（.exe 文件的运行）。
|
||||
|
||||
|
||||
|
||||
### 11.2 何为线程?
|
||||
|
||||
线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享进程的**堆**和**方法区**资源，但每个线程有自己的**程序计数器**、**虚拟机栈**和**本地方法栈**，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
|
||||
|
||||
Java 程序天生就是多线程程序，我们可以通过 JMX 来看一下一个普通的 Java 程序有哪些线程，代码如下。
|
||||
|
||||
```java
|
||||
public class MultiThread {
|
||||
public static void main(String[] args) {
|
||||
// 获取 Java 线程管理 MXBean
|
||||
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
|
||||
// 不需要获取同步的 monitor 和 synchronizer 信息，仅获取线程和线程堆栈信息
|
||||
ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
|
||||
// 遍历线程信息，仅打印线程 ID 和线程名称信息
|
||||
for (ThreadInfo threadInfo : threadInfos) {
|
||||
System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
上述程序输出如下（输出内容可能不同，不用太纠结下面每个线程的作用，只用知道 main 线程执行 main 方法即可）：
|
||||
|
||||
```
|
||||
[5] Attach Listener //添加事件
|
||||
[4] Signal Dispatcher // 分发处理给 JVM 信号的线程
|
||||
[3] Finalizer //调用对象 finalize 方法的线程
|
||||
[2] Reference Handler //清除 reference 线程
|
||||
[1] main //main 线程,程序入口
|
||||
```
|
||||
|
||||
从上面的输出内容可以看出：**一个 Java 程序的运行是 main 线程和多个其他线程同时运行**。
|
||||
|
||||
## 十二. 请简要描述线程与进程的关系,区别及优缺点？
|
||||
|
||||
**从 JVM 角度说进程和线程之间的关系**
|
||||
|
||||
### 12.1 图解进程和线程的关系
|
||||
|
||||
下图是 Java 内存区域，通过下图我们从 JVM 的角度来说一下线程和进程之间的关系。如果你对 Java 内存区域 (运行时数据区) 这部分知识不太了解的话可以阅读一下这篇文章：[《可能是把 Java 内存区域讲的最清楚的一篇文章》](https://github.com/Snailclimb/JavaGuide/blob/3965c02cc0f294b0bd3580df4868d5e396959e2e/Java%E7%9B%B8%E5%85%B3/%E5%8F%AF%E8%83%BD%E6%98%AF%E6%8A%8AJava%E5%86%85%E5%AD%98%E5%8C%BA%E5%9F%9F%E8%AE%B2%E7%9A%84%E6%9C%80%E6%B8%85%E6%A5%9A%E7%9A%84%E4%B8%80%E7%AF%87%E6%96%87%E7%AB%A0.md "《可能是把 Java 内存区域讲的最清楚的一篇文章》")
|
||||
|
||||
<div align="center">
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3/JVM运行时数据区域.png" width="600px"/>
|
||||
</div>
|
||||
|
||||
从上图可以看出：一个进程中可以有多个线程，多个线程共享进程的**堆**和**方法区 (JDK1.8 之后的元空间)**资源，但是每个线程有自己的**程序计数器**、**虚拟机栈** 和 **本地方法栈**。
|
||||
|
||||
**总结：** 线程 是 进程 划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。线程执行开销小，但不利于资源的管理和保护；而进程正相反
|
||||
|
||||
下面是该知识点的扩展内容！
|
||||
|
||||
下面来思考这样一个问题：为什么**程序计数器**、**虚拟机栈**和**本地方法栈**是线程私有的呢？为什么堆和方法区是线程共享的呢？
|
||||
|
||||
### 12.2 程序计数器为什么是私有的?
|
||||
|
||||
程序计数器主要有下面两个作用：
|
||||
|
||||
1. 字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制，如：顺序执行、选择、循环、异常处理。
|
||||
2. 在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。
|
||||
|
||||
需要注意的是，如果执行的是 native 方法，那么程序计数器记录的是 undefined 地址，只有执行的是 Java 代码时程序计数器记录的才是下一条指令的地址。
|
||||
|
||||
所以，程序计数器私有主要是为了**线程切换后能恢复到正确的执行位置**。
|
||||
|
||||
### 12.3 虚拟机栈和本地方法栈为什么是私有的?
|
||||
|
||||
- **虚拟机栈：** 每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
|
||||
- **本地方法栈：** 和虚拟机栈所发挥的作用非常相似，区别是： **虚拟机栈为虚拟机执行 Java 方法 （也就是字节码）服务，而本地方法栈则为虚拟机使用到的 Native 方法服务。** 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。
|
||||
|
||||
所以，为了**保证线程中的局部变量不被别的线程访问到**，虚拟机栈和本地方法栈是线程私有的。
|
||||
|
||||
### 12.4 一句话简单了解堆和方法区
|
||||
|
||||
堆和方法区是所有线程共享的资源，其中堆是进程中最大的一块内存，主要用于存放新创建的对象 (所有对象都在这里分配内存)，方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
|
||||
|
||||
## 十三. 说说并发与并行的区别?
|
||||
|
||||
- **并发：** 同一时间段，多个任务都在执行 (单位时间内不一定同时执行)；
|
||||
- **并行：** 单位时间内，多个任务同时执行。
|
||||
|
||||
## 十四. 什么是上下文切换?
|
||||
|
||||
多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。
|
||||
|
||||
概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换回这个任务时，可以再加载这个任务的状态。**任务从保存到再加载的过程就是一次上下文切换**。
|
||||
|
||||
上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。
|
||||
|
||||
Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。
|
||||
|
||||
## 十五. 什么是线程死锁?如何避免死锁?
|
||||
|
||||
### 15.1. 认识线程死锁
|
||||
|
||||
多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
|
||||
|
||||
如下图所示，线程 A 持有资源 2，线程 B 持有资源 1，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。
|
||||
|
||||
|
||||
|
||||
下面通过一个例子来说明线程死锁,代码模拟了上图的死锁的情况 (代码来源于《并发编程之美》)：
|
||||
|
||||
```java
|
||||
public class DeadLockDemo {
|
||||
private static Object resource1 = new Object();//资源 1
|
||||
private static Object resource2 = new Object();//资源 2
|
||||
|
||||
public static void main(String[] args) {
|
||||
new Thread(() -> {
|
||||
synchronized (resource1) {
|
||||
System.out.println(Thread.currentThread() + "get resource1");
|
||||
try {
|
||||
Thread.sleep(1000);
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
System.out.println(Thread.currentThread() + "waiting get resource2");
|
||||
synchronized (resource2) {
|
||||
System.out.println(Thread.currentThread() + "get resource2");
|
||||
}
|
||||
}
|
||||
}, "线程 1").start();
|
||||
|
||||
new Thread(() -> {
|
||||
synchronized (resource2) {
|
||||
System.out.println(Thread.currentThread() + "get resource2");
|
||||
try {
|
||||
Thread.sleep(1000);
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
System.out.println(Thread.currentThread() + "waiting get resource1");
|
||||
synchronized (resource1) {
|
||||
System.out.println(Thread.currentThread() + "get resource1");
|
||||
}
|
||||
}
|
||||
}, "线程 2").start();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Output
|
||||
|
||||
```
|
||||
Thread[线程 1,5,main]get resource1
|
||||
Thread[线程 2,5,main]get resource2
|
||||
Thread[线程 1,5,main]waiting get resource2
|
||||
Thread[线程 2,5,main]waiting get resource1
|
||||
```
|
||||
|
||||
线程 A 通过 synchronized (resource1) 获得 resource1 的监视器锁，然后通过`Thread.sleep(1000);`让线程 A 休眠 1s 为的是让线程 B 得到执行然后获取到 resource2 的监视器锁。线程 A 和线程 B 休眠结束了都开始企图请求获取对方的资源，然后这两个线程就会陷入互相等待的状态，这也就产生了死锁。上面的例子符合产生死锁的四个必要条件。
|
||||
|
||||
学过操作系统的朋友都知道产生死锁必须具备以下四个条件：
|
||||
|
||||
1. 互斥条件：该资源任意一个时刻只由一个线程占用。
|
||||
2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
|
||||
3. 不剥夺条件:线程已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
|
||||
4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
|
||||
|
||||
### 15.2 如何避免线程死锁?
|
||||
|
||||
我们只要破坏产生死锁的四个条件中的其中一个就可以了。
|
||||
|
||||
**破坏互斥条件**
|
||||
|
||||
这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。
|
||||
|
||||
**破坏请求与保持条件**
|
||||
|
||||
一次性申请所有的资源。
|
||||
|
||||
**破坏不剥夺条件**
|
||||
|
||||
占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
|
||||
|
||||
**破坏循环等待条件**
|
||||
|
||||
靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。
|
||||
|
||||
我们对线程 2 的代码修改成下面这样就不会产生死锁了。
|
||||
|
||||
```java
|
||||
new Thread(() -> {
|
||||
synchronized (resource1) {
|
||||
System.out.println(Thread.currentThread() + "get resource1");
|
||||
try {
|
||||
Thread.sleep(1000);
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
System.out.println(Thread.currentThread() + "waiting get resource2");
|
||||
synchronized (resource2) {
|
||||
System.out.println(Thread.currentThread() + "get resource2");
|
||||
}
|
||||
}
|
||||
}, "线程 2").start();
|
||||
```
|
||||
|
||||
Output
|
||||
|
||||
```
|
||||
Thread[线程 1,5,main]get resource1
|
||||
Thread[线程 1,5,main]waiting get resource2
|
||||
Thread[线程 1,5,main]get resource2
|
||||
Thread[线程 2,5,main]get resource1
|
||||
Thread[线程 2,5,main]waiting get resource2
|
||||
Thread[线程 2,5,main]get resource2
|
||||
|
||||
Process finished with exit code 0
|
||||
```
|
||||
|
||||
我们分析一下上面的代码为什么避免了死锁的发生?
|
||||
|
||||
线程 1 首先获得到 resource1 的监视器锁,这时候线程 2 就获取不到了。然后线程 1 再去获取 resource2 的监视器锁，可以获取到。然后线程 1 释放了对 resource1、resource2 的监视器锁的占用，线程 2 获取到就可以执行了。这样就破坏了破坏循环等待条件，因此避免了死锁。
|
||||
|
||||
## 十六. 说说 sleep() 方法和 wait() 方法区别和共同点?
|
||||
|
||||
- 两者最主要的区别在于：**sleep 方法没有释放锁，而 wait 方法释放了锁** 。
|
||||
- 两者都可以暂停线程的执行。
|
||||
- Wait 通常被用于线程间交互/通信，sleep 通常被用于暂停执行。
|
||||
- wait() 方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的 notify() 或者 notifyAll() 方法。sleep() 方法执行完成后，线程会自动苏醒。或者可以使用 wait(long timeout)超时后线程会自动苏醒。
|
||||
|
||||
## 十七. 为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？
|
||||
|
||||
这是另一个非常经典的 java 多线程面试问题，而且在面试中会经常被问到。很简单，但是很多人都会答不上来！
|
||||
|
||||
new 一个 Thread，线程进入了新建状态;调用 start() 方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。 start() 会执行线程的相应准备工作，然后自动执行 run() 方法的内容，这是真正的多线程工作。 而直接执行 run() 方法，会把 run 方法当成一个 main 线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。
|
||||
|
||||
**总结： 调用 start 方法方可启动线程并使线程进入就绪状态，而 run 方法只是 thread 的一个普通方法调用，还是在主线程里执行。**
|
||||
|
||||
## 参考
|
||||
|
||||
- [https://blog.csdn.net/zhzhao999/article/details/53449504](https://blog.csdn.net/zhzhao999/article/details/53449504 "https://blog.csdn.net/zhzhao999/article/details/53449504")
|
||||
- [https://www.cnblogs.com/skywang12345/p/3324958.html](https://www.cnblogs.com/skywang12345/p/3324958.html "https://www.cnblogs.com/skywang12345/p/3324958.html")
|
||||
- [https://www.cnblogs.com/Eason-S/p/5524837.html](https://www.cnblogs.com/Eason-S/p/5524837.html "https://www.cnblogs.com/Eason-S/p/5524837.html")
|
||||
@ -1,21 +1,43 @@
|
||||
# 程序员的简历就该这样写
|
||||
<!-- TOC -->
|
||||
|
||||
### 1 前言
|
||||
<font color="red">一份好的简历可以在整个申请面试以及面试过程中起到非常好的作用。</font> 在不夸大自己能力的情况下，写出一份好的简历也是一项很棒的能力。
|
||||
- [程序员简历就该这样写](#程序员简历就该这样写)
|
||||
- [为什么说简历很重要？](#为什么说简历很重要)
|
||||
- [先从面试前来说](#先从面试前来说)
|
||||
- [再从面试中来说](#再从面试中来说)
|
||||
- [下面这几点你必须知道](#下面这几点你必须知道)
|
||||
- [必须了解的两大法则](#必须了解的两大法则)
|
||||
- [STAR法则（Situation Task Action Result）](#star法则situation-task-action-result)
|
||||
- [FAB 法则（Feature Advantage Benefit）](#fab-法则feature-advantage-benefit)
|
||||
- [项目经历怎么写？](#项目经历怎么写)
|
||||
- [专业技能该怎么写？](#专业技能该怎么写)
|
||||
- [排版注意事项](#排版注意事项)
|
||||
- [其他的一些小tips](#其他的一些小tips)
|
||||
- [推荐的工具/网站](#推荐的工具网站)
|
||||
|
||||
### 2 为什么说简历很重要？
|
||||
<!-- /TOC -->
|
||||
|
||||
#### 2.1 先从面试前来说
|
||||
# 程序员简历就该这样写
|
||||
|
||||
假如你是网申，你的简历必然会经过HR的筛选，一张简历HR可能也就花费10秒钟看一下，然后HR就会决定你这一关是Fail还是Pass。
|
||||
本篇文章除了教大家用Markdown如何写一份程序员专属的简历，后面还会给大家推荐一些不错的用来写Markdown简历的软件或者网站，以及如何优雅的将Markdown格式转变为PDF格式或者其他格式。
|
||||
|
||||
假如你是内推，如果你的简历没有什么优势的话，就算是内推你的人再用心，也无能为力。
|
||||
推荐大家使用Markdown语法写简历，然后再将Markdown格式转换为PDF格式后进行简历投递。
|
||||
|
||||
如果你对Markdown语法不太了解的话，可以花半个小时简单看一下Markdown语法说明: http://www.markdown.cn 。
|
||||
|
||||
## 为什么说简历很重要？
|
||||
|
||||
一份好的简历可以在整个申请面试以及面试过程中起到非常好的作用。 在不夸大自己能力的情况下，写出一份好的简历也是一项很棒的能力。为什么说简历很重要呢?
|
||||
|
||||
### 先从面试前来说
|
||||
|
||||
- 假如你是网申，你的简历必然会经过HR的筛选，一张简历HR可能也就花费10秒钟看一下，然后HR就会决定你这一关是Fail还是Pass。
|
||||
- 假如你是内推，如果你的简历没有什么优势的话，就算是内推你的人再用心，也无能为力。
|
||||
|
||||
另外，就算你通过了筛选，后面的面试中，面试官也会根据你的简历来判断你究竟是否值得他花费很多时间去面试。
|
||||
|
||||
所以，简历就像是我们的一个门面一样，它在很大程度上决定了你能否进入到下一轮的面试中。
|
||||
|
||||
#### 2.2 再从面试中来说
|
||||
### 再从面试中来说
|
||||
|
||||
我发现大家比较喜欢看面经 ，这点无可厚非，但是大部分面经都没告诉你很多问题都是在特定条件下才问的。举个简单的例子：一般情况下你的简历上注明你会的东西才会被问到（Java、数据结构、网络、算法这些基础是每个人必问的），比如写了你会 redis,那面试官就很大概率会问你 redis 的一些问题。比如：redis的常见数据类型及应用场景、redis是单线程为什么还这么快、 redis 和 memcached 的区别、redis 内存淘汰机制等等。
|
||||
|
||||
@ -23,17 +45,16 @@
|
||||
|
||||
面试和工作是两回事，聪明的人会把面试官往自己擅长的领域领，其他人则被面试官牵着鼻子走。虽说面试和工作是两回事，但是你要想要获得自己满意的 offer ，你自身的实力必须要强。
|
||||
|
||||
### 3 下面这几点你必须知道
|
||||
## 下面这几点你必须知道
|
||||
|
||||
1. 大部分公司的HR都说我们不看重学历（骗你的！），但是如果你的学校不出众的话，很难在一堆简历中脱颖而出，除非你的简历上有特别的亮点，比如：某某大厂的实习经历、获得了某某大赛的奖等等。
|
||||
1. 大部分公司的HR都说我们不看重学历（骗你的！），但是如果你的学校不出众的话，很难在一堆简历中脱颖而出，除非你的简历上有特别的亮点，比如：某某大厂的实习经历、获得了某某大赛的奖等等。
|
||||
2. **大部分应届生找工作的硬伤是没有工作经验或实习经历，所以如果你是应届生就不要错过秋招和春招。一旦错过，你后面就极大可能会面临社招，这个时候没有工作经验的你可能就会面临各种碰壁，导致找不到一个好的工作**
|
||||
3. **写在简历上的东西一定要慎重，这是面试官大量提问的地方；**
|
||||
4. **将自己的项目经历完美的展示出来非常重要。**
|
||||
4. **将自己的项目经历完美的展示出来非常重要。**
|
||||
|
||||
### 4 必须了解的两大法则
|
||||
## 必须了解的两大法则
|
||||
|
||||
|
||||
**①STAR法则（Situation Task Action Result）：**
|
||||
### STAR法则（Situation Task Action Result）
|
||||
|
||||
- **Situation：** 事情是在什么情况下发生；
|
||||
- **Task:：** 你是如何明确你的任务的；
|
||||
@ -42,14 +63,7 @@
|
||||
|
||||
简而言之，STAR法则，就是一种讲述自己故事的方式，或者说，是一个清晰、条理的作文模板。不管是什么，合理熟练运用此法则，可以轻松的对面试官描述事物的逻辑方式，表现出自己分析阐述问题的清晰性、条理性和逻辑性。
|
||||
|
||||
下面这段内容摘自百度百科，我觉得写的非常不错：
|
||||
|
||||
> STAR法则，500强面试题回答时的技巧法则，备受面试者成功者和500强HR的推崇。
|
||||
由于这个法则被广泛应用于面试问题的回答，尽管我们还在写简历阶段，但是，写简历时能把面试的问题就想好，会使自己更加主动和自信，做到简历，面试关联性，逻辑性强，不至于在一个月后去面试，却把简历里的东西都忘掉了（更何况有些朋友会稍微夸大简历内容）
|
||||
在我们写简历时，每个人都要写上自己的工作经历，活动经历，想必每一个同学，都会起码花上半天甚至更长的时间去搜寻脑海里所有有关的经历，争取找出最好的东西写在简历上。
|
||||
但是此时，我们要注意了，简历上的任何一个信息点都有可能成为日后面试时的重点提问对象，所以说，不能只管写上让自己感觉最牛的经历就完事了，要想到今后，在面试中，你所写的经历万一被面试官问到，你真的能回答得流利，顺畅，且能通过这段经历，证明自己正是适合这个职位的人吗？
|
||||
|
||||
**②FAB 法则（Feature Advantage Benefit）：**
|
||||
### FAB 法则（Feature Advantage Benefit）
|
||||
|
||||
- **Feature：** 是什么；
|
||||
- **Advantage：** 比别人好在哪些地方；
|
||||
@ -57,7 +71,7 @@
|
||||
|
||||
简单来说，这个法则主要是让你的面试官知道你的优势、招了你之后对公司有什么帮助。
|
||||
|
||||
### 5 项目经历怎么写？
|
||||
## 项目经历怎么写？
|
||||
|
||||
简历上有一两个项目经历很正常，但是真正能把项目经历很好的展示给面试官的非常少。对于项目经历大家可以考虑从如下几点来写：
|
||||
|
||||
@ -66,7 +80,8 @@
|
||||
3. 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用
|
||||
4. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的又或者说你在这个项目用了什么技术实现了什么功能比如:用redis做缓存提高访问速度和并发量、使用消息队列削峰和降流等等。
|
||||
|
||||
### 6 专业技能该怎么写？
|
||||
## 专业技能该怎么写？
|
||||
|
||||
先问一下你自己会什么，然后看看你意向的公司需要什么。一般HR可能并不太懂技术，所以他在筛选简历的时候可能就盯着你专业技能的关键词来看。对于公司有要求而你不会的技能，你可以花几天时间学习一下，然后在简历上可以写上自己了解这个技能。比如你可以这样写(下面这部分内容摘自我的简历，大家可以根据自己的情况做一些修改和完善)：
|
||||
|
||||
- 计算机网络、数据结构、算法、操作系统等课内基础知识：掌握
|
||||
@ -79,28 +94,28 @@
|
||||
- Zookeeper: 掌握
|
||||
- 常见消息队列: 掌握
|
||||
- Linux：掌握
|
||||
- MySQL常见优化手段：掌握
|
||||
- MySQL常见优化手段：掌握
|
||||
- Spring Boot +Spring Cloud +Docker:了解
|
||||
- Hadoop 生态相关技术中的 HDFS、Storm、MapReduce、Hive、Hbase ：了解
|
||||
- Python 基础、一些常见第三方库比如OpenCV、wxpy、wordcloud、matplotlib：熟悉
|
||||
|
||||
### 7 开源程序员Markdown格式简历模板分享
|
||||
## 排版注意事项
|
||||
|
||||
分享一个Github上开源的程序员简历模板。包括PHP程序员简历模板、iOS程序员简历模板、Android程序员简历模板、Web前端程序员简历模板、Java程序员简历模板、C/C++程序员简历模板、NodeJS程序员简历模板、架构师简历模板以及通用程序员简历模板 。
|
||||
Github地址：[https://github.com/geekcompany/ResumeSample](https://github.com/geekcompany/ResumeSample)
|
||||
1. 尽量简洁，不要太花里胡哨；
|
||||
2. 一些技术名词不要弄错了大小写比如MySQL不要写成mysql，Java不要写成java。这个在我看来还是比较忌讳的，所以一定要注意这个细节；
|
||||
3. 中文和数字英文之间加上空格的话看起来会舒服一点；
|
||||
|
||||
|
||||
我的下面这篇文章讲了如何写一份Markdown格式的简历，另外，文中还提到了一种实现 Markdown 格式到PDF、HTML、JPEG这几种格式的转换方法。
|
||||
|
||||
[手把手教你用Markdown写一份高质量的简历](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484347&idx=1&sn=a986ea7e199871999a5257bd3ed78be1&chksm=fd9855dacaefdccc2c5d5f8f79c4aa1b608ad5b42936bccaefb99a850a2e6e8e2e910e1b3153&token=719595858&lang=zh_CN#rd)
|
||||
|
||||
### 8 其他的一些小tips
|
||||
## 其他的一些小tips
|
||||
|
||||
1. 尽量避免主观表述，少一点语义模糊的形容词，尽量要简洁明了，逻辑结构清晰。
|
||||
2. 注意排版（不需要花花绿绿的），尽量使用Markdown语法。
|
||||
3. 如果自己有博客或者个人技术栈点的话，写上去会为你加分很多。
|
||||
4. 如果自己的Github比较活跃的话，写上去也会为你加分很多。
|
||||
5. 注意简历真实性，一定不要写自己不会的东西，或者带有欺骗性的内容
|
||||
6. 项目经历建议以时间倒序排序，另外项目经历不在于多，而在于有亮点。
|
||||
7. 如果内容过多的话，不需要非把内容压缩到一页，保持排版干净整洁就可以了。
|
||||
8. 简历最后最好能加上：“感谢您花时间阅读我的简历，期待能有机会和您共事。”这句话，显的你会很有礼貌。
|
||||
2. 如果自己有博客或者个人技术栈点的话，写上去会为你加分很多。
|
||||
3. 如果自己的Github比较活跃的话，写上去也会为你加分很多。
|
||||
4. 注意简历真实性，一定不要写自己不会的东西，或者带有欺骗性的内容
|
||||
5. 项目经历建议以时间倒序排序，另外项目经历不在于多，而在于有亮点。
|
||||
6. 如果内容过多的话，不需要非把内容压缩到一页，保持排版干净整洁就可以了。
|
||||
7. 简历最后最好能加上：“感谢您花时间阅读我的简历，期待能有机会和您共事。”这句话，显的你会很有礼貌。
|
||||
|
||||
## 推荐的工具/网站
|
||||
|
||||
- 冷熊简历(MarkDown在线简历工具，可在线预览、编辑和生成PDF):<http://cv.ftqq.com/>
|
||||
- Typora+[Java程序员简历模板](https://github.com/geekcompany/ResumeSample/blob/master/java.md)
|
||||
@ -0,0 +1,925 @@
|
||||
<!-- TOC -->
|
||||
|
||||
- [一 基础篇](#一-基础篇)
|
||||
- [1. `System.out.println(3|9)`输出什么?](#1-systemoutprintln39输出什么)
|
||||
- [2. 说一下转发(Forward)和重定向(Redirect)的区别](#2-说一下转发forward和重定向redirect的区别)
|
||||
- [3. 在浏览器中输入 url 地址到显示主页的过程,整个过程会使用哪些协议](#3-在浏览器中输入-url-地址到显示主页的过程整个过程会使用哪些协议)
|
||||
- [4. TCP 三次握手和四次挥手](#4-tcp-三次握手和四次挥手)
|
||||
- [为什么要三次握手](#为什么要三次握手)
|
||||
- [为什么要传回 SYN](#为什么要传回-syn)
|
||||
- [传了 SYN,为啥还要传 ACK](#传了-syn为啥还要传-ack)
|
||||
- [为什么要四次挥手](#为什么要四次挥手)
|
||||
- [5. IP 地址与 MAC 地址的区别](#5-ip-地址与-mac-地址的区别)
|
||||
- [6. HTTP 请求,响应报文格式](#6-http-请求响应报文格式)
|
||||
- [7. 为什么要使用索引?索引这么多优点,为什么不对表中的每一个列创建一个索引呢?索引是如何提高查询速度的?说一下使用索引的注意事项?Mysql 索引主要使用的两种数据结构?什么是覆盖索引?](#7-为什么要使用索引索引这么多优点为什么不对表中的每一个列创建一个索引呢索引是如何提高查询速度的说一下使用索引的注意事项mysql-索引主要使用的两种数据结构什么是覆盖索引)
|
||||
- [8. 进程与线程的区别是什么?进程间的几种通信方式说一下?线程间的几种通信方式知道不?](#8-进程与线程的区别是什么进程间的几种通信方式说一下线程间的几种通信方式知道不)
|
||||
- [9. 为什么要用单例模式?手写几种线程安全的单例模式?](#9-为什么要用单例模式手写几种线程安全的单例模式)
|
||||
- [10. 简单介绍一下 bean;知道 Spring 的 bean 的作用域与生命周期吗?](#10-简单介绍一下-bean知道-spring-的-bean-的作用域与生命周期吗)
|
||||
- [11. Spring 中的事务传播行为了解吗?TransactionDefinition 接口中哪五个表示隔离级别的常量?](#11-spring-中的事务传播行为了解吗transactiondefinition-接口中哪五个表示隔离级别的常量)
|
||||
- [事务传播行为](#事务传播行为)
|
||||
- [隔离级别](#隔离级别)
|
||||
- [12. SpringMVC 原理了解吗?](#12-springmvc-原理了解吗)
|
||||
- [13. Spring AOP IOC 实现原理](#13-spring-aop-ioc-实现原理)
|
||||
- [二 进阶篇](#二-进阶篇)
|
||||
- [1 消息队列 MQ 的套路](#1-消息队列-mq-的套路)
|
||||
- [1.1 介绍一下消息队列 MQ 的应用场景/使用消息队列的好处](#11-介绍一下消息队列-mq-的应用场景使用消息队列的好处)
|
||||
- [1)通过异步处理提高系统性能](#1通过异步处理提高系统性能)
|
||||
- [2)降低系统耦合性](#2降低系统耦合性)
|
||||
- [1.2 那么使用消息队列会带来什么问题?考虑过这些问题吗?](#12-那么使用消息队列会带来什么问题考虑过这些问题吗)
|
||||
- [1.3 介绍一下你知道哪几种消息队列,该如何选择呢?](#13-介绍一下你知道哪几种消息队列该如何选择呢)
|
||||
- [1.4 关于消息队列其他一些常见的问题展望](#14-关于消息队列其他一些常见的问题展望)
|
||||
- [2 谈谈 InnoDB 和 MyIsam 两者的区别](#2-谈谈-innodb-和-myisam-两者的区别)
|
||||
- [2.1 两者的对比](#21-两者的对比)
|
||||
- [2.2 关于两者的总结](#22-关于两者的总结)
|
||||
- [3 聊聊 Java 中的集合吧!](#3-聊聊-java-中的集合吧)
|
||||
- [3.1 Arraylist 与 LinkedList 有什么不同?(注意加上从数据结构分析的内容)](#31-arraylist-与-linkedlist-有什么不同注意加上从数据结构分析的内容)
|
||||
- [3.2 HashMap 的底层实现](#32-hashmap-的底层实现)
|
||||
- [1)JDK1.8 之前](#1jdk18-之前)
|
||||
- [2)JDK1.8 之后](#2jdk18-之后)
|
||||
- [3.3 既然谈到了红黑树,你给我手绘一个出来吧,然后简单讲一下自己对于红黑树的理解](#33-既然谈到了红黑树你给我手绘一个出来吧然后简单讲一下自己对于红黑树的理解)
|
||||
- [3.4 红黑树这么优秀,为何不直接使用红黑树得了?](#34-红黑树这么优秀为何不直接使用红黑树得了)
|
||||
- [3.5 HashMap 和 Hashtable 的区别/HashSet 和 HashMap 区别](#35-hashmap-和-hashtable-的区别hashset-和-hashmap-区别)
|
||||
- [三 终结篇](#三-终结篇)
|
||||
- [1. Object 类有哪些方法?](#1-object-类有哪些方法)
|
||||
- [1.1 Object 类的常见方法总结](#11-object-类的常见方法总结)
|
||||
- [1.2 hashCode 与 equals](#12-hashcode-与-equals)
|
||||
- [1.2.1 hashCode()介绍](#121-hashcode介绍)
|
||||
- [1.2.2 为什么要有 hashCode](#122-为什么要有-hashcode)
|
||||
- [1.2.3 hashCode()与 equals()的相关规定](#123-hashcode与-equals的相关规定)
|
||||
- [1.2.4 为什么两个对象有相同的 hashcode 值,它们也不一定是相等的?](#124-为什么两个对象有相同的-hashcode-值它们也不一定是相等的)
|
||||
- [1.3 ==与 equals](#13-与-equals)
|
||||
- [2 ConcurrentHashMap 相关问题](#2-concurrenthashmap-相关问题)
|
||||
- [2.1 ConcurrentHashMap 和 Hashtable 的区别](#21-concurrenthashmap-和-hashtable-的区别)
|
||||
- [2.2 ConcurrentHashMap 线程安全的具体实现方式/底层具体实现](#22-concurrenthashmap-线程安全的具体实现方式底层具体实现)
|
||||
- [JDK1.7(上面有示意图)](#jdk17上面有示意图)
|
||||
- [JDK1.8(上面有示意图)](#jdk18上面有示意图)
|
||||
- [3 谈谈 synchronized 和 ReentrantLock 的区别](#3-谈谈-synchronized-和-reentrantlock-的区别)
|
||||
- [4 线程池了解吗?](#4-线程池了解吗)
|
||||
- [4.1 为什么要用线程池?](#41-为什么要用线程池)
|
||||
- [4.2 Java 提供了哪几种线程池?他们各自的使用场景是什么?](#42-java-提供了哪几种线程池他们各自的使用场景是什么)
|
||||
- [Java 主要提供了下面 4 种线程池](#java-主要提供了下面-4-种线程池)
|
||||
- [各种线程池的适用场景介绍](#各种线程池的适用场景介绍)
|
||||
- [4.3 创建的线程池的方式](#43-创建的线程池的方式)
|
||||
- [5 Nginx](#5-nginx)
|
||||
- [5.1 简单介绍一下 Nginx](#51-简单介绍一下-nginx)
|
||||
- [反向代理](#反向代理)
|
||||
- [负载均衡](#负载均衡)
|
||||
- [动静分离](#动静分离)
|
||||
- [5.2 为什么要用 Nginx?](#52-为什么要用-nginx)
|
||||
- [5.3 Nginx 的四个主要组成部分了解吗?](#53-nginx-的四个主要组成部分了解吗)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
这些问题是 2018 年去美团面试的同学被问到的一些常见的问题，希望对你有帮助！
|
||||
|
||||
# 一 基础篇
|
||||
|
||||
## 1. `System.out.println(3|9)`输出什么?
|
||||
|
||||
正确答案：11。
|
||||
|
||||
**考察知识点：&和&&；|和||**
|
||||
|
||||
**&和&&：**
|
||||
|
||||
共同点：两者都可做逻辑运算符。它们都表示运算符的两边都是 true 时，结果为 true；
|
||||
|
||||
不同点: &也是位运算符。& 表示在运算时两边都会计算，然后再判断；&&表示先运算符号左边的东西，然后判断是否为 true，是 true 就继续运算右边的然后判断并输出，是 false 就停下来直接输出不会再运行后面的东西。
|
||||
|
||||
**|和||：**
|
||||
|
||||
共同点：两者都可做逻辑运算符。它们都表示运算符的两边任意一边为 true，结果为 true，两边都不是 true，结果就为 false；
|
||||
|
||||
不同点：|也是位运算符。| 表示两边都会运算，然后再判断结果；|| 表示先运算符号左边的东西，然后判断是否为 true，是 true 就停下来直接输出不会再运行后面的东西，是 false 就继续运算右边的然后判断并输出。
|
||||
|
||||
**回到本题：**
|
||||
|
||||
3 | 9=0011（二进制） | 1001（二进制）=1011（二进制）=11（十进制）
|
||||
|
||||
## 2. 说一下转发(Forward)和重定向(Redirect)的区别
|
||||
|
||||
**转发是服务器行为，重定向是客户端行为。**
|
||||
|
||||
**转发（Forword）** 通过 RequestDispatcher 对象的`forward（HttpServletRequest request,HttpServletResponse response）`方法实现的。`RequestDispatcher` 可以通过`HttpServletRequest` 的 `getRequestDispatcher()`方法获得。例如下面的代码就是跳转到 login_success.jsp 页面。
|
||||
|
||||
```java
|
||||
request.getRequestDispatcher("login_success.jsp").forward(request, response);
|
||||
```
|
||||
|
||||
**重定向（Redirect）** 是利用服务器返回的状态码来实现的。客户端浏览器请求服务器的时候，服务器会返回一个状态码。服务器通过 HttpServletRequestResponse 的 setStatus(int status)方法设置状态码。如果服务器返回 301 或者 302，则浏览器会到新的网址重新请求该资源。
|
||||
|
||||
1. **从地址栏显示来说**：forward 是服务器请求资源，服务器直接访问目标地址的 URL，把那个 URL 的响应内容读取过来，然后把这些内容再发给浏览器。浏览器根本不知道服务器发送的内容从哪里来的，所以它的地址栏还是原来的地址。redirect 是服务端根据逻辑，发送一个状态码，告诉浏览器重新去请求那个地址。所以地址栏显示的是新的 URL。
|
||||
2. **从数据共享来说**：forward：转发页面和转发到的页面可以共享 request 里面的数据。redirect：不能共享数据。
|
||||
3. **从运用地方来说**：forward：一般用于用户登陆的时候，根据角色转发到相应的模块。redirect：一般用于用户注销登陆时返回主页面和跳转到其它的网站等。
|
||||
4. **从效率来说**：forward：高。redirect：低。
|
||||
|
||||
## 3. 在浏览器中输入 url 地址到显示主页的过程,整个过程会使用哪些协议
|
||||
|
||||
图片来源：《图解 HTTP》：
|
||||
|
||||
|
||||
|
||||
总体来说分为以下几个过程:
|
||||
|
||||
1. DNS 解析
|
||||
2. TCP 连接
|
||||
3. 发送 HTTP 请求
|
||||
4. 服务器处理请求并返回 HTTP 报文
|
||||
5. 浏览器解析渲染页面
|
||||
6. 连接结束
|
||||
|
||||
具体可以参考下面这篇文章：
|
||||
|
||||
- [https://segmentfault.com/a/1190000006879700](https://segmentfault.com/a/1190000006879700 "https://segmentfault.com/a/1190000006879700")
|
||||
|
||||
> 修正 [issue-568](https://github.com/Snailclimb/JavaGuide/issues/568 "issue-568")：上图中 IP 数据包在路由器之间使用的协议为 OPSF 协议错误，应该为 OSPF 协议 。
|
||||
>
|
||||
> IP 数据包在路由器之间传播大致分为 IGP 和 BGP 协议，而 IGP 目前主流为 OSPF 协议，思科，华为和 H3C 等主流厂商都有各自实现并使用；BGP 协议为不同 AS（自治系统号）间路由传输，也分为 I-BGP 和 E-BGP，详细资料请查看《TCP/IP 卷一》
|
||||
|
||||
## 4. TCP 三次握手和四次挥手
|
||||
|
||||
为了准确无误地把数据送达目标处，TCP 协议采用了三次握手策略。
|
||||
|
||||
**漫画图解：**
|
||||
|
||||
图片来源：《图解 HTTP》
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-11/tcp三次握手.jpg" style="zoom:50%;" />
|
||||
|
||||
**简单示意图：**
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-11/tcp三次握手2.jpg" style="zoom:50%;" />
|
||||
|
||||
- 客户端–发送带有 SYN 标志的数据包–一次握手–服务端
|
||||
- 服务端–发送带有 SYN/ACK 标志的数据包–二次握手–客户端
|
||||
- 客户端–发送带有带有 ACK 标志的数据包–三次握手–服务端
|
||||
|
||||
#### 为什么要三次握手
|
||||
|
||||
**三次握手的目的是建立可靠的通信信道，说到通讯，简单来说就是数据的发送与接收，而三次握手最主要的目的就是双方确认自己与对方的发送与接收是正常的。**
|
||||
|
||||
第一次握手：Client 什么都不能确认；Server 确认了对方发送正常，自己接收正常。
|
||||
|
||||
第二次握手：Client 确认了：自己发送、接收正常，对方发送、接收正常；Server 确认了：自己接收正常，对方发送正常
|
||||
|
||||
第三次握手：Client 确认了：自己发送、接收正常，对方发送、接收正常；Server 确认了：自己发送、接收正常，对方发送、接收正常
|
||||
|
||||
所以三次握手就能确认双发收发功能都正常，缺一不可。
|
||||
|
||||
#### 为什么要传回 SYN
|
||||
|
||||
接收端传回发送端所发送的 SYN 是为了告诉发送端，我接收到的信息确实就是你所发送的信号了。
|
||||
|
||||
> SYN 是 TCP/IP 建立连接时使用的握手信号。在客户机和服务器之间建立正常的 TCP 网络连接时，客户机首先发出一个 SYN 消息，服务器使用 SYN-ACK 应答表示接收到了这个消息，最后客户机再以 ACK(Acknowledgement[汉译：确认字符 ,在数据通信传输中，接收站发给发送站的一种传输控制字符。它表示确认发来的数据已经接受无误。 ]）消息响应。这样在客户机和服务器之间才能建立起可靠的 TCP 连接，数据才可以在客户机和服务器之间传递。
|
||||
|
||||
#### 传了 SYN,为啥还要传 ACK
|
||||
|
||||
双方通信无误必须是两者互相发送信息都无误。传了 SYN，证明发送方（主动关闭方）到接收方（被动关闭方）的通道没有问题，但是接收方到发送方的通道还需要 ACK 信号来进行验证。
|
||||
|
||||
断开一个 TCP 连接则需要“四次挥手”：
|
||||
|
||||
- 客户端-发送一个 FIN，用来关闭客户端到服务器的数据传送
|
||||
- 服务器-收到这个 FIN，它发回一 个 ACK，确认序号为收到的序号加 1 。和 SYN 一样，一个 FIN 将占用一个序号
|
||||
- 服务器-关闭与客户端的连接，发送一个 FIN 给客户端
|
||||
- 客户端-发回 ACK 报文确认，并将确认序号设置为收到序号加 1
|
||||
|
||||
#### 为什么要四次挥手
|
||||
|
||||
任何一方都可以在数据传送结束后发出连接释放的通知，待对方确认后进入半关闭状态。当另一方也没有数据再发送的时候，则发出连接释放通知，对方确认后就完全关闭了 TCP 连接。
|
||||
|
||||
举个例子：A 和 B 打电话，通话即将结束后，A 说“我没啥要说的了”，B 回答“我知道了”，但是 B 可能还会有要说的话，A 不能要求 B 跟着自己的节奏结束通话，于是 B 可能又巴拉巴拉说了一通，最后 B 说“我说完了”，A 回答“知道了”，这样通话才算结束。
|
||||
|
||||
上面讲的比较概括，推荐一篇讲的比较细致的文章：[https://blog.csdn.net/qzcsu/article/details/72861891](https://blog.csdn.net/qzcsu/article/details/72861891 "https://blog.csdn.net/qzcsu/article/details/72861891")
|
||||
|
||||
## 5. IP 地址与 MAC 地址的区别
|
||||
|
||||
参考：[https://blog.csdn.net/guoweimelon/article/details/50858597](https://blog.csdn.net/guoweimelon/article/details/50858597 "https://blog.csdn.net/guoweimelon/article/details/50858597")
|
||||
|
||||
IP 地址是指互联网协议地址（Internet Protocol Address）IP Address 的缩写。IP 地址是 IP 协议提供的一种统一的地址格式，它为互联网上的每一个网络和每一台主机分配一个逻辑地址，以此来屏蔽物理地址的差异。
|
||||
|
||||
MAC 地址又称为物理地址、硬件地址，用来定义网络设备的位置。网卡的物理地址通常是由网卡生产厂家写入网卡的，具有全球唯一性。MAC 地址用于在网络中唯一标示一个网卡，一台电脑会有一或多个网卡，每个网卡都需要有一个唯一的 MAC 地址。
|
||||
|
||||
## 6. HTTP 请求,响应报文格式
|
||||
|
||||
HTTP 请求报文主要由请求行、请求头部、请求正文 3 部分组成
|
||||
|
||||
HTTP 响应报文主要由状态行、响应头部、响应正文 3 部分组成
|
||||
|
||||
详细内容可以参考：[https://blog.csdn.net/a19881029/article/details/14002273](https://blog.csdn.net/a19881029/article/details/14002273 "https://blog.csdn.net/a19881029/article/details/14002273")
|
||||
|
||||
## 7. 为什么要使用索引?索引这么多优点,为什么不对表中的每一个列创建一个索引呢?索引是如何提高查询速度的?说一下使用索引的注意事项?Mysql 索引主要使用的两种数据结构?什么是覆盖索引?
|
||||
|
||||
**为什么要使用索引？**
|
||||
|
||||
1. 通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
|
||||
2. 可以大大加快 数据的检索速度（大大减少的检索的数据量）, 这也是创建索引的最主要的原因。
|
||||
3. 帮助服务器避免排序和临时表
|
||||
4. 将随机 IO 变为顺序 IO
|
||||
5. 可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
|
||||
|
||||
**索引这么多优点，为什么不对表中的每一个列创建一个索引呢？**
|
||||
|
||||
1. 当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。
|
||||
2. 索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。
|
||||
3. 创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
|
||||
|
||||
**索引是如何提高查询速度的？**
|
||||
|
||||
将无序的数据变成相对有序的数据（就像查目录一样）
|
||||
|
||||
**说一下使用索引的注意事项**
|
||||
|
||||
1. 避免 where 子句中对字段施加函数，这会造成无法命中索引。
|
||||
2. 在使用 InnoDB 时使用与业务无关的自增主键作为主键，即使用逻辑主键，而不要使用业务主键。
|
||||
3. 将打算加索引的列设置为 NOT NULL ，否则将导致引擎放弃使用索引而进行全表扫描
|
||||
4. 删除长期未使用的索引，不用的索引的存在会造成不必要的性能损耗 MySQL 5.7 可以通过查询 sys 库的 schema_unused_indexes 视图来查询哪些索引从未被使用
|
||||
5. 在使用 limit offset 查询缓慢时，可以借助索引来提高性能
|
||||
|
||||
**Mysql 索引主要使用的哪两种数据结构？**
|
||||
|
||||
- 哈希索引：对于哈希索引来说，底层的数据结构就是哈希表，因此在绝大多数需求为单条记录查询的时候，可以选择哈希索引，查询性能最快；其余大部分场景，建议选择 BTree 索引。
|
||||
- BTree 索引：Mysql 的 BTree 索引使用的是 B 树中的 B+Tree。但对于主要的两种存储引擎（MyISAM 和 InnoDB）的实现方式是不同的。
|
||||
|
||||
更多关于索引的内容可以查看我的这篇文章：[【思维导图-索引篇】搞定数据库索引就是这么简单](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484486&idx=1&sn=215450f11e042bca8a58eac9f4a97686&chksm=fd985227caefdb3117b8375f150676f5824aa20d1ebfdbcfb93ff06e23e26efbafae6cf6b48e&token=1990180468&lang=zh_CN#rd)
|
||||
|
||||
**什么是覆盖索引?**
|
||||
|
||||
如果一个索引包含（或者说覆盖）所有需要查询的字段的值，我们就称
|
||||
之为“覆盖索引”。我们知道在 InnoDB 存储引擎中，如果不是主键索引，叶子节点存储的是主键+列值。最终还是要“回表”，也就是要通过主键再查找一次,这样就会比较慢。覆盖索引就是把要查询出的列和索引是对应的，不做回表操作！
|
||||
|
||||
## 8. 进程与线程的区别是什么?进程间的几种通信方式说一下?线程间的几种通信方式知道不?
|
||||
|
||||
**进程与线程的区别是什么？**
|
||||
|
||||
线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。另外，也正是因为共享资源，所以线程中执行时一般都要进行同步和互斥。总的来说，进程和线程的主要差别在于它们是不同的操作系统资源管理方式。
|
||||
|
||||
**进程间的几种通信方式说一下？**
|
||||
|
||||
1. **管道（pipe）**：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有血缘关系的进程间使用。进程的血缘关系通常指父子进程关系。管道分为 pipe（无名管道）和 fifo（命名管道）两种，有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间通信。
|
||||
2. **信号量（semophore）**：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它通常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
|
||||
3. **消息队列（message queue）**：消息队列是由消息组成的链表，存放在内核中 并由消息队列标识符标识。消息队列克服了信号传递信息少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。消息队列与管道通信相比，其优势是对每个消息指定特定的消息类型，接收的时候不需要按照队列次序，而是可以根据自定义条件接收特定类型的消息。
|
||||
4. **信号（signal）**：信号是一种比较复杂的通信方式，用于通知接收进程某一事件已经发生。
|
||||
5. **共享内存（shared memory）**：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问，共享内存是最快的 IPC 方式，它是针对其他进程间的通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量配合使用，来实现进程间的同步和通信。
|
||||
6. **套接字（socket）**：socket，即套接字是一种通信机制，凭借这种机制，客户/服务器（即要进行通信的进程）系统的开发工作既可以在本地单机上进行，也可以跨网络进行。也就是说它可以让不在同一台计算机但通过网络连接计算机上的进程进行通信。也因为这样，套接字明确地将客户端和服务器区分开来。
|
||||
|
||||
**线程间的几种通信方式知道不？**
|
||||
|
||||
1、锁机制
|
||||
|
||||
- 互斥锁：提供了以排它方式阻止数据结构被并发修改的方法。
|
||||
- 读写锁：允许多个线程同时读共享数据，而对写操作互斥。
|
||||
- 条件变量：可以以原子的方式阻塞进程，直到某个特定条件为真为止。对条件测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。
|
||||
|
||||
2、信号量机制：包括无名线程信号量与有名线程信号量
|
||||
|
||||
3、信号机制：类似于进程间的信号处理。
|
||||
|
||||
线程间通信的主要目的是用于线程同步，所以线程没有象进程通信中用于数据交换的通信机制。
|
||||
|
||||
## 9. 为什么要用单例模式?手写几种线程安全的单例模式?
|
||||
|
||||
**简单来说使用单例模式可以带来下面几个好处:**
|
||||
|
||||
- 对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；
|
||||
- 由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻 GC 压力，缩短 GC 停顿时间。
|
||||
|
||||
**懒汉式(双重检查加锁版本)**
|
||||
|
||||
```java
|
||||
public class Singleton {
|
||||
|
||||
//volatile保证，当uniqueInstance变量被初始化成Singleton实例时，多个线程可以正确处理uniqueInstance变量
|
||||
private volatile static Singleton uniqueInstance;
|
||||
private Singleton() {
|
||||
}
|
||||
public static Singleton getInstance() {
|
||||
//检查实例，如果不存在，就进入同步代码块
|
||||
if (uniqueInstance == null) {
|
||||
//只有第一次才彻底执行这里的代码
|
||||
synchronized(Singleton.class) {
|
||||
//进入同步代码块后，再检查一次，如果仍是null，才创建实例
|
||||
if (uniqueInstance == null) {
|
||||
uniqueInstance = new Singleton();
|
||||
}
|
||||
}
|
||||
}
|
||||
return uniqueInstance;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**静态内部类方式**
|
||||
|
||||
静态内部实现的单例是懒加载的且线程安全。
|
||||
|
||||
只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance（只有第一次使用这个单例的实例的时候才加载，同时不会有线程安全问题）。
|
||||
|
||||
```java
|
||||
public class Singleton {
|
||||
private static class SingletonHolder {
|
||||
private static final Singleton INSTANCE = new Singleton();
|
||||
}
|
||||
private Singleton (){}
|
||||
public static final Singleton getInstance() {
|
||||
return SingletonHolder.INSTANCE;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 10. 简单介绍一下 bean;知道 Spring 的 bean 的作用域与生命周期吗?
|
||||
|
||||
在 Spring 中，那些组成应用程序的主体及由 Spring IOC 容器所管理的对象，被称之为 bean。简单地讲，bean 就是由 IOC 容器初始化、装配及管理的对象，除此之外，bean 就与应用程序中的其他对象没有什么区别了。而 bean 的定义以及 bean 相互间的依赖关系将通过配置元数据来描述。
|
||||
|
||||
Spring 中的 bean 默认都是单例的，这些单例 Bean 在多线程程序下如何保证线程安全呢？ 例如对于 Web 应用来说，Web 容器对于每个用户请求都创建一个单独的 Sevlet 线程来处理请求，引入 Spring 框架之后，每个 Action 都是单例的，那么对于 Spring 托管的单例 Service Bean，如何保证其安全呢？ Spring 的单例是基于 BeanFactory 也就是 Spring 容器的，单例 Bean 在此容器内只有一个，Java 的单例是基于 JVM，每个 JVM 内只有一个实例。
|
||||
|
||||
|
||||
|
||||
Spring 的 bean 的生命周期以及更多内容可以查看：[一文轻松搞懂 Spring 中 bean 的作用域与生命周期](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484400&idx=2&sn=7201eb365102fce017f89cb3527fb0bc&chksm=fd985591caefdc872a2fac897288119f94c345e4e12150774f960bf5f816b79e4b9b46be3d7f&token=1990180468&lang=zh_CN#rd)
|
||||
|
||||
## 11. Spring 中的事务传播行为了解吗?TransactionDefinition 接口中哪五个表示隔离级别的常量?
|
||||
|
||||
#### 事务传播行为
|
||||
|
||||
事务传播行为（为了解决业务层方法之间互相调用的事务问题）：
|
||||
当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。在 TransactionDefinition 定义中包括了如下几个表示传播行为的常量：
|
||||
|
||||
**支持当前事务的情况：**
|
||||
|
||||
- TransactionDefinition.PROPAGATION_REQUIRED： 如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
|
||||
- TransactionDefinition.PROPAGATION_SUPPORTS： 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
|
||||
- TransactionDefinition.PROPAGATION_MANDATORY： 如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。（mandatory：强制性）
|
||||
|
||||
**不支持当前事务的情况：**
|
||||
|
||||
- TransactionDefinition.PROPAGATION_REQUIRES_NEW： 创建一个新的事务，如果当前存在事务，则把当前事务挂起。
|
||||
- TransactionDefinition.PROPAGATION_NOT_SUPPORTED： 以非事务方式运行，如果当前存在事务，则把当前事务挂起。
|
||||
- TransactionDefinition.PROPAGATION_NEVER： 以非事务方式运行，如果当前存在事务，则抛出异常。
|
||||
|
||||
**其他情况：**
|
||||
|
||||
- TransactionDefinition.PROPAGATION_NESTED： 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于 TransactionDefinition.PROPAGATION_REQUIRED。
|
||||
|
||||
#### 隔离级别
|
||||
|
||||
TransactionDefinition 接口中定义了五个表示隔离级别的常量：
|
||||
|
||||
- **TransactionDefinition.ISOLATION_DEFAULT:** 使用后端数据库默认的隔离级别，Mysql 默认采用的 REPEATABLE_READ 隔离级别 Oracle 默认采用的 READ_COMMITTED 隔离级别.
|
||||
- **TransactionDefinition.ISOLATION_READ_UNCOMMITTED:** 最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读
|
||||
- **TransactionDefinition.ISOLATION_READ_COMMITTED:** 允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生
|
||||
- **TransactionDefinition.ISOLATION_REPEATABLE_READ:** 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生。
|
||||
- **TransactionDefinition.ISOLATION_SERIALIZABLE:** 最高的隔离级别，完全服从 ACID 的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。
|
||||
|
||||
## 12. SpringMVC 原理了解吗?
|
||||
|
||||
|
||||
|
||||
客户端发送请求-> 前端控制器 DispatcherServlet 接受客户端请求 -> 找到处理器映射 HandlerMapping 解析请求对应的 Handler-> HandlerAdapter 会根据 Handler 来调用真正的处理器处理请求，并处理相应的业务逻辑 -> 处理器返回一个模型视图 ModelAndView -> 视图解析器进行解析 -> 返回一个视图对象->前端控制器 DispatcherServlet 渲染数据（Model）->将得到视图对象返回给用户
|
||||
|
||||
关于 SpringMVC 原理更多内容可以查看我的这篇文章：[SpringMVC 工作原理详解](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484496&idx=1&sn=5472ffa687fe4a05f8900d8ee6726de4&chksm=fd985231caefdb27fc75b44ecf76b6f43e4617e0b01b3c040f8b8fab32e51dfa5118eed1d6ad&token=1990180468&lang=zh_CN#rd)
|
||||
|
||||
## 13. Spring AOP IOC 实现原理
|
||||
|
||||
过了秋招挺长一段时间了，说实话我自己也忘了如何简要概括 Spring AOP IOC 实现原理，就在网上找了一个较为简洁的答案，下面分享给各位。
|
||||
|
||||
**IOC：** 控制反转也叫依赖注入。IOC 利用 java 反射机制，AOP 利用代理模式。IOC 概念看似很抽象，但是很容易理解。说简单点就是将对象交给容器管理，你只需要在 spring 配置文件中配置对应的 bean 以及设置相关的属性，让 spring 容器来生成类的实例对象以及管理对象。在 spring 容器启动的时候，spring 会把你在配置文件中配置的 bean 都初始化好，然后在你需要调用的时候，就把它已经初始化好的那些 bean 分配给你需要调用这些 bean 的类。
|
||||
|
||||
**AOP：** 面向切面编程。（Aspect-Oriented Programming） 。AOP 可以说是对 OOP 的补充和完善。OOP 引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。实现 AOP 的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码，属于静态代理。
|
||||
|
||||
# 二 进阶篇
|
||||
|
||||
## 1 消息队列 MQ 的套路
|
||||
|
||||
消息队列/消息中间件应该是 Java 程序员必备的一个技能了，如果你之前没接触过消息队列的话，建议先去百度一下某某消息队列入门，然后花 2 个小时就差不多可以学会任何一种消息队列的使用了。如果说仅仅学会使用是万万不够的，在实际生产环境还要考虑消息丢失等等情况。关于消息队列面试相关的问题，推荐大家也可以看一下视频《Java 工程师面试突击第 1 季-中华石杉老师》，如果大家没有资源的话，可以在我的公众号“Java 面试通关手册”后台回复关键字“1”即可！
|
||||
|
||||
### 1.1 介绍一下消息队列 MQ 的应用场景/使用消息队列的好处
|
||||
|
||||
面试官一般会先问你这个问题，预热一下，看你知道消息队列不，一般在第一面的时候面试官可能只会问消息队列 MQ 的应用场景/使用消息队列的好处、使用消息队列会带来什么问题、消息队列的技术选型这几个问题，不会太深究下去，在后面的第二轮/第三轮技术面试中可能会深入问一下。
|
||||
|
||||
**《大型网站技术架构》第四章和第七章均有提到消息队列对应用性能及扩展性的提升。**
|
||||
|
||||
#### 1)通过异步处理提高系统性能
|
||||
|
||||
|
||||
如上图，**在不使用消息队列服务器的时候，用户的请求数据直接写入数据库，在高并发的情况下数据库压力剧增，使得响应速度变慢。但是在使用消息队列之后，用户的请求数据发送给消息队列之后立即 返回，再由消息队列的消费者进程从消息队列中获取数据，异步写入数据库。由于消息队列服务器处理速度快于数据库（消息队列也比数据库有更好的伸缩性），因此响应速度得到大幅改善。**
|
||||
|
||||
通过以上分析我们可以得出**消息队列具有很好的削峰作用的功能**——即**通过异步处理，将短时间高并发产生的事务消息存储在消息队列中，从而削平高峰期的并发事务。** 举例：在电子商务一些秒杀、促销活动中，合理使用消息队列可以有效抵御促销活动刚开始大量订单涌入对系统的冲击。如下图所示：
|
||||
|
||||
因为**用户请求数据写入消息队列之后就立即返回给用户了，但是请求数据在后续的业务校验、写数据库等操作中可能失败**。因此使用消息队列进行异步处理之后，需要**适当修改业务流程进行配合**，比如**用户在提交订单之后，订单数据写入消息队列，不能立即返回用户订单提交成功，需要在消息队列的订单消费者进程真正处理完该订单之后，甚至出库后，再通过电子邮件或短信通知用户订单成功**，以免交易纠纷。这就类似我们平时手机订火车票和电影票。
|
||||
|
||||
#### 2)降低系统耦合性
|
||||
|
||||
我们知道模块分布式部署以后聚合方式通常有两种：1.**分布式消息队列**和 2.**分布式服务**。
|
||||
|
||||
> **先来简单说一下分布式服务：**
|
||||
|
||||
目前使用比较多的用来构建**SOA（Service Oriented Architecture 面向服务体系结构）**的**分布式服务框架**是阿里巴巴开源的**Dubbo**。如果想深入了解 Dubbo 的可以看我写的关于 Dubbo 的这一篇文章：**《高性能优秀的服务框架-dubbo 介绍》**：[https://juejin.im/post/5acadeb1f265da2375072f9c](https://juejin.im/post/5acadeb1f265da2375072f9c "https://juejin.im/post/5acadeb1f265da2375072f9c")
|
||||
|
||||
> **再来谈我们的分布式消息队列：**
|
||||
|
||||
我们知道如果模块之间不存在直接调用，那么新增模块或者修改模块就对其他模块影响较小，这样系统的可扩展性无疑更好一些。
|
||||
|
||||
我们最常见的**事件驱动架构**类似生产者消费者模式，在大型网站中通常用利用消息队列实现事件驱动结构。如下图所示：
|
||||
|
||||
|
||||
**消息队列使利用发布-订阅模式工作，消息发送者（生产者）发布消息，一个或多个消息接受者（消费者）订阅消息。** 从上图可以看到**消息发送者（生产者）和消息接受者（消费者）之间没有直接耦合**，消息发送者将消息发送至分布式消息队列即结束对消息的处理，消息接受者从分布式消息队列获取该消息后进行后续处理，并不需要知道该消息从何而来。**对新增业务，只要对该类消息感兴趣，即可订阅该消息，对原有系统和业务没有任何影响，从而实现网站业务的可扩展性设计**。
|
||||
|
||||
消息接受者对消息进行过滤、处理、包装后，构造成一个新的消息类型，将消息继续发送出去，等待其他消息接受者订阅该消息。因此基于事件（消息对象）驱动的业务架构可以是一系列流程。
|
||||
|
||||
**另外为了避免消息队列服务器宕机造成消息丢失，会将成功发送到消息队列的消息存储在消息生产者服务器上，等消息真正被消费者服务器处理后才删除消息。在消息队列服务器宕机后，生产者服务器会选择分布式消息队列服务器集群中的其他服务器发布消息。**
|
||||
|
||||
**备注：** 不要认为消息队列只能利用发布-订阅模式工作，只不过在解耦这个特定业务环境下是使用发布-订阅模式的，**比如在我们的 ActiveMQ 消息队列中还有点对点工作模式**，具体的会在后面的文章给大家详细介绍，这一篇文章主要还是让大家对消息队列有一个更透彻的了解。
|
||||
|
||||
> 这个问题一般会在上一个问题问完之后，紧接着被问到。“使用消息队列会带来什么问题？”这个问题要引起重视，一般我们都会考虑使用消息队列会带来的好处而忽略它带来的问题！
|
||||
|
||||
### 1.2 那么使用消息队列会带来什么问题?考虑过这些问题吗?
|
||||
|
||||
- **系统可用性降低：** 系统可用性在某种程度上降低，为什么这样说呢？在加入 MQ 之前，你不用考虑消息丢失或者说 MQ 挂掉等等的情况，但是，引入 MQ 之后你就需要去考虑了！
|
||||
- **系统复杂性提高：** 加入 MQ 之后，你需要保证消息没有被重复消费、处理消息丢失的情况、保证消息传递的顺序性等等问题！
|
||||
- **一致性问题：** 我上面讲了消息队列可以实现异步，消息队列带来的异步确实可以提高系统响应速度。但是，万一消息的真正消费者并没有正确消费消息怎么办？这样就会导致数据不一致的情况了!
|
||||
|
||||
> 了解下面这个问题是为了我们更好的进行技术选型！该部分摘自：《Java 工程师面试突击第 1 季-中华石杉老师》，如果大家没有资源的话，可以在我的公众号“Java 面试通关手册”后台回复关键字“1”即可！
|
||||
|
||||
### 1.3 介绍一下你知道哪几种消息队列,该如何选择呢?
|
||||
|
||||
| 特性 | ActiveMQ | RabbitMQ | RocketMQ | Kafka |
|
||||
| :----------------------- | -----------------------------------------------------------: | -----------------------------------------------------------: | -----------------------------------------------------------: | -----------------------------------------------------------: |
|
||||
| 单机吞吐量 | 万级，吞吐量比 RocketMQ 和 Kafka 要低了一个数量级 | 万级，吞吐量比 RocketMQ 和 Kafka 要低了一个数量级 | 10 万级，RocketMQ 也是可以支撑高吞吐的一种 MQ | 10 万级别，这是 kafka 最大的优点，就是吞吐量高。一般配合大数据类的系统来进行实时数据计算、日志采集等场景 |
|
||||
| topic 数量对吞吐量的影响 | | | topic 可以达到几百，几千个的级别，吞吐量会有较小幅度的下降这是 RocketMQ 的一大优势，在同等机器下，可以支撑大量的 topic | topic 从几十个到几百个的时候，吞吐量会大幅度下降。所以在同等机器下，kafka 尽量保证 topic 数量不要过多。如果要支撑大规模 topic，需要增加更多的机器资源 |
|
||||
| 可用性 | 高，基于主从架构实现高可用性 | 高，基于主从架构实现高可用性 | 非常高，分布式架构 | 非常高，kafka 是分布式的，一个数据多个副本，少数机器宕机，不会丢失数据，不会导致不可用 |
|
||||
| 消息可靠性 | 有较低的概率丢失数据 | | 经过参数优化配置，可以做到 0 丢失 | 经过参数优化配置，消息可以做到 0 丢失 |
|
||||
| 时效性 | ms 级 | 微秒级，这是 rabbitmq 的一大特点，延迟是最低的 | ms 级 | 延迟在 ms 级以内 |
|
||||
| 功能支持 | MQ 领域的功能极其完备 | 基于 erlang 开发，所以并发能力很强，性能极其好，延时很低 | MQ 功能较为完善，还是分布式的，扩展性好 | 功能较为简单，主要支持简单的 MQ 功能，在大数据领域的实时计算以及日志采集被大规模使用，是事实上的标准 |
|
||||
| 优劣势总结 | 非常成熟，功能强大，在业内大量的公司以及项目中都有应用。偶尔会有较低概率丢失消息，而且现在社区以及国内应用都越来越少，官方社区现在对 ActiveMQ 5.x 维护越来越少，几个月才发布一个版本而且确实主要是基于解耦和异步来用的，较少在大规模吞吐的场景中使用 | erlang 语言开发，性能极其好，延时很低；吞吐量到万级，MQ 功能比较完备而且开源提供的管理界面非常棒，用起来很好用。社区相对比较活跃，几乎每个月都发布几个版本分在国内一些互联网公司近几年用 rabbitmq 也比较多一些但是问题也是显而易见的，RabbitMQ 确实吞吐量会低一些，这是因为他做的实现机制比较重。而且 erlang 开发，国内有几个公司有实力做 erlang 源码级别的研究和定制？如果说你没这个实力的话，确实偶尔会有一些问题，你很难去看懂源码，你公司对这个东西的掌控很弱，基本职能依赖于开源社区的快速维护和修复 bug。而且 rabbitmq 集群动态扩展会很麻烦，不过这个我觉得还好。其实主要是 erlang 语言本身带来的问题。很难读源码，很难定制和掌控。 | 接口简单易用，而且毕竟在阿里大规模应用过，有阿里品牌保障。日处理消息上百亿之多，可以做到大规模吞吐，性能也非常好，分布式扩展也很方便，社区维护还可以，可靠性和可用性都是 ok 的，还可以支撑大规模的 topic 数量，支持复杂 MQ 业务场景。而且一个很大的优势在于，阿里出品都是 java 系的，我们可以自己阅读源码，定制自己公司的 MQ，可以掌控。社区活跃度相对较为一般，不过也还可以，文档相对来说简单一些，然后接口这块不是按照标准 JMS 规范走的有些系统要迁移需要修改大量代码。还有就是阿里出台的技术，你得做好这个技术万一被抛弃，社区黄掉的风险，那如果你们公司有技术实力我觉得用 RocketMQ 挺好的 | kafka 的特点其实很明显，就是仅仅提供较少的核心功能，但是提供超高的吞吐量，ms 级的延迟，极高的可用性以及可靠性，而且分布式可以任意扩展。同时 kafka 最好是支撑较少的 topic 数量即可，保证其超高吞吐量。而且 kafka 唯一的一点劣势是有可能消息重复消费，那么对数据准确性会造成极其轻微的影响，在大数据领域中以及日志采集中，这点轻微影响可以忽略这个特性天然适合大数据实时计算以及日志收集。 |
|
||||
|
||||
> 这部分内容，我这里不给出答案，大家可以自行根据自己学习的消息队列查阅相关内容，我可能会在后面的文章中介绍到这部分内容。另外，下面这些问题在视频《Java 工程师面试突击第 1 季-中华石杉老师》中都有提到，如果大家没有资源的话，可以在我的公众号“Java 面试通关手册”后台回复关键字“1”即可！
|
||||
|
||||
### 1.4 关于消息队列其他一些常见的问题展望
|
||||
|
||||
1. 引入消息队列之后如何保证高可用性？
|
||||
2. 如何保证消息不被重复消费呢？
|
||||
3. 如何保证消息的可靠性传输（如何处理消息丢失的问题）？
|
||||
4. 我该怎么保证从消息队列里拿到的数据按顺序执行？
|
||||
5. 如何解决消息队列的延时以及过期失效问题？消息队列满了以后该怎么处理？有几百万消息持续积压几小时，说说怎么解决？
|
||||
6. 如果让你来开发一个消息队列中间件，你会怎么设计架构？
|
||||
|
||||
## 2 谈谈 InnoDB 和 MyIsam 两者的区别
|
||||
|
||||
### 2.1 两者的对比
|
||||
|
||||
1. **count 运算上的区别：** 因为 MyISAM 缓存有表 meta-data（行数等），因此在做 COUNT(\*)时对于一个结构很好的查询是不需要消耗多少资源的。而对于 InnoDB 来说，则没有这种缓存
|
||||
2. **是否支持事务和崩溃后的安全恢复：** MyISAM 强调的是性能，每次查询具有原子性，其执行速度比 InnoDB 类型更快，但是不提供事务支持。但是 InnoDB 提供事务支持，外部键等高级数据库功能。 具有事务(commit)、回滚(rollback)和崩溃修复能力(crash recovery capabilities)的事务安全(transaction-safe (ACID compliant))型表。
|
||||
3. **是否支持外键：** MyISAM 不支持，而 InnoDB 支持。
|
||||
|
||||
### 2.2 关于两者的总结
|
||||
|
||||
MyISAM 更适合读密集的表，而 InnoDB 更适合写密集的表。 在数据库做主从分离的情况下，经常选择 MyISAM 作为主库的存储引擎。
|
||||
|
||||
一般来说，如果需要事务支持，并且有较高的并发读取频率(MyISAM 的表锁的粒度太大，所以当该表写并发量较高时，要等待的查询就会很多了)，InnoDB 是不错的选择。如果你的数据量很大（MyISAM 支持压缩特性可以减少磁盘的空间占用），而且不需要支持事务时，MyISAM 是最好的选择。
|
||||
|
||||
## 3 聊聊 Java 中的集合吧!
|
||||
|
||||
### 3.1 Arraylist 与 LinkedList 有什么不同?(注意加上从数据结构分析的内容)
|
||||
|
||||
- **1. 是否保证线程安全：** ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；
|
||||
- **2. 底层数据结构：** Arraylist 底层使用的是 Object 数组；LinkedList 底层使用的是双向链表数据结构（注意双向链表和双向循环链表的区别：）；
|
||||
- **3. 插入和删除是否受元素位置的影响：** ① **ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。** 比如：执行`add(E e)`方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是 O(1)。但是如果要在指定位置 i 插入和删除元素的话（`add(int index, E element)`）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。 ② **LinkedList 采用链表存储，所以插入，删除元素时间复杂度不受元素位置的影响，都是近似 O(1) 而数组为近似 O(n) 。**
|
||||
- **4. 是否支持快速随机访问：** LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象（对应于`get(int index)`方法）。
|
||||
- **5. 内存空间占用：** ArrayList 的空 间浪费主要体现在在 list 列表的结尾会预留一定的容量空间，而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间（因为要存放直接后继和直接前驱以及数据）。
|
||||
|
||||
**补充内容:RandomAccess 接口**
|
||||
|
||||
```java
|
||||
public interface RandomAccess {
|
||||
}
|
||||
```
|
||||
|
||||
查看源码我们发现实际上 RandomAccess 接口中什么都没有定义。所以，在我看来 RandomAccess 接口不过是一个标识罢了。标识什么？ 标识实现这个接口的类具有随机访问功能。
|
||||
|
||||
在 binarySearch() 方法中，它要判断传入的 list 是否 RamdomAccess 的实例，如果是，调用 indexedBinarySearch() 方法，如果不是，那么调用 iteratorBinarySearch() 方法
|
||||
|
||||
```java
|
||||
public static <T>
|
||||
int binarySearch(List<? extends Comparable<? super T>> list, T key) {
|
||||
if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
|
||||
return Collections.indexedBinarySearch(list, key);
|
||||
else
|
||||
return Collections.iteratorBinarySearch(list, key);
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
ArraysList 实现了 RandomAccess 接口， 而 LinkedList 没有实现。为什么呢？我觉得还是和底层数据结构有关！ArraysList 底层是数组，而 LinkedList 底层是链表。数组天然支持随机访问，时间复杂度为 O(1) ，所以称为快速随机访问。链表需要遍历到特定位置才能访问特定位置的元素，时间复杂度为 O(n) ，所以不支持快速随机访问。，ArraysList 实现了 RandomAccess 接口，就表明了他具有快速随机访问功能。 RandomAccess 接口只是标识，并不是说 ArraysList 实现 RandomAccess 接口才具有快速随机访问功能的！
|
||||
|
||||
**下面再总结一下 list 的遍历方式选择：**
|
||||
|
||||
- 实现了 RandomAccess 接口的 list，优先选择普通 for 循环 ，其次 foreach,
|
||||
- 未实现 RandomAccess 接口的 ist， 优先选择 iterator 遍历（foreach 遍历底层也是通过 iterator 实现的），大 size 的数据，千万不要使用普通 for 循环
|
||||
|
||||
> Java 中的集合这类问题几乎是面试必问的，问到这类问题的时候，HashMap 又是几乎必问的问题，所以大家一定要引起重视！
|
||||
|
||||
### 3.2 HashMap 的底层实现
|
||||
|
||||
#### 1)JDK1.8 之前
|
||||
|
||||
JDK1.8 之前 HashMap 底层是 **数组和链表** 结合在一起使用也就是 **链表散列**。**HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值，然后通过 `(n - 1) & hash` 判断当前元素存放的位置（这里的 n 指的时数组的长度），如果当前位置存在元素的话，就判断该元素与要存入的元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。**
|
||||
|
||||
**所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 换句话说使用扰动函数之后可以减少碰撞。**
|
||||
|
||||
**JDK 1.8 HashMap 的 hash 方法源码:**
|
||||
|
||||
JDK 1.8 的 hash 方法 相比于 JDK 1.7 hash 方法更加简化，但是原理不变。
|
||||
|
||||
```java
|
||||
static final int hash(Object key) {
|
||||
int h;
|
||||
// key.hashCode()：返回散列值也就是hashcode
|
||||
// ^ ：按位异或
|
||||
// >>>:无符号右移，忽略符号位，空位都以0补齐
|
||||
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
|
||||
}
|
||||
```
|
||||
|
||||
对比一下 JDK1.7 的 HashMap 的 hash 方法源码.
|
||||
|
||||
```java
|
||||
static int hash(int h) {
|
||||
// This function ensures that hashCodes that differ only by
|
||||
// constant multiples at each bit position have a bounded
|
||||
// number of collisions (approximately 8 at default load factor).
|
||||
|
||||
h ^= (h >>> 20) ^ (h >>> 12);
|
||||
return h ^ (h >>> 7) ^ (h >>> 4);
|
||||
}
|
||||
```
|
||||
|
||||
相比于 JDK1.8 的 hash 方法 ，JDK 1.7 的 hash 方法的性能会稍差一点点，因为毕竟扰动了 4 次。
|
||||
|
||||
所谓 **“拉链法”** 就是：将链表和数组相结合。也就是说创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可。
|
||||
|
||||
|
||||
|
||||
#### 2)JDK1.8 之后
|
||||
|
||||
相比于之前的版本， JDK1.8 之后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）时，将链表转化为红黑树，以减少搜索时间。
|
||||
|
||||
|
||||
|
||||
TreeMap、TreeSet 以及 JDK1.8 之后的 HashMap 底层都用到了红黑树。红黑树就是为了解决二叉查找树的缺陷，因为二叉查找树在某些情况下会退化成一个线性结构。
|
||||
|
||||
> 问完 HashMap 的底层原理之后，面试官可能就会紧接着问你 HashMap 底层数据结构相关的问题！
|
||||
|
||||
### 3.3 既然谈到了红黑树,你给我手绘一个出来吧,然后简单讲一下自己对于红黑树的理解
|
||||
|
||||
|
||||
|
||||
**红黑树特点:**
|
||||
|
||||
1. 每个节点非红即黑；
|
||||
2. 根节点总是黑色的；
|
||||
3. 每个叶子节点都是黑色的空节点（NIL 节点）；
|
||||
4. 如果节点是红色的，则它的子节点必须是黑色的（反之不一定）；
|
||||
5. 从根节点到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点（即相同的黑色高度）
|
||||
|
||||
**红黑树的应用：**
|
||||
|
||||
TreeMap、TreeSet 以及 JDK1.8 之后的 HashMap 底层都用到了红黑树。
|
||||
|
||||
**为什么要用红黑树**
|
||||
|
||||
简单来说红黑树就是为了解决二叉查找树的缺陷，因为二叉查找树在某些情况下会退化成一个线性结构。
|
||||
|
||||
### 3.4 红黑树这么优秀,为何不直接使用红黑树得了?
|
||||
|
||||
说一下自己对于这个问题的看法：我们知道红黑树属于（自）平衡二叉树，但是为了保持“平衡”是需要付出代价的，红黑树在插入新数据后可能需要通过左旋，右旋、变色这些操作来保持平衡，这费事啊。你说说我们引入红黑树就是为了查找数据快，如果链表长度很短的话，根本不需要引入红黑树的，你引入之后还要付出代价维持它的平衡。但是链表过长就不一样了。至于为什么选 8 这个值呢？通过概率统计所得，这个值是综合查询成本和新增元素成本得出的最好的一个值。
|
||||
|
||||
### 3.5 HashMap 和 Hashtable 的区别/HashSet 和 HashMap 区别
|
||||
|
||||
**HashMap 和 Hashtable 的区别**
|
||||
|
||||
1. **线程是否安全：** HashMap 是非线程安全的，Hashtable 是线程安全的；Hashtable 内部的方法基本都经过 `synchronized` 修饰。（如果你要保证线程安全的话就使用 ConcurrentHashMap 吧！）；
|
||||
2. **效率：** 因为线程安全的问题，HashMap 要比 Hashtable 效率高一点。另外，Hashtable 基本被淘汰，不要在代码中使用它；
|
||||
3. **对 Null key 和 Null value 的支持：** HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。但是在 Hashtable 中 put 进的键值只要有一个 null，直接抛出 NullPointerException。
|
||||
4. **初始容量大小和每次扩充容量大小的不同 ：** ① 创建时如果不指定容量初始值，Hashtable 默认的初始大小为 11，之后每次扩充，容量变为原来的 2n+1。HashMap 默认的初始化大小为 16。之后每次扩充，容量变为原来的 2 倍。② 创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为 2 的幂次方大小（HashMap 中的`tableSizeFor()`方法保证，下面给出了源代码）。也就是说 HashMap 总是使用 2 的幂作为哈希表的大小,后面会介绍到为什么是 2 的幂次方。
|
||||
5. **底层数据结构：** JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。
|
||||
|
||||
**HashSet 和 HashMap 区别**
|
||||
|
||||
如果你看过 HashSet 源码的话就应该知道：HashSet 底层就是基于 HashMap 实现的。（HashSet 的源码非常非常少，因为除了 clone() 方法、writeObject()方法、readObject()方法是 HashSet 自己不得不实现之外，其他方法都是直接调用 HashMap 中的方法。）
|
||||
|
||||
|
||||
|
||||
# 三 终结篇
|
||||
|
||||
## 1. Object 类有哪些方法?
|
||||
|
||||
这个问题，面试中经常出现。我觉得不论是出于应付面试还是说更好地掌握 Java 这门编程语言，大家都要掌握！
|
||||
|
||||
### 1.1 Object 类的常见方法总结
|
||||
|
||||
Object 类是一个特殊的类，是所有类的父类。它主要提供了以下 11 个方法：
|
||||
|
||||
```java
|
||||
|
||||
public final native Class<?> getClass()//native方法，用于返回当前运行时对象的Class对象，使用了final关键字修饰，故不允许子类重写。
|
||||
|
||||
public native int hashCode() //native方法，用于返回对象的哈希码，主要使用在哈希表中，比如JDK中的HashMap。
|
||||
public boolean equals(Object obj)//用于比较2个对象的内存地址是否相等，String类对该方法进行了重写用户比较字符串的值是否相等。
|
||||
|
||||
protected native Object clone() throws CloneNotSupportedException//naitive方法，用于创建并返回当前对象的一份拷贝。一般情况下，对于任何对象 x，表达式 x.clone() != x 为true，x.clone().getClass() == x.getClass() 为true。Object本身没有实现Cloneable接口，所以不重写clone方法并且进行调用的话会发生CloneNotSupportedException异常。
|
||||
|
||||
public String toString()//返回类的名字@实例的哈希码的16进制的字符串。建议Object所有的子类都重写这个方法。
|
||||
|
||||
public final native void notify()//native方法，并且不能重写。唤醒一个在此对象监视器上等待的线程(监视器相当于就是锁的概念)。如果有多个线程在等待只会任意唤醒一个。
|
||||
|
||||
public final native void notifyAll()//native方法，并且不能重写。跟notify一样，唯一的区别就是会唤醒在此对象监视器上等待的所有线程，而不是一个线程。
|
||||
|
||||
public final native void wait(long timeout) throws InterruptedException//native方法，并且不能重写。暂停线程的执行。注意：sleep方法没有释放锁，而wait方法释放了锁 。timeout是等待时间。
|
||||
|
||||
public final void wait(long timeout, int nanos) throws InterruptedException//多了nanos参数，这个参数表示额外时间（以毫微秒为单位，范围是 0-999999）。 所以超时的时间还需要加上nanos毫秒。
|
||||
|
||||
public final void wait() throws InterruptedException//跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间这个概念
|
||||
|
||||
protected void finalize() throws Throwable { }//实例被垃圾回收器回收的时候触发的操作
|
||||
|
||||
```
|
||||
|
||||
> 问完上面这个问题之后，面试官很可能紧接着就会问你“hashCode 与 equals”相关的问题。
|
||||
|
||||
### 1.2 hashCode 与 equals
|
||||
|
||||
面试官可能会问你：“你重写过 hashcode 和 equals 么，为什么重写 equals 时必须重写 hashCode 方法？”
|
||||
|
||||
#### 1.2.1 hashCode()介绍
|
||||
|
||||
hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个 int 整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在 JDK 的 Object.java 中，这就意味着 Java 中的任何类都包含有 hashCode() 函数。另外需要注意的是： Object 的 hashcode 方法是本地方法，也就是用 c 语言或 c++ 实现的，该方法通常用来将对象的 内存地址 转换为整数之后返回。
|
||||
|
||||
```java
|
||||
public native int hashCode();
|
||||
```
|
||||
|
||||
散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）
|
||||
|
||||
#### 1.2.2 为什么要有 hashCode
|
||||
|
||||
**我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：**
|
||||
|
||||
当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的 hashcode，HashSet 会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals（）方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自我的 Java 启蒙书《Head fist java》第二版）。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。
|
||||
|
||||
#### 1.2.3 hashCode()与 equals()的相关规定
|
||||
|
||||
1. 如果两个对象相等，则 hashcode 一定也是相同的
|
||||
2. 两个对象相等，对两个对象分别调用 equals 方法都返回 true
|
||||
3. 两个对象有相同的 hashcode 值，它们也不一定是相等的
|
||||
4. **因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖**
|
||||
5. hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）
|
||||
|
||||
#### 1.2.4 为什么两个对象有相同的 hashcode 值,它们也不一定是相等的?
|
||||
|
||||
在这里解释一位小伙伴的问题。以下内容摘自《Head Fisrt Java》。
|
||||
|
||||
因为 hashCode() 所使用的杂凑算法也许刚好会让多个对象传回相同的杂凑值。越糟糕的杂凑算法越容易碰撞，但这也与数据值域分布的特性有关（所谓碰撞也就是指的是不同的对象得到相同的 hashCode）。
|
||||
|
||||
我们刚刚也提到了 HashSet,如果 HashSet 在对比的时候，同样的 hashcode 有多个对象，它会使用 equals() 来判断是否真的相同。也就是说 hashcode 只是用来缩小查找成本。
|
||||
|
||||
> ==与 equals 的对比也是比较常问的基础问题之一！
|
||||
|
||||
### 1.3 ==与 equals
|
||||
|
||||
**==** : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。(基本数据类型==比较的是值，引用数据类型==比较的是内存地址)
|
||||
|
||||
**equals()** : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：
|
||||
|
||||
- 情况 1：类没有覆盖 equals()方法。则通过 equals()比较该类的两个对象时，等价于通过“==”比较这两个对象。
|
||||
- 情况 2：类覆盖了 equals()方法。一般，我们都覆盖 equals()方法来两个对象的内容相等；若它们的内容相等，则返回 true(即，认为这两个对象相等)。
|
||||
|
||||
**举个例子：**
|
||||
|
||||
```java
|
||||
public class test1 {
|
||||
public static void main(String[] args) {
|
||||
String a = new String("ab"); // a 为一个引用
|
||||
String b = new String("ab"); // b为另一个引用,对象的内容一样
|
||||
String aa = "ab"; // 放在常量池中
|
||||
String bb = "ab"; // 从常量池中查找
|
||||
if (aa == bb) // true
|
||||
System.out.println("aa==bb");
|
||||
if (a == b) // false，非同一对象
|
||||
System.out.println("a==b");
|
||||
if (a.equals(b)) // true
|
||||
System.out.println("aEQb");
|
||||
if (42 == 42.0) { // true
|
||||
System.out.println("true");
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**说明：**
|
||||
|
||||
- String 中的 equals()方法是被重写过的，因为 Object 的 equals()方法是比较的对象的内存地址，而 String 的 equals()方法比较的是对象的值。
|
||||
- 当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。
|
||||
|
||||
> 在[【备战春招/秋招系列 5】美团面经总结进阶篇 （附详解答案）](https://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484625&idx=1&sn=9c4fa1f7d4291a5fbd7daa44bac2b012&chksm=fd9852b0caefdba6edcf9a827aa4a17ddc97bf6ad2e5ee6f7e1aa1b443b54444d05d2b76732b&token=723699735&lang=zh_CN#rd) 这篇文章中，我们已经提到了一下关于 HashMap 在面试中常见的问题：HashMap 的底层实现、简单讲一下自己对于红黑树的理解、红黑树这么优秀，为何不直接使用红黑树得了、HashMap 和 Hashtable 的区别/HashSet 和 HashMap 区别。HashMap 和 ConcurrentHashMap 这俩兄弟在一般只要面试中问到集合相关的问题就一定会被问到，所以各位务必引起重视！
|
||||
|
||||
## 2 ConcurrentHashMap 相关问题
|
||||
|
||||
### 2.1 ConcurrentHashMap 和 Hashtable 的区别
|
||||
|
||||
ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。
|
||||
|
||||
- **底层数据结构：** JDK1.7 的 ConcurrentHashMap 底层采用 **分段的数组+链表** 实现，JDK1.8 采用的数据结构跟 HashMap1.8 的结构一样，数组+链表/红黑二叉树。Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 **数组+链表** 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的；
|
||||
- **实现线程安全的方式（重要）：** ① **在 JDK1.7 的时候，ConcurrentHashMap（分段锁）** 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。（默认分配 16 个 Segment，比 Hashtable 效率提高 16 倍。） **到了 JDK1.8 的时候已经摒弃了 Segment 的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6 以后 对 synchronized 锁做了很多优化）** 整个看起来就像是优化过且线程安全的 HashMap，虽然在 JDK1.8 中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② **Hashtable(同一把锁)**：使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。
|
||||
|
||||
**两者的对比图：**
|
||||
|
||||
图片来源：http://www.cnblogs.com/chengxiao/p/6842045.html
|
||||
|
||||
Hashtable：
|
||||
|
||||
|
||||
JDK1.7 的 ConcurrentHashMap：
|
||||
|
||||
JDK1.8 的 ConcurrentHashMap（TreeBin: 红黑二叉树节点
|
||||
Node: 链表节点）：
|
||||
|
||||
|
||||
### 2.2 ConcurrentHashMap 线程安全的具体实现方式/底层具体实现
|
||||
|
||||
#### JDK1.7(上面有示意图)
|
||||
|
||||
首先将数据分为一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据时，其他段的数据也能被其他线程访问。
|
||||
|
||||
**ConcurrentHashMap 是由 Segment 数组结构和 HashEntry 数组结构组成**。
|
||||
|
||||
Segment 实现了 ReentrantLock，所以 Segment 是一种可重入锁，扮演锁的角色。HashEntry 用于存储键值对数据。
|
||||
|
||||
```java
|
||||
static class Segment<K,V> extends ReentrantLock implements Serializable {
|
||||
}
|
||||
```
|
||||
|
||||
一个 ConcurrentHashMap 里包含一个 Segment 数组。Segment 的结构和 HashMap 类似，是一种数组和链表结构，一个 Segment 包含一个 HashEntry 数组，每个 HashEntry 是一个链表结构的元素，每个 Segment 守护着一个 HashEntry 数组里的元素，当对 HashEntry 数组的数据进行修改时，必须首先获得对应的 Segment 的锁。
|
||||
|
||||
#### JDK1.8(上面有示意图)
|
||||
|
||||
ConcurrentHashMap 取消了 Segment 分段锁，采用 CAS 和 synchronized 来保证并发安全。数据结构跟 HashMap1.8 的结构类似，数组+链表/红黑二叉树。
|
||||
|
||||
synchronized 只锁定当前链表或红黑二叉树的首节点，这样只要 hash 不冲突，就不会产生并发，效率又提升 N 倍。
|
||||
|
||||
## 3 谈谈 synchronized 和 ReentrantLock 的区别
|
||||
|
||||
**① 两者都是可重入锁**
|
||||
|
||||
两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增 1，所以要等到锁的计数器下降为 0 时才能释放锁。
|
||||
|
||||
**② synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API**
|
||||
|
||||
synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。
|
||||
|
||||
**③ ReentrantLock 比 synchronized 增加了一些高级功能**
|
||||
|
||||
相比 synchronized，ReentrantLock 增加了一些高级功能。主要来说主要有三点：**① 等待可中断；② 可实现公平锁；③ 可实现选择性通知（锁可以绑定多个条件）**
|
||||
|
||||
- **ReentrantLock 提供了一种能够中断等待锁的线程的机制**，通过 lock.lockInterruptibly() 来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。
|
||||
- **ReentrantLock 可以指定是公平锁还是非公平锁。而 synchronized 只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。** ReentrantLock 默认情况是非公平的，可以通过 ReentrantLock 类的`ReentrantLock(boolean fair)`构造方法来制定是否是公平的。
|
||||
- synchronized 关键字与 wait()和 notify/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock 类当然也可以实现，但是需要借助于 Condition 接口与 newCondition() 方法。Condition 是 JDK1.5 之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个 Lock 对象中可以创建多个 Condition 实例（即对象监视器），**线程对象可以注册在指定的 Condition 中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。 在使用 notify/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，用 ReentrantLock 类结合 Condition 实例可以实现“选择性通知”** ，这个功能非常重要，而且是 Condition 接口默认提供的。而 synchronized 关键字就相当于整个 Lock 对象中只有一个 Condition 实例，所有的线程都注册在它一个身上。如果执行 notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而 Condition 实例的 signalAll()方法 只会唤醒注册在该 Condition 实例中的所有等待线程。
|
||||
|
||||
如果你想使用上述功能，那么选择 ReentrantLock 是一个不错的选择。
|
||||
|
||||
**④ 两者的性能已经相差无几**
|
||||
|
||||
在 JDK1.6 之前，synchronized 的性能是比 ReentrantLock 差很多。具体表示为：synchronized 关键字吞吐量岁线程数的增加，下降得非常严重。而 ReentrantLock 基本保持一个比较稳定的水平。我觉得这也侧面反映了， synchronized 关键字还有非常大的优化余地。后续的技术发展也证明了这一点，我们上面也讲了在 JDK1.6 之后 JVM 团队对 synchronized 关键字做了很多优化。JDK1.6 之后，synchronized 和 ReentrantLock 的性能基本是持平了。所以网上那些说因为性能才选择 ReentrantLock 的文章都是错的！JDK1.6 之后，性能已经不是选择 synchronized 和 ReentrantLock 的影响因素了！而且虚拟机在未来的性能改进中会更偏向于原生的 synchronized，所以还是提倡在 synchronized 能满足你的需求的情况下，优先考虑使用 synchronized 关键字来进行同步！优化后的 synchronized 和 ReentrantLock 一样，在很多地方都是用到了 CAS 操作。
|
||||
|
||||
## 4 线程池了解吗?
|
||||
|
||||
### 4.1 为什么要用线程池?
|
||||
|
||||
线程池提供了一种限制和管理资源（包括执行一个任务）。 每个线程池还维护一些基本统计信息，例如已完成任务的数量。
|
||||
|
||||
这里借用《Java 并发编程的艺术》提到的来说一下使用线程池的好处：
|
||||
|
||||
- **降低资源消耗。** 通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
|
||||
- **提高响应速度。** 当任务到达时，任务可以不需要的等到线程创建就能立即执行。
|
||||
- **提高线程的可管理性。** 线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
|
||||
|
||||
### 4.2 Java 提供了哪几种线程池?他们各自的使用场景是什么?
|
||||
|
||||
#### Java 主要提供了下面 4 种线程池
|
||||
|
||||
- **FixedThreadPool：** 该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。
|
||||
- **SingleThreadExecutor：** 方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。
|
||||
- **CachedThreadPool：** 该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。
|
||||
- **ScheduledThreadPoolExecutor：** 主要用来在给定的延迟后运行任务，或者定期执行任务。ScheduledThreadPoolExecutor 又分为：ScheduledThreadPoolExecutor（包含多个线程）和 SingleThreadScheduledExecutor （只包含一个线程）两种。
|
||||
|
||||
#### 各种线程池的适用场景介绍
|
||||
|
||||
- **FixedThreadPool：** 适用于为了满足资源管理需求，而需要限制当前线程数量的应用场景。它适用于负载比较重的服务器；
|
||||
- **SingleThreadExecutor：** 适用于需要保证顺序地执行各个任务并且在任意时间点，不会有多个线程是活动的应用场景；
|
||||
- **CachedThreadPool：** 适用于执行很多的短期异步任务的小程序，或者是负载较轻的服务器；
|
||||
- **ScheduledThreadPoolExecutor：** 适用于需要多个后台执行周期任务，同时为了满足资源管理需求而需要限制后台线程的数量的应用场景；
|
||||
- **SingleThreadScheduledExecutor：** 适用于需要单个后台线程执行周期任务，同时保证顺序地执行各个任务的应用场景。
|
||||
|
||||
### 4.3 创建的线程池的方式
|
||||
|
||||
**（1） 使用 Executors 创建**
|
||||
|
||||
我们上面刚刚提到了 Java 提供的几种线程池，通过 Executors 工具类我们可以很轻松的创建我们上面说的几种线程池。但是实际上我们一般都不是直接使用 Java 提供好的线程池，另外在《阿里巴巴 Java 开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 构造函数 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
|
||||
|
||||
```java
|
||||
Executors 返回线程池对象的弊端如下：
|
||||
|
||||
FixedThreadPool 和 SingleThreadExecutor ： 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致OOM。
|
||||
CachedThreadPool 和 ScheduledThreadPool ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致OOM。
|
||||
|
||||
```
|
||||
|
||||
**（2） ThreadPoolExecutor 的构造函数创建**
|
||||
|
||||
我们可以自己直接调用 ThreadPoolExecutor 的构造函数来自己创建线程池。在创建的同时，给 BlockQueue 指定容量就可以了。示例如下：
|
||||
|
||||
```java
|
||||
private static ExecutorService executor = new ThreadPoolExecutor(13, 13,
|
||||
60L, TimeUnit.SECONDS,
|
||||
new ArrayBlockingQueue(13));
|
||||
```
|
||||
|
||||
这种情况下，一旦提交的线程数超过当前可用线程数时，就会抛出 java.util.concurrent.RejectedExecutionException，这是因为当前线程池使用的队列是有边界队列，队列已经满了便无法继续处理新的请求。但是异常（Exception）总比发生错误（Error）要好。
|
||||
|
||||
**（3） 使用开源类库**
|
||||
|
||||
Hollis 大佬之前在他的文章中也提到了：“除了自己定义 ThreadPoolExecutor 外。还有其他方法。这个时候第一时间就应该想到开源类库，如 apache 和 guava 等。”他推荐使用 guava 提供的 ThreadFactoryBuilder 来创建线程池。下面是参考他的代码示例：
|
||||
|
||||
```java
|
||||
public class ExecutorsDemo {
|
||||
|
||||
private static ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
|
||||
.setNameFormat("demo-pool-%d").build();
|
||||
|
||||
private static ExecutorService pool = new ThreadPoolExecutor(5, 200,
|
||||
0L, TimeUnit.MILLISECONDS,
|
||||
new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
|
||||
|
||||
public static void main(String[] args) {
|
||||
|
||||
for (int i = 0; i < Integer.MAX_VALUE; i++) {
|
||||
pool.execute(new SubThread());
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
通过上述方式创建线程时，不仅可以避免 OOM 的问题，还可以自定义线程名称，更加方便的出错的时候溯源。
|
||||
|
||||
## 5 Nginx
|
||||
|
||||
### 5.1 简单介绍一下 Nginx
|
||||
|
||||
Nginx 是一款轻量级的 Web 服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器。 Nginx 主要提供反向代理、负载均衡、动静分离(静态资源服务)等服务。下面我简单地介绍一下这些名词。
|
||||
|
||||
#### 反向代理
|
||||
|
||||
谈到反向代理，就不得不提一下正向代理。无论是正向代理，还是反向代理，说到底，就是代理模式的衍生版本罢了
|
||||
|
||||
- **正向代理：**某些情况下，代理我们用户去访问服务器，需要用户手动的设置代理服务器的 ip 和端口号。正向代理比较常见的一个例子就是 VPN 了。
|
||||
- **反向代理：** 是用来代理服务器的，代理我们要访问的目标服务器。代理服务器接受请求，然后将请求转发给内部网络的服务器，并将从服务器上得到的结果返回给客户端，此时代理服务器对外就表现为一个服务器。
|
||||
|
||||
通过下面两幅图，大家应该更好理解（图源：http://blog.720ui.com/2016/nginx_action_05_proxy/）：
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
所以，简单的理解，就是正向代理是为客户端做代理，代替客户端去访问服务器，而反向代理是为服务器做代理，代替服务器接受客户端请求。
|
||||
|
||||
#### 负载均衡
|
||||
|
||||
在高并发情况下需要使用，其原理就是将并发请求分摊到多个服务器执行，减轻每台服务器的压力，多台服务器(集群)共同完成工作任务，从而提高了数据的吞吐量。
|
||||
|
||||
Nginx 支持的 weight 轮询（默认）、ip_hash、fair、url_hash 这四种负载均衡调度算法，感兴趣的可以自行查阅。
|
||||
|
||||
负载均衡相比于反向代理更侧重的是将请求分担到多台服务器上去，所以谈论负载均衡只有在提供某服务的服务器大于两台时才有意义。
|
||||
|
||||
#### 动静分离
|
||||
|
||||
动静分离是让动态网站里的动态网页根据一定规则把不变的资源和经常变的资源区分开来，动静资源做好了拆分以后，我们就可以根据静态资源的特点将其做缓存操作，这就是网站静态化处理的核心思路。
|
||||
|
||||
### 5.2 为什么要用 Nginx?
|
||||
|
||||
> 这部分内容参考极客时间—[Nginx 核心知识 100 讲的内容](https://time.geekbang.org/course/intro/138?code=AycjiiQk6uQRxnVJzBupFkrGkvZlmYELPRsZbWzaAHE= "Nginx核心知识100讲的内容")。
|
||||
|
||||
如果面试官问你这个问题，就一定想看你知道 Nginx 服务器的一些优点吗。
|
||||
|
||||
Nginx 有以下 5 个优点：
|
||||
|
||||
1. 高并发、高性能（这是其他 web 服务器不具有的）
|
||||
2. 可扩展性好（模块化设计，第三方插件生态圈丰富）
|
||||
3. 高可靠性（可以在服务器行持续不间断的运行数年）
|
||||
4. 热部署（这个功能对于 Nginx 来说特别重要，热部署指可以在不停止 Nginx 服务的情况下升级 Nginx）
|
||||
5. BSD 许可证（意味着我们可以将源代码下载下来进行修改然后使用自己的版本）
|
||||
|
||||
### 5.3 Nginx 的四个主要组成部分了解吗?
|
||||
|
||||
> 这部分内容参考极客时间—[Nginx 核心知识 100 讲的内容](https://time.geekbang.org/course/intro/138?code=AycjiiQk6uQRxnVJzBupFkrGkvZlmYELPRsZbWzaAHE= "Nginx核心知识100讲的内容")。
|
||||
|
||||
- Nginx 二进制可执行文件：由各模块源码编译出一个文件
|
||||
- nginx.conf 配置文件：控制 Nginx 行为
|
||||
- acess.log 访问日志： 记录每一条 HTTP 请求信息
|
||||
- error.log 错误日志：定位问题
|
||||
@ -0,0 +1,64 @@
|
||||
我还记得当时我去参加面试的时候，几乎每一场面试，特别是HR面和高管面的时候，面试官总是会在结尾问我:“问了你这么多问题了，你有什么问题问我吗？”。这个时候很多人内心就会陷入短暂的纠结中：我该问吗？不问的话面试官会不会对我影响不好？问什么问题？问这个问题会不会让面试官对我的影响不好啊？
|
||||
|
||||
|
||||
|
||||
### 这个问题对最终面试结果的影响到底大不大?
|
||||
|
||||
就技术面试而言，回答这个问题的时候，只要你不是触碰到你所面试的公司的雷区，那么我觉得这对你能不能拿到最终offer来说影响确实是不大的。我说这些并不代表你就可以直接对面试官说：“我没问题了。”，笔主当时面试的时候确实也说过挺多次“没问题要问了。”，最终也没有导致笔主被pass掉（可能是前面表现比较好，哈哈，自恋一下）。我现在回想起来，觉得自己当时做法其实挺不对的。面试本身就是一个双向选择的过程，你对这个问题的回答也会侧面反映出你对这次面试的上心程度，你的问题是否有价值，也影响了你最终的选择与公司是否选择你。
|
||||
|
||||
面试官在技术面试中主要考察的还是你这样个人到底有没有胜任这个工作的能力以及你是否适合公司未来的发展需要，很多公司还需要你认同它的文化，我觉得你只要不是太笨，应该不会栽在这里。除非你和另外一个人在能力上相同，但是只能在你们两个人中选一个，那么这个问题才对你能不能拿到offer至关重要。有准备总比没准备好，给面试官留一个好的影响总归是没错的。
|
||||
|
||||
但是，就非技术面试来说，我觉得好好回答这个问题对你最终的结果还是比较重要的。
|
||||
|
||||
总的来说不管是技术面试还是非技术面试，如果你想赢得公司的青睐和尊重，我觉得我们都应该重视这个问题。
|
||||
|
||||
### 真诚一点,不要问太 Low 的问题
|
||||
|
||||
回答这个问题很重要的一点就是你没有必要放低自己的姿态问一些很虚或者故意讨好面试官的问题，也不要把自己从面经上学到的东西照搬下来使用。面试官也不是傻子，特别是那种特别有经验的面试官，你是真心诚意的问问题，还是从别处照搬问题来讨好面试官，人家可能一听就听出来了。总的来说，还是要真诚。除此之外，不要问太 Low 的问题，会显得你整个人格局比较小或者说你根本没有准备（侧面反映你对这家公司不上心，既然你不上心，为什么要要你呢）。举例几个比较 Low 的问题，大家看看自己有没有问过其中的问题：
|
||||
|
||||
- 贵公司的主要业务是什么？（面试之前自己不知道提前网上查一下吗？）
|
||||
- 贵公司的男女比例如何？（考虑脱单？记住你是来工作的！）
|
||||
- 贵公司一年搞几次外出旅游？（你是来工作的，这些娱乐活动先别放在心上！）
|
||||
- ......
|
||||
|
||||
### 有哪些有价值的问题值得问?
|
||||
|
||||
针对这个问题。笔主专门找了几个专门做HR工作的小哥哥小姐姐们询问并且查阅了挺多前辈们的回答，然后结合自己的实际经历，我概括了下面几个比较适合问的问题。
|
||||
|
||||
#### 面对HR或者其他Level比较低的面试官时
|
||||
|
||||
1. **能不能谈谈你作为一个公司老员工对公司的感受?** (这个问题比较容易回答，不会让面试官陷入无话可说的尴尬境地。另外，从面试官的回答中你可以加深对这个公司的了解，让你更加清楚这个公司到底是不是你想的那样或者说你是否能适应这个公司的文化。除此之外，这样的问题在某种程度上还可以拉进你与面试官的距离。)
|
||||
2. **能不能问一下，你当时因为什么原因选择加入这家公司的呢或者说这家公司有哪些地方吸引你？有什么地方你觉得还不太好或者可以继续完善吗？** （类似第一个问题，都是问面试官个人对于公司的看法。）
|
||||
3. **我觉得我这次表现的不是太好，你有什么建议或者评价给我吗？**(这个是我常问的。我觉得说自己表现不好只是这个语境需要这样来说，这样可以显的你比较谦虚好学上进。)
|
||||
4. **接下来我会有一段空档期，有什么值得注意或者建议学习的吗？** （体现出你对工作比较上心，自助学习意识比较强。）
|
||||
5. **这个岗位为什么还在招人？** (岗位真实性和价值咨询)
|
||||
6. **大概什么时候能给我回复呢？** (终面的时候，如果面试官没有说的话，可以问一下)
|
||||
7. ......
|
||||
|
||||
|
||||
|
||||
#### 面对部门领导
|
||||
|
||||
1. **部门的主要人员分配以及对应的主要工作能简单介绍一下吗？**
|
||||
2. **未来如果我要加入这个团队，你对我的期望是什么？** （部门领导一般情况下是你的直属上级了，你以后和他打交道的机会应该是最多的。你问这个问题，会让他感觉你是一个对他的部门比较上心，比较有团体意识，并且愿意倾听的候选人。）
|
||||
3. **公司对新入职的员工的培养机制是什么样的呢？** （正规的公司一般都有培养机制，提前问一下是对你自己的负责也会显的你比较上心）
|
||||
4. **以您来看，这个岗位未来在公司内部的发展如何？** (在我看来，问这个问题也是对你自己的负责吧，谁不想发展前景更好的岗位呢？)
|
||||
5. **团队现在面临的最大挑战是什么？** (这样的问题不会暴露你对公司的不了解，并且也能让你对未来工作的挑战或困难有一个提前的预期。)
|
||||
|
||||
|
||||
|
||||
#### 面对Level比较高的(比如总裁,老板)
|
||||
|
||||
1. **贵公司的发展目标和方向是什么？** （看下公司的发展是否满足自己的期望）
|
||||
2. **与同行业的竞争者相比，贵公司的核心竞争优势在什么地方？** （充分了解自己的优势和劣势）
|
||||
3. **公司现在面临的最大挑战是什么？**
|
||||
|
||||
### 来个补充,顺便送个祝福给大家
|
||||
|
||||
薪酬待遇和相关福利问题一般在终面的时候（最好不要在前面几面的时候就问到这个问题），面试官会提出来或者在面试完之后以邮件的形式告知你。一般来说，如果面试官很愿意为你回答问题，对你的问题也比较上心的话，那他肯定是觉得你就是他们要招的人。
|
||||
|
||||
大家在面试的时候，可以根据自己对于公司或者岗位的了解程度，对上面提到的问题进行适当修饰或者修改。上面提到的一些问题只是给没有经验的朋友一个参考，如果你还有其他比较好的问题的话，那当然也更好啦！
|
||||
|
||||
金三银四。过了二月就到了面试高峰期或者说是黄金期。几份惊喜几份愁，愿各位能始终不忘初心！每个人都有每个人的难处。引用一句《阿甘正传》里面的台词：“生活就像一盒巧克力，你永远不知道下一块是什么味道“。
|
||||
|
||||
|
||||
@ -0,0 +1,222 @@
|
||||
本文的内容都是根据读者投稿的真实面试经历改编而来，首次尝试这种风格的文章，花了几天晚上才总算写完，希望对你有帮助。
|
||||
|
||||
本文主要涵盖下面的内容：
|
||||
|
||||
1. 分布式商城系统：架构图讲解；
|
||||
2. 消息队列相关：削峰和解耦；
|
||||
3. Redis 相关：缓存穿透问题的解决；
|
||||
4. 一些基础问题：
|
||||
- 网络相关：1.浏览器输入 URL 发生了什么? 2.TCP 和 UDP 区别? 3.TCP 如何保证传输可靠性?
|
||||
- Java 基础：1. 既然有了字节流,为什么还要有字符流? 2.深拷贝 和 浅拷贝有啥区别呢？
|
||||
|
||||
下面是正文！
|
||||
|
||||
面试开始，坐在我前面的就是这次我的面试官吗？这发量看着根本不像程序员啊？我心里正嘀咕着，只听见面试官说：“小伙，下午好，我今天就是你的面试官，咱们开始面试吧！”。
|
||||
|
||||
### 第一面开始
|
||||
|
||||
**面试官：** 我也不用多说了，你先自我介绍一下吧，简历上有的就不要再说了哈。
|
||||
|
||||
**我：** 内心 os:"果然如我所料，就知道会让我先自我介绍一下，还好我看了 [JavaGuide](https://github.com/Snailclimb/JavaGuide "JavaGuide") ，学到了一些套路。套路总结起来就是：**最好准备好两份自我介绍，一份对 hr 说的，主要讲能突出自己的经历，会的编程技术一语带过；另一份对技术面试官说的，主要讲自己会的技术细节，项目经验，经历那些就一语带过。** 所以，我按照这个套路准备了一个还算通用的模板，毕竟我懒嘛！不想多准备一个自我介绍，整个通用的多好！
|
||||
|
||||
> 面试官，您好！我叫小李子。大学时间我主要利用课外时间学习 Java 相关的知识。在校期间参与过一个某某系统的开发，主要负责数据库设计和后端系统开发.，期间解决了什么问题，巴拉巴拉。另外，我自己在学习过程中也参照网上的教程写过一个电商系统的网站，写这个电商网站主要是为了能让自己接触到分布式系统的开发。在学习之余，我比较喜欢通过博客整理分享自己所学知识。我现在已经是某社区的认证作者，写过一系列关于 线程池使用以及源码分析的文章深受好评。另外，我获得过省级编程比赛二等奖,我将这个获奖项目开源到 Github 还收获了 2k 的 Star 呢？
|
||||
|
||||
**面试官：** 你刚刚说参考网上的教程做了一个电商系统？你能画画这个电商系统的架构图吗？
|
||||
|
||||
**我：** 内心 os: "这可难不倒我！早知道写在简历上的项目要重视了，提前都把这个系统的架构图画了好多遍了呢！"
|
||||
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-11/商城系统-架构图plus.png" style="zoom:50%;" />
|
||||
|
||||
做过分布式电商系统的一定很熟悉上面的架构图（目前比较流行的是微服务架构，但是如果你有分布式开发经验也是非常加分的！）。
|
||||
|
||||
**面试官：** 简单介绍一下你做的这个系统吧！
|
||||
|
||||
**我：** 我一本正经的对着我刚刚画的商城架构图开始了满嘴造火箭的讲起来：
|
||||
|
||||
> 本系统主要分为展示层、服务层和持久层这三层。表现层顾名思义主要就是为了用来展示，比如我们的后台管理系统的页面、商城首页的页面、搜索系统的页面等等，这一层都只是作为展示，并没有提供任何服务。
|
||||
>
|
||||
> 展示层和服务层一般是部署在不同的机器上来提高并发量和扩展性，那么展示层和服务层怎样才能交互呢？在本系统中我们使用 Dubbo 来进行服务治理。Dubbo 是一款高性能、轻量级的开源 Java RPC 框架。Dubbo 在本系统的主要作用就是提供远程 RPC 调用。在本系统中服务层的信息通过 Dubbo 注册给 ZooKeeper，表现层通过 Dubbo 去 ZooKeeper 中获取服务的相关信息。Zookeeper 的作用仅仅是存放提供服务的服务器的地址和一些服务的相关信息，实现 RPC 远程调用功能的还是 Dubbo。如果需要引用到某个服务的时候，我们只需要在配置文件中配置相关信息就可以在代码中直接使用了，就像调用本地方法一样。假如说某个服务的使用量增加时，我们只用为这单个服务增加服务器，而不需要为整个系统添加服务。
|
||||
>
|
||||
> 另外，本系统的数据库使用的是常用的 MySQL，并且用到了数据库中间件 MyCat。另外，本系统还用到 redis 内存数据库来作为缓存来提高系统的反应速度。假如用户第一次访问数据库中的某些数据，这个过程会比较慢，因为是从硬盘上读取的。将该用户访问的数据存在数缓存中，这样下一次再访问这些数据的时候就可以直接从缓存中获取了。操作缓存就是直接操作内存，所以速度相当快。
|
||||
>
|
||||
> 系统还用到了 Elasticsearch 来提供搜索功能。使用 Elasticsearch 我们可以非常方便的为我们的商城系统添加必备的搜索功能，并且使用 Elasticsearch 还能提供其它非常实用的功能，并且很容易扩展。
|
||||
|
||||
**面试官：** 我看你的系统里面还用到了消息队列，能说说为什么要用它吗？
|
||||
|
||||
**我：**
|
||||
|
||||
> 使用消息队列主要是为了：
|
||||
>
|
||||
> 1. 减少响应所需时间和削峰。
|
||||
> 2. 降低系统耦合性（解耦/提升系统可扩展性）。
|
||||
|
||||
**面试官：** 你这说的太简单了！能不能稍微详细一点，最好能画图给我解释一下。
|
||||
|
||||
**我：** 内心 os:"都 2019 年了，大部分面试者都能对消息队列的为系统带来的这两个好处倒背如流了，如果你想走的更远就要别别人懂的更深一点！"
|
||||
|
||||
> 当我们不使用消息队列的时候，所有的用户的请求会直接落到服务器，然后通过数据库或者缓存响应。假如在高并发的场景下，如果没有缓存或者数据库承受不了这么大的压力的话，就会造成响应速度缓慢，甚至造成数据库宕机。但是，在使用消息队列之后，用户的请求数据发送给了消息队列之后就可以立即返回，再由消息队列的消费者进程从消息队列中获取数据，异步写入数据库，不过要确保消息不被重复消费还要考虑到消息丢失问题。由于消息队列服务器处理速度快于数据库，因此响应速度得到大幅改善。
|
||||
>
|
||||
> 文字 is too 空洞，直接上图吧！下图展示了使用消息前后系统处理用户请求的对比（ps:我自己都被我画的这个图美到了，如果你也觉得这张图好看的话麻烦来个素质三连！）。
|
||||
>
|
||||
> 
|
||||
>
|
||||
> 通过以上分析我们可以得出**消息队列具有很好的削峰作用的功能**——即**通过异步处理，将短时间高并发产生的事务消息存储在消息队列中，从而削平高峰期的并发事务。** 举例：在电子商务一些秒杀、促销活动中，合理使用消息队列可以有效抵御促销活动刚开始大量订单涌入对系统的冲击。如下图所示：
|
||||
>
|
||||
> 
|
||||
>
|
||||
> 使用消息队列还可以降低系统耦合性。我们知道如果模块之间不存在直接调用，那么新增模块或者修改模块就对其他模块影响较小，这样系统的可扩展性无疑更好一些。还是直接上图吧：
|
||||
>
|
||||
> 
|
||||
>
|
||||
> 生产者（客户端）发送消息到消息队列中去，接受者（服务端）处理消息，需要消费的系统直接去消息队列取消息进行消费即可而不需要和其他系统有耦合， 这显然也提高了系统的扩展性。
|
||||
|
||||
**面试官：** 你觉得它有什么缺点吗？或者说怎么考虑用不用消息队列？
|
||||
|
||||
**我：** 内心 os: "面试官真鸡贼！这不是勾引我上钩么？还好我准备充分。"
|
||||
|
||||
> 我觉得可以从下面几个方面来说：
|
||||
>
|
||||
> 1. **系统可用性降低：** 系统可用性在某种程度上降低，为什么这样说呢？在加入 MQ 之前，你不用考虑消息丢失或者说 MQ 挂掉等等的情况，但是，引入 MQ 之后你就需要去考虑了！
|
||||
> 2. **系统复杂性提高：** 加入 MQ 之后，你需要保证消息没有被重复消费、处理消息丢失的情况、保证消息传递的顺序性等等问题！
|
||||
> 3. **一致性问题：** 我上面讲了消息队列可以实现异步，消息队列带来的异步确实可以提高系统响应速度。但是，万一消息的真正消费者并没有正确消费消息怎么办？这样就会导致数据不一致的情况了!
|
||||
|
||||
**面试官**：做项目的过程中遇到了什么问题吗？解决了吗？如果解决的话是如何解决的呢？
|
||||
|
||||
**我** ： 内心 os: "做的过程中好像也没有遇到什么问题啊！怎么办？怎么办？突然想到可以说我在使用 Redis 过程中遇到的问题，毕竟我对 Redis 还算熟悉嘛，**把面试官往这个方向吸引**，准没错。"
|
||||
|
||||
> 我在使用 Redis 对常用数据进行缓冲的过程中出现了缓存穿透问题。然后，我通过谷歌搜索相关的解决方案来解决的。
|
||||
|
||||
**面试官：** 你还知道缓存穿透啊？不错啊！来说说什么是缓存穿透以及你最后的解决办法。
|
||||
|
||||
**我：** 我先来谈谈什么是缓存穿透吧！
|
||||
|
||||
> 缓存穿透说简单点就是大量请求的 key 根本不存在于缓存中，导致请求直接到了数据库上，根本没有经过缓存这一层。举个例子：某个黑客故意制造我们缓存中不存在的 key 发起大量请求，导致大量请求落到数据库。
|
||||
>
|
||||
> 总结一下就是：
|
||||
>
|
||||
> 1. 缓存层不命中。
|
||||
> 2. 存储层不命中，不将空结果写回缓存。
|
||||
> 3. 返回空结果给客户端。
|
||||
>
|
||||
> 一般 MySQL 默认的最大连接数在 150 左右，这个可以通过 `show variables like '%max_connections%';`命令来查看。最大连接数一个还只是一个指标，cpu，内存，磁盘，网络等物理条件都是其运行指标，这些指标都会限制其并发能力！所以，一般 3000 的并发请求就能打死大部分数据库了。
|
||||
|
||||
**面试官：** 小伙子不错啊！还准备问你：“为什么 3000 的并发能把支持最大连接数 4000 数据库压死？”想不到你自己就提前回答了！不错！
|
||||
|
||||
**我：** 别夸了！别夸了！我再来说说我知道的一些解决办法以及我最后采用的方案吧！您帮忙看看有没有问题。
|
||||
|
||||
> 最基本的就是首先做好参数校验，一些不合法的参数请求直接抛出异常信息返回给客户端。比如查询的数据库 id 不能小于 0、传入的邮箱格式不对的时候直接返回错误消息给客户端等等。
|
||||
>
|
||||
> 参数校验通过的情况还是会出现缓存穿透，我们还可以通过以下几个方案来解决这个问题：
|
||||
>
|
||||
> **1）缓存无效 key** : 如果缓存和数据库都查不到某个 key 的数据就写一个到 redis 中去并设置过期时间，具体命令如下：`SET key value EX 10086`。这种方式可以解决请求的 key 变化不频繁的情况，如何黑客恶意攻击，每次构建的不同的请求 key，会导致 redis 中缓存大量无效的 key 。很明显，这种方案并不能从根本上解决此问题。如果非要用这种方式来解决穿透问题的话，尽量将无效的 key 的过期时间设置短一点比如 1 分钟。
|
||||
>
|
||||
> 另外，这里多说一嘴，一般情况下我们是这样设计 key 的： `表名:列名:主键名:主键值`。
|
||||
>
|
||||
> **2）布隆过滤器：** 布隆过滤器是一个非常神奇的数据结构，通过它我们可以非常方便地判断一个给定数据是否存在于海量数据中。我们需要的就是判断 key 是否合法，有没有感觉布隆过滤器就是我们想要找的那个“人”。
|
||||
|
||||
**面试官：** 不错不错！你还知道布隆过滤器啊！来给我谈一谈。
|
||||
|
||||
**我：** 内心 os：“如果你准备过海量数据处理的面试题，你一定对：“如何确定一个数字是否在于包含大量数字的数字集中（数字集很大，5 亿以上！）?”这个题目很了解了！解决这道题目就要用到布隆过滤器。”
|
||||
|
||||
> 布隆过滤器在针对海量数据去重或者验证数据合法性的时候非常有用。**布隆过滤器的本质实际上是 “位(bit)数组”，也就是说每一个存入布隆过滤器的数据都只占一位。相比于我们平时常用的的 List、Map 、Set 等数据结构，它占用空间更少并且效率更高，但是缺点是其返回的结果是概率性的，而不是非常准确的。**
|
||||
>
|
||||
> **当一个元素加入布隆过滤器中的时候，会进行如下操作：**
|
||||
>
|
||||
> 1. 使用布隆过滤器中的哈希函数对元素值进行计算，得到哈希值（有几个哈希函数得到几个哈希值）。
|
||||
> 2. 根据得到的哈希值，在位数组中把对应下标的值置为 1。
|
||||
>
|
||||
> **当我们需要判断一个元素是否存在于布隆过滤器的时候，会进行如下操作：**
|
||||
>
|
||||
> 1. 对给定元素再次进行相同的哈希计算；
|
||||
> 2. 得到值之后判断位数组中的每个元素是否都为 1，如果值都为 1，那么说明这个值在布隆过滤器中，如果存在一个值不为 1，说明该元素不在布隆过滤器中。
|
||||
>
|
||||
> 举个简单的例子：
|
||||
>
|
||||
> 
|
||||
>
|
||||
> 如图所示，当字符串存储要加入到布隆过滤器中时，该字符串首先由多个哈希函数生成不同的哈希值，然后在对应的位数组的下表的元素设置为 1（当位数组初始化时 ，所有位置均为 0）。当第二次存储相同字符串时，因为先前的对应位置已设置为 1，所以很容易知道此值已经存在（去重非常方便）。
|
||||
>
|
||||
> 如果我们需要判断某个字符串是否在布隆过滤器中时，只需要对给定字符串再次进行相同的哈希计算，得到值之后判断位数组中的每个元素是否都为 1，如果值都为 1，那么说明这个值在布隆过滤器中，如果存在一个值不为 1，说明该元素不在布隆过滤器中。
|
||||
>
|
||||
> **不同的字符串可能哈希出来的位置相同，这种情况我们可以适当增加位数组大小或者调整我们的哈希函数。**
|
||||
>
|
||||
> 综上，我们可以得出：**布隆过滤器说某个元素存在，小概率会误判。布隆过滤器说某个元素不在，那么这个元素一定不在。**
|
||||
|
||||
**面试官：** 看来你对布隆过滤器了解的还挺不错的嘛！那你快说说你最后是怎么利用它来解决缓存穿透的。
|
||||
|
||||
**我：** 知道了布隆过滤器的原理就之后就很容易做了。我是利用 Redis 布隆过滤器来做的。我把所有可能存在的请求的值都存放在布隆过滤器中，当用户请求过来，我会先判断用户发来的请求的值是否存在于布隆过滤器中。不存在的话，直接返回请求参数错误信息给客户端，存在的话才会走下面的流程。总结一下就是下面这张图(这张图片不是我画的，为了省事直接在网上找的)：
|
||||
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-11/布隆过滤器-缓存穿透-redis.png" style="zoom:50%;" />
|
||||
|
||||
更多关于布隆过滤器的内容可以看我的这篇原创：[《不了解布隆过滤器？一文给你整的明明白白！》](https://github.com/Snailclimb/JavaGuide/blob/master/docs/dataStructures-algorithms/data-structure/bloom-filter.md "《不了解布隆过滤器？一文给你整的明明白白！》") ，强烈推荐，个人感觉网上应该找不到总结的这么明明白白的文章了。
|
||||
|
||||
**面试官：** 好了好了。项目就暂时问到这里吧！下面有一些比较基础的问题我简单地问一下你。内心 os： 难不成这家伙满口高并发，连最基础的东西都不会吧！
|
||||
|
||||
**我：** 好的好的！没问题！
|
||||
|
||||
**面试官：** 浏览器输入 URL 发生了什么?
|
||||
|
||||
**我：** 内心 os：“很常问的一个问题，建议拿小本本记好了！另外，百度好像最喜欢问这个问题，去百度面试可要提前备好这道题的功课哦！相似问题：打开一个网页，整个过程会使用哪些协议？”。
|
||||
|
||||
> 图解（图片来源：《图解 HTTP》）：
|
||||
>
|
||||
> <img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-11/url输入到展示出来的过程.jpg" style="zoom:50%;" />
|
||||
>
|
||||
> 总体来说分为以下几个过程:
|
||||
>
|
||||
> 1. DNS 解析
|
||||
> 2. TCP 连接
|
||||
> 3. 发送 HTTP 请求
|
||||
> 4. 服务器处理请求并返回 HTTP 报文
|
||||
> 5. 浏览器解析渲染页面
|
||||
> 6. 连接结束
|
||||
>
|
||||
> 具体可以参考下面这篇文章：
|
||||
>
|
||||
> - [https://segmentfault.com/a/1190000006879700](https://segmentfault.com/a/1190000006879700 "https://segmentfault.com/a/1190000006879700")
|
||||
|
||||
**面试官：** TCP 和 UDP 区别?
|
||||
|
||||
**我：**
|
||||
|
||||
> 
|
||||
>
|
||||
> UDP 在传送数据之前不需要先建立连接，远地主机在收到 UDP 报文后，不需要给出任何确认。虽然 UDP 不提供可靠交付，但在某些情况下 UDP 确是一种最有效的工作方式（一般用于即时通信），比如： QQ 语音、 QQ 视频 、直播等等
|
||||
>
|
||||
> TCP 提供面向连接的服务。在传送数据之前必须先建立连接，数据传送结束后要释放连接。 TCP 不提供广播或多播服务。由于 TCP 要提供可靠的，面向连接的传输服务（TCP 的可靠体现在 TCP 在传递数据之前，会有三次握手来建立连接，而且在数据传递时，有确认、窗口、重传、拥塞控制机制，在数据传完后，还会断开连接用来节约系统资源），这一难以避免增加了许多开销，如确认，流量控制，计时器以及连接管理等。这不仅使协议数据单元的首部增大很多，还要占用许多处理机资源。TCP 一般用于文件传输、发送和接收邮件、远程登录等场景。
|
||||
|
||||
**面试官：** TCP 如何保证传输可靠性?
|
||||
|
||||
**我：**
|
||||
|
||||
> 1. 应用数据被分割成 TCP 认为最适合发送的数据块。
|
||||
> 2. TCP 给发送的每一个包进行编号，接收方对数据包进行排序，把有序数据传送给应用层。
|
||||
> 3. **校验和：** TCP 将保持它首部和数据的检验和。这是一个端到端的检验和，目的是检测数据在传输过程中的任何变化。如果收到段的检验和有差错，TCP 将丢弃这个报文段和不确认收到此报文段。
|
||||
> 4. TCP 的接收端会丢弃重复的数据。
|
||||
> 5. **流量控制：** TCP 连接的每一方都有固定大小的缓冲空间，TCP 的接收端只允许发送端发送接收端缓冲区能接纳的数据。当接收方来不及处理发送方的数据，能提示发送方降低发送的速率，防止包丢失。TCP 使用的流量控制协议是可变大小的滑动窗口协议。 （TCP 利用滑动窗口实现流量控制）
|
||||
> 6. **拥塞控制：** 当网络拥塞时，减少数据的发送。
|
||||
> 7. **ARQ 协议：** 也是为了实现可靠传输的，它的基本原理就是每发完一个分组就停止发送，等待对方确认。在收到确认后再发下一个分组。
|
||||
> 8. **超时重传：** 当 TCP 发出一个段后，它启动一个定时器，等待目的端确认收到这个报文段。如果不能及时收到一个确认，将重发这个报文段。
|
||||
|
||||
**面试官：** 我再来问你一些 Java 基础的问题吧！小伙子。
|
||||
|
||||
**我：** 好的。（内心 os:“你尽管来！”）
|
||||
|
||||
**面试官：** 既然有了字节流,为什么还要有字符流?
|
||||
|
||||
我：内心 os ：“问题本质想问：**不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？**”
|
||||
|
||||
> 字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还算是非常耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。所以， I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。
|
||||
|
||||
**面试官**：深拷贝 和 浅拷贝有啥区别呢？
|
||||
|
||||
**我：**
|
||||
|
||||
> 1. **浅拷贝**：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。
|
||||
> 2. **深拷贝**：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。
|
||||
>
|
||||
> 
|
||||
|
||||
**面试官：** 好的！面试结束。小伙子可以的！回家等通知吧！
|
||||
|
||||
**我：** 好的好的！辛苦您了！
|
||||
@ -1,3 +1,22 @@
|
||||
点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。
|
||||
|
||||
<!-- TOC -->
|
||||
|
||||
- [何谓悲观锁与乐观锁](#何谓悲观锁与乐观锁)
|
||||
- [悲观锁](#悲观锁)
|
||||
- [乐观锁](#乐观锁)
|
||||
- [两种锁的使用场景](#两种锁的使用场景)
|
||||
- [乐观锁常见的两种实现方式](#乐观锁常见的两种实现方式)
|
||||
- [1. 版本号机制](#1-版本号机制)
|
||||
- [2. CAS算法](#2-cas算法)
|
||||
- [乐观锁的缺点](#乐观锁的缺点)
|
||||
- [1 ABA 问题](#1-aba-问题)
|
||||
- [2 循环时间长开销大](#2-循环时间长开销大)
|
||||
- [3 只能保证一个共享变量的原子操作](#3-只能保证一个共享变量的原子操作)
|
||||
- [CAS与synchronized的使用情景](#cas与synchronized的使用情景)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
### 何谓悲观锁与乐观锁
|
||||
|
||||
> 乐观锁对应于生活中乐观的人总是想着事情往好的方向发展，悲观锁对应于生活中悲观的人总是想着事情往坏的方向发展。这两种人各有优缺点，不能不以场景而定说一种人好于另外一种人。
|
||||
@ -64,8 +83,6 @@ JDK 1.5 以后的 `AtomicStampedReference 类`就提供了此种能力，其中
|
||||
|
||||
CAS 只对单个共享变量有效，当操作涉及跨多个共享变量时 CAS 无效。但是从 JDK 1.5开始，提供了`AtomicReference类`来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行 CAS 操作.所以我们可以使用锁或者利用`AtomicReference类`把多个共享变量合并成一个共享变量来操作。
|
||||
|
||||
|
||||
|
||||
### CAS与synchronized的使用情景
|
||||
|
||||
> **简单的来说CAS适用于写比较少的情况下（多读场景，冲突一般较少），synchronized适用于写比较多的情况下（多写场景，冲突一般较多）**
|
||||
@ -73,10 +90,17 @@ CAS 只对单个共享变量有效，当操作涉及跨多个共享变量时 CAS
|
||||
1. 对于资源竞争较少（线程冲突较轻）的情况，使用synchronized同步锁进行线程阻塞和唤醒切换以及用户态内核态间的切换操作额外浪费消耗cpu资源；而CAS基于硬件实现，不需要进入内核，不需要切换线程，操作自旋几率较少，因此可以获得更高的性能。
|
||||
2. 对于资源竞争严重（线程冲突严重）的情况，CAS自旋的概率会比较大，从而浪费更多的CPU资源，效率低于synchronized。
|
||||
|
||||
|
||||
补充： Java并发编程这个领域中synchronized关键字一直都是元老级的角色，很久之前很多人都会称它为 **“重量级锁”** 。但是，在JavaSE 1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的 **偏向锁** 和 **轻量级锁** 以及其它**各种优化**之后变得在某些情况下并不是那么重了。synchronized的底层实现主要依靠 **Lock-Free** 的队列，基本思路是 **自旋后阻塞**，**竞争切换后继续竞争锁**，**稍微牺牲了公平性，但获得了高吞吐量**。在线程冲突较少的情况下，可以获得和CAS类似的性能；而线程冲突严重的情况下，性能远高于CAS。
|
||||
|
||||
|
||||
## 公众号
|
||||
|
||||
如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。
|
||||
|
||||
**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"面试突击"** 即可免费领取！
|
||||
|
||||
**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
78
docs/github-trending/2018-12.md
Normal file
78
docs/github-trending/2018-12.md
Normal file
@ -0,0 +1,78 @@
|
||||
本文数据统计于 1.1 号凌晨，由 SnailClimb 整理。
|
||||
|
||||
### 1. JavaGuide
|
||||
|
||||
- **Github地址**： [https://github.com/Snailclimb/JavaGuide](https://github.com/Snailclimb/JavaGuide)
|
||||
- **star**: 18.2k
|
||||
- **介绍**: 【Java学习+面试指南】 一份涵盖大部分Java程序员所需要掌握的核心知识。
|
||||
|
||||
### 2. mall
|
||||
|
||||
- **Github地址**： [https://github.com/macrozheng/mall](https://github.com/macrozheng/mall)
|
||||
- **star**: 3.3k
|
||||
- **介绍**: mall项目是一套电商系统，包括前台商城系统及后台管理系统，基于SpringBoot+MyBatis实现。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。
|
||||
|
||||
### 3. advanced-java
|
||||
|
||||
- **Github地址**：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java)
|
||||
- **star**: 3.3k
|
||||
- **介绍**: 互联网 Java 工程师进阶知识完全扫盲
|
||||
|
||||
### 4. matrix
|
||||
|
||||
- **Github地址**：[https://github.com/Tencent/matrix](https://github.com/Tencent/matrix)
|
||||
- **star**: 2.5k
|
||||
- **介绍**: Matrix 是一款微信研发并日常使用的 APM（Application Performance Manage），当前主要运行在 Android 平台上。 Matrix 的目标是建立统一的应用性能接入框架，通过各种性能监控方案，对性能监控项的异常数据进行采集和分析，输出相应的问题分析、定位与优化建议，从而帮助开发者开发出更高质量的应用。
|
||||
|
||||
### 5. miaosha
|
||||
|
||||
- **Github地址**：[https://github.com/qiurunze123/miaosha](https://github.com/qiurunze123/miaosha)
|
||||
- **star**: 2.4k
|
||||
- **介绍**: 高并发大流量如何进行秒杀架构，我对这部分知识做了一个系统的整理，写了一套系统。
|
||||
|
||||
### 6. arthas
|
||||
|
||||
- **Github地址**：[https://github.com/alibaba/arthas](https://github.com/alibaba/arthas)
|
||||
- **star**: 8.2k
|
||||
- **介绍**: Arthas 是Alibaba开源的Java诊断工具，深受开发者喜爱。
|
||||
|
||||
### 7 spring-boot
|
||||
|
||||
- **Github地址**： [https://github.com/spring-projects/spring-boot](https://github.com/spring-projects/spring-boot)
|
||||
- **star:** 32.6k
|
||||
- **介绍**： 虽然Spring的组件代码是轻量级的，但它的配置却是重量级的（需要大量XML配置）,不过Spring Boot 让这一切成为了过去。 另外Spring Cloud也是基于Spring Boot构建的，我个人非常有必要学习一下。
|
||||
|
||||
**关于Spring Boot官方的介绍：**
|
||||
|
||||
> Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”…Most Spring Boot applications need very little Spring configuration.(Spring Boot可以轻松创建独立的生产级基于Spring的应用程序,只要通过 “just run”（可能是run ‘Application’或java -jar 或 tomcat 或 maven插件run 或 shell脚本）便可以运行项目。大部分Spring Boot项目只需要少量的配置即可)
|
||||
|
||||
### 8. tutorials
|
||||
|
||||
- **Github地址**：[https://github.com/eugenp/tutorials](https://github.com/eugenp/tutorials)
|
||||
- **star**: 10k
|
||||
- **介绍**: 该项目是一系列小而专注的教程 - 每个教程都涵盖Java生态系统中单一且定义明确的开发领域。 当然，它们的重点是Spring Framework - Spring，Spring Boot和Spring Securiyt。 除了Spring之外，还有以下技术：核心Java，Jackson，HttpClient，Guava。
|
||||
|
||||
### 9. qmq
|
||||
|
||||
- **Github地址**：[https://github.com/qunarcorp/qmq](https://github.com/qunarcorp/qmq)
|
||||
- **star**: 1.1k
|
||||
- **介绍**: QMQ是去哪儿网内部广泛使用的消息中间件，自2012年诞生以来在去哪儿网所有业务场景中广泛的应用，包括跟交易息息相关的订单场景； 也包括报价搜索等高吞吐量场景。
|
||||
|
||||
|
||||
### 10. symphony
|
||||
|
||||
- **Github地址**：[https://github.com/b3log/symphony](https://github.com/b3log/symphony)
|
||||
- **star**: 9k
|
||||
- **介绍**: 一款用 Java 实现的现代化社区（论坛/BBS/社交网络/博客）平台。
|
||||
|
||||
### 11. incubator-dubbo
|
||||
|
||||
- **Github地址**：[https://github.com/apache/incubator-dubbo](https://github.com/apache/incubator-dubbo)
|
||||
- **star**: 23.6k
|
||||
- **介绍**: 阿里开源的一个基于Java的高性能开源RPC框架。
|
||||
|
||||
### 12. apollo
|
||||
|
||||
- **Github地址**：[https://github.com/ctripcorp/apollo](https://github.com/ctripcorp/apollo)
|
||||
- **star**: 10k
|
||||
- **介绍**: Apollo（阿波罗）是携程框架部门研发的分布式配置中心，能够集中化管理应用不同环境、不同集群的配置，配置修改后能够实时推送到应用端，并且具备规范的权限、流程治理等特性，适用于微服务配置管理场景。
|
||||
76
docs/github-trending/2019-1.md
Normal file
76
docs/github-trending/2019-1.md
Normal file
@ -0,0 +1,76 @@
|
||||
### 1. JavaGuide
|
||||
|
||||
- **Github地址**： [https://github.com/Snailclimb/JavaGuide](https://github.com/Snailclimb/JavaGuide)
|
||||
- **star**: 22.8k
|
||||
- **介绍**: 【Java学习+面试指南】 一份涵盖大部分Java程序员所需要掌握的核心知识。
|
||||
|
||||
### 2. advanced-java
|
||||
|
||||
- **Github地址**：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java)
|
||||
- **star**: 7.9k
|
||||
- **介绍**: 互联网 Java 工程师进阶知识完全扫盲
|
||||
|
||||
### 3. fescar
|
||||
|
||||
- **Github地址**：[https://github.com/alibaba/fescar](https://github.com/alibaba/fescar)
|
||||
- **star**: 4.6k
|
||||
- **介绍**: 具有 **高性能** 和 **易用性** 的 **微服务架构** 的 **分布式事务** 的解决方案。（特点：高性能且易于使用，旨在实现简单并快速的事务提交与回滚。
|
||||
|
||||
### 4. mall
|
||||
|
||||
- **Github地址**： [https://github.com/macrozheng/mall](https://github.com/macrozheng/mall)
|
||||
- **star**: 5.6 k
|
||||
- **介绍**: mall项目是一套电商系统，包括前台商城系统及后台管理系统，基于SpringBoot+MyBatis实现。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。
|
||||
|
||||
### 5. miaosha
|
||||
|
||||
- **Github地址**：[https://github.com/qiurunze123/miaosha](https://github.com/qiurunze123/miaosha)
|
||||
- **star**: 4.4k
|
||||
- **介绍**: 高并发大流量如何进行秒杀架构，我对这部分知识做了一个系统的整理，写了一套系统。
|
||||
|
||||
### 6. flink
|
||||
|
||||
- **Github地址**：[https://github.com/apache/flink](https://github.com/apache/flink)
|
||||
- **star**: 7.1 k
|
||||
- **介绍**: Apache Flink是一个开源流处理框架，具有强大的流和批处理功能。
|
||||
|
||||
### 7. cim
|
||||
|
||||
- **Github地址**：[https://github.com/crossoverJie/cim](https://github.com/crossoverJie/cim)
|
||||
- **star**: 1.8 k
|
||||
- **介绍**: cim(cross IM) 适用于开发者的即时通讯系统。
|
||||
|
||||
### 8. symphony
|
||||
|
||||
- **Github地址**：[https://github.com/b3log/symphony](https://github.com/b3log/symphony)
|
||||
- **star**: 10k
|
||||
- **介绍**: 一款用 Java 实现的现代化社区（论坛/BBS/社交网络/博客）平台。
|
||||
|
||||
### 9. spring-boot
|
||||
|
||||
- **Github地址**： [https://github.com/spring-projects/spring-boot](https://github.com/spring-projects/spring-boot)
|
||||
- **star:** 32.6k
|
||||
- **介绍**： 虽然Spring的组件代码是轻量级的，但它的配置却是重量级的（需要大量XML配置）,不过Spring Boot 让这一切成为了过去。 另外Spring Cloud也是基于Spring Boot构建的，我个人非常有必要学习一下。
|
||||
|
||||
**关于Spring Boot官方的介绍：**
|
||||
|
||||
> Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”…Most Spring Boot applications need very little Spring configuration.(Spring Boot可以轻松创建独立的生产级基于Spring的应用程序,只要通过 “just run”（可能是run ‘Application’或java -jar 或 tomcat 或 maven插件run 或 shell脚本）便可以运行项目。大部分Spring Boot项目只需要少量的配置即可)
|
||||
|
||||
### 10. arthas
|
||||
|
||||
- **Github地址**：[https://github.com/alibaba/arthas](https://github.com/alibaba/arthas)
|
||||
- **star**: 9.5k
|
||||
- **介绍**: Arthas 是Alibaba开源的Java诊断工具。
|
||||
|
||||
**概览：**
|
||||
|
||||
当你遇到以下类似问题而束手无策时，`Arthas`可以帮助你解决：
|
||||
|
||||
0. 这个类从哪个 jar 包加载的？为什么会报各种类相关的 Exception？
|
||||
1. 我改的代码为什么没有执行到？难道是我没 commit？分支搞错了？
|
||||
2. 遇到问题无法在线上 debug，难道只能通过加日志再重新发布吗？
|
||||
3. 线上遇到某个用户的数据处理有问题，但线上同样无法 debug，线下无法重现！
|
||||
4. 是否有一个全局视角来查看系统的运行状况？
|
||||
5. 有什么办法可以监控到JVM的实时运行状态？
|
||||
|
||||
`Arthas`支持JDK 6+，支持Linux/Mac/Winodws，采用命令行交互模式，同时提供丰富的 `Tab` 自动补全功能，进一步方便进行问题的定位和诊断。
|
||||
144
docs/github-trending/2019-12.md
Normal file
144
docs/github-trending/2019-12.md
Normal file
@ -0,0 +1,144 @@
|
||||
# 年末将至，值得你关注的16个Java 开源项目！
|
||||
|
||||
Star 的数量统计于 2019-12-29。
|
||||
|
||||
### 1.JavaGuide
|
||||
|
||||
Guide 哥大三开始维护的，目前算是纯 Java 类型项目中 Star 数量最多的项目了。但是，本仓库的价值远远（+N次 ）比不上像 Spring Boot、Elasticsearch 等等这样非常非常非常优秀的项目。希望以后我也有能力为这些项目贡献一些有价值的代码。
|
||||
|
||||
- **Github 地址**：<https://github.com/Snailclimb/JavaGuide>
|
||||
- **Star**: 66.3k
|
||||
- **介绍**: 【Java 学习+面试指南】 一份涵盖大部分 Java 程序员所需要掌握的核心知识。
|
||||
|
||||
### 2.java-design-patterns
|
||||
|
||||
感觉还不错。根据官网介绍：
|
||||
|
||||
> 设计模式是程序员在设计应用程序或系统时可以用来解决常见问题的最佳形式化实践。 设计模式可以通过提供经过测试的，经过验证的开发范例来加快开发过程。 重用设计模式有助于防止引起重大问题的细微问题，并且还可以提高熟悉模式的编码人员和架构师的代码可读性。
|
||||
|
||||
|
||||
|
||||
- **Github 地址** : [https://github.com/iluwatar/java-design-patterns](https://github.com/iluwatar/java-design-patterns)
|
||||
- **Star**: 53.8k
|
||||
- **介绍**: 用 Java 实现的设计模式。[https://java-design-patterns.com](https://java-design-patterns.com/)。
|
||||
|
||||
### 3.elasticsearch
|
||||
|
||||
搜索引擎界的扛把子，但不仅仅是搜素引擎那么简单。
|
||||
|
||||
- **Github 地址** : [https://github.com/elastic/elasticsearch](https://github.com/elastic/elasticsearch)
|
||||
- **Star**: 46.2k
|
||||
- **介绍**: 开源，分布式，RESTful 搜索引擎。
|
||||
|
||||
### 4.spring-boot
|
||||
|
||||
必须好好学啊，一定要好好学！现在 Java 后端新项目有不用 Spring Boot 开发的有吗？如果有的话，请把这个人的联系方式告诉我，我有很多话想给他交流交流！
|
||||
|
||||
- **Github地址**： [https://github.com/spring-projects/spring-boot](https://github.com/spring-projects/spring-boot)
|
||||
- **star:** 34.8k (1,073 stars this month)
|
||||
- **介绍**： 虽然Spring的组件代码是轻量级的，但它的配置却是重量级的（需要大量XML配置）,不过Spring Boot 让这一切成为了过去。 另外Spring Cloud也是基于Spring Boot构建的，我个人非常有必要学习一下。
|
||||
|
||||
### 5.RxJava
|
||||
|
||||
这个没怎么用过，不做太多评价。
|
||||
|
||||
- **Github 地址** : [https://github.com/ReactiveX/RxJava](https://github.com/ReactiveX/RxJava)
|
||||
- **Star**: 41.5k
|
||||
- **介绍**: `RxJava` 是一个 基于事件流、实现异步操作的库。
|
||||
|
||||
### 6.advanced-java
|
||||
|
||||
本项目大部分内容来自中华石杉的一个课程，内容涵盖高并发、分布式、高可用、微服务、海量数据处理等领域知识，非常不错了！
|
||||
|
||||
- **Github 地址**：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java)
|
||||
- **Star**: 36.7k
|
||||
- **介绍**: 互联网 Java 工程师进阶知识完全扫盲：涵盖高并发、分布式、高可用、微服务等领域知识，后端同学必看，前端同学也可学习。
|
||||
|
||||
### 7.mall
|
||||
|
||||
很牛逼的实战项目，还附有详细的文档，作为毕设或者练手项目都再好不过了。
|
||||
|
||||
- **Github地址**： [https://github.com/macrozheng/mall](https://github.com/macrozheng/mall)
|
||||
- **star**: 27.6k
|
||||
- **介绍**: mall项目是一套电商系统，包括前台商城系统及后台管理系统，基于SpringBoot+MyBatis实现。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。
|
||||
|
||||
### 8.okhttp
|
||||
|
||||
给我感觉是安卓项目中用的居多。当然，Java 后端项目也会经常用，但是一般使用 Spring Boot 进行开发的时候，如果需要远程调用的话建议使用 Spring 封装的 `RestTemplate `。
|
||||
|
||||
- **Github地址**：[https://github.com/square/okhttp](https://github.com/square/okhttp)
|
||||
- **star**: 35.4k
|
||||
- **介绍**: 适用于Android，Kotlin和Java的HTTP客户端。https://square.github.io/okhttp/。
|
||||
|
||||
### 9.guava
|
||||
|
||||
很厉害很厉害！提供了很多非常实用的工具类、更加实用的集合类、一些常用的数据结构比如布隆过滤器、缓存等等。
|
||||
|
||||
- **Github地址**：[https://github.com/google/guava](https://github.com/google/guava)
|
||||
- **star**: 35.3k
|
||||
- **介绍**: Guava是一组核心库，其中包括新的集合类型（例如 multimap 和 multiset），不可变集合，图形库以及用于并发，I / O，哈希，基元，字符串等的实用程序！
|
||||
|
||||
### 10.Spark
|
||||
|
||||
我木有用过，留下了没有技术的眼泪。
|
||||
|
||||
- **Github地址**：[https://github.com/apache/spark](https://github.com/apache/spark)
|
||||
- **star**: 24.7k
|
||||
- **介绍**: Spark 是一个快速、通用的大规模数据处理引擎，和Hadoop的MapReduce计算框架类似，但是相对于MapReduce，Spark凭借其可伸缩、基于内存计算等特点，以及可以直接读写Hadoop上任何格式数据的优势，进行批处理时更加高效，并有更低的延迟。
|
||||
|
||||
### 11.arthas
|
||||
|
||||
虽然我自己没有亲身用过，但是身边用过的朋友评价都还挺好的。根据官网介绍，这家伙可以解决下面这些让人脑壳疼的问题：
|
||||
|
||||
1. 这个类从哪个 jar 包加载的？为什么会报各种类相关的 Exception？
|
||||
2. 我改的代码为什么没有执行到？难道是我没 commit？分支搞错了？
|
||||
3. 遇到问题无法在线上 debug，难道只能通过加日志再重新发布吗？
|
||||
4. 线上遇到某个用户的数据处理有问题，但线上同样无法 debug，线下无法重现！
|
||||
5. 是否有一个全局视角来查看系统的运行状况？
|
||||
6. 有什么办法可以监控到JVM的实时运行状态？
|
||||
7. 怎么快速定位应用的热点，生成火焰图？
|
||||
|
||||
- **Github 地址**：[https://github.com/alibaba/arthas](https://github.com/alibaba/arthas)
|
||||
- **star**: 18.8 k
|
||||
- **介绍**: Arthas 是 Alibaba 开源的 Java 诊断工具。
|
||||
|
||||
### 12.spring-boot-examples
|
||||
|
||||
学习 Spring Boot 必备！配合上我的 **springboot-guide** ：[https://github.com/Snailclimb/springboot-guide](https://github.com/Snailclimb/springboot-guide)，效果杠杠滴！
|
||||
|
||||
- **Github 地址**：[https://github.com/ityouknow/spring-boot-examples](https://github.com/ityouknow/spring-boot-examples)
|
||||
- **star**: 20.2 k
|
||||
- **介绍**: Spring Boot 教程、技术栈示例代码，快速简单上手教程。
|
||||
|
||||
### 13.lombok
|
||||
|
||||
使用 Lombok 我们可以简化我们的 Java 代码，比如使用它之后我们通过注释就可以实现 getter/setter、equals等方法。
|
||||
|
||||
- **Github 地址**：[https://github.com/rzwitserloot/lombok](https://github.com/rzwitserloot/lombok)
|
||||
- **star**: 20.2 k
|
||||
- **介绍**: 对 Java 编程语言的非常刺激的补充。[https://projectlombok.org/](https://projectlombok.org/) 。
|
||||
|
||||
### 14.p3c
|
||||
|
||||
与我而言，没有特别惊艳，但是一些提供的一些代码规范确实挺有用的！
|
||||
|
||||
- **Github 地址**：[https://github.com/alibaba/p3c](https://github.com/alibaba/p3c)
|
||||
- **star**: 19.8 k
|
||||
- **介绍**: 阿里巴巴Java编码指南pmd实现和IDE插件。
|
||||
|
||||
### 15.spring-boot-demo
|
||||
|
||||
- **Github 地址**：[https://github.com/xkcoding/spring-boot-demo](https://github.com/xkcoding/spring-boot-demo)
|
||||
- **Star**: 8.8k
|
||||
- **介绍**: spring boot demo 是一个用来深度学习并实战 spring boot 的项目。
|
||||
|
||||
### 16. awesome-java
|
||||
|
||||
Guide 哥半个多月前开始维护的，虽然现在 Star 数量比较少，我相信后面一定会有更多人喜欢上这个项目，我也会继续认真维护下去。
|
||||
|
||||
- **Github 地址**：[https://github.com/Snailclimb/awesome-java](https://github.com/Snailclimb/awesome-java)
|
||||
- **Star**: 0.3 k
|
||||
- **介绍**: Github 上非常棒的 Java 开源项目集合。
|
||||
|
||||
|
||||
|
||||
64
docs/github-trending/2019-2.md
Normal file
64
docs/github-trending/2019-2.md
Normal file
@ -0,0 +1,64 @@
|
||||
### 1. JavaGuide
|
||||
|
||||
- **Github地址**： [https://github.com/Snailclimb/JavaGuide](https://github.com/Snailclimb/JavaGuide)
|
||||
- **Star**: 27.2k (4,437 stars this month)
|
||||
- **介绍**: 【Java学习+面试指南】 一份涵盖大部分Java程序员所需要掌握的核心知识。
|
||||
|
||||
### 2.DoraemonKit
|
||||
|
||||
- **Github地址**： <https://github.com/didi/DoraemonKit>
|
||||
- **Star**: 5.2k (3,786 stars this month)
|
||||
- **介绍**: 简称 "DoKit" 。一款功能齐全的客户端（ iOS 、Android ）研发助手，你值得拥有。
|
||||
|
||||
### 3.advanced-java
|
||||
|
||||
- **Github地址**：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java)
|
||||
- **Star**:11.2k (3,042 stars this month)
|
||||
- **介绍**: 互联网 Java 工程师进阶知识完全扫盲。
|
||||
|
||||
### 4. spring-boot-examples
|
||||
|
||||
- **Github地址**：<https://github.com/ityouknow/spring-boot-examples>
|
||||
- **star**: 9.6 k (1,764 stars this month)
|
||||
- **介绍**: Spring Boot 教程、技术栈示例代码，快速简单上手教程。
|
||||
|
||||
### 5. mall
|
||||
|
||||
- **Github地址**： [https://github.com/macrozheng/mall](https://github.com/macrozheng/mall)
|
||||
- **star**: 7.4 k (1,736 stars this month)
|
||||
- **介绍**: mall项目是一套电商系统，包括前台商城系统及后台管理系统，基于SpringBoot+MyBatis实现。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。
|
||||
|
||||
### 6. fescar
|
||||
|
||||
- **Github地址**：[https://github.com/alibaba/fescar](https://github.com/alibaba/fescar)
|
||||
- **star**: 6.0 k (1,308 stars this month)
|
||||
- **介绍**: 具有 **高性能** 和 **易用性** 的 **微服务架构** 的 **分布式事务** 的解决方案。（特点：高性能且易于使用，旨在实现简单并快速的事务提交与回滚。）
|
||||
|
||||
### 7. h4cker
|
||||
|
||||
- **Github地址**：<https://github.com/The-Art-of-Hacking/h4cker>
|
||||
- **star**: 2.1 k (1,303 stars this month)
|
||||
- **介绍**: 该仓库主要由Omar Santos维护，包括与道德黑客/渗透测试，数字取证和事件响应（DFIR），漏洞研究，漏洞利用开发，逆向工程等相关的资源。
|
||||
|
||||
### 8. spring-boot
|
||||
|
||||
- **Github地址**： [https://github.com/spring-projects/spring-boot](https://github.com/spring-projects/spring-boot)
|
||||
- **star:** 34.8k (1,073 stars this month)
|
||||
- **介绍**： 虽然Spring的组件代码是轻量级的，但它的配置却是重量级的（需要大量XML配置）,不过Spring Boot 让这一切成为了过去。 另外Spring Cloud也是基于Spring Boot构建的，我个人非常有必要学习一下。
|
||||
|
||||
**关于Spring Boot官方的介绍：**
|
||||
|
||||
> Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”…Most Spring Boot applications need very little Spring configuration.(Spring Boot可以轻松创建独立的生产级基于Spring的应用程序,只要通过 “just run”（可能是run ‘Application’或java -jar 或 tomcat 或 maven插件run 或 shell脚本）便可以运行项目。大部分Spring Boot项目只需要少量的配置即可)
|
||||
|
||||
### 9. arthas
|
||||
|
||||
- **Github地址**：[https://github.com/alibaba/arthas](https://github.com/alibaba/arthas)
|
||||
- **star**: 10.5 k (970 stars this month)
|
||||
- **介绍**: Arthas 是Alibaba开源的Java诊断工具。
|
||||
|
||||
### 10. tutorials
|
||||
|
||||
- **Github地址**：[https://github.com/eugenp/tutorials](https://github.com/eugenp/tutorials)
|
||||
- **star**: 12.1 k (789 stars this month)
|
||||
- **介绍**: 该项目是一系列小而专注的教程 - 每个教程都涵盖Java生态系统中单一且定义明确的开发领域。 当然，它们的重点是Spring Framework - Spring，Spring Boot和Spring Securiyt。 除了Spring之外，还有以下技术：核心Java，Jackson，HttpClient，Guava。
|
||||
|
||||
60
docs/github-trending/2019-3.md
Normal file
60
docs/github-trending/2019-3.md
Normal file
@ -0,0 +1,60 @@
|
||||
### 1. JavaGuide
|
||||
|
||||
- **Github 地址**： [https://github.com/Snailclimb/JavaGuide](https://github.com/Snailclimb/JavaGuide)
|
||||
- **Star**: 32.9k (6,196 stars this month)
|
||||
- **介绍**: 【Java 学习+面试指南】 一份涵盖大部分 Java 程序员所需要掌握的核心知识。
|
||||
|
||||
### 2.advanced-java
|
||||
|
||||
- **Github 地址**：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java)
|
||||
- **Star**: 15.1k (4,012 stars this month)
|
||||
- **介绍**: 互联网 Java 工程师进阶知识完全扫盲。
|
||||
|
||||
### 3.spring-boot-examples
|
||||
|
||||
- **Github 地址**：[https://github.com/ityouknow/spring-boot-examples](https://github.com/ityouknow/spring-boot-examples)
|
||||
- **Star**: 12.8k (3,462 stars this month)
|
||||
- **介绍**: Spring Boot 教程、技术栈示例代码，快速简单上手教程。
|
||||
|
||||
### 4. mall
|
||||
|
||||
- **Github 地址**： [https://github.com/macrozheng/mall](https://github.com/macrozheng/mall)
|
||||
- **star**: 9.7 k (2,418 stars this month)
|
||||
- **介绍**: mall 项目是一套电商系统，包括前台商城系统及后台管理系统，基于 SpringBoot+MyBatis 实现。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。
|
||||
|
||||
### 5. seata
|
||||
|
||||
- **Github 地址** : [https://github.com/seata/seata](https://github.com/seata/seata)
|
||||
- **star**: 7.2 k (1359 stars this month)
|
||||
- **介绍**: Seata 是一种易于使用，高性能，基于 Java 的开源分布式事务解决方案。
|
||||
|
||||
### 6. quarkus
|
||||
|
||||
- **Github 地址**：[https://github.com/quarkusio/quarkus](https://github.com/quarkusio/quarkus)
|
||||
- **star**: 12 k (1,224 stars this month)
|
||||
- **介绍**: Quarkus 是为 GraalVM 和 HotSpot 量身定制的 Kubernetes Native Java 框架，由最佳的 Java 库和标准精心打造而成。Quarkus 的目标是使 Java 成为 Kubernetes 和无服务器环境中的领先平台，同时为开发人员提供统一的反应式和命令式编程模型，以优化地满足更广泛的分布式应用程序架构。
|
||||
|
||||
### 7. arthas
|
||||
|
||||
- **Github 地址**：[https://github.com/alibaba/arthas](https://github.com/alibaba/arthas)
|
||||
- **star**: 11.6 k (1,199 stars this month)
|
||||
- **介绍**: Arthas 是 Alibaba 开源的 Java 诊断工具。
|
||||
|
||||
### 8.DoraemonKit
|
||||
|
||||
- **Github 地址**： <https://github.com/didi/DoraemonKit>
|
||||
- **Star**: 6.2k (1,177 stars this month)
|
||||
- **介绍**: 简称 "DoKit" 。一款功能齐全的客户端（ iOS 、Android ）研发助手，你值得拥有。
|
||||
|
||||
### 9.elasticsearch
|
||||
|
||||
- **Github 地址** [https://github.com/elastic/elasticsearch](https://github.com/elastic/elasticsearch)
|
||||
- **Star**: 39.7k (1,069 stars this month)
|
||||
- **介绍**: 开源，分布式，RESTful 搜索引擎。
|
||||
|
||||
### 10. tutorials
|
||||
|
||||
- **Github 地址**：[https://github.com/eugenp/tutorials](https://github.com/eugenp/tutorials)
|
||||
- **star**: 13 k (998 stars this month)
|
||||
- **介绍**: 该项目是一系列小而专注的教程 - 每个教程都涵盖 Java 生态系统中单一且定义明确的开发领域。 当然，它们的重点是 Spring Framework - Spring，Spring Boot 和 Spring Securiyt。 除了 Spring 之外，还有以下技术：核心 Java，Jackson，HttpClient，Guava。
|
||||
|
||||
98
docs/github-trending/2019-4.md
Normal file
98
docs/github-trending/2019-4.md
Normal file
@ -0,0 +1,98 @@
|
||||
以下涉及到的数据统计与 2019 年 5 月 1 日 12 点，数据来源：<https://github.com/trending/java?since=monthly> 。
|
||||
|
||||
下面的内容从 Java 学习文档到最热门的框架再到热门的工具应有尽有，比如下面推荐到的开源项目 Hutool 就是近期比较热门的项目之一，它是 Java 工具包，能够帮助我们简化代码！我觉得下面这些项目对于学习 Java 的朋友还是很有帮助的！
|
||||
|
||||
|
||||
### 1. JavaGuide
|
||||
|
||||
- **Github 地址**： [https://github.com/Snailclimb/JavaGuide](https://github.com/Snailclimb/JavaGuide)
|
||||
- **Star**: 37.9k (5,660 stars this month)
|
||||
- **介绍**: 【Java 学习+面试指南】 一份涵盖大部分 Java 程序员所需要掌握的核心知识。
|
||||
|
||||
### 2. advanced-java
|
||||
|
||||
- **Github 地址**：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java)
|
||||
- **Star**: 15.1k (4,654 stars this month)
|
||||
- **介绍**: 互联网 Java 工程师进阶知识完全扫盲。
|
||||
|
||||
### 3. CS-Notes
|
||||
|
||||
- **Github 地址**：<https://github.com/CyC2018/CS-Notes>
|
||||
- **Star**: 59.2k (4,012 stars this month)
|
||||
- **介绍**: 技术面试必备基础知识。
|
||||
|
||||
### 4. ghidra
|
||||
|
||||
- **Github 地址**：<https://github.com/NationalSecurityAgency/ghidra>
|
||||
- **Star**: 15.0k (2,995 stars this month)
|
||||
- **介绍**: Ghidra是一个软件逆向工程（SRE）框架。
|
||||
|
||||
### 5. mall
|
||||
|
||||
- **Github 地址**： [https://github.com/macrozheng/mall](https://github.com/macrozheng/mall)
|
||||
- **star**: 11.6 k (2,100 stars this month)
|
||||
- **介绍**: mall 项目是一套电商系统，包括前台商城系统及后台管理系统，基于 SpringBoot+MyBatis 实现。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。
|
||||
|
||||
### 6. ZXBlog
|
||||
|
||||
- **Github 地址**： <https://github.com/ZXZxin/ZXBlog>
|
||||
- **star**: 2.1 k (2,086 stars this month)
|
||||
- **介绍**: 记录各种学习笔记(算法、Java、数据库、并发......)。
|
||||
|
||||
### 7.DoraemonKit
|
||||
|
||||
- **Github地址**： <https://github.com/didi/DoraemonKit>
|
||||
- **Star**: 7.6k (1,541 stars this month)
|
||||
- **介绍**: 简称 "DoKit" 。一款功能齐全的客户端（ iOS 、Android ）研发助手，你值得拥有。
|
||||
|
||||
### 8. spring-boot
|
||||
|
||||
- **Github地址**： [https://github.com/spring-projects/spring-boot](https://github.com/spring-projects/spring-boot)
|
||||
- **star:** 37.3k (1,489 stars this month)
|
||||
- **介绍**： 虽然Spring的组件代码是轻量级的，但它的配置却是重量级的（需要大量XML配置）,不过Spring Boot 让这一切成为了过去。 另外Spring Cloud也是基于Spring Boot构建的，我个人非常有必要学习一下。
|
||||
|
||||
**Spring Boot官方的介绍：**
|
||||
|
||||
> Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”…Most Spring Boot applications need very little Spring configuration.(Spring Boot可以轻松创建独立的生产级基于Spring的应用程序,只要通过 “just run”（可能是run ‘Application’或java -jar 或 tomcat 或 maven插件run 或 shell脚本）便可以运行项目。大部分Spring Boot项目只需要少量的配置即可)
|
||||
|
||||
### 9. spring-boot-examples
|
||||
|
||||
- **Github 地址**：[https://github.com/ityouknow/spring-boot-examples](https://github.com/ityouknow/spring-boot-examples)
|
||||
- **Star**: 12.8k (1,453 stars this month)
|
||||
- **介绍**: Spring Boot 教程、技术栈示例代码，快速简单上手教程。
|
||||
|
||||
### 10. seata
|
||||
|
||||
- **Github 地址** : [https://github.com/seata/seata](https://github.com/seata/seata)
|
||||
- **star**: 8.4 k (1441 stars this month)
|
||||
- **介绍**: Seata 是一种易于使用，高性能，基于 Java 的开源分布式事务解决方案。
|
||||
|
||||
### 11. litemall
|
||||
|
||||
- **Github 地址**：[https://github.com/ityouknow/spring-boot-examples](https://github.com/ityouknow/spring-boot-examples)
|
||||
- **Star**: 6.0k (1,427 stars this month)
|
||||
- **介绍**: 又一个小商城。litemall = Spring Boot后端 + Vue管理员前端 + 微信小程序用户前端 + Vue用户移动端。
|
||||
|
||||
### 12. skywalking
|
||||
|
||||
- **Github 地址**：<https://github.com/apache/skywalking>
|
||||
- **Star**: 8.0k (1,381 stars this month)
|
||||
- **介绍**: 针对分布式系统的应用性能监控，尤其是针对微服务、云原生和面向容器的分布式系统架构。
|
||||
|
||||
### 13. elasticsearch
|
||||
|
||||
- **Github 地址** [https://github.com/elastic/elasticsearch](https://github.com/elastic/elasticsearch)
|
||||
- **Star**: 4.0k (1,068stars this month)
|
||||
- **介绍**: 开源，分布式，RESTful 搜索引擎。
|
||||
|
||||
### 14. arthas
|
||||
|
||||
- **Github地址**：[https://github.com/alibaba/arthas](https://github.com/alibaba/arthas)
|
||||
- **star**: 12.6 k (1,080 stars this month)
|
||||
- **介绍**: Arthas 是Alibaba开源的Java诊断工具。
|
||||
|
||||
### 15. hutool
|
||||
|
||||
- **Github地址**：<https://github.com/looly/hutool>
|
||||
- **star**: 4.5 k (1,031 stars this month)
|
||||
- **介绍**: Hutool是一个Java工具包，也只是一个工具包，它帮助我们简化每一行代码，减少每一个方法，让Java语言也可以“甜甜的”。Hutool最初是我项目中“util”包的一个整理，后来慢慢积累并加入更多非业务相关功能，并广泛学习其它开源项目精髓，经过自己整理修改，最终形成丰富的开源工具集。官网:<https://www.hutool.cn/> 。
|
||||
125
docs/github-trending/2019-5.md
Normal file
125
docs/github-trending/2019-5.md
Normal file
@ -0,0 +1,125 @@
|
||||
以下涉及到的数据统计与 2019 年 6 月 1 日 18 点，数据来源：<https://github.com/trending/java?since=monthly> 。下面推荐的内容从 Java 学习文档到最热门的框架再到热门的工具应有尽有，建议收藏+在看！
|
||||
|
||||
### 1.LeetCodeAnimation
|
||||
|
||||
- **Github 地址**： <https://github.com/MisterBooo/LeetCodeAnimation>
|
||||
- **Star**: 29.0k (11,492 stars this month)
|
||||
- **介绍**: Demonstrate all the questions on LeetCode in the form of animation.（用动画的形式呈现解LeetCode题目的思路）。
|
||||
|
||||
### 2.CS-Notes
|
||||
|
||||
- **Github 地址**：<https://github.com/CyC2018/CS-Notes>
|
||||
- **Star**: 64.4k (5513 stars this month)
|
||||
- **介绍**: 技术面试必备基础知识、Leetcode 题解、后端面试、Java 面试、春招、秋招、操作系统、计算机网络、系统设计。
|
||||
|
||||
### 3.JavaGuide
|
||||
|
||||
- **Github 地址**：<https://github.com/Snailclimb/JavaGuide>
|
||||
- **Star**: 42.0k (4,442 stars this month)
|
||||
- **介绍**: 【Java 学习+面试指南】 一份涵盖大部分 Java 程序员所需要掌握的核心知识。
|
||||
|
||||
### 4.mall
|
||||
|
||||
- **Github 地址**： [https://github.com/macrozheng/mall](https://github.com/macrozheng/mall)
|
||||
- **star**: 14.6 k (3,086 stars this month)
|
||||
- **介绍**: mall 项目是一套电商系统，包括前台商城系统及后台管理系统，基于 SpringBoot+MyBatis 实现。 前台商城系统包含首页门户、商品推荐、商品搜索、商品展示、购物车、订单流程、会员中心、客户服务、帮助中心等模块。 后台管理系统包含商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等模块。
|
||||
|
||||
### 5.advanced-java
|
||||
|
||||
- **Github 地址**：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java)
|
||||
- **Star**: 20.8k (2,394 stars this month)
|
||||
- **介绍**: 互联网 Java 工程师进阶知识完全扫盲。
|
||||
|
||||
### 6.spring-boot
|
||||
|
||||
- **Github地址**： [https://github.com/spring-projects/spring-boot](https://github.com/spring-projects/spring-boot)
|
||||
- **star:** 38.5k (1,339 stars this month)
|
||||
- **介绍**： 虽然Spring的组件代码是轻量级的，但它的配置却是重量级的（需要大量XML配置）,不过Spring Boot 让这一切成为了过去。 另外Spring Cloud也是基于Spring Boot构建的，我个人非常有必要学习一下。
|
||||
|
||||
**Spring Boot官方的介绍：**
|
||||
|
||||
> Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”…Most Spring Boot applications need very little Spring configuration.(Spring Boot可以轻松创建独立的生产级基于Spring的应用程序,只要通过 “just run”（可能是run ‘Application’或java -jar 或 tomcat 或 maven插件run 或 shell脚本）便可以运行项目。大部分Spring Boot项目只需要少量的配置即可)
|
||||
|
||||
### 7. Java
|
||||
|
||||
- **Github 地址**：<https://github.com/TheAlgorithms/Java>
|
||||
- **Star**:14.3k (1,334 stars this month)
|
||||
- **介绍**: All Algorithms implemented in Java。
|
||||
|
||||
### 8.server
|
||||
|
||||
- **Github 地址**：<https://github.com/wildfirechat/server>
|
||||
- **star**: 2.2 k (1,275 stars this month)
|
||||
- **介绍**: 全开源即时通讯(IM)系统。
|
||||
|
||||
### 9.litemall
|
||||
|
||||
- **Github 地址**：<https://github.com/linlinjava/litemall>
|
||||
- **Star**: 7.1k (1,114 stars this month)
|
||||
- **介绍**: 又一个小商城。litemall = Spring Boot后端 + Vue管理员前端 + 微信小程序用户前端 + Vue用户移动端。
|
||||
|
||||
### 10.Linkage-RecyclerView
|
||||
|
||||
- **Github 地址**：<https://github.com/KunMinX/Linkage-RecyclerView>
|
||||
- **Star**: 10.0k (1,093 stars this month)
|
||||
- **介绍**: 即使不用饿了么订餐，也请务必收藏好该库！🔥 一行代码即可接入，二级联动订餐列表 - Even if you don't order food by PrubHub, be sure to collect this library, please! 🔥 This secondary linkage list widget can be accessed by only one line of code. Supporting by RecyclerView & AndroidX.
|
||||
|
||||
### 11.toBeTopJavaer
|
||||
|
||||
- **Github 地址** : <https://github.com/hollischuang/toBeTopJavaer>
|
||||
- **Star**: 3.3k (1,007 stars this month)
|
||||
- **介绍**: To Be Top Javaer - Java工程师成神之路
|
||||
|
||||
### 12.elasticsearch
|
||||
|
||||
- **Github 地址** : [https://github.com/elastic/elasticsearch](https://github.com/elastic/elasticsearch)
|
||||
- **Star**: 48.0k (968 stars this month)
|
||||
- **介绍**: 开源，分布式，RESTful 搜索引擎。
|
||||
|
||||
### 13.java-design-patterns
|
||||
|
||||
- **Github 地址** : <https://github.com/iluwatar/java-design-patterns>
|
||||
- **Star**: 41.5k (955 stars this month)
|
||||
- **介绍**: Design patterns implemented in Java。
|
||||
|
||||
### 14.apollo
|
||||
|
||||
- **Github 地址** : <https://github.com/ctripcorp/apollo>
|
||||
- **Star**: 14.5k (927 stars this month)
|
||||
- **介绍**: Apollo（阿波罗）是携程框架部门研发的分布式配置中心，能够集中化管理应用不同环境、不同集群的配置，配置修改后能够实时推送到应用端，并且具备规范的权限、流程治理等特性，适用于微服务配置管理场景。
|
||||
|
||||
### 15.arthas
|
||||
|
||||
- **Github地址**：[https://github.com/alibaba/arthas](https://github.com/alibaba/arthas)
|
||||
- **star**: 13.5 k (933 stars this month)
|
||||
- **介绍**: Arthas 是Alibaba开源的Java诊断工具。
|
||||
|
||||
### 16.dubbo
|
||||
|
||||
- **Github地址**：<https://github.com/apache/dubbo>
|
||||
- **star**: 26.9 k (769 stars this month)
|
||||
- **介绍**: Apache Dubbo是一个基于Java的高性能开源RPC框架。
|
||||
|
||||
### 17.DoraemonKit
|
||||
|
||||
- **Github地址**： <https://github.com/didi/DoraemonKit>
|
||||
- **Star**: 8.5k (909 stars this month)
|
||||
- **介绍**: 简称 "DoKit" 。一款功能齐全的客户端（ iOS 、Android ）研发助手，你值得拥有。
|
||||
|
||||
### 18.halo
|
||||
|
||||
- **Github地址**： <https://github.com/halo-dev/halo>
|
||||
- **Star**: 4.1k (829 stars this month)
|
||||
- **介绍**: Halo 可能是最好的 Java 博客系统。
|
||||
|
||||
### 19.seata
|
||||
|
||||
- **Github 地址** : [https://github.com/seata/seata](https://github.com/seata/seata)
|
||||
- **star**: 9.2 k (776 stars this month)
|
||||
- **介绍**: Seata 是一种易于使用，高性能，基于 Java 的开源分布式事务解决方案。
|
||||
|
||||
### 20.hutool
|
||||
|
||||
- **Github地址**：<https://github.com/looly/hutool>
|
||||
- **star**: 5,3 k (812 stars this month)
|
||||
- **介绍**: Hutool是一个Java工具包，也只是一个工具包，它帮助我们简化每一行代码，减少每一个方法，让Java语言也可以“甜甜的”。Hutool最初是我项目中“util”包的一个整理，后来慢慢积累并加入更多非业务相关功能，并广泛学习其它开源项目精髓，经过自己整理修改，最终形成丰富的开源工具集。官网:<https://www.hutool.cn/> 。
|
||||
119
docs/github-trending/2019-6.md
Normal file
119
docs/github-trending/2019-6.md
Normal file
@ -0,0 +1,119 @@
|
||||
### 1.CS-Notes
|
||||
|
||||
- **Github 地址**：https://github.com/CyC2018/CS-Notes
|
||||
- **Star**: 69.8k
|
||||
- **介绍**: 技术面试必备基础知识、Leetcode 题解、后端面试、Java 面试、春招、秋招、操作系统、计算机网络、系统设计。
|
||||
|
||||
### 2.toBeTopJavaer
|
||||
|
||||
- **Github 地址：**[https://github.com/hollischuang/toBeTopJavaer](https://github.com/hollischuang/toBeTopJavaer)
|
||||
- **Star**: 4.7k
|
||||
- **介绍**: To Be Top Javaer - Java工程师成神之路。
|
||||
|
||||
### 3.p3c
|
||||
|
||||
- **Github 地址：** [https://github.com/alibaba/p3c](https://github.com/alibaba/p3c)
|
||||
- **Star**: 16.6k
|
||||
- **介绍**: Alibaba Java Coding Guidelines pmd implements and IDE plugin。Eclipse 和 IDEA 上都有该插件，推荐使用！
|
||||
|
||||
### 4.SpringCloudLearning
|
||||
|
||||
- **Github 地址：** [https://github.com/forezp/SpringCloudLearning](https://github.com/forezp/SpringCloudLearning)
|
||||
- **Star**: 8.7k
|
||||
- **介绍**: 史上最简单的Spring Cloud教程源码。
|
||||
|
||||
### 5.dubbo
|
||||
|
||||
- **Github地址**：<https://github.com/apache/dubbo>
|
||||
- **star**: 27.6 k
|
||||
- **介绍**: Apache Dubbo是一个基于Java的高性能开源RPC框架。
|
||||
|
||||
### 6.jeecg-boot
|
||||
|
||||
- **Github地址**： [https://github.com/zhangdaiscott/jeecg-boot](https://github.com/zhangdaiscott/jeecg-boot)
|
||||
- **star**: 3.3 k
|
||||
- **介绍**: 一款基于代码生成器的JAVA快速开发平台！全新架构前后端分离：SpringBoot 2.x，Ant Design&Vue，Mybatis，Shiro，JWT。强大的代码生成器让前后端代码一键生成，无需写任何代码，绝对是全栈开发福音！！ JeecgBoot的宗旨是提高UI能力的同时,降低前后分离的开发成本，JeecgBoot还独创在线开发模式，No代码概念，一系列在线智能开发：在线配置表单、在线配置报表、在线设计流程等等。
|
||||
|
||||
### 7.advanced-java
|
||||
|
||||
- **Github 地址**：[https://github.com/doocs/advanced-java](https://github.com/doocs/advanced-java)
|
||||
- **Star**: 24.2k
|
||||
- **介绍**: 互联网 Java 工程师进阶知识完全扫盲：涵盖高并发、分布式、高可用、微服务等领域知识，后端同学必看，前端同学也可学习。
|
||||
|
||||
### 8.FEBS-Shiro
|
||||
|
||||
- **Github 地址**：[https://github.com/wuyouzhuguli/FEBS-Shiro](https://github.com/wuyouzhuguli/FEBS-Shiro)
|
||||
- **Star**: 2.6k
|
||||
- **介绍**: Spring Boot 2.1.3，Shiro1.4.0 & Layui 2.5.4 权限管理系统。预览地址：http://49.234.20.223:8080/login。
|
||||
|
||||
### 9.SpringAll
|
||||
|
||||
- **Github 地址**: [https://github.com/wuyouzhuguli/SpringAll](https://github.com/wuyouzhuguli/SpringAll)
|
||||
- **Star**: 5.4k
|
||||
- **介绍**: 循序渐进，学习Spring Boot、Spring Boot & Shiro、Spring Cloud、Spring Security & Spring Security OAuth2，博客Spring系列源码。
|
||||
|
||||
### 10.JavaGuide
|
||||
|
||||
- **Github 地址**：<https://github.com/Snailclimb/JavaGuide>
|
||||
- **Star**: 47.2k
|
||||
- **介绍**: 【Java 学习+面试指南】 一份涵盖大部分 Java 程序员所需要掌握的核心知识。
|
||||
|
||||
### 11.vhr
|
||||
|
||||
- **Github 地址**：[https://github.com/lenve/vhr](https://github.com/lenve/vhr)
|
||||
- **Star**: 4.9k
|
||||
- **介绍**: 微人事是一个前后端分离的人力资源管理系统，项目采用SpringBoot+Vue开发。
|
||||
|
||||
### 12. tutorials
|
||||
|
||||
- **Github 地址**：[https://github.com/eugenp/tutorials](https://github.com/eugenp/tutorials)
|
||||
- **star**: 15.4 k
|
||||
- **介绍**: 该项目是一系列小而专注的教程 - 每个教程都涵盖 Java 生态系统中单一且定义明确的开发领域。 当然，它们的重点是 Spring Framework - Spring，Spring Boot 和 Spring Securiyt。 除了 Spring 之外，还有以下技术：核心 Java，Jackson，HttpClient，Guava。
|
||||
|
||||
### 13.EasyScheduler
|
||||
|
||||
- **Github 地址**：[https://github.com/analysys/EasyScheduler](https://github.com/analysys/EasyScheduler)
|
||||
- **star**: 1.1 k
|
||||
- **介绍**: Easy Scheduler是一个分布式工作流任务调度系统，主要解决“复杂任务依赖但无法直接监控任务健康状态”的问题。Easy Scheduler以DAG方式组装任务，可以实时监控任务的运行状态。同时，它支持重试，重新运行等操作... 。https://analysys.github.io/easyscheduler_docs_cn/
|
||||
|
||||
### 14.thingsboard
|
||||
|
||||
- **Github 地址**：[https://github.com/thingsboard/thingsboard](https://github.com/thingsboard/thingsboard)
|
||||
- **star**: 3.7 k
|
||||
- **介绍**: 开源物联网平台 - 设备管理，数据收集，处理和可视化。 [https://thingsboard.io](https://thingsboard.io/)
|
||||
|
||||
### 15.mall-learning
|
||||
|
||||
- **Github 地址**: [https://github.com/macrozheng/mall-learning](https://github.com/macrozheng/mall-learning)
|
||||
- **star**: 0.6 k
|
||||
- **介绍**: mall学习教程，架构、业务、技术要点全方位解析。mall项目（16k+star）是一套电商系统，使用现阶段主流技术实现。 涵盖了SpringBoot2.1.3、MyBatis3.4.6、Elasticsearch6.2.2、RabbitMQ3.7.15、Redis3.2、Mongodb3.2、Mysql5.7等技术，采用Docker容器化部署。 https://github.com/macrozheng/mall
|
||||
|
||||
### 16. flink
|
||||
|
||||
- **Github地址**：[https://github.com/apache/flink](https://github.com/apache/flink)
|
||||
- **star**: 9.3 k
|
||||
- **介绍**: Apache Flink是一个开源流处理框架，具有强大的流和批处理功能。
|
||||
|
||||
### 17.spring-cloud-kubernetes
|
||||
|
||||
- **Github地址**：[https://github.com/spring-cloud/spring-cloud-kubernetes](https://github.com/spring-cloud/spring-cloud-kubernetes)
|
||||
- **star**: 1.4 k
|
||||
- **介绍**: Kubernetes 集成 Spring Cloud Discovery Client, Configuration, etc...
|
||||
|
||||
### 18.springboot-learning-example
|
||||
|
||||
- **Github地址**：[https://github.com/JeffLi1993/springboot-learning-example](https://github.com/JeffLi1993/springboot-learning-example)
|
||||
- **star**: 10.0 k
|
||||
- **介绍**: spring boot 实践学习案例，是 spring boot 初学者及核心技术巩固的最佳实践。
|
||||
|
||||
### 19.canal
|
||||
|
||||
- **Github地址**：[https://github.com/alibaba/canal](https://github.com/alibaba/canal)
|
||||
- **star**: 9.3 k
|
||||
- **介绍**: 阿里巴巴 MySQL binlog 增量订阅&消费组件。
|
||||
|
||||
### 20.react-native-device-info
|
||||
|
||||
- **Github地址**：[https://github.com/react-native-community/react-native-device-info](https://github.com/react-native-community/react-native-device-info)
|
||||
- **star**: 4.0 k
|
||||
- **介绍**: React Native iOS和Android的设备信息。
|
||||
8
docs/github-trending/JavaGithubTrending.md
Normal file
8
docs/github-trending/JavaGithubTrending.md
Normal file
@ -0,0 +1,8 @@
|
||||
- [2018 年 12 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2018-12.md)
|
||||
- [2019 年 1 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2019-1.md)
|
||||
- [2019 年 2 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2019-2.md)
|
||||
- [2019 年 3 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2019-3.md)
|
||||
- [2019 年 4 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2019-4.md)
|
||||
- [2019 年 5 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2019-5.md)
|
||||
- [2019 年 6 月](https://github.com/Snailclimb/JavaGuide/blob/master/docs/github-trending/2019-6.md)
|
||||
|
||||
@ -42,7 +42,7 @@
|
||||
- **阻塞：** 阻塞就是发起一个请求，调用者一直等待请求结果返回，也就是当前线程会被挂起，无法从事其他任务，只有当条件就绪才能继续。
|
||||
- **非阻塞：** 非阻塞就是发起一个请求，调用者不用一直等着结果返回，可以先去干其他事情。
|
||||
|
||||
举个生活中简单的例子，你妈妈让你烧水，小时候你比较笨啊，在哪里傻等着水开（**同步阻塞**）。等你稍微再长大一点，你知道每次烧水的空隙可以去干点其他事，然后只需要时不时来看看水开了没有（**同步非阻塞**）。后来，你们家用上了水开了会发出声音的壶，这样你就只需要听到响声后就知道水开了，在这期间你可以随便干自己的事情，你需要去倒水了（**异步非阻塞**）。
|
||||
举个生活中简单的例子，你妈妈让你烧水，小时候你比较笨啊，在那里傻等着水开（**同步阻塞**）。等你稍微再长大一点，你知道每次烧水的空隙可以去干点其他事，然后只需要时不时来看看水开了没有（**同步非阻塞**）。后来，你们家用上了水开了会发出声音的壶，这样你就只需要听到响声后就知道水开了，在这期间你可以随便干自己的事情，你需要去倒水了（**异步非阻塞**）。
|
||||
|
||||
|
||||
## 1. BIO (Blocking I/O)
|
||||
@ -73,7 +73,7 @@ BIO通信（一请求一应答）模型图如下(图源网络，原出处不明)
|
||||
|
||||
采用线程池和任务队列可以实现一种叫做伪异步的 I/O 通信框架，它的模型图如上图所示。当有新的客户端接入时，将客户端的 Socket 封装成一个Task（该任务实现java.lang.Runnable接口）投递到后端的线程池中进行处理，JDK 的线程池维护一个消息队列和 N 个活跃线程，对消息队列中的任务进行处理。由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。
|
||||
|
||||
伪异步I/O通信框架采用了线程池实现，因此避免了为每个请求都创建一个独立线程造成的线程资源耗尽问题。不过因为它的底层任然是同步阻塞的BIO模型，因此无法从根本上解决问题。
|
||||
伪异步I/O通信框架采用了线程池实现，因此避免了为每个请求都创建一个独立线程造成的线程资源耗尽问题。不过因为它的底层仍然是同步阻塞的BIO模型，因此无法从根本上解决问题。
|
||||
|
||||
### 1.3 代码示例
|
||||
|
||||
@ -170,8 +170,8 @@ public class IOServer {
|
||||
|
||||
### 2.1 NIO 简介
|
||||
|
||||
NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应 java.nio 包，提供了 Channel , Selector，Buffer等抽象。
|
||||
|
||||
NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了 NIO 框架，对应 java.nio 包，提供了 Channel , Selector，Buffer等抽象。
|
||||
|
||||
NIO中的N可以理解为Non-blocking，不单纯是New。它支持面向缓冲的，基于通道的I/O操作方法。 NIO提供了与传统BIO模型中的 `Socket` 和 `ServerSocket` 相对应的 `SocketChannel` 和 `ServerSocketChannel` 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发。
|
||||
|
||||
### 2.2 NIO的特性/NIO与IO区别
|
||||
@ -202,13 +202,13 @@ NIO 通过Channel（通道） 进行读写。
|
||||
|
||||
通道是双向的，可读也可写，而流的读写是单向的。无论读写，通道只能和Buffer交互。因为 Buffer，通道可以异步地读写。
|
||||
|
||||
#### 4)Selectors(选择器)
|
||||
#### 4)Selector (选择器)
|
||||
|
||||
NIO有选择器，而IO没有。
|
||||
|
||||
选择器用于使用单个线程处理多个通道。因此，它需要较少的线程来处理这些通道。线程之间的切换对于操作系统来说是昂贵的。 因此，为了提高系统效率选择器是有用的。
|
||||
|
||||
|
||||
|
||||
|
||||
### 2.3 NIO 读数据和写数据方式
|
||||
通常来说NIO中的所有IO都是从 Channel（通道） 开始的。
|
||||
@ -273,8 +273,7 @@ public class NIOServer {
|
||||
|
||||
if (key.isAcceptable()) {
|
||||
try {
|
||||
// (1)
|
||||
// 每来一个新连接，不需要创建一个线程，而是直接注册到clientSelector
|
||||
// (1) 每来一个新连接，不需要创建一个线程，而是直接注册到clientSelector
|
||||
SocketChannel clientChannel = ((ServerSocketChannel) key.channel()).accept();
|
||||
clientChannel.configureBlocking(false);
|
||||
clientChannel.register(clientSelector, SelectionKey.OP_READ);
|
||||
383
docs/java/Basis/Arrays,CollectionsCommonMethods.md
Normal file
383
docs/java/Basis/Arrays,CollectionsCommonMethods.md
Normal file
@ -0,0 +1,383 @@
|
||||
<!-- TOC -->
|
||||
|
||||
- [Collections 工具类和 Arrays 工具类常见方法](#collections-工具类和-arrays-工具类常见方法)
|
||||
- [Collections](#collections)
|
||||
- [排序操作](#排序操作)
|
||||
- [查找,替换操作](#查找替换操作)
|
||||
- [同步控制](#同步控制)
|
||||
- [Arrays类的常见操作](#arrays类的常见操作)
|
||||
- [排序 : `sort()`](#排序--sort)
|
||||
- [查找 : `binarySearch()`](#查找--binarysearch)
|
||||
- [比较: `equals()`](#比较-equals)
|
||||
- [填充 : `fill()`](#填充--fill)
|
||||
- [转列表 `asList()`](#转列表-aslist)
|
||||
- [转字符串 `toString()`](#转字符串-tostring)
|
||||
- [复制 `copyOf()`](#复制-copyof)
|
||||
|
||||
<!-- /TOC -->
|
||||
# Collections 工具类和 Arrays 工具类常见方法
|
||||
|
||||
## Collections
|
||||
|
||||
Collections 工具类常用方法:
|
||||
|
||||
1. 排序
|
||||
2. 查找,替换操作
|
||||
3. 同步控制(不推荐，需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合)
|
||||
|
||||
### 排序操作
|
||||
|
||||
```java
|
||||
void reverse(List list)//反转
|
||||
void shuffle(List list)//随机排序
|
||||
void sort(List list)//按自然排序的升序排序
|
||||
void sort(List list, Comparator c)//定制排序，由Comparator控制排序逻辑
|
||||
void swap(List list, int i , int j)//交换两个索引位置的元素
|
||||
void rotate(List list, int distance)//旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面。
|
||||
```
|
||||
|
||||
**示例代码:**
|
||||
|
||||
```java
|
||||
ArrayList<Integer> arrayList = new ArrayList<Integer>();
|
||||
arrayList.add(-1);
|
||||
arrayList.add(3);
|
||||
arrayList.add(3);
|
||||
arrayList.add(-5);
|
||||
arrayList.add(7);
|
||||
arrayList.add(4);
|
||||
arrayList.add(-9);
|
||||
arrayList.add(-7);
|
||||
System.out.println("原始数组:");
|
||||
System.out.println(arrayList);
|
||||
// void reverse(List list)：反转
|
||||
Collections.reverse(arrayList);
|
||||
System.out.println("Collections.reverse(arrayList):");
|
||||
System.out.println(arrayList);
|
||||
|
||||
|
||||
Collections.rotate(arrayList, 4);
|
||||
System.out.println("Collections.rotate(arrayList, 4):");
|
||||
System.out.println(arrayList);
|
||||
|
||||
// void sort(List list),按自然排序的升序排序
|
||||
Collections.sort(arrayList);
|
||||
System.out.println("Collections.sort(arrayList):");
|
||||
System.out.println(arrayList);
|
||||
|
||||
// void shuffle(List list),随机排序
|
||||
Collections.shuffle(arrayList);
|
||||
System.out.println("Collections.shuffle(arrayList):");
|
||||
System.out.println(arrayList);
|
||||
|
||||
// void swap(List list, int i , int j),交换两个索引位置的元素
|
||||
Collections.swap(arrayList, 2, 5);
|
||||
System.out.println("Collections.swap(arrayList, 2, 5):");
|
||||
System.out.println(arrayList);
|
||||
|
||||
// 定制排序的用法
|
||||
Collections.sort(arrayList, new Comparator<Integer>() {
|
||||
|
||||
@Override
|
||||
public int compare(Integer o1, Integer o2) {
|
||||
return o2.compareTo(o1);
|
||||
}
|
||||
});
|
||||
System.out.println("定制排序后：");
|
||||
System.out.println(arrayList);
|
||||
```
|
||||
|
||||
### 查找,替换操作
|
||||
|
||||
```java
|
||||
int binarySearch(List list, Object key)//对List进行二分查找，返回索引，注意List必须是有序的
|
||||
int max(Collection coll)//根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)
|
||||
int max(Collection coll, Comparator c)//根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)
|
||||
void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素。
|
||||
int frequency(Collection c, Object o)//统计元素出现次数
|
||||
int indexOfSubList(List list, List target)//统计target在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target).
|
||||
boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替换旧元素
|
||||
```
|
||||
|
||||
**示例代码：**
|
||||
|
||||
```java
|
||||
ArrayList<Integer> arrayList = new ArrayList<Integer>();
|
||||
arrayList.add(-1);
|
||||
arrayList.add(3);
|
||||
arrayList.add(3);
|
||||
arrayList.add(-5);
|
||||
arrayList.add(7);
|
||||
arrayList.add(4);
|
||||
arrayList.add(-9);
|
||||
arrayList.add(-7);
|
||||
ArrayList<Integer> arrayList2 = new ArrayList<Integer>();
|
||||
arrayList2.add(-3);
|
||||
arrayList2.add(-5);
|
||||
arrayList2.add(7);
|
||||
System.out.println("原始数组:");
|
||||
System.out.println(arrayList);
|
||||
|
||||
System.out.println("Collections.max(arrayList):");
|
||||
System.out.println(Collections.max(arrayList));
|
||||
|
||||
System.out.println("Collections.min(arrayList):");
|
||||
System.out.println(Collections.min(arrayList));
|
||||
|
||||
System.out.println("Collections.replaceAll(arrayList, 3, -3):");
|
||||
Collections.replaceAll(arrayList, 3, -3);
|
||||
System.out.println(arrayList);
|
||||
|
||||
System.out.println("Collections.frequency(arrayList, -3):");
|
||||
System.out.println(Collections.frequency(arrayList, -3));
|
||||
|
||||
System.out.println("Collections.indexOfSubList(arrayList, arrayList2):");
|
||||
System.out.println(Collections.indexOfSubList(arrayList, arrayList2));
|
||||
|
||||
System.out.println("Collections.binarySearch(arrayList, 7):");
|
||||
// 对List进行二分查找，返回索引，List必须是有序的
|
||||
Collections.sort(arrayList);
|
||||
System.out.println(Collections.binarySearch(arrayList, 7));
|
||||
```
|
||||
|
||||
### 同步控制
|
||||
|
||||
Collections提供了多个`synchronizedXxx()`方法·，该方法可以将指定集合包装成线程同步的集合，从而解决多线程并发访问集合时的线程安全问题。
|
||||
|
||||
我们知道 HashSet，TreeSet，ArrayList,LinkedList,HashMap,TreeMap 都是线程不安全的。Collections提供了多个静态方法可以把他们包装成线程同步的集合。
|
||||
|
||||
**最好不要用下面这些方法，效率非常低，需要线程安全的集合类型时请考虑使用 JUC 包下的并发集合。**
|
||||
|
||||
方法如下：
|
||||
|
||||
```java
|
||||
synchronizedCollection(Collection<T> c) //返回指定 collection 支持的同步（线程安全的）collection。
|
||||
synchronizedList(List<T> list)//返回指定列表支持的同步（线程安全的）List。
|
||||
synchronizedMap(Map<K,V> m) //返回由指定映射支持的同步（线程安全的）Map。
|
||||
synchronizedSet(Set<T> s) //返回指定 set 支持的同步（线程安全的）set。
|
||||
```
|
||||
|
||||
### Collections还可以设置不可变集合，提供了如下三类方法：
|
||||
|
||||
```java
|
||||
emptyXxx(): 返回一个空的、不可变的集合对象，此处的集合既可以是List，也可以是Set，还可以是Map。
|
||||
singletonXxx(): 返回一个只包含指定对象（只有一个或一个元素）的不可变的集合对象，此处的集合可以是：List，Set，Map。
|
||||
unmodifiableXxx(): 返回指定集合对象的不可变视图，此处的集合可以是：List，Set，Map。
|
||||
上面三类方法的参数是原有的集合对象，返回值是该集合的”只读“版本。
|
||||
```
|
||||
|
||||
**示例代码：**
|
||||
|
||||
```java
|
||||
ArrayList<Integer> arrayList = new ArrayList<Integer>();
|
||||
arrayList.add(-1);
|
||||
arrayList.add(3);
|
||||
arrayList.add(3);
|
||||
arrayList.add(-5);
|
||||
arrayList.add(7);
|
||||
arrayList.add(4);
|
||||
arrayList.add(-9);
|
||||
arrayList.add(-7);
|
||||
HashSet<Integer> integers1 = new HashSet<>();
|
||||
integers1.add(1);
|
||||
integers1.add(3);
|
||||
integers1.add(2);
|
||||
Map scores = new HashMap();
|
||||
scores.put("语文" , 80);
|
||||
scores.put("Java" , 82);
|
||||
|
||||
//Collections.emptyXXX();创建一个空的、不可改变的XXX对象
|
||||
List<Object> list = Collections.emptyList();
|
||||
System.out.println(list);//[]
|
||||
Set<Object> objects = Collections.emptySet();
|
||||
System.out.println(objects);//[]
|
||||
Map<Object, Object> objectObjectMap = Collections.emptyMap();
|
||||
System.out.println(objectObjectMap);//{}
|
||||
|
||||
//Collections.singletonXXX();
|
||||
List<ArrayList<Integer>> arrayLists = Collections.singletonList(arrayList);
|
||||
System.out.println(arrayLists);//[[-1, 3, 3, -5, 7, 4, -9, -7]]
|
||||
//创建一个只有一个元素，且不可改变的Set对象
|
||||
Set<ArrayList<Integer>> singleton = Collections.singleton(arrayList);
|
||||
System.out.println(singleton);//[[-1, 3, 3, -5, 7, 4, -9, -7]]
|
||||
Map<String, String> nihao = Collections.singletonMap("1", "nihao");
|
||||
System.out.println(nihao);//{1=nihao}
|
||||
|
||||
//unmodifiableXXX();创建普通XXX对象对应的不可变版本
|
||||
List<Integer> integers = Collections.unmodifiableList(arrayList);
|
||||
System.out.println(integers);//[-1, 3, 3, -5, 7, 4, -9, -7]
|
||||
Set<Integer> integers2 = Collections.unmodifiableSet(integers1);
|
||||
System.out.println(integers2);//[1, 2, 3]
|
||||
Map<Object, Object> objectObjectMap2 = Collections.unmodifiableMap(scores);
|
||||
System.out.println(objectObjectMap2);//{Java=82, 语文=80}
|
||||
|
||||
//添加出现异常：java.lang.UnsupportedOperationException
|
||||
// list.add(1);
|
||||
// arrayLists.add(arrayList);
|
||||
// integers.add(1);
|
||||
```
|
||||
|
||||
## Arrays类的常见操作
|
||||
1. 排序 : `sort()`
|
||||
2. 查找 : `binarySearch()`
|
||||
3. 比较: `equals()`
|
||||
4. 填充 : `fill()`
|
||||
5. 转列表: `asList()`
|
||||
6. 转字符串 : `toString()`
|
||||
7. 复制: `copyOf()`
|
||||
|
||||
|
||||
### 排序 : `sort()`
|
||||
|
||||
```java
|
||||
// *************排序 sort****************
|
||||
int a[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
|
||||
// sort(int[] a)方法按照数字顺序排列指定的数组。
|
||||
Arrays.sort(a);
|
||||
System.out.println("Arrays.sort(a):");
|
||||
for (int i : a) {
|
||||
System.out.print(i);
|
||||
}
|
||||
// 换行
|
||||
System.out.println();
|
||||
|
||||
// sort(int[] a,int fromIndex,int toIndex)按升序排列数组的指定范围
|
||||
int b[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
|
||||
Arrays.sort(b, 2, 6);
|
||||
System.out.println("Arrays.sort(b, 2, 6):");
|
||||
for (int i : b) {
|
||||
System.out.print(i);
|
||||
}
|
||||
// 换行
|
||||
System.out.println();
|
||||
|
||||
int c[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
|
||||
// parallelSort(int[] a) 按照数字顺序排列指定的数组(并行的)。同sort方法一样也有按范围的排序
|
||||
Arrays.parallelSort(c);
|
||||
System.out.println("Arrays.parallelSort(c)：");
|
||||
for (int i : c) {
|
||||
System.out.print(i);
|
||||
}
|
||||
// 换行
|
||||
System.out.println();
|
||||
|
||||
// parallelSort给字符数组排序，sort也可以
|
||||
char d[] = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
|
||||
Arrays.parallelSort(d);
|
||||
System.out.println("Arrays.parallelSort(d)：");
|
||||
for (char d2 : d) {
|
||||
System.out.print(d2);
|
||||
}
|
||||
// 换行
|
||||
System.out.println();
|
||||
|
||||
```
|
||||
|
||||
在做算法面试题的时候，我们还可能会经常遇到对字符串排序的情况,`Arrays.sort()` 对每个字符串的特定位置进行比较，然后按照升序排序。
|
||||
|
||||
```java
|
||||
String[] strs = { "abcdehg", "abcdefg", "abcdeag" };
|
||||
Arrays.sort(strs);
|
||||
System.out.println(Arrays.toString(strs));//[abcdeag, abcdefg, abcdehg]
|
||||
```
|
||||
|
||||
### 查找 : `binarySearch()`
|
||||
|
||||
```java
|
||||
// *************查找 binarySearch()****************
|
||||
char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
|
||||
// 排序后再进行二分查找，否则找不到
|
||||
Arrays.sort(e);
|
||||
System.out.println("Arrays.sort(e)" + Arrays.toString(e));
|
||||
System.out.println("Arrays.binarySearch(e, 'c')：");
|
||||
int s = Arrays.binarySearch(e, 'c');
|
||||
System.out.println("字符c在数组的位置：" + s);
|
||||
```
|
||||
|
||||
### 比较: `equals()`
|
||||
|
||||
```java
|
||||
// *************比较 equals****************
|
||||
char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
|
||||
char[] f = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
|
||||
/*
|
||||
* 元素数量相同，并且相同位置的元素相同。 另外，如果两个数组引用都是null，则它们被认为是相等的 。
|
||||
*/
|
||||
// 输出true
|
||||
System.out.println("Arrays.equals(e, f):" + Arrays.equals(e, f));
|
||||
```
|
||||
|
||||
### 填充 : `fill()`
|
||||
|
||||
```java
|
||||
// *************填充fill(批量初始化)****************
|
||||
int[] g = { 1, 2, 3, 3, 3, 3, 6, 6, 6 };
|
||||
// 数组中所有元素重新分配值
|
||||
Arrays.fill(g, 3);
|
||||
System.out.println("Arrays.fill(g, 3)：");
|
||||
// 输出结果：333333333
|
||||
for (int i : g) {
|
||||
System.out.print(i);
|
||||
}
|
||||
// 换行
|
||||
System.out.println();
|
||||
|
||||
int[] h = { 1, 2, 3, 3, 3, 3, 6, 6, 6, };
|
||||
// 数组中指定范围元素重新分配值
|
||||
Arrays.fill(h, 0, 2, 9);
|
||||
System.out.println("Arrays.fill(h, 0, 2, 9);：");
|
||||
// 输出结果：993333666
|
||||
for (int i : h) {
|
||||
System.out.print(i);
|
||||
}
|
||||
```
|
||||
|
||||
### 转列表 `asList()`
|
||||
|
||||
```java
|
||||
// *************转列表 asList()****************
|
||||
/*
|
||||
* 返回由指定数组支持的固定大小的列表。
|
||||
* （将返回的列表更改为“写入数组”。）该方法作为基于数组和基于集合的API之间的桥梁，与Collection.toArray()相结合 。
|
||||
* 返回的列表是可序列化的，并实现RandomAccess 。
|
||||
* 此方法还提供了一种方便的方式来创建一个初始化为包含几个元素的固定大小的列表如下：
|
||||
*/
|
||||
List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
|
||||
System.out.println(stooges);
|
||||
```
|
||||
|
||||
### 转字符串 `toString()`
|
||||
|
||||
```java
|
||||
// *************转字符串 toString()****************
|
||||
/*
|
||||
* 返回指定数组的内容的字符串表示形式。
|
||||
*/
|
||||
char[] k = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
|
||||
System.out.println(Arrays.toString(k));// [a, f, b, c, e, A, C, B]
|
||||
```
|
||||
|
||||
### 复制 `copyOf()`
|
||||
|
||||
```java
|
||||
// *************复制 copy****************
|
||||
// copyOf 方法实现数组复制,h为数组，6为复制的长度
|
||||
int[] h = { 1, 2, 3, 3, 3, 3, 6, 6, 6, };
|
||||
int i[] = Arrays.copyOf(h, 6);
|
||||
System.out.println("Arrays.copyOf(h, 6);：");
|
||||
// 输出结果：123333
|
||||
for (int j : i) {
|
||||
System.out.print(j);
|
||||
}
|
||||
// 换行
|
||||
System.out.println();
|
||||
// copyOfRange将指定数组的指定范围复制到新数组中
|
||||
int j[] = Arrays.copyOfRange(h, 6, 11);
|
||||
System.out.println("Arrays.copyOfRange(h, 6, 11)：");
|
||||
// 输出结果66600(h数组只有9个元素这里是从索引6到索引11复制所以不足的就为0)
|
||||
for (int j2 : j) {
|
||||
System.out.print(j2);
|
||||
}
|
||||
// 换行
|
||||
System.out.println();
|
||||
```
|
||||
@ -1,5 +1,108 @@
|
||||
<!-- MarkdownTOC -->
|
||||
|
||||
# static 关键字
|
||||
- [final,static,this,super 关键字总结](#finalstaticthissuper-关键字总结)
|
||||
- [final 关键字](#final-关键字)
|
||||
- [static 关键字](#static-关键字)
|
||||
- [this 关键字](#this-关键字)
|
||||
- [super 关键字](#super-关键字)
|
||||
- [参考](#参考)
|
||||
- [static 关键字详解](#static-关键字详解)
|
||||
- [static 关键字主要有以下四种使用场景](#static-关键字主要有以下四种使用场景)
|
||||
- [修饰成员变量和成员方法\(常用\)](#修饰成员变量和成员方法常用)
|
||||
- [静态代码块](#静态代码块)
|
||||
- [静态内部类](#静态内部类)
|
||||
- [静态导包](#静态导包)
|
||||
- [补充内容](#补充内容)
|
||||
- [静态方法与非静态方法](#静态方法与非静态方法)
|
||||
- [static{}静态代码块与{}非静态代码块\(构造代码块\)](#static静态代码块与非静态代码块构造代码块)
|
||||
- [参考](#参考-1)
|
||||
|
||||
<!-- /MarkdownTOC -->
|
||||
|
||||
# final,static,this,super 关键字总结
|
||||
|
||||
## final 关键字
|
||||
|
||||
**final关键字主要用在三个地方：变量、方法、类。**
|
||||
|
||||
1. **对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。**
|
||||
|
||||
2. **当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。**
|
||||
|
||||
3. 使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。
|
||||
|
||||
## static 关键字
|
||||
|
||||
**static 关键字主要有以下四种使用场景：**
|
||||
|
||||
1. **修饰成员变量和成员方法:** 被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static 声明的成员变量属于静态成员变量，静态变量 存放在 Java 内存区域的方法区。调用格式：`类名.静态变量名` `类名.静态方法名()`
|
||||
2. **静态代码块:** 静态代码块定义在类中方法外, 静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。 该类不管创建多少对象，静态代码块只执行一次.
|
||||
3. **静态内部类（static修饰类的话只能修饰内部类）：** 静态内部类与非静态内部类之间存在一个最大的区别: 非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，但是静态内部类却没有。没有这个引用就意味着：1. 它的创建是不需要依赖外围类的创建。2. 它不能使用任何外围类的非static成员变量和方法。
|
||||
4. **静态导包(用来导入类中的静态资源，1.5之后的新特性):** 格式为：`import static` 这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名调用类中静态成员，可以直接使用类中静态成员变量和成员方法。
|
||||
|
||||
## this 关键字
|
||||
|
||||
this关键字用于引用类的当前实例。 例如：
|
||||
|
||||
```java
|
||||
class Manager {
|
||||
Employees[] employees;
|
||||
|
||||
void manageEmployees() {
|
||||
int totalEmp = this.employees.length;
|
||||
System.out.println("Total employees: " + totalEmp);
|
||||
this.report();
|
||||
}
|
||||
|
||||
void report() { }
|
||||
}
|
||||
```
|
||||
|
||||
在上面的示例中，this关键字用于两个地方：
|
||||
|
||||
- this.employees.length：访问类Manager的当前实例的变量。
|
||||
- this.report（）：调用类Manager的当前实例的方法。
|
||||
|
||||
此关键字是可选的，这意味着如果上面的示例在不使用此关键字的情况下表现相同。 但是，使用此关键字可能会使代码更易读或易懂。
|
||||
|
||||
## super 关键字
|
||||
|
||||
super关键字用于从子类访问父类的变量和方法。 例如：
|
||||
|
||||
```java
|
||||
public class Super {
|
||||
protected int number;
|
||||
|
||||
protected showNumber() {
|
||||
System.out.println("number = " + number);
|
||||
}
|
||||
}
|
||||
|
||||
public class Sub extends Super {
|
||||
void bar() {
|
||||
super.number = 10;
|
||||
super.showNumber();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
在上面的例子中，Sub 类访问父类成员变量 number 并调用其其父类 Super 的 `showNumber（）` 方法。
|
||||
|
||||
**使用 this 和 super 要注意的问题：**
|
||||
|
||||
- 在构造器中使用 `super（）` 调用父类中的其他构造方法时，该语句必须处于构造器的首行，否则编译器会报错。另外，this 调用本类中的其他构造方法时，也要放在首行。
|
||||
- this、super不能用在static方法中。
|
||||
|
||||
**简单解释一下：**
|
||||
|
||||
被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享。而 this 代表对本类对象的引用，指向本类对象；而 super 代表对父类对象的引用，指向父类对象；所以， **this和super是属于对象范畴的东西，而静态方法是属于类范畴的东西**。
|
||||
|
||||
## 参考
|
||||
|
||||
- https://www.codejava.net/java-core/the-java-language/java-keywords
|
||||
- https://blog.csdn.net/u013393958/article/details/79881037
|
||||
|
||||
# static 关键字详解
|
||||
|
||||
## static 关键字主要有以下四种使用场景
|
||||
|
||||
@ -8,7 +111,7 @@
|
||||
3. 修饰类(只能修饰内部类)
|
||||
4. 静态导包(用来导入类中的静态资源，1.5之后的新特性)
|
||||
|
||||
### 修饰成员变量和成员方法(常用)
|
||||
### 修饰成员变量和成员方法(常用)
|
||||
|
||||
被 static 修饰的成员属于类，不属于单个这个类的某个对象，被类中所有对象共享，可以并且建议通过类名调用。被static 声明的成员变量属于静态成员变量，静态变量 存放在 Java 内存区域的方法区。
|
||||
|
||||
@ -16,8 +119,6 @@
|
||||
|
||||
HotSpot 虚拟机中方法区也常被称为 “永久代”，本质上两者并不等价。仅仅是因为 HotSpot 虚拟机设计团队用永久代来实现方法区而已，这样 HotSpot 虚拟机的垃圾收集器就可以像管理 Java 堆一样管理这部分内存了。但是这并不是一个好主意，因为这样更容易遇到内存溢出问题。
|
||||
|
||||
|
||||
|
||||
调用格式：
|
||||
|
||||
- 类名.静态变量名
|
||||
@ -93,7 +194,7 @@ static {
|
||||
静态内部类与非静态内部类之间存在一个最大的区别，我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，但是静态内部类却没有。没有这个引用就意味着：
|
||||
|
||||
1. 它的创建是不需要依赖外围类的创建。
|
||||
2. 它不能使用任何外围类的非static成员变量和方法。
|
||||
2. 它不能使用任何外围类的非static成员变量和方法。
|
||||
|
||||
|
||||
Example（静态内部类实现单例模式）
|
||||
@ -137,11 +238,11 @@ import static java.lang.Math.;
|
||||
换成import static java.lang.Math.max;具有一样的效果
|
||||
|
||||
public class Demo {
|
||||
public static void main(String[] args) {
|
||||
public static void main(String[] args) {
|
||||
|
||||
int max = max(1,2);
|
||||
System.out.println(max);
|
||||
}
|
||||
int max = max(1,2);
|
||||
System.out.println(max);
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
@ -180,7 +281,7 @@ class Foo {
|
||||
- 在外部调用静态方法时，可以使用”类名.方法名”的方式，也可以使用”对象名.方法名”的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
|
||||
- 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制
|
||||
|
||||
### static{}静态代码块与{}非静态代码块（构造代码块）
|
||||
### static{}静态代码块与{}非静态代码块(构造代码块)
|
||||
|
||||
相同点： 都是在JVM加载类时且在构造方法执行之前执行，在类中都可以定义多个，定义多个时按定义的顺序执行，一般在代码块中对一些static变量进行赋值。
|
||||
|
||||
@ -232,7 +333,7 @@ public class Test {
|
||||
```
|
||||
|
||||
|
||||
非静态代码块与构造函数的区别是： 非静态代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化，因为构造函数是可以多个的，运行哪个构造函数就会建立什么样的对象，但无论建立哪个对象，都会先执行相同的构造代码块。也就是说，构造代码块中定义的是不同对象共性的初始化内容。
|
||||
非静态代码块与构造函数的区别是： 非静态代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化，因为构造函数是可以多个的，运行哪个构造函数就会建立什么样的对象，但无论建立哪个对象，都会先执行相同的构造代码块。也就是说，构造代码块中定义的是不同对象共性的初始化内容。
|
||||
|
||||
### 参考
|
||||
|
||||
561
docs/java/Basis/用好Java中的枚举,真的没有那么简单!.md
Normal file
561
docs/java/Basis/用好Java中的枚举,真的没有那么简单!.md
Normal file
@ -0,0 +1,561 @@
|
||||
> 最近重看 Java 枚举，看到这篇觉得还不错的文章，于是简单翻译和完善了一些内容，分享给大家，希望你们也能有所收获。另外，不要忘了文末还有补充哦！
|
||||
>
|
||||
> ps: 这里发一篇枚举的文章，也是因为后面要发一篇非常实用的关于 SpringBoot 全局异常处理的比较好的实践，里面就用到了枚举。
|
||||
>
|
||||
> 这篇文章由 JavaGuide 翻译，公众号: JavaGuide,原文地址：https://www.baeldung.com/a-guide-to-java-enums 。
|
||||
>
|
||||
> 转载请注明上面这段文字。
|
||||
|
||||
## 1.概览
|
||||
|
||||
在本文中，我们将看到什么是 Java 枚举，它们解决了哪些问题以及如何在实践中使用 Java 枚举实现一些设计模式。
|
||||
|
||||
enum关键字在 java5 中引入，表示一种特殊类型的类，其总是继承java.lang.Enum类，更多内容可以自行查看其[官方文档](https://docs.oracle.com/javase/6/docs/api/java/lang/Enum.html)。
|
||||
|
||||
枚举在很多时候会和常量拿来对比，可能因为本身我们大量实际使用枚举的地方就是为了替代常量。那么这种方式由什么优势呢？
|
||||
|
||||
**以这种方式定义的常量使代码更具可读性，允许进行编译时检查，预先记录可接受值的列表，并避免由于传入无效值而引起的意外行为。**
|
||||
|
||||
下面示例定义一个简单的枚举类型 pizza 订单的状态，共有三种 ORDERED, READY, DELIVERED状态:
|
||||
|
||||
```java
|
||||
package shuang.kou.enumdemo.enumtest;
|
||||
|
||||
public enum PizzaStatus {
|
||||
ORDERED,
|
||||
READY,
|
||||
DELIVERED;
|
||||
}
|
||||
```
|
||||
|
||||
**简单来说，我们通过上面的代码避免了定义常量，我们将所有和 pizza 订单的状态的常量都统一放到了一个枚举类型里面。**
|
||||
|
||||
```java
|
||||
System.out.println(PizzaStatus.ORDERED.name());//ORDERED
|
||||
System.out.println(PizzaStatus.ORDERED);//ORDERED
|
||||
System.out.println(PizzaStatus.ORDERED.name().getClass());//class java.lang.String
|
||||
System.out.println(PizzaStatus.ORDERED.getClass());//class shuang.kou.enumdemo.enumtest.PizzaStatus
|
||||
```
|
||||
|
||||
## 2.自定义枚举方法
|
||||
|
||||
现在我们对枚举是什么以及如何使用它们有了基本的了解，让我们通过在枚举上定义一些额外的API方法，将上一个示例提升到一个新的水平：
|
||||
|
||||
```java
|
||||
public class Pizza {
|
||||
private PizzaStatus status;
|
||||
public enum PizzaStatus {
|
||||
ORDERED,
|
||||
READY,
|
||||
DELIVERED;
|
||||
}
|
||||
|
||||
public boolean isDeliverable() {
|
||||
if (getStatus() == PizzaStatus.READY) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Methods that set and get the status variable.
|
||||
}
|
||||
```
|
||||
|
||||
## 3.使用 == 比较枚举类型
|
||||
|
||||
由于枚举类型确保JVM中仅存在一个常量实例，因此我们可以安全地使用“ ==”运算符比较两个变量，如上例所示；此外，“ ==”运算符可提供编译时和运行时的安全性。
|
||||
|
||||
首先，让我们看一下以下代码段中的运行时安全性，其中“ ==”运算符用于比较状态，并且如果两个值均为null 都不会引发 NullPointerException。相反，如果使用equals方法，将抛出 NullPointerException：
|
||||
|
||||
```java
|
||||
if(testPz.getStatus().equals(Pizza.PizzaStatus.DELIVERED));
|
||||
if(testPz.getStatus() == Pizza.PizzaStatus.DELIVERED);
|
||||
```
|
||||
|
||||
对于编译时安全性，我们看另一个示例，两个不同枚举类型进行比较，使用equal方法比较结果确定为true，因为getStatus方法的枚举值与另一个类型枚举值一致，但逻辑上应该为false。这个问题可以使用==操作符避免。因为编译器会表示类型不兼容错误：
|
||||
|
||||
```java
|
||||
if(testPz.getStatus().equals(TestColor.GREEN));
|
||||
if(testPz.getStatus() == TestColor.GREEN);
|
||||
```
|
||||
|
||||
## 4.在 switch 语句中使用枚举类型
|
||||
|
||||
```java
|
||||
public int getDeliveryTimeInDays() {
|
||||
switch (status) {
|
||||
case ORDERED: return 5;
|
||||
case READY: return 2;
|
||||
case DELIVERED: return 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
## 5.枚举类型的属性,方法和构造函数
|
||||
|
||||
> 文末有我(JavaGuide)的补充。
|
||||
|
||||
你可以通过在枚举类型中定义属性,方法和构造函数让它变得更加强大。
|
||||
|
||||
下面，让我们扩展上面的示例，实现从比萨的一个阶段到另一个阶段的过渡，并了解如何摆脱之前使用的if语句和switch语句：
|
||||
|
||||
```java
|
||||
public class Pizza {
|
||||
|
||||
private PizzaStatus status;
|
||||
public enum PizzaStatus {
|
||||
ORDERED (5){
|
||||
@Override
|
||||
public boolean isOrdered() {
|
||||
return true;
|
||||
}
|
||||
},
|
||||
READY (2){
|
||||
@Override
|
||||
public boolean isReady() {
|
||||
return true;
|
||||
}
|
||||
},
|
||||
DELIVERED (0){
|
||||
@Override
|
||||
public boolean isDelivered() {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
private int timeToDelivery;
|
||||
|
||||
public boolean isOrdered() {return false;}
|
||||
|
||||
public boolean isReady() {return false;}
|
||||
|
||||
public boolean isDelivered(){return false;}
|
||||
|
||||
public int getTimeToDelivery() {
|
||||
return timeToDelivery;
|
||||
}
|
||||
|
||||
PizzaStatus (int timeToDelivery) {
|
||||
this.timeToDelivery = timeToDelivery;
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isDeliverable() {
|
||||
return this.status.isReady();
|
||||
}
|
||||
|
||||
public void printTimeToDeliver() {
|
||||
System.out.println("Time to delivery is " +
|
||||
this.getStatus().getTimeToDelivery());
|
||||
}
|
||||
|
||||
// Methods that set and get the status variable.
|
||||
}
|
||||
```
|
||||
|
||||
下面这段代码展示它是如何 work 的：
|
||||
|
||||
```java
|
||||
@Test
|
||||
public void givenPizaOrder_whenReady_thenDeliverable() {
|
||||
Pizza testPz = new Pizza();
|
||||
testPz.setStatus(Pizza.PizzaStatus.READY);
|
||||
assertTrue(testPz.isDeliverable());
|
||||
}
|
||||
```
|
||||
|
||||
## 6.EnumSet and EnumMap
|
||||
|
||||
### 6.1. EnumSet
|
||||
|
||||
`EnumSet` 是一种专门为枚举类型所设计的 `Set` 类型。
|
||||
|
||||
与`HashSet`相比，由于使用了内部位向量表示，因此它是特定 `Enum` 常量集的非常有效且紧凑的表示形式。
|
||||
|
||||
它提供了类型安全的替代方法，以替代传统的基于int的“位标志”，使我们能够编写更易读和易于维护的简洁代码。
|
||||
|
||||
`EnumSet` 是抽象类，其有两个实现：`RegularEnumSet` 、`JumboEnumSet`，选择哪一个取决于实例化时枚举中常量的数量。
|
||||
|
||||
在很多场景中的枚举常量集合操作（如：取子集、增加、删除、`containsAll`和`removeAll`批操作）使用`EnumSet`非常合适；如果需要迭代所有可能的常量则使用`Enum.values()`。
|
||||
|
||||
```java
|
||||
public class Pizza {
|
||||
|
||||
private static EnumSet<PizzaStatus> undeliveredPizzaStatuses =
|
||||
EnumSet.of(PizzaStatus.ORDERED, PizzaStatus.READY);
|
||||
|
||||
private PizzaStatus status;
|
||||
|
||||
public enum PizzaStatus {
|
||||
...
|
||||
}
|
||||
|
||||
public boolean isDeliverable() {
|
||||
return this.status.isReady();
|
||||
}
|
||||
|
||||
public void printTimeToDeliver() {
|
||||
System.out.println("Time to delivery is " +
|
||||
this.getStatus().getTimeToDelivery() + " days");
|
||||
}
|
||||
|
||||
public static List<Pizza> getAllUndeliveredPizzas(List<Pizza> input) {
|
||||
return input.stream().filter(
|
||||
(s) -> undeliveredPizzaStatuses.contains(s.getStatus()))
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
||||
public void deliver() {
|
||||
if (isDeliverable()) {
|
||||
PizzaDeliverySystemConfiguration.getInstance().getDeliveryStrategy()
|
||||
.deliver(this);
|
||||
this.setStatus(PizzaStatus.DELIVERED);
|
||||
}
|
||||
}
|
||||
|
||||
// Methods that set and get the status variable.
|
||||
}
|
||||
```
|
||||
|
||||
下面的测试演示了展示了 `EnumSet` 在某些场景下的强大功能：
|
||||
|
||||
```java
|
||||
@Test
|
||||
public void givenPizaOrders_whenRetrievingUnDeliveredPzs_thenCorrectlyRetrieved() {
|
||||
List<Pizza> pzList = new ArrayList<>();
|
||||
Pizza pz1 = new Pizza();
|
||||
pz1.setStatus(Pizza.PizzaStatus.DELIVERED);
|
||||
|
||||
Pizza pz2 = new Pizza();
|
||||
pz2.setStatus(Pizza.PizzaStatus.ORDERED);
|
||||
|
||||
Pizza pz3 = new Pizza();
|
||||
pz3.setStatus(Pizza.PizzaStatus.ORDERED);
|
||||
|
||||
Pizza pz4 = new Pizza();
|
||||
pz4.setStatus(Pizza.PizzaStatus.READY);
|
||||
|
||||
pzList.add(pz1);
|
||||
pzList.add(pz2);
|
||||
pzList.add(pz3);
|
||||
pzList.add(pz4);
|
||||
|
||||
List<Pizza> undeliveredPzs = Pizza.getAllUndeliveredPizzas(pzList);
|
||||
assertTrue(undeliveredPzs.size() == 3);
|
||||
}
|
||||
```
|
||||
|
||||
### 6.2. EnumMap
|
||||
|
||||
`EnumMap`是一个专门化的映射实现，用于将枚举常量用作键。与对应的 `HashMap` 相比，它是一个高效紧凑的实现，并且在内部表示为一个数组:
|
||||
|
||||
```java
|
||||
EnumMap<Pizza.PizzaStatus, Pizza> map;
|
||||
```
|
||||
|
||||
让我们快速看一个真实的示例，该示例演示如何在实践中使用它：
|
||||
|
||||
```java
|
||||
public static EnumMap<PizzaStatus, List<Pizza>>
|
||||
groupPizzaByStatus(List<Pizza> pizzaList) {
|
||||
EnumMap<PizzaStatus, List<Pizza>> pzByStatus =
|
||||
new EnumMap<PizzaStatus, List<Pizza>>(PizzaStatus.class);
|
||||
|
||||
for (Pizza pz : pizzaList) {
|
||||
PizzaStatus status = pz.getStatus();
|
||||
if (pzByStatus.containsKey(status)) {
|
||||
pzByStatus.get(status).add(pz);
|
||||
} else {
|
||||
List<Pizza> newPzList = new ArrayList<Pizza>();
|
||||
newPzList.add(pz);
|
||||
pzByStatus.put(status, newPzList);
|
||||
}
|
||||
}
|
||||
return pzByStatus;
|
||||
}
|
||||
```
|
||||
|
||||
下面的测试演示了展示了 `EnumMap` 在某些场景下的强大功能：
|
||||
|
||||
```java
|
||||
@Test
|
||||
public void givenPizaOrders_whenGroupByStatusCalled_thenCorrectlyGrouped() {
|
||||
List<Pizza> pzList = new ArrayList<>();
|
||||
Pizza pz1 = new Pizza();
|
||||
pz1.setStatus(Pizza.PizzaStatus.DELIVERED);
|
||||
|
||||
Pizza pz2 = new Pizza();
|
||||
pz2.setStatus(Pizza.PizzaStatus.ORDERED);
|
||||
|
||||
Pizza pz3 = new Pizza();
|
||||
pz3.setStatus(Pizza.PizzaStatus.ORDERED);
|
||||
|
||||
Pizza pz4 = new Pizza();
|
||||
pz4.setStatus(Pizza.PizzaStatus.READY);
|
||||
|
||||
pzList.add(pz1);
|
||||
pzList.add(pz2);
|
||||
pzList.add(pz3);
|
||||
pzList.add(pz4);
|
||||
|
||||
EnumMap<Pizza.PizzaStatus,List<Pizza>> map = Pizza.groupPizzaByStatus(pzList);
|
||||
assertTrue(map.get(Pizza.PizzaStatus.DELIVERED).size() == 1);
|
||||
assertTrue(map.get(Pizza.PizzaStatus.ORDERED).size() == 2);
|
||||
assertTrue(map.get(Pizza.PizzaStatus.READY).size() == 1);
|
||||
}
|
||||
```
|
||||
|
||||
## 7. 通过枚举实现一些设计模式
|
||||
|
||||
### 7.1 单例模式
|
||||
|
||||
通常，使用类实现 Singleton 模式并非易事，枚举提供了一种实现单例的简便方法。
|
||||
|
||||
《Effective Java 》和《Java与模式》都非常推荐这种方式，使用这种方式方式实现枚举可以有什么好处呢？
|
||||
|
||||
《Effective Java》
|
||||
|
||||
> 这种方法在功能上与公有域方法相近，但是它更加简洁，无偿提供了序列化机制，绝对防止多次实例化，即使是在面对复杂序列化或者反射攻击的时候。虽然这种方法还没有广泛采用，但是单元素的枚举类型已经成为实现 Singleton的最佳方法。 —-《Effective Java 中文版 第二版》
|
||||
|
||||
《Java与模式》
|
||||
|
||||
> 《Java与模式》中，作者这样写道，使用枚举来实现单实例控制会更加简洁，而且无偿地提供了序列化机制，并由JVM从根本上提供保障，绝对防止多次实例化，是更简洁、高效、安全的实现单例的方式。
|
||||
|
||||
下面的代码段显示了如何使用枚举实现单例模式：
|
||||
|
||||
```java
|
||||
public enum PizzaDeliverySystemConfiguration {
|
||||
INSTANCE;
|
||||
PizzaDeliverySystemConfiguration() {
|
||||
// Initialization configuration which involves
|
||||
// overriding defaults like delivery strategy
|
||||
}
|
||||
|
||||
private PizzaDeliveryStrategy deliveryStrategy = PizzaDeliveryStrategy.NORMAL;
|
||||
|
||||
public static PizzaDeliverySystemConfiguration getInstance() {
|
||||
return INSTANCE;
|
||||
}
|
||||
|
||||
public PizzaDeliveryStrategy getDeliveryStrategy() {
|
||||
return deliveryStrategy;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
如何使用呢？请看下面的代码：
|
||||
|
||||
```java
|
||||
PizzaDeliveryStrategy deliveryStrategy = PizzaDeliverySystemConfiguration.getInstance().getDeliveryStrategy();
|
||||
```
|
||||
|
||||
通过 `PizzaDeliverySystemConfiguration.getInstance()` 获取的就是单例的 `PizzaDeliverySystemConfiguration`
|
||||
|
||||
### 7.2 策略模式
|
||||
|
||||
通常，策略模式由不同类实现同一个接口来实现的。
|
||||
|
||||
这也就意味着添加新策略意味着添加新的实现类。使用枚举，可以轻松完成此任务，添加新的实现意味着只定义具有某个实现的另一个实例。
|
||||
|
||||
下面的代码段显示了如何使用枚举实现策略模式：
|
||||
|
||||
```java
|
||||
public enum PizzaDeliveryStrategy {
|
||||
EXPRESS {
|
||||
@Override
|
||||
public void deliver(Pizza pz) {
|
||||
System.out.println("Pizza will be delivered in express mode");
|
||||
}
|
||||
},
|
||||
NORMAL {
|
||||
@Override
|
||||
public void deliver(Pizza pz) {
|
||||
System.out.println("Pizza will be delivered in normal mode");
|
||||
}
|
||||
};
|
||||
|
||||
public abstract void deliver(Pizza pz);
|
||||
}
|
||||
```
|
||||
|
||||
给 `Pizza `增加下面的方法：
|
||||
|
||||
```java
|
||||
public void deliver() {
|
||||
if (isDeliverable()) {
|
||||
PizzaDeliverySystemConfiguration.getInstance().getDeliveryStrategy()
|
||||
.deliver(this);
|
||||
this.setStatus(PizzaStatus.DELIVERED);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
如何使用呢？请看下面的代码：
|
||||
|
||||
```java
|
||||
@Test
|
||||
public void givenPizaOrder_whenDelivered_thenPizzaGetsDeliveredAndStatusChanges() {
|
||||
Pizza pz = new Pizza();
|
||||
pz.setStatus(Pizza.PizzaStatus.READY);
|
||||
pz.deliver();
|
||||
assertTrue(pz.getStatus() == Pizza.PizzaStatus.DELIVERED);
|
||||
}
|
||||
```
|
||||
|
||||
## 8. Java 8 与枚举
|
||||
|
||||
Pizza 类可以用Java 8重写，您可以看到方法 lambda 和Stream API如何使 `getAllUndeliveredPizzas（）`和`groupPizzaByStatus（）`方法变得如此简洁：
|
||||
|
||||
`getAllUndeliveredPizzas（）`:
|
||||
|
||||
```java
|
||||
public static List<Pizza> getAllUndeliveredPizzas(List<Pizza> input) {
|
||||
return input.stream().filter(
|
||||
(s) -> !deliveredPizzaStatuses.contains(s.getStatus()))
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
```
|
||||
|
||||
`groupPizzaByStatus（）` :
|
||||
|
||||
```java
|
||||
public static EnumMap<PizzaStatus, List<Pizza>>
|
||||
groupPizzaByStatus(List<Pizza> pzList) {
|
||||
EnumMap<PizzaStatus, List<Pizza>> map = pzList.stream().collect(
|
||||
Collectors.groupingBy(Pizza::getStatus,
|
||||
() -> new EnumMap<>(PizzaStatus.class), Collectors.toList()));
|
||||
return map;
|
||||
}
|
||||
```
|
||||
|
||||
## 9. Enum 类型的 JSON 表现形式
|
||||
|
||||
使用Jackson库，可以将枚举类型的JSON表示为POJO。下面的代码段显示了可以用于同一目的的Jackson批注：
|
||||
|
||||
```java
|
||||
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
|
||||
public enum PizzaStatus {
|
||||
ORDERED (5){
|
||||
@Override
|
||||
public boolean isOrdered() {
|
||||
return true;
|
||||
}
|
||||
},
|
||||
READY (2){
|
||||
@Override
|
||||
public boolean isReady() {
|
||||
return true;
|
||||
}
|
||||
},
|
||||
DELIVERED (0){
|
||||
@Override
|
||||
public boolean isDelivered() {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
private int timeToDelivery;
|
||||
|
||||
public boolean isOrdered() {return false;}
|
||||
|
||||
public boolean isReady() {return false;}
|
||||
|
||||
public boolean isDelivered(){return false;}
|
||||
|
||||
@JsonProperty("timeToDelivery")
|
||||
public int getTimeToDelivery() {
|
||||
return timeToDelivery;
|
||||
}
|
||||
|
||||
private PizzaStatus (int timeToDelivery) {
|
||||
this.timeToDelivery = timeToDelivery;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
我们可以按如下方式使用 `Pizza` 和 `PizzaStatus`：
|
||||
|
||||
```java
|
||||
Pizza pz = new Pizza();
|
||||
pz.setStatus(Pizza.PizzaStatus.READY);
|
||||
System.out.println(Pizza.getJsonString(pz));
|
||||
```
|
||||
|
||||
生成 Pizza 状态以以下JSON展示：
|
||||
|
||||
```json
|
||||
{
|
||||
"status" : {
|
||||
"timeToDelivery" : 2,
|
||||
"ready" : true,
|
||||
"ordered" : false,
|
||||
"delivered" : false
|
||||
},
|
||||
"deliverable" : true
|
||||
}
|
||||
```
|
||||
|
||||
有关枚举类型的JSON序列化/反序列化（包括自定义）的更多信息，请参阅[Jackson-将枚举序列化为JSON对象。](https://www.baeldung.com/jackson-serialize-enums)
|
||||
|
||||
## 10.总结
|
||||
|
||||
本文我们讨论了Java枚举类型，从基础知识到高级应用以及实际应用场景，让我们感受到枚举的强大功能。
|
||||
|
||||
## 11. 补充
|
||||
|
||||
我们在上面讲到了，我们可以通过在枚举类型中定义属性,方法和构造函数让它变得更加强大。
|
||||
|
||||
下面我通过一个实际的例子展示一下，当我们调用短信验证码的时候可能有几种不同的用途，我们在下面这样定义：
|
||||
|
||||
```java
|
||||
|
||||
public enum PinType {
|
||||
|
||||
REGISTER(100000, "注册使用"),
|
||||
FORGET_PASSWORD(100001, "忘记密码使用"),
|
||||
UPDATE_PHONE_NUMBER(100002, "更新手机号码使用");
|
||||
|
||||
private final int code;
|
||||
private final String message;
|
||||
|
||||
PinType(int code, String message) {
|
||||
this.code = code;
|
||||
this.message = message;
|
||||
}
|
||||
|
||||
public int getCode() {
|
||||
return code;
|
||||
}
|
||||
|
||||
public String getMessage() {
|
||||
return message;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "PinType{" +
|
||||
"code=" + code +
|
||||
", message='" + message + '\'' +
|
||||
'}';
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
实际使用：
|
||||
|
||||
```java
|
||||
System.out.println(PinType.FORGET_PASSWORD.getCode());
|
||||
System.out.println(PinType.FORGET_PASSWORD.getMessage());
|
||||
System.out.println(PinType.FORGET_PASSWORD.toString());
|
||||
```
|
||||
|
||||
Output:
|
||||
|
||||
```java
|
||||
100001
|
||||
忘记密码使用
|
||||
PinType{code=100001, message='忘记密码使用'}
|
||||
```
|
||||
|
||||
这样的话，在实际使用起来就会非常灵活方便！
|
||||
@ -1,3 +1,5 @@
|
||||
点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。
|
||||
|
||||
<!-- MarkdownTOC -->
|
||||
|
||||
- [Servlet总结](#servlet总结)
|
||||
@ -26,7 +28,7 @@
|
||||
|
||||
## Servlet总结
|
||||
|
||||
在Java Web程序中，**Servlet**主要负责接收用户请求**HttpServletRequest**,在**doGet()**,**doPost()**中做相应的处理，并将回应**HttpServletResponse**反馈给用户。Servlet可以设置初始化参数，供Servlet内部使用。一个Servlet类只会有一个实例，在它初始化时调用**init()方法**，销毁时调用**destroy()方法**。**Servlet需要在web.xml中配置**（MyEclipse中创建Servlet会自动配置），**一个Servlet可以设置多个URL访问**。**Servlet不是线程安全**，因此要谨慎使用类变量。
|
||||
在Java Web程序中，**Servlet**主要负责接收用户请求 `HttpServletRequest`,在`doGet()`,`doPost()`中做相应的处理，并将回应`HttpServletResponse`反馈给用户。**Servlet** 可以设置初始化参数，供Servlet内部使用。一个Servlet类只会有一个实例，在它初始化时调用`init()`方法，销毁时调用`destroy()`方法**。**Servlet需要在web.xml中配置（MyEclipse中创建Servlet会自动配置），**一个Servlet可以设置多个URL访问**。**Servlet不是线程安全**，因此要谨慎使用类变量。
|
||||
|
||||
## 阐述Servlet和CGI的区别?
|
||||
|
||||
@ -55,33 +57,23 @@
|
||||
## Servlet接口中有哪些方法及Servlet生命周期探秘
|
||||
Servlet接口定义了5个方法，其中**前三个方法与Servlet生命周期相关**：
|
||||
|
||||
- **void init(ServletConfig config) throws ServletException**
|
||||
- **void service(ServletRequest req, ServletResponse resp) throws ServletException, java.io.IOException**
|
||||
- **void destory()**
|
||||
- java.lang.String getServletInfo()
|
||||
- ServletConfig getServletConfig()
|
||||
- `void init(ServletConfig config) throws ServletException`
|
||||
- `void service(ServletRequest req, ServletResponse resp) throws ServletException, java.io.IOException`
|
||||
- `void destroy()`
|
||||
- `java.lang.String getServletInfo()`
|
||||
- `ServletConfig getServletConfig()`
|
||||
|
||||
**生命周期：** **Web容器加载Servlet并将其实例化后，Servlet生命周期开始**，容器运行其**init()方法**进行Servlet的初始化；请求到达时调用Servlet的**service()方法**，service()方法会根据需要调用与请求对应的**doGet或doPost**等方法；当服务器关闭或项目被卸载时服务器会将Servlet实例销毁，此时会调用Servlet的**destroy()方法**。**init方法和destory方法只会执行一次，service方法客户端每次请求Servlet都会执行**。Servlet中有时会用到一些需要初始化与销毁的资源，因此可以把初始化资源的代码放入init方法中，销毁资源的代码放入destroy方法中，这样就不需要每次处理客户端的请求都要初始化与销毁资源。
|
||||
**生命周期：** **Web容器加载Servlet并将其实例化后，Servlet生命周期开始**，容器运行其**init()方法**进行Servlet的初始化；请求到达时调用Servlet的**service()方法**，service()方法会根据需要调用与请求对应的**doGet或doPost**等方法；当服务器关闭或项目被卸载时服务器会将Servlet实例销毁，此时会调用Servlet的**destroy()方法**。**init方法和destroy方法只会执行一次，service方法客户端每次请求Servlet都会执行**。Servlet中有时会用到一些需要初始化与销毁的资源，因此可以把初始化资源的代码放入init方法中，销毁资源的代码放入destroy方法中，这样就不需要每次处理客户端的请求都要初始化与销毁资源。
|
||||
|
||||
参考：《javaweb整合开发王者归来》P81
|
||||
|
||||
## get和post请求的区别
|
||||
|
||||
> 网上也有文章说：get和post请求实际上是没有区别，大家可以自行查询相关文章（参考文章：[https://www.cnblogs.com/logsharing/p/8448446.html](https://www.cnblogs.com/logsharing/p/8448446.html)，知乎对应的问题链接：[get和post区别？](https://www.zhihu.com/question/28586791)）！我下面给出的只是一种常见的答案。
|
||||
get和post请求实际上是没有区别，大家可以自行查询相关文章（参考文章：[https://www.cnblogs.com/logsharing/p/8448446.html](https://www.cnblogs.com/logsharing/p/8448446.html)，知乎对应的问题链接：[get和post区别？](https://www.zhihu.com/question/28586791)）！
|
||||
|
||||
①get请求用来从服务器上获得资源，而post是用来向服务器提交数据；
|
||||
可以把 get 和 post 当作两个不同的行为，两者并没有什么本质区别，底层都是 TCP 连接。 get请求用来从服务器上获得资源，而post是用来向服务器提交数据。比如你要获取人员列表可以用 get 请求，你需要创建一个人员可以用 post 。这也是 Restful API 最基本的一个要求。
|
||||
|
||||
②get将表单中数据按照name=value的形式，添加到action 所指向的URL 后面，并且两者使用"?"连接，而各个变量之间使用"&"连接；post是将表单中的数据放在HTTP协议的请求头或消息体中，传递到action所指向URL；
|
||||
|
||||
③get传输的数据要受到URL长度限制（最大长度是 2048 个字符）；而post可以传输大量的数据，上传文件通常要使用post方式；
|
||||
|
||||
④使用get时参数会显示在地址栏上，如果这些数据不是敏感数据，那么可以使用get；对于敏感数据还是应用使用post；
|
||||
|
||||
⑤get使用MIME类型application/x-www-form-urlencoded的URL编码（也叫百分号编码）文本的格式传递参数，保证被传送的参数由遵循规范的文本组成，例如一个空格的编码是"%20"。
|
||||
|
||||
补充：GET方式提交表单的典型应用是搜索引擎。GET方式就是被设计为查询用的。
|
||||
|
||||
还有另外一种回答。推荐大家看一下：
|
||||
推荐阅读：
|
||||
|
||||
- https://www.zhihu.com/question/28586791
|
||||
- https://mp.weixin.qq.com/s?__biz=MzI3NzIzMzg3Mw==&mid=100000054&idx=1&sn=71f6c214f3833d9ca20b9f7dcd9d33e4#rd
|
||||
@ -93,7 +85,7 @@ Form标签里的method的属性为get时调用doGet()，为post时调用doPost()
|
||||
|
||||
**转发是服务器行为，重定向是客户端行为。**
|
||||
|
||||
**转发（Forword）**
|
||||
**转发（Forward）**
|
||||
通过RequestDispatcher对象的forward（HttpServletRequest request,HttpServletResponse response）方法实现的。RequestDispatcher可以通过HttpServletRequest 的getRequestDispatcher()方法获得。例如下面的代码就是跳转到login_success.jsp页面。
|
||||
```java
|
||||
request.getRequestDispatcher("login_success.jsp").forward(request, response);
|
||||
@ -143,13 +135,11 @@ Response.setHeader("Refresh","5;URL=http://localhost:8080/servlet/example.htm");
|
||||
JSP是一种Servlet，但是与HttpServlet的工作方式不太一样。HttpServlet是先由源代码编译为class文件后部署到服务器下，为先编译后部署。而JSP则是先部署后编译。JSP会在客户端第一次请求JSP文件时被编译为HttpJspPage类（接口Servlet的一个子类）。该类会被服务器临时存放在服务器工作目录里面。下面通过实例给大家介绍。
|
||||
工程JspLoginDemo下有一个名为login.jsp的Jsp文件，把工程第一次部署到服务器上后访问这个Jsp文件，我们发现这个目录下多了下图这两个东东。
|
||||
.class文件便是JSP对应的Servlet。编译完毕后再运行class文件来响应客户端请求。以后客户端访问login.jsp的时候，Tomcat将不再重新编译JSP文件，而是直接调用class文件来响应客户端请求。
|
||||
|
||||
|
||||
由于JSP只会在客户端第一次请求的时候被编译 ，因此第一次请求JSP时会感觉比较慢，之后就会感觉快很多。如果把服务器保存的class文件删除，服务器也会重新编译JSP。
|
||||
|
||||
开发Web程序时经常需要修改JSP。Tomcat能够自动检测到JSP程序的改动。如果检测到JSP源代码发生了改动。Tomcat会在下次客户端请求JSP时重新编译JSP，而不需要重启Tomcat。这种自动检测功能是默认开启的，检测改动会消耗少量的时间，在部署Web应用的时候可以在web.xml中将它关掉。
|
||||
|
||||
|
||||
|
||||
参考：《javaweb整合开发王者归来》P97
|
||||
|
||||
## JSP有哪些内置对象、作用分别是什么
|
||||
@ -195,31 +185,31 @@ JSP有9个内置对象：
|
||||
## request.getAttribute()和 request.getParameter()有何区别
|
||||
**从获取方向来看：**
|
||||
|
||||
getParameter()是获取 POST/GET 传递的参数值；
|
||||
`getParameter()`是获取 POST/GET 传递的参数值；
|
||||
|
||||
getAttribute()是获取对象容器中的数据值；
|
||||
`getAttribute()`是获取对象容器中的数据值；
|
||||
|
||||
**从用途来看：**
|
||||
|
||||
getParameter用于客户端重定向时，即点击了链接或提交按扭时传值用，即用于在用表单或url重定向传值时接收数据用。
|
||||
`getParameter()`用于客户端重定向时，即点击了链接或提交按扭时传值用，即用于在用表单或url重定向传值时接收数据用。
|
||||
|
||||
getAttribute用于服务器端重定向时，即在 sevlet 中使用了 forward 函数,或 struts 中使用了
|
||||
`getAttribute()` 用于服务器端重定向时，即在 sevlet 中使用了 forward 函数,或 struts 中使用了
|
||||
mapping.findForward。 getAttribute 只能收到程序用 setAttribute 传过来的值。
|
||||
|
||||
另外，可以用 setAttribute,getAttribute 发送接收对象.而 getParameter 显然只能传字符串。
|
||||
setAttribute 是应用服务器把这个对象放在该页面所对应的一块内存中去，当你的页面服务器重定向到另一个页面时，应用服务器会把这块内存拷贝另一个页面所对应的内存中。这样getAttribute就能取得你所设下的值，当然这种方法可以传对象。session也一样，只是对象在内存中的生命周期不一样而已。getParameter只是应用服务器在分析你送上来的 request页面的文本时，取得你设在表单或 url 重定向时的值。
|
||||
另外，可以用 `setAttribute()`,`getAttribute()` 发送接收对象.而 `getParameter()` 显然只能传字符串。
|
||||
`setAttribute()` 是应用服务器把这个对象放在该页面所对应的一块内存中去，当你的页面服务器重定向到另一个页面时，应用服务器会把这块内存拷贝另一个页面所对应的内存中。这样`getAttribute()`就能取得你所设下的值，当然这种方法可以传对象。session也一样，只是对象在内存中的生命周期不一样而已。`getParameter()`只是应用服务器在分析你送上来的 request页面的文本时，取得你设在表单或 url 重定向时的值。
|
||||
|
||||
**总结：**
|
||||
|
||||
getParameter 返回的是String,用于读取提交的表单中的值;（获取之后会根据实际需要转换为自己需要的相应类型，比如整型，日期类型啊等等）
|
||||
`getParameter()`返回的是String,用于读取提交的表单中的值;（获取之后会根据实际需要转换为自己需要的相应类型，比如整型，日期类型啊等等）
|
||||
|
||||
getAttribute 返回的是Object，需进行转换,可用setAttribute 设置成任意对象，使用很灵活，可随时用
|
||||
`getAttribute()`返回的是Object，需进行转换,可用`setAttribute()`设置成任意对象，使用很灵活，可随时用
|
||||
|
||||
## include指令include的行为的区别
|
||||
**include指令：** JSP可以通过include指令来包含其他文件。被包含的文件可以是JSP文件、HTML文件或文本文件。包含的文件就好像是该JSP文件的一部分，会被同时编译执行。 语法格式如下：
|
||||
<%@ include file="文件相对 url 地址" %>
|
||||
|
||||
i**nclude动作：** <jsp:include>动作元素用来包含静态和动态的文件。该动作把指定文件插入正在生成的页面。语法格式如下：
|
||||
i**nclude动作：** `<jsp:include>`动作元素用来包含静态和动态的文件。该动作把指定文件插入正在生成的页面。语法格式如下：
|
||||
<jsp:include page="相对 URL 地址" flush="true" />
|
||||
|
||||
## JSP九大内置对象，七大动作，三大指令
|
||||
@ -232,11 +222,9 @@ JSP中的四种作用域包括page、request、session和application，具体来
|
||||
- **session**代表与某个用户与服务器建立的一次会话相关的对象和属性。跟某个用户相关的数据应该放在用户自己的session中。
|
||||
- **application**代表与整个Web应用程序相关的对象和属性，它实质上是跨越整个Web应用程序，包括多个页面、请求和会话的一个全局作用域。
|
||||
|
||||
|
||||
|
||||
## 如何实现JSP或Servlet的单线程模式
|
||||
对于JSP页面，可以通过page指令进行设置。
|
||||
<%@page isThreadSafe=”false”%>
|
||||
`<%@page isThreadSafe="false"%>`
|
||||
|
||||
对于Servlet，可以让自定义的Servlet实现SingleThreadModel标识接口。
|
||||
|
||||
@ -294,12 +282,20 @@ if(cookies !=null){
|
||||
在所有会话跟踪技术中，HttpSession对象是最强大也是功能最多的。当一个用户第一次访问某个网站时会自动创建 HttpSession，每个用户可以访问他自己的HttpSession。可以通过HttpServletRequest对象的getSession方 法获得HttpSession，通过HttpSession的setAttribute方法可以将一个值放在HttpSession中，通过调用 HttpSession对象的getAttribute方法，同时传入属性名就可以获取保存在HttpSession中的对象。与上面三种方式不同的 是，HttpSession放在服务器的内存中，因此不要将过大的对象放在里面，即使目前的Servlet容器可以在内存将满时将HttpSession 中的对象移到其他存储设备中，但是这样势必影响性能。添加到HttpSession中的值可以是任意Java对象，这个对象最好实现了 Serializable接口，这样Servlet容器在必要的时候可以将其序列化到文件中，否则在序列化时就会出现异常。
|
||||
## Cookie和Session的的区别
|
||||
|
||||
1. 由于HTTP协议是无状态的协议，所以服务端需要记录用户的状态时，就需要用某种机制来识具体的用户，这个机制就是Session.典型的场景比如购物车，当你点击下单按钮时，由于HTTP协议无状态，所以并不知道是哪个用户操作的，所以服务端要为特定的用户创建了特定的Session，用用于标识这个用户，并且跟踪用户，这样才知道购物车里面有几本书。这个Session是保存在服务端的，有一个唯一标识。在服务端保存Session的方法很多，内存、数据库、文件都有。集群的时候也要考虑Session的转移，在大型的网站，一般会有专门的Session服务器集群，用来保存用户会话，这个时候 Session 信息都是放在内存的，使用一些缓存服务比如Memcached之类的来放 Session。
|
||||
2. 思考一下服务端如何识别特定的客户？这个时候Cookie就登场了。每次HTTP请求的时候，客户端都会发送相应的Cookie信息到服务端。实际上大多数的应用都是用 Cookie 来实现Session跟踪的，第一次创建Session的时候，服务端会在HTTP协议中告诉客户端，需要在 Cookie 里面记录一个Session ID，以后每次请求把这个会话ID发送到服务器，我就知道你是谁了。有人问，如果客户端的浏览器禁用了 Cookie 怎么办？一般这种情况下，会使用一种叫做URL重写的技术来进行会话跟踪，即每次HTTP交互，URL后面都会被附加上一个诸如 sid=xxxxx 这样的参数，服务端据此来识别用户。
|
||||
3. Cookie其实还可以用在一些方便用户的场景下，设想你某次登陆过一个网站，下次登录的时候不想再次输入账号了，怎么办？这个信息可以写到Cookie里面，访问网站的时候，网站页面的脚本可以读取这个信息，就自动帮你把用户名给填了，能够方便一下用户。这也是Cookie名称的由来，给用户的一点甜头。所以，总结一下：Session是在服务端保存的一个数据结构，用来跟踪用户的状态，这个数据可以保存在集群、数据库、文件中；Cookie是客户端保存用户信息的一种机制，用来记录用户的一些信息，也是实现Session的一种方式。
|
||||
Cookie 和 Session都是用来跟踪浏览器用户身份的会话方式，但是两者的应用场景不太一样。
|
||||
|
||||
参考：
|
||||
**Cookie 一般用来保存用户信息** 比如①我们在 Cookie 中保存已经登录过得用户信息，下次访问网站的时候页面可以自动帮你登录的一些基本信息给填了；②一般的网站都会有保持登录也就是说下次你再访问网站的时候就不需要重新登录了，这是因为用户登录的时候我们可以存放了一个 Token 在 Cookie 中，下次登录的时候只需要根据 Token 值来查找用户即可(为了安全考虑，重新登录一般要将 Token 重写)；③登录一次网站后访问网站其他页面不需要重新登录。**Session 的主要作用就是通过服务端记录用户的状态。** 典型的场景是购物车，当你要添加商品到购物车的时候，系统不知道是哪个用户操作的，因为 HTTP 协议是无状态的。服务端给特定的用户创建特定的 Session 之后就可以标识这个用户并且跟踪这个用户了。
|
||||
|
||||
https://www.zhihu.com/question/19786827/answer/28752144
|
||||
Cookie 数据保存在客户端(浏览器端)，Session 数据保存在服务器端。
|
||||
|
||||
《javaweb整合开发王者归来》P158 Cookie和Session的比较
|
||||
Cookie 存储在客户端中，而Session存储在服务器上，相对来说 Session 安全性更高。如果使用 Cookie 的一些敏感信息不要写入 Cookie 中，最好能将 Cookie 信息加密然后使用到的时候再去服务器端解密。
|
||||
|
||||
## 公众号
|
||||
|
||||
如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。
|
||||
|
||||
**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"Java面试突击"** 即可免费领取！
|
||||
|
||||
**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
|
||||
|
||||
|
||||
@ -27,12 +27,12 @@
|
||||
|
||||
**（1） 按操作方式分类结构图：**
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
**（2）按操作对象分类结构图**
|
||||
|
||||
|
||||
|
||||
|
||||
### [二 java IO体系的学习总结](https://blog.csdn.net/nightcurtis/article/details/51324105)
|
||||
1. **IO流的分类：**
|
||||
@ -92,7 +92,7 @@
|
||||
- 写入数据到缓冲区（Writing Data to a Buffer）
|
||||
|
||||
**写数据到Buffer有两种方法：**
|
||||
|
||||
|
||||
1.从Channel中写数据到Buffer
|
||||
```java
|
||||
int bytesRead = inChannel.read(buf); //read into buffer.
|
||||
@ -103,7 +103,7 @@
|
||||
```
|
||||
|
||||
4. **Buffer常用方法测试**
|
||||
|
||||
|
||||
说实话，NIO编程真的难，通过后面这个测试例子，你可能才能勉强理解前面说的Buffer方法的作用。
|
||||
|
||||
|
||||
556
docs/java/Java基础知识.md
Normal file
556
docs/java/Java基础知识.md
Normal file
@ -0,0 +1,556 @@
|
||||
点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。
|
||||
|
||||
<!-- TOC -->
|
||||
|
||||
- [1. 面向对象和面向过程的区别](#1-面向对象和面向过程的区别)
|
||||
- [2. Java 语言有哪些特点?](#2-java-语言有哪些特点)
|
||||
- [3. 关于 JVM JDK 和 JRE 最详细通俗的解答](#3-关于-jvm-jdk-和-jre-最详细通俗的解答)
|
||||
- [JVM](#jvm)
|
||||
- [JDK 和 JRE](#jdk-和-jre)
|
||||
- [4. Oracle JDK 和 OpenJDK 的对比](#4-oracle-jdk-和-openjdk-的对比)
|
||||
- [5. Java和C++的区别?](#5-java和c的区别)
|
||||
- [6. 什么是 Java 程序的主类 应用程序和小程序的主类有何不同?](#6-什么是-java-程序的主类-应用程序和小程序的主类有何不同)
|
||||
- [7. Java 应用程序与小程序之间有哪些差别?](#7-java-应用程序与小程序之间有哪些差别)
|
||||
- [8. 字符型常量和字符串常量的区别?](#8-字符型常量和字符串常量的区别)
|
||||
- [9. 构造器 Constructor 是否可被 override?](#9-构造器-constructor-是否可被-override)
|
||||
- [10. 重载和重写的区别](#10-重载和重写的区别)
|
||||
- [11. Java 面向对象编程三大特性: 封装 继承 多态](#11-java-面向对象编程三大特性-封装-继承-多态)
|
||||
- [封装](#封装)
|
||||
- [继承](#继承)
|
||||
- [多态](#多态)
|
||||
- [12. String StringBuffer 和 StringBuilder 的区别是什么? String 为什么是不可变的?](#12-string-stringbuffer-和-stringbuilder-的区别是什么-string-为什么是不可变的)
|
||||
- [13. 自动装箱与拆箱](#13-自动装箱与拆箱)
|
||||
- [14. 在一个静态方法内调用一个非静态成员为什么是非法的?](#14-在一个静态方法内调用一个非静态成员为什么是非法的)
|
||||
- [15. 在 Java 中定义一个不做事且没有参数的构造方法的作用](#15-在-java-中定义一个不做事且没有参数的构造方法的作用)
|
||||
- [16. import java和javax有什么区别？](#16-import-java和javax有什么区别)
|
||||
- [17. 接口和抽象类的区别是什么？](#17-接口和抽象类的区别是什么)
|
||||
- [18. 成员变量与局部变量的区别有哪些？](#18-成员变量与局部变量的区别有哪些)
|
||||
- [19. 创建一个对象用什么运算符?对象实体与对象引用有何不同?](#19-创建一个对象用什么运算符对象实体与对象引用有何不同)
|
||||
- [20. 什么是方法的返回值?返回值在类的方法里的作用是什么?](#20-什么是方法的返回值返回值在类的方法里的作用是什么)
|
||||
- [21. 一个类的构造方法的作用是什么? 若一个类没有声明构造方法，该程序能正确执行吗? 为什么?](#21-一个类的构造方法的作用是什么-若一个类没有声明构造方法该程序能正确执行吗-为什么)
|
||||
- [22. 构造方法有哪些特性？](#22-构造方法有哪些特性)
|
||||
- [23. 静态方法和实例方法有何不同](#23-静态方法和实例方法有何不同)
|
||||
- [24. 对象的相等与指向他们的引用相等,两者有什么不同?](#24-对象的相等与指向他们的引用相等两者有什么不同)
|
||||
- [25. 在调用子类构造方法之前会先调用父类没有参数的构造方法,其目的是?](#25-在调用子类构造方法之前会先调用父类没有参数的构造方法其目的是)
|
||||
- [26. == 与 equals(重要)](#26--与-equals重要)
|
||||
- [27. hashCode 与 equals (重要)](#27-hashcode-与-equals-重要)
|
||||
- [hashCode（）介绍](#hashcode介绍)
|
||||
- [为什么要有 hashCode](#为什么要有-hashcode)
|
||||
- [hashCode（）与equals（）的相关规定](#hashcode与equals的相关规定)
|
||||
- [28. 为什么Java中只有值传递？](#28-为什么java中只有值传递)
|
||||
- [29. 简述线程、程序、进程的基本概念。以及他们之间关系是什么?](#29-简述线程程序进程的基本概念以及他们之间关系是什么)
|
||||
- [30. 线程有哪些基本状态?](#30-线程有哪些基本状态)
|
||||
- [31 关于 final 关键字的一些总结](#31-关于-final-关键字的一些总结)
|
||||
- [32 Java 中的异常处理](#32-java-中的异常处理)
|
||||
- [Java异常类层次结构图](#java异常类层次结构图)
|
||||
- [Throwable类常用方法](#throwable类常用方法)
|
||||
- [异常处理总结](#异常处理总结)
|
||||
- [33 Java序列化中如果有些字段不想进行序列化，怎么办？](#33-java序列化中如果有些字段不想进行序列化怎么办)
|
||||
- [34 获取用键盘输入常用的两种方法](#34-获取用键盘输入常用的两种方法)
|
||||
- [35 Java 中 IO 流](#35-java-中-io-流)
|
||||
- [Java 中 IO 流分为几种?](#java-中-io-流分为几种)
|
||||
- [既然有了字节流,为什么还要有字符流?](#既然有了字节流为什么还要有字符流)
|
||||
- [BIO,NIO,AIO 有什么区别?](#bionioaio-有什么区别)
|
||||
- [36. 常见关键字总结:static,final,this,super](#36-常见关键字总结staticfinalthissuper)
|
||||
- [37. Collections 工具类和 Arrays 工具类常见方法总结](#37-collections-工具类和-arrays-工具类常见方法总结)
|
||||
- [参考](#参考)
|
||||
- [公众号](#公众号)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
## 1. 面向对象和面向过程的区别
|
||||
|
||||
- **面向过程** ：**面向过程性能比面向对象高。** 因为类调用时需要实例化，开销比较大，比较消耗资源，所以当性能是最重要的考量因素的时候，比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发。但是，**面向过程没有面向对象易维护、易复用、易扩展。**
|
||||
- **面向对象** ：**面向对象易维护、易复用、易扩展。** 因为面向对象有封装、继承、多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护。但是，**面向对象性能比面向过程低**。
|
||||
|
||||
参见 issue : [面向过程 ：面向过程性能比面向对象高？？](https://github.com/Snailclimb/JavaGuide/issues/431)
|
||||
|
||||
> 这个并不是根本原因，面向过程也需要分配内存，计算内存偏移量，Java性能差的主要原因并不是因为它是面向对象语言，而是Java是半编译语言，最终的执行代码并不是可以直接被CPU执行的二进制机械码。
|
||||
>
|
||||
> 而面向过程语言大多都是直接编译成机械码在电脑上执行，并且其它一些面向过程的脚本语言性能也并不一定比Java好。
|
||||
|
||||
## 2. Java 语言有哪些特点?
|
||||
|
||||
1. 简单易学；
|
||||
2. 面向对象（封装，继承，多态）；
|
||||
3. 平台无关性（ Java 虚拟机实现平台无关性）；
|
||||
4. 可靠性；
|
||||
5. 安全性；
|
||||
6. 支持多线程（ C++ 语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而 Java 语言却提供了多线程支持）；
|
||||
7. 支持网络编程并且很方便（ Java 语言诞生本身就是为简化网络编程设计的，因此 Java 语言不仅支持网络编程而且很方便）；
|
||||
8. 编译与解释并存；
|
||||
|
||||
> 修正（参见： [issue#544](https://github.com/Snailclimb/JavaGuide/issues/544)）：C++11开始（2011年的时候）,C++就引入了多线程库，在windows、linux、macos都可以使用`std::thread`和`std::async`来创建线程。参考链接：http://www.cplusplus.com/reference/thread/thread/?kw=thread
|
||||
|
||||
## 3. 关于 JVM JDK 和 JRE 最详细通俗的解答
|
||||
|
||||
### JVM
|
||||
|
||||
Java虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。
|
||||
|
||||
**什么是字节码?采用字节码的好处是什么?**
|
||||
|
||||
> 在 Java 中，JVM可以理解的代码就叫做`字节码`（即扩展名为 `.class` 的文件），它不面向任何特定的处理器，只面向虚拟机。Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比较高效，而且，由于字节码并不针对一种特定的机器，因此，Java程序无须重新编译便可在多种不同操作系统的计算机上运行。
|
||||
|
||||
**Java 程序从源代码到运行一般有下面3步：**
|
||||
|
||||
|
||||
|
||||
我们需要格外注意的是 .class->机器码 这一步。在这一步 JVM 类加载器首先加载字节码文件，然后通过解释器逐行解释执行，这种方式的执行速度会相对比较慢。而且，有些方法和代码块是经常需要被调用的(也就是所谓的热点代码)，所以后面引进了 JIT 编译器，而JIT 属于运行时编译。当 JIT 编译器完成第一次编译后，其会将字节码对应的机器码保存下来，下次可以直接使用。而我们知道，机器码的运行效率肯定是高于 Java 解释器的。这也解释了我们为什么经常会说 Java 是编译与解释共存的语言。
|
||||
|
||||
> HotSpot采用了惰性评估(Lazy Evaluation)的做法，根据二八定律，消耗大部分系统资源的只有那一小部分的代码（热点代码），而这也就是JIT所需要编译的部分。JVM会根据代码每次被执行的情况收集信息并相应地做出一些优化，因此执行的次数越多，它的速度就越快。JDK 9引入了一种新的编译模式AOT(Ahead of Time Compilation)，它是直接将字节码编译成机器码，这样就避免了JIT预热等各方面的开销。JDK支持分层编译和AOT协作使用。但是 ，AOT 编译器的编译质量是肯定比不上 JIT 编译器的。
|
||||
|
||||
**总结：**
|
||||
|
||||
Java虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。
|
||||
|
||||
### JDK 和 JRE
|
||||
|
||||
JDK是Java Development Kit，它是功能齐全的Java SDK。它拥有JRE所拥有的一切，还有编译器（javac）和工具（如javadoc和jdb）。它能够创建和编译程序。
|
||||
|
||||
JRE 是 Java运行时环境。它是运行已编译 Java 程序所需的所有内容的集合，包括 Java虚拟机（JVM），Java类库，java命令和其他的一些基础构件。但是，它不能用于创建新程序。
|
||||
|
||||
如果你只是为了运行一下 Java 程序的话，那么你只需要安装 JRE 就可以了。如果你需要进行一些 Java 编程方面的工作，那么你就需要安装JDK了。但是，这不是绝对的。有时，即使您不打算在计算机上进行任何Java开发，仍然需要安装JDK。例如，如果要使用JSP部署Web应用程序，那么从技术上讲，您只是在应用程序服务器中运行Java程序。那你为什么需要JDK呢？因为应用程序服务器会将 JSP 转换为 Java servlet，并且需要使用 JDK 来编译 servlet。
|
||||
|
||||
## 4. Oracle JDK 和 OpenJDK 的对比
|
||||
|
||||
可能在看这个问题之前很多人和我一样并没有接触和使用过 OpenJDK 。那么Oracle和OpenJDK之间是否存在重大差异？下面我通过收集到的一些资料，为你解答这个被很多人忽视的问题。
|
||||
|
||||
对于Java 7，没什么关键的地方。OpenJDK项目主要基于Sun捐赠的HotSpot源代码。此外，OpenJDK被选为Java 7的参考实现，由Oracle工程师维护。关于JVM，JDK，JRE和OpenJDK之间的区别，Oracle博客帖子在2012年有一个更详细的答案：
|
||||
|
||||
> 问：OpenJDK存储库中的源代码与用于构建Oracle JDK的代码之间有什么区别？
|
||||
>
|
||||
> 答：非常接近 - 我们的Oracle JDK版本构建过程基于OpenJDK 7构建，只添加了几个部分，例如部署代码，其中包括Oracle的Java插件和Java WebStart的实现，以及一些封闭的源代码派对组件，如图形光栅化器，一些开源的第三方组件，如Rhino，以及一些零碎的东西，如附加文档或第三方字体。展望未来，我们的目的是开源Oracle JDK的所有部分，除了我们考虑商业功能的部分。
|
||||
|
||||
**总结：**
|
||||
|
||||
1. Oracle JDK大概每6个月发一次主要版本，而OpenJDK版本大概每三个月发布一次。但这不是固定的，我觉得了解这个没啥用处。详情参见：https://blogs.oracle.com/java-platform-group/update-and-faq-on-the-java-se-release-cadence。
|
||||
2. OpenJDK 是一个参考模型并且是完全开源的，而Oracle JDK是OpenJDK的一个实现，并不是完全开源的；
|
||||
3. Oracle JDK 比 OpenJDK 更稳定。OpenJDK和Oracle JDK的代码几乎相同，但Oracle JDK有更多的类和一些错误修复。因此，如果您想开发企业/商业软件，我建议您选择Oracle JDK，因为它经过了彻底的测试和稳定。某些情况下，有些人提到在使用OpenJDK 可能会遇到了许多应用程序崩溃的问题，但是，只需切换到Oracle JDK就可以解决问题；
|
||||
4. 在响应性和JVM性能方面，Oracle JDK与OpenJDK相比提供了更好的性能；
|
||||
5. Oracle JDK不会为即将发布的版本提供长期支持，用户每次都必须通过更新到最新版本获得支持来获取最新版本；
|
||||
6. Oracle JDK根据二进制代码许可协议获得许可，而OpenJDK根据GPL v2许可获得许可。
|
||||
|
||||
## 5. Java和C++的区别?
|
||||
|
||||
我知道很多人没学过 C++，但是面试官就是没事喜欢拿咱们 Java 和 C++ 比呀！没办法！！！就算没学过C++，也要记下来！
|
||||
|
||||
- 都是面向对象的语言，都支持封装、继承和多态
|
||||
- Java 不提供指针来直接访问内存，程序内存更加安全
|
||||
- Java 的类是单继承的，C++ 支持多重继承；虽然 Java 的类不可以多继承，但是接口可以多继承。
|
||||
- Java 有自动内存管理机制，不需要程序员手动释放无用内存
|
||||
- **在 C 语言中，字符串或字符数组最后都会有一个额外的字符‘\0’来表示结束。但是，Java 语言中没有结束符这一概念。** 这是一个值得深度思考的问题，具体原因推荐看这篇文章： [https://blog.csdn.net/sszgg2006/article/details/49148189]( https://blog.csdn.net/sszgg2006/article/details/49148189)
|
||||
|
||||
|
||||
## 6. 什么是 Java 程序的主类 应用程序和小程序的主类有何不同?
|
||||
|
||||
一个程序中可以有多个类，但只能有一个类是主类。在 Java 应用程序中，这个主类是指包含 main（）方法的类。而在 Java 小程序中，这个主类是一个继承自系统类 JApplet 或 Applet 的子类。应用程序的主类不一定要求是 public 类，但小程序的主类要求必须是 public 类。主类是 Java 程序执行的入口点。
|
||||
|
||||
## 7. Java 应用程序与小程序之间有哪些差别?
|
||||
|
||||
简单说应用程序是从主线程启动(也就是 `main()` 方法)。applet 小程序没有 `main()` 方法，主要是嵌在浏览器页面上运行(调用`init()`或者`run()`来启动)，嵌入浏览器这点跟 flash 的小游戏类似。
|
||||
|
||||
## 8. 字符型常量和字符串常量的区别?
|
||||
|
||||
1. 形式上: 字符常量是单引号引起的一个字符; 字符串常量是双引号引起的若干个字符
|
||||
2. 含义上: 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)
|
||||
3. 占内存大小 字符常量只占2个字节; 字符串常量占若干个字节 (**注意： char在Java中占两个字节**)
|
||||
|
||||
> java编程思想第四版：2.2.2节
|
||||
|
||||
|
||||
## 9. 构造器 Constructor 是否可被 override?
|
||||
|
||||
Constructor 不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况。
|
||||
|
||||
## 10. 重载和重写的区别
|
||||
|
||||
#### 重载
|
||||
|
||||
发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同。
|
||||
|
||||
下面是《Java核心技术》对重载这个概念的介绍：
|
||||
|
||||
|
||||
|
||||
#### 重写
|
||||
|
||||
重写是子类对父类的允许访问的方法的实现过程进行重新编写,发生在子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。另外，如果父类方法访问修饰符为 private 则子类就不能重写该方法。**也就是说方法提供的行为改变，而方法的外貌并没有改变。**
|
||||
|
||||
## 11. Java 面向对象编程三大特性: 封装 继承 多态
|
||||
|
||||
### 封装
|
||||
|
||||
封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。
|
||||
|
||||
|
||||
### 继承
|
||||
继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码。
|
||||
|
||||
**关于继承如下 3 点请记住：**
|
||||
|
||||
1. 子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，**只是拥有**。
|
||||
2. 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
|
||||
3. 子类可以用自己的方式实现父类的方法。（以后介绍）。
|
||||
|
||||
### 多态
|
||||
|
||||
所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
|
||||
|
||||
在Java中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）。
|
||||
|
||||
## 12. String StringBuffer 和 StringBuilder 的区别是什么? String 为什么是不可变的?
|
||||
|
||||
**可变性**
|
||||
|
||||
简单的来说：String 类中使用 final 关键字修饰字符数组来保存字符串，`private final char value[]`，所以 String 对象是不可变的。而StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串`char[]value` 但是没有用 final 关键字修饰，所以这两种对象都是可变的。
|
||||
|
||||
StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是 AbstractStringBuilder 实现的，大家可以自行查阅源码。
|
||||
|
||||
AbstractStringBuilder.java
|
||||
|
||||
```java
|
||||
abstract class AbstractStringBuilder implements Appendable, CharSequence {
|
||||
char[] value;
|
||||
int count;
|
||||
AbstractStringBuilder() {
|
||||
}
|
||||
AbstractStringBuilder(int capacity) {
|
||||
value = new char[capacity];
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
**线程安全性**
|
||||
|
||||
String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。
|
||||
|
||||
**性能**
|
||||
|
||||
每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
|
||||
|
||||
**对于三者使用的总结：**
|
||||
|
||||
1. 操作少量的数据: 适用String
|
||||
2. 单线程操作字符串缓冲区下操作大量数据: 适用StringBuilder
|
||||
3. 多线程操作字符串缓冲区下操作大量数据: 适用StringBuffer
|
||||
|
||||
## 13. 自动装箱与拆箱
|
||||
|
||||
- **装箱**：将基本类型用它们对应的引用类型包装起来；
|
||||
- **拆箱**：将包装类型转换为基本数据类型；
|
||||
|
||||
## 14. 在一个静态方法内调用一个非静态成员为什么是非法的?
|
||||
|
||||
由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。
|
||||
|
||||
## 15. 在 Java 中定义一个不做事且没有参数的构造方法的作用
|
||||
|
||||
Java 程序在执行子类的构造方法之前，如果没有用 `super() `来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 `super() `来调用父类中特定的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。
|
||||
|
||||
## 16. import java和javax有什么区别？
|
||||
|
||||
刚开始的时候 JavaAPI 所必需的包是 java 开头的包，javax 当时只是扩展 API 包来使用。然而随着时间的推移，javax 逐渐地扩展成为 Java API 的组成部分。但是，将扩展从 javax 包移动到 java 包确实太麻烦了，最终会破坏一堆现有的代码。因此，最终决定 javax 包将成为标准API的一部分。
|
||||
|
||||
所以，实际上java和javax没有区别。这都是一个名字。
|
||||
|
||||
## 17. 接口和抽象类的区别是什么？
|
||||
|
||||
1. 接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现），而抽象类可以有非抽象的方法。
|
||||
2. 接口中除了static、final变量，不能有其他变量，而抽象类中则不一定。
|
||||
3. 一个类可以实现多个接口，但只能实现一个抽象类。接口自己本身可以通过extends关键字扩展多个接口。
|
||||
4. 接口方法默认修饰符是public，抽象方法可以有public、protected和default这些修饰符（抽象方法就是为了被重写所以不能使用private关键字修饰！）。
|
||||
5. 从设计层面来说，抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范。
|
||||
|
||||
备注：在JDK8中，接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。如果同时实现两个接口，接口中定义了一样的默认方法，则必须重写，不然会报错。(详见issue:[https://github.com/Snailclimb/JavaGuide/issues/146](https://github.com/Snailclimb/JavaGuide/issues/146))
|
||||
|
||||
## 18. 成员变量与局部变量的区别有哪些？
|
||||
|
||||
1. 从语法形式上看:成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
|
||||
2. 从变量在内存中的存储方式来看:如果成员变量是使用`static`修饰的，那么这个成员变量是属于类的，如果没有使用`static`修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
|
||||
3. 从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。
|
||||
4. 成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。
|
||||
|
||||
## 19. 创建一个对象用什么运算符?对象实体与对象引用有何不同?
|
||||
|
||||
new运算符，new创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。一个对象引用可以指向0个或1个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有n个引用指向它（可以用n条绳子系住一个气球）。
|
||||
|
||||
## 20. 什么是方法的返回值?返回值在类的方法里的作用是什么?
|
||||
|
||||
方法的返回值是指我们获取到的某个方法体中的代码执行后产生的结果！（前提是该方法可能产生结果）。返回值的作用:接收出结果，使得它可以用于其他的操作！
|
||||
|
||||
## 21. 一个类的构造方法的作用是什么? 若一个类没有声明构造方法，该程序能正确执行吗? 为什么?
|
||||
|
||||
主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。
|
||||
|
||||
## 22. 构造方法有哪些特性？
|
||||
|
||||
1. 名字与类名相同。
|
||||
2. 没有返回值，但不能用void声明构造函数。
|
||||
3. 生成类的对象时自动执行，无需调用。
|
||||
|
||||
## 23. 静态方法和实例方法有何不同
|
||||
|
||||
1. 在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
|
||||
|
||||
2. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。
|
||||
|
||||
## 24. 对象的相等与指向他们的引用相等,两者有什么不同?
|
||||
|
||||
对象的相等，比的是内存中存放的内容是否相等。而引用相等，比较的是他们指向的内存地址是否相等。
|
||||
|
||||
## 25. 在调用子类构造方法之前会先调用父类没有参数的构造方法,其目的是?
|
||||
|
||||
帮助子类做初始化工作。
|
||||
|
||||
## 26. == 与 equals(重要)
|
||||
|
||||
**==** : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象(基本数据类型==比较的是值，引用数据类型==比较的是内存地址)。
|
||||
|
||||
**equals()** : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：
|
||||
- 情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。
|
||||
- 情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来比较两个对象的内容是否相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。
|
||||
|
||||
|
||||
**举个例子：**
|
||||
|
||||
```java
|
||||
public class test1 {
|
||||
public static void main(String[] args) {
|
||||
String a = new String("ab"); // a 为一个引用
|
||||
String b = new String("ab"); // b为另一个引用,对象的内容一样
|
||||
String aa = "ab"; // 放在常量池中
|
||||
String bb = "ab"; // 从常量池中查找
|
||||
if (aa == bb) // true
|
||||
System.out.println("aa==bb");
|
||||
if (a == b) // false，非同一对象
|
||||
System.out.println("a==b");
|
||||
if (a.equals(b)) // true
|
||||
System.out.println("aEQb");
|
||||
if (42 == 42.0) { // true
|
||||
System.out.println("true");
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**说明：**
|
||||
|
||||
- String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是对象的值。
|
||||
- 当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。
|
||||
|
||||
## 27. hashCode 与 equals (重要)
|
||||
|
||||
面试官可能会问你：“你重写过 hashcode 和 equals 么，为什么重写equals时必须重写hashCode方法？”
|
||||
|
||||
### hashCode（）介绍
|
||||
hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。
|
||||
|
||||
散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）
|
||||
|
||||
### 为什么要有 hashCode
|
||||
|
||||
**我们先以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：** 当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 `equals()`方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自我的Java启蒙书《Head first java》第二版）。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。
|
||||
|
||||
通过我们可以看出：`hashCode()` 的作用就是**获取哈希码**，也称为散列码；它实际上是返回一个int整数。这个**哈希码的作用**是确定该对象在哈希表中的索引位置。**`hashCode() `在散列表中才有用，在其它情况下没用**。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。
|
||||
|
||||
### hashCode（）与equals（）的相关规定
|
||||
|
||||
1. 如果两个对象相等，则hashcode一定也是相同的
|
||||
2. 两个对象相等,对两个对象分别调用equals方法都返回true
|
||||
3. 两个对象有相同的hashcode值，它们也不一定是相等的
|
||||
4. **因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖**
|
||||
5. hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）
|
||||
|
||||
推荐阅读：[Java hashCode() 和 equals()的若干问题解答](https://www.cnblogs.com/skywang12345/p/3324958.html)
|
||||
|
||||
|
||||
## 28. 为什么Java中只有值传递？
|
||||
|
||||
[为什么Java中只有值传递？](https://juejin.im/post/5e18879e6fb9a02fc63602e2)
|
||||
|
||||
|
||||
## 29. 简述线程、程序、进程的基本概念。以及他们之间关系是什么?
|
||||
|
||||
**线程**与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
|
||||
|
||||
**程序**是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。
|
||||
|
||||
**进程**是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。
|
||||
线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。
|
||||
|
||||
## 30. 线程有哪些基本状态?
|
||||
|
||||
Java 线程在运行的生命周期中的指定时刻只可能处于下面6种不同状态的其中一个状态（图源《Java 并发编程艺术》4.1.4节）。
|
||||
|
||||
|
||||
|
||||
线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变迁如下图所示（图源《Java 并发编程艺术》4.1.4节）：
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
由上图可以看出：
|
||||
|
||||
线程创建之后它将处于 **NEW（新建）** 状态，调用 `start()` 方法后开始运行，线程这时候处于 **READY（可运行）** 状态。可运行状态的线程获得了 cpu 时间片（timeslice）后就处于 **RUNNING（运行）** 状态。
|
||||
|
||||
> 操作系统隐藏 Java虚拟机（JVM）中的 READY 和 RUNNING 状态，它只能看到 RUNNABLE 状态（图源：[HowToDoInJava](https://howtodoinjava.com/)：[Java Thread Life Cycle and Thread States](https://howtodoinjava.com/java/multi-threading/java-thread-life-cycle-and-thread-states/)），所以 Java 系统一般将这两个状态统称为 **RUNNABLE（运行中）** 状态 。
|
||||
|
||||
|
||||
|
||||
当线程执行 `wait()`方法之后，线程进入 **WAITING（等待）**状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而 **TIME_WAITING(超时等待)** 状态相当于在等待状态的基础上增加了超时限制，比如通过 `sleep（long millis）`方法或 `wait（long millis）`方法可以将 Java 线程置于 TIMED WAITING 状态。当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到 **BLOCKED（阻塞）** 状态。线程在执行 Runnable 的` run() `方法之后将会进入到 **TERMINATED（终止）** 状态。
|
||||
|
||||
## 31 关于 final 关键字的一些总结
|
||||
|
||||
final关键字主要用在三个地方：变量、方法、类。
|
||||
|
||||
1. 对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
|
||||
2. 当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。
|
||||
3. 使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。
|
||||
|
||||
## 32 Java 中的异常处理
|
||||
|
||||
### Java异常类层次结构图
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
在 Java 中，所有的异常都有一个共同的祖先java.lang包中的 **Throwable类**。Throwable： 有两个重要的子类：**Exception（异常）** 和 **Error（错误）** ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。
|
||||
|
||||
**Error（错误）:是程序无法处理的错误**，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
|
||||
|
||||
这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。
|
||||
|
||||
**Exception（异常）:是程序本身可以处理的异常**。</font>Exception 类有一个重要的子类 **RuntimeException**。RuntimeException 异常由Java虚拟机抛出。**NullPointerException**（要访问的变量没有引用任何对象时，抛出该异常）、**ArithmeticException**（算术运算异常，一个整数除以0时，抛出该异常）和 **ArrayIndexOutOfBoundsException** （下标越界异常）。
|
||||
|
||||
**注意：异常和错误的区别：异常能被程序本身处理，错误是无法处理。**
|
||||
|
||||
### Throwable类常用方法
|
||||
|
||||
- **public string getMessage()**:返回异常发生时的简要描述
|
||||
- **public string toString()**:返回异常发生时的详细信息
|
||||
- **public string getLocalizedMessage()**:返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以生成本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
|
||||
- **public void printStackTrace()**:在控制台上打印Throwable对象封装的异常信息
|
||||
|
||||
### 异常处理总结
|
||||
|
||||
- **try 块：** 用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
|
||||
- **catch 块：** 用于处理try捕获到的异常。
|
||||
- **finally 块：** 无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return
|
||||
语句时，finally语句块将在方法返回之前被执行。
|
||||
|
||||
**在以下4种特殊情况下，finally块不会被执行：**
|
||||
|
||||
1. 在finally语句块第一行发生了异常。 因为在其他行，finally块还是会得到执行
|
||||
2. 在前面的代码中用了System.exit(int)已退出程序。 exit是带参函数 ；若该语句在异常语句之后，finally会执行
|
||||
3. 程序所在的线程死亡。
|
||||
4. 关闭CPU。
|
||||
|
||||
下面这部分内容来自issue:<https://github.com/Snailclimb/JavaGuide/issues/190>。
|
||||
|
||||
**注意：** 当try语句和finally语句中都有return语句时，在方法返回之前，finally语句的内容将被执行，并且finally语句的返回值将会覆盖原始的返回值。如下：
|
||||
|
||||
```java
|
||||
public static int f(int value) {
|
||||
try {
|
||||
return value * value;
|
||||
} finally {
|
||||
if (value == 2) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
如果调用 `f(2)`，返回值将是0，因为finally语句的返回值覆盖了try语句块的返回值。
|
||||
|
||||
## 33 Java序列化中如果有些字段不想进行序列化，怎么办？
|
||||
|
||||
对于不想进行序列化的变量，使用transient关键字修饰。
|
||||
|
||||
transient关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被transient修饰的变量值不会被持久化和恢复。transient只能修饰变量，不能修饰类和方法。
|
||||
|
||||
## 34 获取用键盘输入常用的两种方法
|
||||
|
||||
方法1：通过 Scanner
|
||||
|
||||
```java
|
||||
Scanner input = new Scanner(System.in);
|
||||
String s = input.nextLine();
|
||||
input.close();
|
||||
```
|
||||
|
||||
方法2：通过 BufferedReader
|
||||
|
||||
```java
|
||||
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
|
||||
String s = input.readLine();
|
||||
```
|
||||
|
||||
## 35 Java 中 IO 流
|
||||
|
||||
### Java 中 IO 流分为几种?
|
||||
|
||||
- 按照流的流向分，可以分为输入流和输出流；
|
||||
- 按照操作单元划分，可以划分为字节流和字符流；
|
||||
- 按照流的角色划分为节点流和处理流。
|
||||
|
||||
Java Io流共涉及40多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧密的联系， Java I0流的40多个类都是从如下4个抽象类基类中派生出来的。
|
||||
|
||||
- InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
|
||||
- OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。
|
||||
|
||||
按操作方式分类结构图：
|
||||
|
||||
|
||||
|
||||
|
||||
按操作对象分类结构图：
|
||||
|
||||
|
||||
|
||||
### 既然有了字节流,为什么还要有字符流?
|
||||
|
||||
问题本质想问：**不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？**
|
||||
|
||||
回答：字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还算是非常耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。所以， I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。
|
||||
|
||||
### BIO,NIO,AIO 有什么区别?
|
||||
|
||||
- **BIO (Blocking I/O):** 同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。
|
||||
- **NIO (New I/O):** NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应 java.nio 包，提供了 Channel , Selector，Buffer等抽象。NIO中的N可以理解为Non-blocking，不单纯是New。它支持面向缓冲的，基于通道的I/O操作方法。 NIO提供了与传统BIO模型中的 `Socket` 和 `ServerSocket` 相对应的 `SocketChannel` 和 `ServerSocketChannel` 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发
|
||||
- **AIO (Asynchronous I/O):** AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO操作本身是同步的。查阅网上相关资料，我发现就目前来说 AIO 的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。
|
||||
|
||||
## 36. 常见关键字总结:static,final,this,super
|
||||
|
||||
详见笔主的这篇文章: <https://gitee.com/SnailClimb/JavaGuide/blob/master/docs/java/Basis/final、static、this、super.md>
|
||||
|
||||
## 37. Collections 工具类和 Arrays 工具类常见方法总结
|
||||
|
||||
详见笔主的这篇文章: <https://gitee.com/SnailClimb/JavaGuide/blob/master/docs/java/Basis/Arrays,CollectionsCommonMethods.md>
|
||||
|
||||
### 38. 深拷贝 vs 浅拷贝
|
||||
|
||||
1. **浅拷贝**：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此为浅拷贝。
|
||||
2. **深拷贝**：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。
|
||||
|
||||
|
||||
|
||||
## 参考
|
||||
|
||||
- https://stackoverflow.com/questions/1906445/what-is-the-difference-between-jdk-and-jre
|
||||
- https://www.educba.com/oracle-vs-openjdk/
|
||||
- https://stackoverflow.com/questions/22358071/differences-between-oracle-jdk-and-openjdk?answertab=active#tab-top
|
||||
|
||||
## 公众号
|
||||
|
||||
如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。
|
||||
|
||||
**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"Java面试突击"** 即可免费领取！
|
||||
|
||||
**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
|
||||
|
||||
|
||||
|
||||
373
docs/java/Java疑难点.md
Normal file
373
docs/java/Java疑难点.md
Normal file
@ -0,0 +1,373 @@
|
||||
<!-- TOC -->
|
||||
|
||||
- [1. 基础](#1-基础)
|
||||
- [1.1. 正确使用 equals 方法](#11-正确使用-equals-方法)
|
||||
- [1.2. 整型包装类值的比较](#12-整型包装类值的比较)
|
||||
- [1.3. BigDecimal](#13-bigdecimal)
|
||||
- [1.3.1. BigDecimal 的用处](#131-bigdecimal-的用处)
|
||||
- [1.3.2. BigDecimal 的大小比较](#132-bigdecimal-的大小比较)
|
||||
- [1.3.3. BigDecimal 保留几位小数](#133-bigdecimal-保留几位小数)
|
||||
- [1.3.4. BigDecimal 的使用注意事项](#134-bigdecimal-的使用注意事项)
|
||||
- [1.3.5. 总结](#135-总结)
|
||||
- [1.4. 基本数据类型与包装数据类型的使用标准](#14-基本数据类型与包装数据类型的使用标准)
|
||||
- [2. 集合](#2-集合)
|
||||
- [2.1. Arrays.asList()使用指南](#21-arraysaslist使用指南)
|
||||
- [2.1.1. 简介](#211-简介)
|
||||
- [2.1.2. 《阿里巴巴Java 开发手册》对其的描述](#212-阿里巴巴java-开发手册对其的描述)
|
||||
- [2.1.3. 使用时的注意事项总结](#213-使用时的注意事项总结)
|
||||
- [2.1.4. 如何正确的将数组转换为ArrayList?](#214-如何正确的将数组转换为arraylist)
|
||||
- [2.2. Collection.toArray()方法使用的坑&如何反转数组](#22-collectiontoarray方法使用的坑如何反转数组)
|
||||
- [2.3. 不要在 foreach 循环里进行元素的 remove/add 操作](#23-不要在-foreach-循环里进行元素的-removeadd-操作)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
# 1. 基础
|
||||
|
||||
## 1.1. 正确使用 equals 方法
|
||||
|
||||
Object的equals方法容易抛空指针异常，应使用常量或确定有值的对象来调用 equals。
|
||||
|
||||
举个例子：
|
||||
|
||||
```java
|
||||
// 不能使用一个值为null的引用类型变量来调用非静态方法，否则会抛出异常
|
||||
String str = null;
|
||||
if (str.equals("SnailClimb")) {
|
||||
...
|
||||
} else {
|
||||
..
|
||||
}
|
||||
```
|
||||
|
||||
运行上面的程序会抛出空指针异常，但是我们把第二行的条件判断语句改为下面这样的话，就不会抛出空指针异常，else 语句块得到执行。：
|
||||
|
||||
```java
|
||||
"SnailClimb".equals(str);// false
|
||||
```
|
||||
不过更推荐使用 `java.util.Objects#equals`(JDK7 引入的工具类)。
|
||||
|
||||
```java
|
||||
Objects.equals(null,"SnailClimb");// false
|
||||
```
|
||||
我们看一下`java.util.Objects#equals`的源码就知道原因了。
|
||||
```java
|
||||
public static boolean equals(Object a, Object b) {
|
||||
// 可以避免空指针异常。如果a==null的话此时a.equals(b)就不会得到执行，避免出现空指针异常。
|
||||
return (a == b) || (a != null && a.equals(b));
|
||||
}
|
||||
```
|
||||
|
||||
**注意：**
|
||||
|
||||
Reference:[Java中equals方法造成空指针异常的原因及解决方案](https://blog.csdn.net/tick_tock97/article/details/72824894)
|
||||
|
||||
- 每种原始类型都有默认值一样，如int默认值为 0，boolean 的默认值为 false，null 是任何引用类型的默认值，不严格的说是所有 Object 类型的默认值。
|
||||
- 可以使用 == 或者 != 操作来比较null值，但是不能使用其他算法或者逻辑操作。在Java中`null == null`将返回true。
|
||||
- 不能使用一个值为null的引用类型变量来调用非静态方法，否则会抛出异常
|
||||
|
||||
## 1.2. 整型包装类值的比较
|
||||
|
||||
所有整型包装类对象值的比较必须使用equals方法。
|
||||
|
||||
先看下面这个例子：
|
||||
|
||||
```java
|
||||
Integer x = 3;
|
||||
Integer y = 3;
|
||||
System.out.println(x == y);// true
|
||||
Integer a = new Integer(3);
|
||||
Integer b = new Integer(3);
|
||||
System.out.println(a == b);//false
|
||||
System.out.println(a.equals(b));//true
|
||||
```
|
||||
|
||||
当使用自动装箱方式创建一个Integer对象时，当数值在-128 ~127时，会将创建的 Integer 对象缓存起来，当下次再出现该数值时，直接从缓存中取出对应的Integer对象。所以上述代码中，x和y引用的是相同的Integer对象。
|
||||
|
||||
**注意：**如果你的IDE(IDEA/Eclipse)上安装了阿里巴巴的p3c插件，这个插件如果检测到你用 ==的话会报错提示，推荐安装一个这个插件，很不错。
|
||||
|
||||
## 1.3. BigDecimal
|
||||
|
||||
### 1.3.1. BigDecimal 的用处
|
||||
|
||||
《阿里巴巴Java开发手册》中提到：**浮点数之间的等值判断，基本数据类型不能用==来比较，包装数据类型不能用 equals 来判断。** 具体原理和浮点数的编码方式有关，这里就不多提了，我们下面直接上实例：
|
||||
|
||||
```java
|
||||
float a = 1.0f - 0.9f;
|
||||
float b = 0.9f - 0.8f;
|
||||
System.out.println(a);// 0.100000024
|
||||
System.out.println(b);// 0.099999964
|
||||
System.out.println(a == b);// false
|
||||
```
|
||||
具有基本数学知识的我们很清楚的知道输出并不是我们想要的结果（**精度丢失**），我们如何解决这个问题呢？一种很常用的方法是：**使用使用 BigDecimal 来定义浮点数的值，再进行浮点数的运算操作。**
|
||||
|
||||
```java
|
||||
BigDecimal a = new BigDecimal("1.0");
|
||||
BigDecimal b = new BigDecimal("0.9");
|
||||
BigDecimal c = new BigDecimal("0.8");
|
||||
BigDecimal x = a.subtract(b);// 0.1
|
||||
BigDecimal y = b.subtract(c);// 0.1
|
||||
System.out.println(x.equals(y));// true
|
||||
```
|
||||
|
||||
### 1.3.2. BigDecimal 的大小比较
|
||||
|
||||
`a.compareTo(b)` : 返回 -1 表示小于，0 表示 等于， 1表示 大于。
|
||||
|
||||
```java
|
||||
BigDecimal a = new BigDecimal("1.0");
|
||||
BigDecimal b = new BigDecimal("0.9");
|
||||
System.out.println(a.compareTo(b));// 1
|
||||
```
|
||||
### 1.3.3. BigDecimal 保留几位小数
|
||||
|
||||
通过 `setScale`方法设置保留几位小数以及保留规则。保留规则有挺多种，不需要记，IDEA会提示。
|
||||
|
||||
```java
|
||||
BigDecimal m = new BigDecimal("1.255433");
|
||||
BigDecimal n = m.setScale(3,BigDecimal.ROUND_HALF_DOWN);
|
||||
System.out.println(n);// 1.255
|
||||
```
|
||||
|
||||
### 1.3.4. BigDecimal 的使用注意事项
|
||||
|
||||
注意：我们在使用BigDecimal时，为了防止精度丢失，推荐使用它的 **BigDecimal(String)** 构造方法来创建对象。《阿里巴巴Java开发手册》对这部分内容也有提到如下图所示。
|
||||
|
||||
|
||||
|
||||
### 1.3.5. 总结
|
||||
|
||||
BigDecimal 主要用来操作（大）浮点数，BigInteger 主要用来操作大整数（超过 long 类型）。
|
||||
|
||||
BigDecimal 的实现利用到了 BigInteger, 所不同的是 BigDecimal 加入了小数位的概念
|
||||
|
||||
## 1.4. 基本数据类型与包装数据类型的使用标准
|
||||
|
||||
Reference:《阿里巴巴Java开发手册》
|
||||
|
||||
- 【强制】所有的 POJO 类属性必须使用包装数据类型。
|
||||
- 【强制】RPC 方法的返回值和参数必须使用包装数据类型。
|
||||
- 【推荐】所有的局部变量使用基本数据类型。
|
||||
|
||||
比如我们如果自定义了一个Student类,其中有一个属性是成绩score,如果用Integer而不用int定义,一次考试,学生可能没考,值是null,也可能考了,但考了0分,值是0,这两个表达的状态明显不一样.
|
||||
|
||||
**说明** :POJO 类属性没有初值是提醒使用者在需要使用时，必须自己显式地进行赋值，任何 NPE 问题，或者入库检查，都由使用者来保证。
|
||||
|
||||
**正例** : 数据库的查询结果可能是 null，因为自动拆箱，用基本数据类型接收有 NPE 风险。
|
||||
|
||||
**反例** : 比如显示成交总额涨跌情况，即正负 x%，x 为基本数据类型，调用的 RPC 服务，调用不成功时，返回的是默认值，页面显示为 0%，这是不合理的，应该显示成中划线。所以包装数据类型的 null 值，能够表示额外的信息，如:远程调用失败，异常退出。
|
||||
|
||||
# 2. 集合
|
||||
|
||||
## 2.1. Arrays.asList()使用指南
|
||||
|
||||
最近使用`Arrays.asList()`遇到了一些坑，然后在网上看到这篇文章：[Java Array to List Examples](http://javadevnotes.com/java-array-to-list-examples) 感觉挺不错的，但是还不是特别全面。所以，自己对于这块小知识点进行了简单的总结。
|
||||
|
||||
### 2.1.1. 简介
|
||||
|
||||
`Arrays.asList()`在平时开发中还是比较常见的，我们可以使用它将一个数组转换为一个List集合。
|
||||
|
||||
```java
|
||||
String[] myArray = { "Apple", "Banana", "Orange" }；
|
||||
List<String> myList = Arrays.asList(myArray);
|
||||
//上面两个语句等价于下面一条语句
|
||||
List<String> myList = Arrays.asList("Apple","Banana", "Orange");
|
||||
```
|
||||
|
||||
JDK 源码对于这个方法的说明：
|
||||
|
||||
```java
|
||||
/**
|
||||
*返回由指定数组支持的固定大小的列表。此方法作为基于数组和基于集合的API之间的桥梁，与 Collection.toArray()结合使用。返回的List是可序列化并实现RandomAccess接口。
|
||||
*/
|
||||
public static <T> List<T> asList(T... a) {
|
||||
return new ArrayList<>(a);
|
||||
}
|
||||
```
|
||||
|
||||
### 2.1.2. 《阿里巴巴Java 开发手册》对其的描述
|
||||
|
||||
`Arrays.asList()`将数组转换为集合后,底层其实还是数组，《阿里巴巴Java 开发手册》对于这个方法有如下描述：
|
||||
|
||||
方法.png)
|
||||
|
||||
### 2.1.3. 使用时的注意事项总结
|
||||
|
||||
**传递的数组必须是对象数组，而不是基本类型。**
|
||||
|
||||
`Arrays.asList()`是泛型方法，传入的对象必须是对象数组。
|
||||
|
||||
```java
|
||||
int[] myArray = { 1, 2, 3 };
|
||||
List myList = Arrays.asList(myArray);
|
||||
System.out.println(myList.size());//1
|
||||
System.out.println(myList.get(0));//数组地址值
|
||||
System.out.println(myList.get(1));//报错：ArrayIndexOutOfBoundsException
|
||||
int [] array=(int[]) myList.get(0);
|
||||
System.out.println(array[0]);//1
|
||||
```
|
||||
当传入一个原生数据类型数组时，`Arrays.asList()` 的真正得到的参数就不是数组中的元素，而是数组对象本身！此时List 的唯一元素就是这个数组，这也就解释了上面的代码。
|
||||
|
||||
我们使用包装类型数组就可以解决这个问题。
|
||||
|
||||
```java
|
||||
Integer[] myArray = { 1, 2, 3 };
|
||||
```
|
||||
|
||||
**使用集合的修改方法:`add()`、`remove()`、`clear()`会抛出异常。**
|
||||
|
||||
```java
|
||||
List myList = Arrays.asList(1, 2, 3);
|
||||
myList.add(4);//运行时报错：UnsupportedOperationException
|
||||
myList.remove(1);//运行时报错：UnsupportedOperationException
|
||||
myList.clear();//运行时报错：UnsupportedOperationException
|
||||
```
|
||||
|
||||
`Arrays.asList()` 方法返回的并不是 `java.util.ArrayList` ，而是 `java.util.Arrays` 的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。
|
||||
|
||||
```java
|
||||
List myList = Arrays.asList(1, 2, 3);
|
||||
System.out.println(myList.getClass());//class java.util.Arrays$ArrayList
|
||||
```
|
||||
|
||||
下图是`java.util.Arrays$ArrayList`的简易源码，我们可以看到这个类重写的方法有哪些。
|
||||
|
||||
```java
|
||||
private static class ArrayList<E> extends AbstractList<E>
|
||||
implements RandomAccess, java.io.Serializable
|
||||
{
|
||||
...
|
||||
|
||||
@Override
|
||||
public E get(int index) {
|
||||
...
|
||||
}
|
||||
|
||||
@Override
|
||||
public E set(int index, E element) {
|
||||
...
|
||||
}
|
||||
|
||||
@Override
|
||||
public int indexOf(Object o) {
|
||||
...
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean contains(Object o) {
|
||||
...
|
||||
}
|
||||
|
||||
@Override
|
||||
public void forEach(Consumer<? super E> action) {
|
||||
...
|
||||
}
|
||||
|
||||
@Override
|
||||
public void replaceAll(UnaryOperator<E> operator) {
|
||||
...
|
||||
}
|
||||
|
||||
@Override
|
||||
public void sort(Comparator<? super E> c) {
|
||||
...
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
我们再看一下`java.util.AbstractList`的`remove()`方法，这样我们就明白为啥会抛出`UnsupportedOperationException`。
|
||||
|
||||
```java
|
||||
public E remove(int index) {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
```
|
||||
|
||||
### 2.1.4. 如何正确的将数组转换为ArrayList?
|
||||
|
||||
stackoverflow：https://dwz.cn/vcBkTiTW
|
||||
|
||||
**1. 自己动手实现（教育目的）**
|
||||
|
||||
```java
|
||||
//JDK1.5+
|
||||
static <T> List<T> arrayToList(final T[] array) {
|
||||
final List<T> l = new ArrayList<T>(array.length);
|
||||
|
||||
for (final T s : array) {
|
||||
l.add(s);
|
||||
}
|
||||
return (l);
|
||||
}
|
||||
```
|
||||
|
||||
```java
|
||||
Integer [] myArray = { 1, 2, 3 };
|
||||
System.out.println(arrayToList(myArray).getClass());//class java.util.ArrayList
|
||||
```
|
||||
|
||||
**2. 最简便的方法(推荐)**
|
||||
|
||||
```java
|
||||
List list = new ArrayList<>(Arrays.asList("a", "b", "c"))
|
||||
```
|
||||
|
||||
**3. 使用 Java8 的Stream(推荐)**
|
||||
|
||||
```java
|
||||
Integer [] myArray = { 1, 2, 3 };
|
||||
List myList = Arrays.stream(myArray).collect(Collectors.toList());
|
||||
//基本类型也可以实现转换（依赖boxed的装箱操作）
|
||||
int [] myArray2 = { 1, 2, 3 };
|
||||
List myList = Arrays.stream(myArray2).boxed().collect(Collectors.toList());
|
||||
```
|
||||
|
||||
**4. 使用 Guava(推荐)**
|
||||
|
||||
对于不可变集合，你可以使用[`ImmutableList`](https://github.com/google/guava/blob/master/guava/src/com/google/common/collect/ImmutableList.java)类及其[`of()`](https://github.com/google/guava/blob/master/guava/src/com/google/common/collect/ImmutableList.java#L101)与[`copyOf()`](https://github.com/google/guava/blob/master/guava/src/com/google/common/collect/ImmutableList.java#L225)工厂方法：（参数不能为空）
|
||||
|
||||
```java
|
||||
List<String> il = ImmutableList.of("string", "elements"); // from varargs
|
||||
List<String> il = ImmutableList.copyOf(aStringArray); // from array
|
||||
```
|
||||
对于可变集合，你可以使用[`Lists`](https://github.com/google/guava/blob/master/guava/src/com/google/common/collect/Lists.java)类及其[`newArrayList()`](https://github.com/google/guava/blob/master/guava/src/com/google/common/collect/Lists.java#L87)工厂方法：
|
||||
|
||||
```java
|
||||
List<String> l1 = Lists.newArrayList(anotherListOrCollection); // from collection
|
||||
List<String> l2 = Lists.newArrayList(aStringArray); // from array
|
||||
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs
|
||||
```
|
||||
|
||||
**5. 使用 Apache Commons Collections**
|
||||
|
||||
```java
|
||||
List<String> list = new ArrayList<String>();
|
||||
CollectionUtils.addAll(list, str);
|
||||
```
|
||||
|
||||
## 2.2. Collection.toArray()方法使用的坑&如何反转数组
|
||||
|
||||
该方法是一个泛型方法：`<T> T[] toArray(T[] a);` 如果`toArray`方法中没有传递任何参数的话返回的是`Object`类型数组。
|
||||
|
||||
```java
|
||||
String [] s= new String[]{
|
||||
"dog", "lazy", "a", "over", "jumps", "fox", "brown", "quick", "A"
|
||||
};
|
||||
List<String> list = Arrays.asList(s);
|
||||
Collections.reverse(list);
|
||||
s=list.toArray(new String[0]);//没有指定类型的话会报错
|
||||
```
|
||||
|
||||
由于JVM优化，`new String[0]`作为`Collection.toArray()`方法的参数现在使用更好，`new String[0]`就是起一个模板的作用，指定了返回数组的类型，0是为了节省空间，因为它只是为了说明返回的类型。详见：<https://shipilev.net/blog/2016/arrays-wisdom-ancients/>
|
||||
|
||||
## 2.3. 不要在 foreach 循环里进行元素的 remove/add 操作
|
||||
|
||||
如果要进行`remove`操作，可以调用迭代器的 `remove `方法而不是集合类的 remove 方法。因为如果列表在任何时间从结构上修改创建迭代器之后，以任何方式除非通过迭代器自身`remove/add`方法，迭代器都将抛出一个`ConcurrentModificationException`,这就是单线程状态下产生的 **fail-fast 机制**。
|
||||
|
||||
> **fail-fast 机制** ：多个线程对 fail-fast 集合进行修改的时，可能会抛出ConcurrentModificationException，单线程下也会出现这种情况，上面已经提到过。
|
||||
|
||||
`java.util`包下面的所有的集合类都是fail-fast的，而`java.util.concurrent`包下面的所有的类都是fail-safe的。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
125
docs/java/Java程序设计题.md
Normal file
125
docs/java/Java程序设计题.md
Normal file
@ -0,0 +1,125 @@
|
||||
## 泛型的实际应用
|
||||
|
||||
### 实现最小值函数
|
||||
|
||||
自己设计一个泛型的获取数组最小值的函数.并且这个方法只能接受Number的子类并且实现了Comparable接口。
|
||||
|
||||
```java
|
||||
//注意：Number并没有实现Comparable
|
||||
private static <T extends Number & Comparable<? super T>> T min(T[] values) {
|
||||
if (values == null || values.length == 0) return null;
|
||||
T min = values[0];
|
||||
for (int i = 1; i < values.length; i++) {
|
||||
if (min.compareTo(values[i]) > 0) min = values[i];
|
||||
}
|
||||
return min;
|
||||
}
|
||||
```
|
||||
|
||||
测试：
|
||||
|
||||
```java
|
||||
int minInteger = min(new Integer[]{1, 2, 3});//result:1
|
||||
double minDouble = min(new Double[]{1.2, 2.2, -1d});//result:-1d
|
||||
String typeError = min(new String[]{"1","3"});//报错
|
||||
```
|
||||
|
||||
## 数据结构
|
||||
|
||||
### 使用数组实现栈
|
||||
|
||||
**自己实现一个栈，要求这个栈具有`push()`、`pop()`（返回栈顶元素并出栈）、`peek()` （返回栈顶元素不出栈）、`isEmpty()`、`size()`这些基本的方法。**
|
||||
|
||||
提示：每次入栈之前先判断栈的容量是否够用，如果不够用就用`Arrays.copyOf()`进行扩容；
|
||||
|
||||
```java
|
||||
public class MyStack {
|
||||
private int[] storage;//存放栈中元素的数组
|
||||
private int capacity;//栈的容量
|
||||
private int count;//栈中元素数量
|
||||
private static final int GROW_FACTOR = 2;
|
||||
|
||||
//TODO：不带初始容量的构造方法。默认容量为8
|
||||
public MyStack() {
|
||||
this.capacity = 8;
|
||||
this.storage=new int[8];
|
||||
this.count = 0;
|
||||
}
|
||||
|
||||
//TODO：带初始容量的构造方法
|
||||
public MyStack(int initialCapacity) {
|
||||
if (initialCapacity < 1)
|
||||
throw new IllegalArgumentException("Capacity too small.");
|
||||
|
||||
this.capacity = initialCapacity;
|
||||
this.storage = new int[initialCapacity];
|
||||
this.count = 0;
|
||||
}
|
||||
|
||||
//TODO：入栈
|
||||
public void push(int value) {
|
||||
if (count == capacity) {
|
||||
ensureCapacity();
|
||||
}
|
||||
storage[count++] = value;
|
||||
}
|
||||
|
||||
//TODO：确保容量大小
|
||||
private void ensureCapacity() {
|
||||
int newCapacity = capacity * GROW_FACTOR;
|
||||
storage = Arrays.copyOf(storage, newCapacity);
|
||||
capacity = newCapacity;
|
||||
}
|
||||
|
||||
//TODO：返回栈顶元素并出栈
|
||||
private int pop() {
|
||||
count--;
|
||||
if (count == -1)
|
||||
throw new IllegalArgumentException("Stack is empty.");
|
||||
|
||||
return storage[count];
|
||||
}
|
||||
|
||||
//TODO：返回栈顶元素不出栈
|
||||
private int peek() {
|
||||
if (count == 0){
|
||||
throw new IllegalArgumentException("Stack is empty.");
|
||||
}else {
|
||||
return storage[count-1];
|
||||
}
|
||||
}
|
||||
|
||||
//TODO：判断栈是否为空
|
||||
private boolean isEmpty() {
|
||||
return count == 0;
|
||||
}
|
||||
|
||||
//TODO：返回栈中元素的个数
|
||||
private int size() {
|
||||
return count;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
验证
|
||||
|
||||
```java
|
||||
MyStack myStack = new MyStack(3);
|
||||
myStack.push(1);
|
||||
myStack.push(2);
|
||||
myStack.push(3);
|
||||
myStack.push(4);
|
||||
myStack.push(5);
|
||||
myStack.push(6);
|
||||
myStack.push(7);
|
||||
myStack.push(8);
|
||||
System.out.println(myStack.peek());//8
|
||||
System.out.println(myStack.size());//8
|
||||
for (int i = 0; i < 8; i++) {
|
||||
System.out.println(myStack.pop());
|
||||
}
|
||||
System.out.println(myStack.isEmpty());//true
|
||||
myStack.pop();//报错：java.lang.IllegalArgumentException: Stack is empty.
|
||||
```
|
||||
30
docs/java/Java编程规范.md
Normal file
30
docs/java/Java编程规范.md
Normal file
@ -0,0 +1,30 @@
|
||||
讲真的，下面推荐的文章或者资源建议阅读 3 遍以上。
|
||||
|
||||
### 团队
|
||||
|
||||
- **阿里巴巴Java开发手册（详尽版）** <https://github.com/alibaba/p3c/blob/master/阿里巴巴Java开发手册（华山版）.pdf>
|
||||
- **Google Java编程风格指南：** <http://hawstein.com/2014/01/20/google-java-style/>
|
||||
|
||||
### 个人
|
||||
|
||||
- **程序员你为什么这么累:** <https://xwjie.github.io/rule/>
|
||||
|
||||
### 如何写出优雅的 Java 代码
|
||||
|
||||
1. 使用 IntelliJ IDEA 作为您的集成开发环境 (IDE)
|
||||
1. 使用 JDK 8 或更高版本
|
||||
1. 使用 Maven/Gradle
|
||||
1. 使用 Lombok
|
||||
1. 编写单元测试
|
||||
1. 重构:常见,但也很慢
|
||||
1. 注意代码规范
|
||||
1. 定期联络客户，以获取他们的反馈
|
||||
|
||||
上述建议的详细内容：[八点建议助您写出优雅的Java代码](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247485140&idx=1&sn=ecaeace613474f1859aaeed0282ae680&chksm=cea2491ff9d5c00982ffaece847ce1aead89fdb3fe190752d9837c075c79fc95db5940992c56&token=1328169465&lang=zh_CN&scene=21#wechat_redirect)。
|
||||
|
||||
更多代码优化相关内容推荐：
|
||||
|
||||
- [业务复杂=if else？刚来的大神竟然用策略+工厂彻底干掉了他们！](https://juejin.im/post/5dad23685188251d2c4ea2b6)
|
||||
- [一些不错的 Java 实践！推荐阅读3遍以上！](http://lrwinx.github.io/2017/03/04/%E7%BB%86%E6%80%9D%E6%9E%81%E6%81%90-%E4%BD%A0%E7%9C%9F%E7%9A%84%E4%BC%9A%E5%86%99java%E5%90%97/)
|
||||
- [[解锁新姿势] 兄dei，你代码需要优化了](https://juejin.im/post/5dafbc02e51d4524a0060bdd)
|
||||
- [消灭 Java 代码的“坏味道”](https://mp.weixin.qq.com/s?__biz=Mzg2OTA0Njk0OA==&mid=2247485599&idx=1&sn=d83ff4e6b1ee951a0a33508a10980ea3&chksm=cea24754f9d5ce426d18b435a8c373ddc580c06c7d6a45cc51377361729c31c7301f1bbc3b78&token=1328169465&lang=zh_CN#rd)
|
||||
713
docs/java/Multithread/AQS.md
Normal file
713
docs/java/Multithread/AQS.md
Normal file
@ -0,0 +1,713 @@
|
||||
点击关注[公众号](#公众号 "公众号")及时获取笔主最新更新文章，并可免费领取本文档配套的《Java 面试突击》以及 Java 工程师必备学习资源。
|
||||
|
||||
<!-- TOC -->
|
||||
|
||||
- [1 AQS 简单介绍](#1-aqs-简单介绍)
|
||||
- [2 AQS 原理](#2-aqs-原理)
|
||||
- [2.1 AQS 原理概览](#21-aqs-原理概览)
|
||||
- [2.2 AQS 对资源的共享方式](#22-aqs-对资源的共享方式)
|
||||
- [2.3 AQS 底层使用了模板方法模式](#23-aqs-底层使用了模板方法模式)
|
||||
- [3 Semaphore(信号量)-允许多个线程同时访问](#3-semaphore信号量-允许多个线程同时访问)
|
||||
- [4 CountDownLatch （倒计时器）](#4-countdownlatch-倒计时器)
|
||||
- [4.1 CountDownLatch 的三种典型用法](#41-countdownlatch-的三种典型用法)
|
||||
- [4.2 CountDownLatch 的使用示例](#42-countdownlatch-的使用示例)
|
||||
- [4.3 CountDownLatch 的不足](#43-countdownlatch-的不足)
|
||||
- [4.4 CountDownLatch 常见面试题](#44-countdownlatch-相常见面试题)
|
||||
- [5 CyclicBarrier(循环栅栏)](#5-cyclicbarrier循环栅栏)
|
||||
- [5.1 CyclicBarrier 的应用场景](#51-cyclicbarrier-的应用场景)
|
||||
- [5.2 CyclicBarrier 的使用示例](#52-cyclicbarrier-的使用示例)
|
||||
- [5.3 `CyclicBarrier`源码分析](#53-cyclicbarrier源码分析)
|
||||
- [5.4 CyclicBarrier 和 CountDownLatch 的区别](#54-cyclicbarrier-和-countdownlatch-的区别)
|
||||
- [6 ReentrantLock 和 ReentrantReadWriteLock](#6-reentrantlock-和-reentrantreadwritelock)
|
||||
- [参考](#参考)
|
||||
- [公众号](#公众号)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
> 常见问题：AQS 原理？;CountDownLatch 和 CyclicBarrier 了解吗,两者的区别是什么？用过 Semaphore 吗？
|
||||
|
||||
### 1 AQS 简单介绍
|
||||
|
||||
AQS 的全称为（AbstractQueuedSynchronizer），这个类在 java.util.concurrent.locks 包下面。
|
||||
|
||||
|
||||
|
||||
AQS 是一个用来构建锁和同步器的框架，使用 AQS 能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的 ReentrantLock，Semaphore，其他的诸如 ReentrantReadWriteLock，SynchronousQueue，FutureTask(jdk1.7) 等等皆是基于 AQS 的。当然，我们自己也能利用 AQS 非常轻松容易地构造出符合我们自己需求的同步器。
|
||||
|
||||
### 2 AQS 原理
|
||||
|
||||
> 在面试中被问到并发知识的时候，大多都会被问到“请你说一下自己对于 AQS 原理的理解”。下面给大家一个示例供大家参考，面试不是背题，大家一定要加入自己的思想，即使加入不了自己的思想也要保证自己能够通俗的讲出来而不是背出来。
|
||||
|
||||
下面大部分内容其实在 AQS 类注释上已经给出了，不过是英语看着比较吃力一点，感兴趣的话可以看看源码。
|
||||
|
||||
#### 2.1 AQS 原理概览
|
||||
|
||||
**AQS 核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制 AQS 是用 CLH 队列锁实现的，即将暂时获取不到锁的线程加入到队列中。**
|
||||
|
||||
> CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS 是将每条请求共享资源的线程封装成一个 CLH 锁队列的一个结点（Node）来实现锁的分配。
|
||||
|
||||
看个 AQS(AbstractQueuedSynchronizer)原理图：
|
||||
|
||||
|
||||
|
||||
AQS 使用一个 int 成员变量来表示同步状态，通过内置的 FIFO 队列来完成获取资源线程的排队工作。AQS 使用 CAS 对该同步状态进行原子操作实现对其值的修改。
|
||||
|
||||
```java
|
||||
private volatile int state;//共享变量，使用volatile修饰保证线程可见性
|
||||
```
|
||||
|
||||
状态信息通过 protected 类型的`getState`，`setState`，`compareAndSetState`进行操作
|
||||
|
||||
```java
|
||||
//返回同步状态的当前值
|
||||
protected final int getState() {
|
||||
return state;
|
||||
}
|
||||
// 设置同步状态的值
|
||||
protected final void setState(int newState) {
|
||||
state = newState;
|
||||
}
|
||||
//原子地（CAS操作）将同步状态值设置为给定值update如果当前同步状态的值等于expect（期望值）
|
||||
protected final boolean compareAndSetState(int expect, int update) {
|
||||
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
|
||||
}
|
||||
```
|
||||
|
||||
#### 2.2 AQS 对资源的共享方式
|
||||
|
||||
**AQS 定义两种资源共享方式**
|
||||
|
||||
**1)Exclusive**（独占）
|
||||
|
||||
只有一个线程能执行，如 ReentrantLock。又可分为公平锁和非公平锁,ReentrantLock 同时支持两种锁,下面以 ReentrantLock 对这两种锁的定义做介绍：
|
||||
|
||||
- 公平锁：按照线程在队列中的排队顺序，先到者先拿到锁
|
||||
- 非公平锁：当线程要获取锁时，先通过两次 CAS 操作去抢锁，如果没抢到，当前线程再加入到队列中等待唤醒。
|
||||
|
||||
> 说明：下面这部分关于 `ReentrantLock` 源代码内容节选自：https://www.javadoop.com/post/AbstractQueuedSynchronizer-2，这是一篇很不错文章，推荐阅读。
|
||||
|
||||
**下面来看 ReentrantLock 中相关的源代码：**
|
||||
|
||||
ReentrantLock 默认采用非公平锁，因为考虑获得更好的性能，通过 boolean 来决定是否用公平锁（传入 true 用公平锁）。
|
||||
|
||||
```java
|
||||
/** Synchronizer providing all implementation mechanics */
|
||||
private final Sync sync;
|
||||
public ReentrantLock() {
|
||||
// 默认非公平锁
|
||||
sync = new NonfairSync();
|
||||
}
|
||||
public ReentrantLock(boolean fair) {
|
||||
sync = fair ? new FairSync() : new NonfairSync();
|
||||
}
|
||||
```
|
||||
|
||||
ReentrantLock 中公平锁的 `lock` 方法
|
||||
|
||||
```java
|
||||
static final class FairSync extends Sync {
|
||||
final void lock() {
|
||||
acquire(1);
|
||||
}
|
||||
// AbstractQueuedSynchronizer.acquire(int arg)
|
||||
public final void acquire(int arg) {
|
||||
if (!tryAcquire(arg) &&
|
||||
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
|
||||
selfInterrupt();
|
||||
}
|
||||
protected final boolean tryAcquire(int acquires) {
|
||||
final Thread current = Thread.currentThread();
|
||||
int c = getState();
|
||||
if (c == 0) {
|
||||
// 1. 和非公平锁相比，这里多了一个判断：是否有线程在等待
|
||||
if (!hasQueuedPredecessors() &&
|
||||
compareAndSetState(0, acquires)) {
|
||||
setExclusiveOwnerThread(current);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else if (current == getExclusiveOwnerThread()) {
|
||||
int nextc = c + acquires;
|
||||
if (nextc < 0)
|
||||
throw new Error("Maximum lock count exceeded");
|
||||
setState(nextc);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
非公平锁的 lock 方法：
|
||||
|
||||
```java
|
||||
static final class NonfairSync extends Sync {
|
||||
final void lock() {
|
||||
// 2. 和公平锁相比，这里会直接先进行一次CAS，成功就返回了
|
||||
if (compareAndSetState(0, 1))
|
||||
setExclusiveOwnerThread(Thread.currentThread());
|
||||
else
|
||||
acquire(1);
|
||||
}
|
||||
// AbstractQueuedSynchronizer.acquire(int arg)
|
||||
public final void acquire(int arg) {
|
||||
if (!tryAcquire(arg) &&
|
||||
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
|
||||
selfInterrupt();
|
||||
}
|
||||
protected final boolean tryAcquire(int acquires) {
|
||||
return nonfairTryAcquire(acquires);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Performs non-fair tryLock. tryAcquire is implemented in
|
||||
* subclasses, but both need nonfair try for trylock method.
|
||||
*/
|
||||
final boolean nonfairTryAcquire(int acquires) {
|
||||
final Thread current = Thread.currentThread();
|
||||
int c = getState();
|
||||
if (c == 0) {
|
||||
// 这里没有对阻塞队列进行判断
|
||||
if (compareAndSetState(0, acquires)) {
|
||||
setExclusiveOwnerThread(current);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else if (current == getExclusiveOwnerThread()) {
|
||||
int nextc = c + acquires;
|
||||
if (nextc < 0) // overflow
|
||||
throw new Error("Maximum lock count exceeded");
|
||||
setState(nextc);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
```
|
||||
|
||||
总结：公平锁和非公平锁只有两处不同：
|
||||
|
||||
1. 非公平锁在调用 lock 后，首先就会调用 CAS 进行一次抢锁，如果这个时候恰巧锁没有被占用，那么直接就获取到锁返回了。
|
||||
2. 非公平锁在 CAS 失败后，和公平锁一样都会进入到 tryAcquire 方法，在 tryAcquire 方法中，如果发现锁这个时候被释放了（state == 0），非公平锁会直接 CAS 抢锁，但是公平锁会判断等待队列是否有线程处于等待状态，如果有则不去抢锁，乖乖排到后面。
|
||||
|
||||
公平锁和非公平锁就这两点区别，如果这两次 CAS 都不成功，那么后面非公平锁和公平锁是一样的，都要进入到阻塞队列等待唤醒。
|
||||
|
||||
相对来说，非公平锁会有更好的性能，因为它的吞吐量比较大。当然，非公平锁让获取锁的时间变得更加不确定，可能会导致在阻塞队列中的线程长期处于饥饿状态。
|
||||
|
||||
**2)Share**（共享）
|
||||
|
||||
多个线程可同时执行，如 Semaphore/CountDownLatch。Semaphore、CountDownLatCh、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。
|
||||
|
||||
ReentrantReadWriteLock 可以看成是组合式，因为 ReentrantReadWriteLock 也就是读写锁允许多个线程同时对某一资源进行读。
|
||||
|
||||
不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS 已经在上层已经帮我们实现好了。
|
||||
|
||||
#### 2.3 AQS 底层使用了模板方法模式
|
||||
|
||||
同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）：
|
||||
|
||||
1. 使用者继承 AbstractQueuedSynchronizer 并重写指定的方法。（这些重写方法很简单，无非是对于共享资源 state 的获取和释放）
|
||||
2. 将 AQS 组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。
|
||||
|
||||
这和我们以往通过实现接口的方式有很大区别，这是模板方法模式很经典的一个运用，下面简单的给大家介绍一下模板方法模式，模板方法模式是一个很容易理解的设计模式之一。
|
||||
|
||||
> 模板方法模式是基于”继承“的，主要是为了在不改变模板结构的前提下在子类中重新定义模板中的内容以实现复用代码。举个很简单的例子假如我们要去一个地方的步骤是：购票`buyTicket()`->安检`securityCheck()`->乘坐某某工具回家`ride()`->到达目的地`arrive()`。我们可能乘坐不同的交通工具回家比如飞机或者火车，所以除了`ride()`方法，其他方法的实现几乎相同。我们可以定义一个包含了这些方法的抽象类，然后用户根据自己的需要继承该抽象类然后修改 `ride()`方法。
|
||||
|
||||
**AQS 使用了模板方法模式，自定义同步器时需要重写下面几个 AQS 提供的模板方法：**
|
||||
|
||||
```java
|
||||
isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。
|
||||
tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。
|
||||
tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。
|
||||
tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
|
||||
tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。
|
||||
|
||||
```
|
||||
|
||||
默认情况下，每个方法都抛出 `UnsupportedOperationException`。 这些方法的实现必须是内部线程安全的，并且通常应该简短而不是阻塞。AQS 类中的其他方法都是 final ，所以无法被其他类使用，只有这几个方法可以被其他类使用。
|
||||
|
||||
以 ReentrantLock 为例，state 初始化为 0，表示未锁定状态。A 线程 lock()时，会调用 tryAcquire()独占该锁并将 state+1。此后，其他线程再 tryAcquire()时就会失败，直到 A 线程 unlock()到 state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A 线程自己是可以重复获取此锁的（state 会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证 state 是能回到零态的。
|
||||
|
||||
再以 CountDownLatch 以例，任务分为 N 个子线程去执行，state 也初始化为 N（注意 N 要与线程个数一致）。这 N 个子线程是并行执行的，每个子线程执行完后 countDown()一次，state 会 CAS(Compare and Swap)减 1。等到所有子线程都执行完后(即 state=0)，会 unpark()主调用线程，然后主调用线程就会从 await()函数返回，继续后余动作。
|
||||
|
||||
一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现`tryAcquire-tryRelease`、`tryAcquireShared-tryReleaseShared`中的一种即可。但 AQS 也支持自定义同步器同时实现独占和共享两种方式，如`ReentrantReadWriteLock`。
|
||||
|
||||
推荐两篇 AQS 原理和相关源码分析的文章：
|
||||
|
||||
- http://www.cnblogs.com/waterystone/p/4920797.html
|
||||
- https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html
|
||||
|
||||
### 3 Semaphore(信号量)-允许多个线程同时访问
|
||||
|
||||
**synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。** 示例代码如下：
|
||||
|
||||
```java
|
||||
/**
|
||||
*
|
||||
* @author Snailclimb
|
||||
* @date 2018年9月30日
|
||||
* @Description: 需要一次性拿一个许可的情况
|
||||
*/
|
||||
public class SemaphoreExample1 {
|
||||
// 请求的数量
|
||||
private static final int threadCount = 550;
|
||||
|
||||
public static void main(String[] args) throws InterruptedException {
|
||||
// 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很慢）
|
||||
ExecutorService threadPool = Executors.newFixedThreadPool(300);
|
||||
// 一次只能允许执行的线程数量。
|
||||
final Semaphore semaphore = new Semaphore(20);
|
||||
|
||||
for (int i = 0; i < threadCount; i++) {
|
||||
final int threadnum = i;
|
||||
threadPool.execute(() -> {// Lambda 表达式的运用
|
||||
try {
|
||||
semaphore.acquire();// 获取一个许可，所以可运行线程数量为20/1=20
|
||||
test(threadnum);
|
||||
semaphore.release();// 释放一个许可
|
||||
} catch (InterruptedException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
});
|
||||
}
|
||||
threadPool.shutdown();
|
||||
System.out.println("finish");
|
||||
}
|
||||
|
||||
public static void test(int threadnum) throws InterruptedException {
|
||||
Thread.sleep(1000);// 模拟请求的耗时操作
|
||||
System.out.println("threadnum:" + threadnum);
|
||||
Thread.sleep(1000);// 模拟请求的耗时操作
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
执行 `acquire` 方法阻塞，直到有一个许可证可以获得然后拿走一个许可证；每个 `release` 方法增加一个许可证，这可能会释放一个阻塞的 acquire 方法。然而，其实并没有实际的许可证这个对象，Semaphore 只是维持了一个可获得许可证的数量。 Semaphore 经常用于限制获取某种资源的线程数量。
|
||||
|
||||
当然一次也可以一次拿取和释放多个许可，不过一般没有必要这样做：
|
||||
|
||||
```java
|
||||
semaphore.acquire(5);// 获取5个许可，所以可运行线程数量为20/5=4
|
||||
test(threadnum);
|
||||
semaphore.release(5);// 获取5个许可，所以可运行线程数量为20/5=4
|
||||
```
|
||||
|
||||
除了 `acquire`方法之外，另一个比较常用的与之对应的方法是`tryAcquire`方法，该方法如果获取不到许可就立即返回 false。
|
||||
|
||||
Semaphore 有两种模式，公平模式和非公平模式。
|
||||
|
||||
- **公平模式：** 调用 acquire 的顺序就是获取许可证的顺序，遵循 FIFO；
|
||||
- **非公平模式：** 抢占式的。
|
||||
|
||||
**Semaphore 对应的两个构造方法如下：**
|
||||
|
||||
```java
|
||||
public Semaphore(int permits) {
|
||||
sync = new NonfairSync(permits);
|
||||
}
|
||||
|
||||
public Semaphore(int permits, boolean fair) {
|
||||
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
|
||||
}
|
||||
```
|
||||
|
||||
**这两个构造方法，都必须提供许可的数量，第二个构造方法可以指定是公平模式还是非公平模式，默认非公平模式。**
|
||||
|
||||
由于篇幅问题，如果对 Semaphore 源码感兴趣的朋友可以看下面这篇文章：
|
||||
|
||||
- https://blog.csdn.net/qq_19431333/article/details/70212663
|
||||
|
||||
### 4 CountDownLatch （倒计时器）
|
||||
|
||||
CountDownLatch 是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。在 Java 并发中，countdownlatch 的概念是一个常见的面试题，所以一定要确保你很好的理解了它。
|
||||
|
||||
#### 4.1 CountDownLatch 的三种典型用法
|
||||
|
||||
① 某一线程在开始运行前等待 n 个线程执行完毕。将 CountDownLatch 的计数器初始化为 n ：`new CountDownLatch(n)`，每当一个任务线程执行完毕，就将计数器减 1 `countdownlatch.countDown()`，当计数器的值变为 0 时，在`CountDownLatch上 await()` 的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。
|
||||
|
||||
② 实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的 `CountDownLatch` 对象，将其计数器初始化为 1 ：`new CountDownLatch(1)`，多个线程在开始执行任务前首先 `coundownlatch.await()`，当主线程调用 countDown() 时，计数器变为 0，多个线程同时被唤醒。
|
||||
|
||||
③ 死锁检测：一个非常方便的使用场景是，你可以使用 n 个线程访问共享资源，在每次测试阶段的线程数目是不同的，并尝试产生死锁。
|
||||
|
||||
#### 4.2 CountDownLatch 的使用示例
|
||||
|
||||
```java
|
||||
/**
|
||||
*
|
||||
* @author SnailClimb
|
||||
* @date 2018年10月1日
|
||||
* @Description: CountDownLatch 使用方法示例
|
||||
*/
|
||||
public class CountDownLatchExample1 {
|
||||
// 请求的数量
|
||||
private static final int threadCount = 550;
|
||||
|
||||
public static void main(String[] args) throws InterruptedException {
|
||||
// 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很慢）
|
||||
ExecutorService threadPool = Executors.newFixedThreadPool(300);
|
||||
final CountDownLatch countDownLatch = new CountDownLatch(threadCount);
|
||||
for (int i = 0; i < threadCount; i++) {
|
||||
final int threadnum = i;
|
||||
threadPool.execute(() -> {// Lambda 表达式的运用
|
||||
try {
|
||||
test(threadnum);
|
||||
} catch (InterruptedException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
} finally {
|
||||
countDownLatch.countDown();// 表示一个请求已经被完成
|
||||
}
|
||||
|
||||
});
|
||||
}
|
||||
countDownLatch.await();
|
||||
threadPool.shutdown();
|
||||
System.out.println("finish");
|
||||
}
|
||||
|
||||
public static void test(int threadnum) throws InterruptedException {
|
||||
Thread.sleep(1000);// 模拟请求的耗时操作
|
||||
System.out.println("threadnum:" + threadnum);
|
||||
Thread.sleep(1000);// 模拟请求的耗时操作
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
上面的代码中，我们定义了请求的数量为 550，当这 550 个请求被处理完成之后，才会执行`System.out.println("finish");`。
|
||||
|
||||
与 CountDownLatch 的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用 CountDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。
|
||||
|
||||
其他 N 个线程必须引用闭锁对象，因为他们需要通知 CountDownLatch 对象，他们已经完成了各自的任务。这种通知机制是通过 CountDownLatch.countDown()方法来完成的；每调用一次这个方法，在构造函数中初始化的 count 值就减 1。所以当 N 个线程都调 用了这个方法，count 的值等于 0，然后主线程就能通过 await()方法，恢复执行自己的任务。
|
||||
|
||||
#### 4.3 CountDownLatch 的不足
|
||||
|
||||
CountDownLatch 是一次性的，计数器的值只能在构造方法中初始化一次，之后没有任何机制再次对其设置值，当 CountDownLatch 使用完毕后，它不能再次被使用。
|
||||
|
||||
#### 4.4 CountDownLatch 相常见面试题：
|
||||
|
||||
解释一下 CountDownLatch 概念？
|
||||
|
||||
CountDownLatch 和 CyclicBarrier 的不同之处？
|
||||
|
||||
给出一些 CountDownLatch 使用的例子？
|
||||
|
||||
CountDownLatch 类中主要的方法？
|
||||
|
||||
### 5 CyclicBarrier(循环栅栏)
|
||||
|
||||
CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。
|
||||
|
||||
CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier 默认的构造方法是 `CyclicBarrier(int parties)`，其参数表示屏障拦截的线程数量，每个线程调用`await`方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。
|
||||
|
||||
再来看一下它的构造函数：
|
||||
|
||||
```java
|
||||
public CyclicBarrier(int parties) {
|
||||
this(parties, null);
|
||||
}
|
||||
|
||||
public CyclicBarrier(int parties, Runnable barrierAction) {
|
||||
if (parties <= 0) throw new IllegalArgumentException();
|
||||
this.parties = parties;
|
||||
this.count = parties;
|
||||
this.barrierCommand = barrierAction;
|
||||
}
|
||||
```
|
||||
|
||||
其中，parties 就代表了有拦截的线程的数量，当拦截的线程数量达到这个值的时候就打开栅栏，让所有线程通过。
|
||||
|
||||
#### 5.1 CyclicBarrier 的应用场景
|
||||
|
||||
CyclicBarrier 可以用于多线程计算数据，最后合并计算结果的应用场景。比如我们用一个 Excel 保存了用户所有银行流水，每个 Sheet 保存一个帐户近一年的每笔银行流水，现在需要统计用户的日均银行流水，先用多线程处理每个 sheet 里的银行流水，都执行完之后，得到每个 sheet 的日均银行流水，最后，再用 barrierAction 用这些线程的计算结果，计算出整个 Excel 的日均银行流水。
|
||||
|
||||
#### 5.2 CyclicBarrier 的使用示例
|
||||
|
||||
示例 1：
|
||||
|
||||
```java
|
||||
/**
|
||||
*
|
||||
* @author Snailclimb
|
||||
* @date 2018年10月1日
|
||||
* @Description: 测试 CyclicBarrier 类中带参数的 await() 方法
|
||||
*/
|
||||
public class CyclicBarrierExample2 {
|
||||
// 请求的数量
|
||||
private static final int threadCount = 550;
|
||||
// 需要同步的线程数量
|
||||
private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5);
|
||||
|
||||
public static void main(String[] args) throws InterruptedException {
|
||||
// 创建线程池
|
||||
ExecutorService threadPool = Executors.newFixedThreadPool(10);
|
||||
|
||||
for (int i = 0; i < threadCount; i++) {
|
||||
final int threadNum = i;
|
||||
Thread.sleep(1000);
|
||||
threadPool.execute(() -> {
|
||||
try {
|
||||
test(threadNum);
|
||||
} catch (InterruptedException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
} catch (BrokenBarrierException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
}
|
||||
threadPool.shutdown();
|
||||
}
|
||||
|
||||
public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {
|
||||
System.out.println("threadnum:" + threadnum + "is ready");
|
||||
try {
|
||||
/**等待60秒，保证子线程完全执行结束*/
|
||||
cyclicBarrier.await(60, TimeUnit.SECONDS);
|
||||
} catch (Exception e) {
|
||||
System.out.println("-----CyclicBarrierException------");
|
||||
}
|
||||
System.out.println("threadnum:" + threadnum + "is finish");
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
运行结果，如下：
|
||||
|
||||
```
|
||||
threadnum:0is ready
|
||||
threadnum:1is ready
|
||||
threadnum:2is ready
|
||||
threadnum:3is ready
|
||||
threadnum:4is ready
|
||||
threadnum:4is finish
|
||||
threadnum:0is finish
|
||||
threadnum:1is finish
|
||||
threadnum:2is finish
|
||||
threadnum:3is finish
|
||||
threadnum:5is ready
|
||||
threadnum:6is ready
|
||||
threadnum:7is ready
|
||||
threadnum:8is ready
|
||||
threadnum:9is ready
|
||||
threadnum:9is finish
|
||||
threadnum:5is finish
|
||||
threadnum:8is finish
|
||||
threadnum:7is finish
|
||||
threadnum:6is finish
|
||||
......
|
||||
```
|
||||
|
||||
可以看到当线程数量也就是请求数量达到我们定义的 5 个的时候， `await`方法之后的方法才被执行。
|
||||
|
||||
另外，CyclicBarrier 还提供一个更高级的构造函数`CyclicBarrier(int parties, Runnable barrierAction)`，用于在线程到达屏障时，优先执行`barrierAction`，方便处理更复杂的业务场景。示例代码如下：
|
||||
|
||||
```java
|
||||
/**
|
||||
*
|
||||
* @author SnailClimb
|
||||
* @date 2018年10月1日
|
||||
* @Description: 新建 CyclicBarrier 的时候指定一个 Runnable
|
||||
*/
|
||||
public class CyclicBarrierExample3 {
|
||||
// 请求的数量
|
||||
private static final int threadCount = 550;
|
||||
// 需要同步的线程数量
|
||||
private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> {
|
||||
System.out.println("------当线程数达到之后，优先执行------");
|
||||
});
|
||||
|
||||
public static void main(String[] args) throws InterruptedException {
|
||||
// 创建线程池
|
||||
ExecutorService threadPool = Executors.newFixedThreadPool(10);
|
||||
|
||||
for (int i = 0; i < threadCount; i++) {
|
||||
final int threadNum = i;
|
||||
Thread.sleep(1000);
|
||||
threadPool.execute(() -> {
|
||||
try {
|
||||
test(threadNum);
|
||||
} catch (InterruptedException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
} catch (BrokenBarrierException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
}
|
||||
});
|
||||
}
|
||||
threadPool.shutdown();
|
||||
}
|
||||
|
||||
public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {
|
||||
System.out.println("threadnum:" + threadnum + "is ready");
|
||||
cyclicBarrier.await();
|
||||
System.out.println("threadnum:" + threadnum + "is finish");
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
运行结果，如下：
|
||||
|
||||
```
|
||||
threadnum:0is ready
|
||||
threadnum:1is ready
|
||||
threadnum:2is ready
|
||||
threadnum:3is ready
|
||||
threadnum:4is ready
|
||||
------当线程数达到之后，优先执行------
|
||||
threadnum:4is finish
|
||||
threadnum:0is finish
|
||||
threadnum:2is finish
|
||||
threadnum:1is finish
|
||||
threadnum:3is finish
|
||||
threadnum:5is ready
|
||||
threadnum:6is ready
|
||||
threadnum:7is ready
|
||||
threadnum:8is ready
|
||||
threadnum:9is ready
|
||||
------当线程数达到之后，优先执行------
|
||||
threadnum:9is finish
|
||||
threadnum:5is finish
|
||||
threadnum:6is finish
|
||||
threadnum:8is finish
|
||||
threadnum:7is finish
|
||||
......
|
||||
```
|
||||
|
||||
#### 5.3 `CyclicBarrier`源码分析
|
||||
|
||||
当调用 `CyclicBarrier` 对象调用 `await()` 方法时，实际上调用的是`dowait(false, 0L)`方法。 `await()` 方法就像树立起一个栅栏的行为一样，将线程挡住了，当拦住的线程数量达到 parties 的值时，栅栏才会打开，线程才得以通过执行。
|
||||
|
||||
```java
|
||||
public int await() throws InterruptedException, BrokenBarrierException {
|
||||
try {
|
||||
return dowait(false, 0L);
|
||||
} catch (TimeoutException toe) {
|
||||
throw new Error(toe); // cannot happen
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
`dowait(false, 0L)`：
|
||||
|
||||
```java
|
||||
// 当线程数量或者请求数量达到 count 时 await 之后的方法才会被执行。上面的示例中 count 的值就为 5。
|
||||
private int count;
|
||||
/**
|
||||
* Main barrier code, covering the various policies.
|
||||
*/
|
||||
private int dowait(boolean timed, long nanos)
|
||||
throws InterruptedException, BrokenBarrierException,
|
||||
TimeoutException {
|
||||
final ReentrantLock lock = this.lock;
|
||||
// 锁住
|
||||
lock.lock();
|
||||
try {
|
||||
final Generation g = generation;
|
||||
|
||||
if (g.broken)
|
||||
throw new BrokenBarrierException();
|
||||
|
||||
// 如果线程中断了，抛出异常
|
||||
if (Thread.interrupted()) {
|
||||
breakBarrier();
|
||||
throw new InterruptedException();
|
||||
}
|
||||
// cout减1
|
||||
int index = --count;
|
||||
// 当 count 数量减为 0 之后说明最后一个线程已经到达栅栏了，也就是达到了可以执行await 方法之后的条件
|
||||
if (index == 0) { // tripped
|
||||
boolean ranAction = false;
|
||||
try {
|
||||
final Runnable command = barrierCommand;
|
||||
if (command != null)
|
||||
command.run();
|
||||
ranAction = true;
|
||||
// 将 count 重置为 parties 属性的初始化值
|
||||
// 唤醒之前等待的线程
|
||||
// 下一波执行开始
|
||||
nextGeneration();
|
||||
return 0;
|
||||
} finally {
|
||||
if (!ranAction)
|
||||
breakBarrier();
|
||||
}
|
||||
}
|
||||
|
||||
// loop until tripped, broken, interrupted, or timed out
|
||||
for (;;) {
|
||||
try {
|
||||
if (!timed)
|
||||
trip.await();
|
||||
else if (nanos > 0L)
|
||||
nanos = trip.awaitNanos(nanos);
|
||||
} catch (InterruptedException ie) {
|
||||
if (g == generation && ! g.broken) {
|
||||
breakBarrier();
|
||||
throw ie;
|
||||
} else {
|
||||
// We're about to finish waiting even if we had not
|
||||
// been interrupted, so this interrupt is deemed to
|
||||
// "belong" to subsequent execution.
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
}
|
||||
|
||||
if (g.broken)
|
||||
throw new BrokenBarrierException();
|
||||
|
||||
if (g != generation)
|
||||
return index;
|
||||
|
||||
if (timed && nanos <= 0L) {
|
||||
breakBarrier();
|
||||
throw new TimeoutException();
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
lock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
总结：`CyclicBarrier` 内部通过一个 count 变量作为计数器，cout 的初始值为 parties 属性的初始化值，每当一个线程到了栅栏这里了，那么就将计数器减一。如果 count 值为 0 了，表示这是这一代最后一个线程到达栅栏，就尝试执行我们构造方法中输入的任务。
|
||||
|
||||
#### 5.4 CyclicBarrier 和 CountDownLatch 的区别
|
||||
|
||||
**下面这个是国外一个大佬的回答：**
|
||||
|
||||
CountDownLatch 是计数器，只能使用一次，而 CyclicBarrier 的计数器提供 reset 功能，可以多次使用。但是我不那么认为它们之间的区别仅仅就是这么简单的一点。我们来从 jdk 作者设计的目的来看，javadoc 是这么描述它们的：
|
||||
|
||||
> CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.(CountDownLatch: 一个或者多个线程，等待其他多个线程完成某件事情之后才能执行；)
|
||||
> CyclicBarrier : A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.(CyclicBarrier : 多个线程互相等待，直到到达同一个同步点，再继续一起执行。)
|
||||
|
||||
对于 CountDownLatch 来说，重点是“一个线程（多个线程）等待”，而其他的 N 个线程在完成“某件事情”之后，可以终止，也可以等待。而对于 CyclicBarrier，重点是多个线程，在任意一个线程没有完成，所有的线程都必须等待。
|
||||
|
||||
CountDownLatch 是计数器，线程完成一个记录一个，只不过计数不是递增而是递减，而 CyclicBarrier 更像是一个阀门，需要所有线程都到达，阀门才能打开，然后继续执行。
|
||||
|
||||
### 6 ReentrantLock 和 ReentrantReadWriteLock
|
||||
|
||||
ReentrantLock 和 synchronized 的区别在上面已经讲过了这里就不多做讲解。另外，需要注意的是：读写锁 ReentrantReadWriteLock 可以保证多个线程可以同时读，所以在读操作远大于写操作的时候，读写锁就非常有用了。
|
||||
|
||||
### 参考
|
||||
|
||||
- https://juejin.im/post/5ae755256fb9a07ac3634067
|
||||
- https://blog.csdn.net/u010185262/article/details/54692886
|
||||
- https://blog.csdn.net/tolcf/article/details/50925145?utm_source=blogxgwz0
|
||||
|
||||
### 公众号
|
||||
|
||||
如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。
|
||||
|
||||
**《Java 面试突击》:** 由本文档衍生的专为面试而生的《Java 面试突击》V2.0 PDF 版本[公众号](#公众号 "公众号")后台回复 **"面试突击"** 即可免费领取！
|
||||
|
||||
**Java 工程师必备学习资源:** 一些 Java 工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
|
||||
|
||||
|
||||
|
||||
556
docs/java/Multithread/Atomic.md
Normal file
556
docs/java/Multithread/Atomic.md
Normal file
@ -0,0 +1,556 @@
|
||||
点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。
|
||||
|
||||
> 个人觉得这一节掌握基本的使用即可！
|
||||
|
||||
<!-- TOC -->
|
||||
|
||||
- [1 Atomic 原子类介绍](#1-atomic-原子类介绍)
|
||||
- [2 基本类型原子类](#2-基本类型原子类)
|
||||
- [2.1 基本类型原子类介绍](#21-基本类型原子类介绍)
|
||||
- [2.2 AtomicInteger 常见方法使用](#22-atomicinteger-常见方法使用)
|
||||
- [2.3 基本数据类型原子类的优势](#23-基本数据类型原子类的优势)
|
||||
- [2.4 AtomicInteger 线程安全原理简单分析](#24-atomicinteger-线程安全原理简单分析)
|
||||
- [3 数组类型原子类](#3-数组类型原子类)
|
||||
- [3.1 数组类型原子类介绍](#31-数组类型原子类介绍)
|
||||
- [3.2 AtomicIntegerArray 常见方法使用](#32-atomicintegerarray-常见方法使用)
|
||||
- [4 引用类型原子类](#4-引用类型原子类)
|
||||
- [4.1 引用类型原子类介绍](#41--引用类型原子类介绍)
|
||||
- [4.2 AtomicReference 类使用示例](#42-atomicreference-类使用示例)
|
||||
- [4.3 AtomicStampedReference 类使用示例](#43-atomicstampedreference-类使用示例)
|
||||
- [4.4 AtomicMarkableReference 类使用示例](#44-atomicmarkablereference-类使用示例)
|
||||
- [5 对象的属性修改类型原子类](#5-对象的属性修改类型原子类)
|
||||
- [5.1 对象的属性修改类型原子类介绍](#51-对象的属性修改类型原子类介绍)
|
||||
- [5.2 AtomicIntegerFieldUpdater 类使用示例](#52-atomicintegerfieldupdater-类使用示例)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
### 1 Atomic 原子类介绍
|
||||
|
||||
Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里 Atomic 是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。
|
||||
|
||||
所以，所谓原子类说简单点就是具有原子/原子操作特征的类。
|
||||
|
||||
并发包 `java.util.concurrent` 的原子类都存放在`java.util.concurrent.atomic`下,如下图所示。
|
||||
|
||||
|
||||
|
||||
根据操作的数据类型，可以将JUC包中的原子类分为4类
|
||||
|
||||
**基本类型**
|
||||
|
||||
使用原子的方式更新基本类型
|
||||
|
||||
- AtomicInteger：整型原子类
|
||||
- AtomicLong：长整型原子类
|
||||
- AtomicBoolean ：布尔型原子类
|
||||
|
||||
**数组类型**
|
||||
|
||||
使用原子的方式更新数组里的某个元素
|
||||
|
||||
|
||||
- AtomicIntegerArray：整型数组原子类
|
||||
- AtomicLongArray：长整型数组原子类
|
||||
- AtomicReferenceArray ：引用类型数组原子类
|
||||
|
||||
**引用类型**
|
||||
|
||||
- AtomicReference：引用类型原子类
|
||||
- AtomicReferenceFieldUpdater：原子更新引用类型里的字段
|
||||
- AtomicMarkableReference ：原子更新带有标记位的引用类型
|
||||
|
||||
**对象的属性修改类型**
|
||||
|
||||
- AtomicIntegerFieldUpdater:原子更新整型字段的更新器
|
||||
- AtomicLongFieldUpdater：原子更新长整型字段的更新器
|
||||
- AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。
|
||||
- AtomicMarkableReference：原子更新带有标记的引用类型。该类将 boolean 标记与引用关联起来，也可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。
|
||||
|
||||
**CAS ABA 问题**
|
||||
- 描述: 第一个线程取到了变量 x 的值 A，然后巴拉巴拉干别的事，总之就是只拿到了变量 x 的值 A。这段时间内第二个线程也取到了变量 x 的值 A，然后把变量 x 的值改为 B，然后巴拉巴拉干别的事，最后又把变量 x 的值变为 A （相当于还原了）。在这之后第一个线程终于进行了变量 x 的操作，但是此时变量 x 的值还是 A，所以 compareAndSet 操作是成功。
|
||||
- 例子描述(可能不太合适，但好理解): 年初，现金为零，然后通过正常劳动赚了三百万，之后正常消费了（比如买房子）三百万。年末，虽然现金零收入（可能变成其他形式了），但是赚了钱是事实，还是得交税的！
|
||||
- 代码例子（以``` AtomicInteger ```为例）
|
||||
|
||||
```java
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
public class AtomicIntegerDefectDemo {
|
||||
public static void main(String[] args) {
|
||||
defectOfABA();
|
||||
}
|
||||
|
||||
static void defectOfABA() {
|
||||
final AtomicInteger atomicInteger = new AtomicInteger(1);
|
||||
|
||||
Thread coreThread = new Thread(
|
||||
() -> {
|
||||
final int currentValue = atomicInteger.get();
|
||||
System.out.println(Thread.currentThread().getName() + " ------ currentValue=" + currentValue);
|
||||
|
||||
// 这段目的：模拟处理其他业务花费的时间
|
||||
try {
|
||||
Thread.sleep(300);
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
boolean casResult = atomicInteger.compareAndSet(1, 2);
|
||||
System.out.println(Thread.currentThread().getName()
|
||||
+ " ------ currentValue=" + currentValue
|
||||
+ ", finalValue=" + atomicInteger.get()
|
||||
+ ", compareAndSet Result=" + casResult);
|
||||
}
|
||||
);
|
||||
coreThread.start();
|
||||
|
||||
// 这段目的：为了让 coreThread 线程先跑起来
|
||||
try {
|
||||
Thread.sleep(100);
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
Thread amateurThread = new Thread(
|
||||
() -> {
|
||||
int currentValue = atomicInteger.get();
|
||||
boolean casResult = atomicInteger.compareAndSet(1, 2);
|
||||
System.out.println(Thread.currentThread().getName()
|
||||
+ " ------ currentValue=" + currentValue
|
||||
+ ", finalValue=" + atomicInteger.get()
|
||||
+ ", compareAndSet Result=" + casResult);
|
||||
|
||||
currentValue = atomicInteger.get();
|
||||
casResult = atomicInteger.compareAndSet(2, 1);
|
||||
System.out.println(Thread.currentThread().getName()
|
||||
+ " ------ currentValue=" + currentValue
|
||||
+ ", finalValue=" + atomicInteger.get()
|
||||
+ ", compareAndSet Result=" + casResult);
|
||||
}
|
||||
);
|
||||
amateurThread.start();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
输出内容如下：
|
||||
|
||||
```
|
||||
Thread-0 ------ currentValue=1
|
||||
Thread-1 ------ currentValue=1, finalValue=2, compareAndSet Result=true
|
||||
Thread-1 ------ currentValue=2, finalValue=1, compareAndSet Result=true
|
||||
Thread-0 ------ currentValue=1, finalValue=2, compareAndSet Result=true
|
||||
```
|
||||
|
||||
下面我们来详细介绍一下这些原子类。
|
||||
|
||||
### 2 基本类型原子类
|
||||
|
||||
#### 2.1 基本类型原子类介绍
|
||||
|
||||
使用原子的方式更新基本类型
|
||||
|
||||
- AtomicInteger：整型原子类
|
||||
- AtomicLong：长整型原子类
|
||||
- AtomicBoolean ：布尔型原子类
|
||||
|
||||
上面三个类提供的方法几乎相同，所以我们这里以 AtomicInteger 为例子来介绍。
|
||||
|
||||
**AtomicInteger 类常用方法**
|
||||
|
||||
```java
|
||||
public final int get() //获取当前的值
|
||||
public final int getAndSet(int newValue)//获取当前的值，并设置新的值
|
||||
public final int getAndIncrement()//获取当前的值，并自增
|
||||
public final int getAndDecrement() //获取当前的值，并自减
|
||||
public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
|
||||
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
|
||||
public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。
|
||||
```
|
||||
|
||||
#### 2.2 AtomicInteger 常见方法使用
|
||||
|
||||
```java
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
public class AtomicIntegerTest {
|
||||
|
||||
public static void main(String[] args) {
|
||||
// TODO Auto-generated method stub
|
||||
int temvalue = 0;
|
||||
AtomicInteger i = new AtomicInteger(0);
|
||||
temvalue = i.getAndSet(3);
|
||||
System.out.println("temvalue:" + temvalue + "; i:" + i);//temvalue:0; i:3
|
||||
temvalue = i.getAndIncrement();
|
||||
System.out.println("temvalue:" + temvalue + "; i:" + i);//temvalue:3; i:4
|
||||
temvalue = i.getAndAdd(5);
|
||||
System.out.println("temvalue:" + temvalue + "; i:" + i);//temvalue:4; i:9
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
#### 2.3 基本数据类型原子类的优势
|
||||
|
||||
通过一个简单例子带大家看一下基本数据类型原子类的优势
|
||||
|
||||
**①多线程环境不使用原子类保证线程安全（基本数据类型）**
|
||||
|
||||
```java
|
||||
class Test {
|
||||
private volatile int count = 0;
|
||||
//若要线程安全执行执行count++，需要加锁
|
||||
public synchronized void increment() {
|
||||
count++;
|
||||
}
|
||||
|
||||
public int getCount() {
|
||||
return count;
|
||||
}
|
||||
}
|
||||
```
|
||||
**②多线程环境使用原子类保证线程安全（基本数据类型）**
|
||||
|
||||
```java
|
||||
class Test2 {
|
||||
private AtomicInteger count = new AtomicInteger();
|
||||
|
||||
public void increment() {
|
||||
count.incrementAndGet();
|
||||
}
|
||||
//使用AtomicInteger之后，不需要加锁，也可以实现线程安全。
|
||||
public int getCount() {
|
||||
return count.get();
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
#### 2.4 AtomicInteger 线程安全原理简单分析
|
||||
|
||||
AtomicInteger 类的部分源码：
|
||||
|
||||
```java
|
||||
// setup to use Unsafe.compareAndSwapInt for updates（更新操作时提供“比较并替换”的作用）
|
||||
private static final Unsafe unsafe = Unsafe.getUnsafe();
|
||||
private static final long valueOffset;
|
||||
|
||||
static {
|
||||
try {
|
||||
valueOffset = unsafe.objectFieldOffset
|
||||
(AtomicInteger.class.getDeclaredField("value"));
|
||||
} catch (Exception ex) { throw new Error(ex); }
|
||||
}
|
||||
|
||||
private volatile int value;
|
||||
```
|
||||
|
||||
AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。
|
||||
|
||||
CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址。另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。
|
||||
|
||||
|
||||
### 3 数组类型原子类
|
||||
|
||||
#### 3.1 数组类型原子类介绍
|
||||
|
||||
使用原子的方式更新数组里的某个元素
|
||||
|
||||
|
||||
- AtomicIntegerArray：整形数组原子类
|
||||
- AtomicLongArray：长整形数组原子类
|
||||
- AtomicReferenceArray ：引用类型数组原子类
|
||||
|
||||
上面三个类提供的方法几乎相同，所以我们这里以 AtomicIntegerArray 为例子来介绍。
|
||||
|
||||
**AtomicIntegerArray 类常用方法**
|
||||
|
||||
```java
|
||||
public final int get(int i) //获取 index=i 位置元素的值
|
||||
public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValue
|
||||
public final int getAndIncrement(int i)//获取 index=i 位置元素的值，并让该位置的元素自增
|
||||
public final int getAndDecrement(int i) //获取 index=i 位置元素的值，并让该位置的元素自减
|
||||
public final int getAndAdd(int delta) //获取 index=i 位置元素的值，并加上预期的值
|
||||
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将 index=i 位置的元素值设置为输入值（update）
|
||||
public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。
|
||||
```
|
||||
#### 3.2 AtomicIntegerArray 常见方法使用
|
||||
|
||||
```java
|
||||
|
||||
import java.util.concurrent.atomic.AtomicIntegerArray;
|
||||
|
||||
public class AtomicIntegerArrayTest {
|
||||
|
||||
public static void main(String[] args) {
|
||||
// TODO Auto-generated method stub
|
||||
int temvalue = 0;
|
||||
int[] nums = { 1, 2, 3, 4, 5, 6 };
|
||||
AtomicIntegerArray i = new AtomicIntegerArray(nums);
|
||||
for (int j = 0; j < nums.length; j++) {
|
||||
System.out.println(i.get(j));
|
||||
}
|
||||
temvalue = i.getAndSet(0, 2);
|
||||
System.out.println("temvalue:" + temvalue + "; i:" + i);
|
||||
temvalue = i.getAndIncrement(0);
|
||||
System.out.println("temvalue:" + temvalue + "; i:" + i);
|
||||
temvalue = i.getAndAdd(0, 5);
|
||||
System.out.println("temvalue:" + temvalue + "; i:" + i);
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
### 4 引用类型原子类
|
||||
|
||||
#### 4.1 引用类型原子类介绍
|
||||
|
||||
基本类型原子类只能更新一个变量，如果需要原子更新多个变量，需要使用 引用类型原子类。
|
||||
|
||||
- AtomicReference：引用类型原子类
|
||||
- AtomicStampedReference：原子更新引用类型里的字段原子类
|
||||
- AtomicMarkableReference ：原子更新带有标记位的引用类型
|
||||
|
||||
上面三个类提供的方法几乎相同，所以我们这里以 AtomicReference 为例子来介绍。
|
||||
|
||||
#### 4.2 AtomicReference 类使用示例
|
||||
|
||||
```java
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
|
||||
public class AtomicReferenceTest {
|
||||
|
||||
public static void main(String[] args) {
|
||||
AtomicReference<Person> ar = new AtomicReference<Person>();
|
||||
Person person = new Person("SnailClimb", 22);
|
||||
ar.set(person);
|
||||
Person updatePerson = new Person("Daisy", 20);
|
||||
ar.compareAndSet(person, updatePerson);
|
||||
|
||||
System.out.println(ar.get().getName());
|
||||
System.out.println(ar.get().getAge());
|
||||
}
|
||||
}
|
||||
|
||||
class Person {
|
||||
private String name;
|
||||
private int age;
|
||||
|
||||
public Person(String name, int age) {
|
||||
super();
|
||||
this.name = name;
|
||||
this.age = age;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public void setName(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
public int getAge() {
|
||||
return age;
|
||||
}
|
||||
|
||||
public void setAge(int age) {
|
||||
this.age = age;
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
上述代码首先创建了一个 Person 对象，然后把 Person 对象设置进 AtomicReference 对象中，然后调用 compareAndSet 方法，该方法就是通过 CAS 操作设置 ar。如果 ar 的值为 person 的话，则将其设置为 updatePerson。实现原理与 AtomicInteger 类中的 compareAndSet 方法相同。运行上面的代码后的输出结果如下：
|
||||
|
||||
```
|
||||
Daisy
|
||||
20
|
||||
```
|
||||
#### 4.3 AtomicStampedReference 类使用示例
|
||||
|
||||
```java
|
||||
import java.util.concurrent.atomic.AtomicStampedReference;
|
||||
|
||||
public class AtomicStampedReferenceDemo {
|
||||
public static void main(String[] args) {
|
||||
// 实例化、取当前值和 stamp 值
|
||||
final Integer initialRef = 0, initialStamp = 0;
|
||||
final AtomicStampedReference<Integer> asr = new AtomicStampedReference<>(initialRef, initialStamp);
|
||||
System.out.println("currentValue=" + asr.getReference() + ", currentStamp=" + asr.getStamp());
|
||||
|
||||
// compare and set
|
||||
final Integer newReference = 666, newStamp = 999;
|
||||
final boolean casResult = asr.compareAndSet(initialRef, newReference, initialStamp, newStamp);
|
||||
System.out.println("currentValue=" + asr.getReference()
|
||||
+ ", currentStamp=" + asr.getStamp()
|
||||
+ ", casResult=" + casResult);
|
||||
|
||||
// 获取当前的值和当前的 stamp 值
|
||||
int[] arr = new int[1];
|
||||
final Integer currentValue = asr.get(arr);
|
||||
final int currentStamp = arr[0];
|
||||
System.out.println("currentValue=" + currentValue + ", currentStamp=" + currentStamp);
|
||||
|
||||
// 单独设置 stamp 值
|
||||
final boolean attemptStampResult = asr.attemptStamp(newReference, 88);
|
||||
System.out.println("currentValue=" + asr.getReference()
|
||||
+ ", currentStamp=" + asr.getStamp()
|
||||
+ ", attemptStampResult=" + attemptStampResult);
|
||||
|
||||
// 重新设置当前值和 stamp 值
|
||||
asr.set(initialRef, initialStamp);
|
||||
System.out.println("currentValue=" + asr.getReference() + ", currentStamp=" + asr.getStamp());
|
||||
|
||||
// [不推荐使用，除非搞清楚注释的意思了] weak compare and set
|
||||
// 困惑！weakCompareAndSet 这个方法最终还是调用 compareAndSet 方法。[版本: jdk-8u191]
|
||||
// 但是注释上写着 "May fail spuriously and does not provide ordering guarantees,
|
||||
// so is only rarely an appropriate alternative to compareAndSet."
|
||||
// todo 感觉有可能是 jvm 通过方法名在 native 方法里面做了转发
|
||||
final boolean wCasResult = asr.weakCompareAndSet(initialRef, newReference, initialStamp, newStamp);
|
||||
System.out.println("currentValue=" + asr.getReference()
|
||||
+ ", currentStamp=" + asr.getStamp()
|
||||
+ ", wCasResult=" + wCasResult);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
输出结果如下：
|
||||
```
|
||||
currentValue=0, currentStamp=0
|
||||
currentValue=666, currentStamp=999, casResult=true
|
||||
currentValue=666, currentStamp=999
|
||||
currentValue=666, currentStamp=88, attemptStampResult=true
|
||||
currentValue=0, currentStamp=0
|
||||
currentValue=666, currentStamp=999, wCasResult=true
|
||||
```
|
||||
|
||||
#### 4.4 AtomicMarkableReference 类使用示例
|
||||
|
||||
``` java
|
||||
import java.util.concurrent.atomic.AtomicMarkableReference;
|
||||
|
||||
public class AtomicMarkableReferenceDemo {
|
||||
public static void main(String[] args) {
|
||||
// 实例化、取当前值和 mark 值
|
||||
final Boolean initialRef = null, initialMark = false;
|
||||
final AtomicMarkableReference<Boolean> amr = new AtomicMarkableReference<>(initialRef, initialMark);
|
||||
System.out.println("currentValue=" + amr.getReference() + ", currentMark=" + amr.isMarked());
|
||||
|
||||
// compare and set
|
||||
final Boolean newReference1 = true, newMark1 = true;
|
||||
final boolean casResult = amr.compareAndSet(initialRef, newReference1, initialMark, newMark1);
|
||||
System.out.println("currentValue=" + amr.getReference()
|
||||
+ ", currentMark=" + amr.isMarked()
|
||||
+ ", casResult=" + casResult);
|
||||
|
||||
// 获取当前的值和当前的 mark 值
|
||||
boolean[] arr = new boolean[1];
|
||||
final Boolean currentValue = amr.get(arr);
|
||||
final boolean currentMark = arr[0];
|
||||
System.out.println("currentValue=" + currentValue + ", currentMark=" + currentMark);
|
||||
|
||||
// 单独设置 mark 值
|
||||
final boolean attemptMarkResult = amr.attemptMark(newReference1, false);
|
||||
System.out.println("currentValue=" + amr.getReference()
|
||||
+ ", currentMark=" + amr.isMarked()
|
||||
+ ", attemptMarkResult=" + attemptMarkResult);
|
||||
|
||||
// 重新设置当前值和 mark 值
|
||||
amr.set(initialRef, initialMark);
|
||||
System.out.println("currentValue=" + amr.getReference() + ", currentMark=" + amr.isMarked());
|
||||
|
||||
// [不推荐使用，除非搞清楚注释的意思了] weak compare and set
|
||||
// 困惑！weakCompareAndSet 这个方法最终还是调用 compareAndSet 方法。[版本: jdk-8u191]
|
||||
// 但是注释上写着 "May fail spuriously and does not provide ordering guarantees,
|
||||
// so is only rarely an appropriate alternative to compareAndSet."
|
||||
// todo 感觉有可能是 jvm 通过方法名在 native 方法里面做了转发
|
||||
final boolean wCasResult = amr.weakCompareAndSet(initialRef, newReference1, initialMark, newMark1);
|
||||
System.out.println("currentValue=" + amr.getReference()
|
||||
+ ", currentMark=" + amr.isMarked()
|
||||
+ ", wCasResult=" + wCasResult);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
输出结果如下：
|
||||
```
|
||||
currentValue=null, currentMark=false
|
||||
currentValue=true, currentMark=true, casResult=true
|
||||
currentValue=true, currentMark=true
|
||||
currentValue=true, currentMark=false, attemptMarkResult=true
|
||||
currentValue=null, currentMark=false
|
||||
currentValue=true, currentMark=true, wCasResult=true
|
||||
```
|
||||
|
||||
### 5 对象的属性修改类型原子类
|
||||
|
||||
#### 5.1 对象的属性修改类型原子类介绍
|
||||
|
||||
如果需要原子更新某个类里的某个字段时，需要用到对象的属性修改类型原子类。
|
||||
|
||||
- AtomicIntegerFieldUpdater:原子更新整形字段的更新器
|
||||
- AtomicLongFieldUpdater：原子更新长整形字段的更新器
|
||||
- AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。
|
||||
|
||||
要想原子地更新对象的属性需要两步。第一步，因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须使用静态方法 newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。第二步，更新的对象属性必须使用 public volatile 修饰符。
|
||||
|
||||
上面三个类提供的方法几乎相同，所以我们这里以 `AtomicIntegerFieldUpdater`为例子来介绍。
|
||||
|
||||
#### 5.2 AtomicIntegerFieldUpdater 类使用示例
|
||||
|
||||
```java
|
||||
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
|
||||
|
||||
public class AtomicIntegerFieldUpdaterTest {
|
||||
public static void main(String[] args) {
|
||||
AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");
|
||||
|
||||
User user = new User("Java", 22);
|
||||
System.out.println(a.getAndIncrement(user));// 22
|
||||
System.out.println(a.get(user));// 23
|
||||
}
|
||||
}
|
||||
|
||||
class User {
|
||||
private String name;
|
||||
public volatile int age;
|
||||
|
||||
public User(String name, int age) {
|
||||
super();
|
||||
this.name = name;
|
||||
this.age = age;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public void setName(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
public int getAge() {
|
||||
return age;
|
||||
}
|
||||
|
||||
public void setAge(int age) {
|
||||
this.age = age;
|
||||
}
|
||||
|
||||
}
|
||||
```
|
||||
|
||||
输出结果：
|
||||
|
||||
```
|
||||
22
|
||||
23
|
||||
```
|
||||
|
||||
## 公众号
|
||||
|
||||
如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。
|
||||
|
||||
**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"面试突击"** 即可免费领取！
|
||||
|
||||
**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
|
||||
|
||||
|
||||
@ -0,0 +1,929 @@
|
||||
点击关注[公众号](#公众号)及时获取笔主最新更新文章，并可免费领取本文档配套的《Java面试突击》以及Java工程师必备学习资源。
|
||||
|
||||
<!-- TOC -->
|
||||
|
||||
- [Java 并发进阶常见面试题总结](#java-并发进阶常见面试题总结)
|
||||
- [1. synchronized 关键字](#1-synchronized-关键字)
|
||||
- [1.1. 说一说自己对于 synchronized 关键字的了解](#11-说一说自己对于-synchronized-关键字的了解)
|
||||
- [1.2. 说说自己是怎么使用 synchronized 关键字，在项目中用到了吗](#12-说说自己是怎么使用-synchronized-关键字在项目中用到了吗)
|
||||
- [1.3. 讲一下 synchronized 关键字的底层原理](#13-讲一下-synchronized-关键字的底层原理)
|
||||
- [1.4. 说说 JDK1.6 之后的synchronized 关键字底层做了哪些优化，可以详细介绍一下这些优化吗](#14-说说-jdk16-之后的synchronized-关键字底层做了哪些优化可以详细介绍一下这些优化吗)
|
||||
- [1.5. 谈谈 synchronized和ReentrantLock 的区别](#15-谈谈-synchronized和reentrantlock-的区别)
|
||||
- [2. volatile关键字](#2-volatile关键字)
|
||||
- [2.1. 讲一下Java内存模型](#21-讲一下java内存模型)
|
||||
- [2.2. 说说 synchronized 关键字和 volatile 关键字的区别](#22-说说-synchronized-关键字和-volatile-关键字的区别)
|
||||
- [3. ThreadLocal](#3-threadlocal)
|
||||
- [3.1. ThreadLocal简介](#31-threadlocal简介)
|
||||
- [3.2. ThreadLocal示例](#32-threadlocal示例)
|
||||
- [3.3. ThreadLocal原理](#33-threadlocal原理)
|
||||
- [3.4. ThreadLocal 内存泄露问题](#34-threadlocal-内存泄露问题)
|
||||
- [4. 线程池](#4-线程池)
|
||||
- [4.1. 为什么要用线程池？](#41-为什么要用线程池)
|
||||
- [4.2. 实现Runnable接口和Callable接口的区别](#42-实现runnable接口和callable接口的区别)
|
||||
- [4.3. 执行execute()方法和submit()方法的区别是什么呢？](#43-执行execute方法和submit方法的区别是什么呢)
|
||||
- [4.4. 如何创建线程池](#44-如何创建线程池)
|
||||
- [5. Atomic 原子类](#5-atomic-原子类)
|
||||
- [5.1. 介绍一下Atomic 原子类](#51-介绍一下atomic-原子类)
|
||||
- [5.2. JUC 包中的原子类是哪4类?](#52-juc-包中的原子类是哪4类)
|
||||
- [5.3. 讲讲 AtomicInteger 的使用](#53-讲讲-atomicinteger-的使用)
|
||||
- [5.4. 能不能给我简单介绍一下 AtomicInteger 类的原理](#54-能不能给我简单介绍一下-atomicinteger-类的原理)
|
||||
- [6. AQS](#6-aqs)
|
||||
- [6.1. AQS 介绍](#61-aqs-介绍)
|
||||
- [6.2. AQS 原理分析](#62-aqs-原理分析)
|
||||
- [6.2.1. AQS 原理概览](#621-aqs-原理概览)
|
||||
- [6.2.2. AQS 对资源的共享方式](#622-aqs-对资源的共享方式)
|
||||
- [6.2.3. AQS底层使用了模板方法模式](#623-aqs底层使用了模板方法模式)
|
||||
- [6.3. AQS 组件总结](#63-aqs-组件总结)
|
||||
- [7 Reference](#7-reference)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
# Java 并发进阶常见面试题总结
|
||||
|
||||
## 1. synchronized 关键字
|
||||
|
||||
### 1.1. 说一说自己对于 synchronized 关键字的了解
|
||||
|
||||
synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。
|
||||
|
||||
另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的 Mutex Lock 来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时需要从用户态转换到内核态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，这也是为什么早期的 synchronized 效率低的原因。庆幸的是在 Java 6 之后 Java 官方对从 JVM 层面对synchronized 较大优化，所以现在的 synchronized 锁效率也优化得很不错了。JDK1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。
|
||||
|
||||
|
||||
### 1.2. 说说自己是怎么使用 synchronized 关键字，在项目中用到了吗
|
||||
|
||||
**synchronized关键字最主要的三种使用方式：**
|
||||
|
||||
- **修饰实例方法:** 作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁
|
||||
- **修饰静态方法:** 也就是给当前类加锁，会作用于类的所有对象实例，因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管new了多少个对象，只有一份）。所以如果一个线程A调用一个实例对象的非静态 synchronized 方法，而线程B需要调用这个实例对象所属类的静态 synchronized 方法，是允许的，不会发生互斥现象，**因为访问静态 synchronized 方法占用的锁是当前类的锁，而访问非静态 synchronized 方法占用的锁是当前实例对象锁**。
|
||||
- **修饰代码块:** 指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。
|
||||
|
||||
**总结：** synchronized 关键字加到 static 静态方法和 synchronized(class)代码块上都是是给 Class 类上锁。synchronized 关键字加到实例方法上是给对象实例上锁。尽量不要使用 synchronized(String a) 因为JVM中，字符串常量池具有缓存功能！
|
||||
|
||||
下面我以一个常见的面试题为例讲解一下 synchronized 关键字的具体使用。
|
||||
|
||||
面试中面试官经常会说：“单例模式了解吗？来给我手写一下！给我解释一下双重检验锁方式实现单例模式的原理呗！”
|
||||
|
||||
**双重校验锁实现对象单例（线程安全）**
|
||||
|
||||
```java
|
||||
public class Singleton {
|
||||
|
||||
private volatile static Singleton uniqueInstance;
|
||||
|
||||
private Singleton() {
|
||||
}
|
||||
|
||||
public static Singleton getUniqueInstance() {
|
||||
//先判断对象是否已经实例过，没有实例化过才进入加锁代码
|
||||
if (uniqueInstance == null) {
|
||||
//类对象加锁
|
||||
synchronized (Singleton.class) {
|
||||
if (uniqueInstance == null) {
|
||||
uniqueInstance = new Singleton();
|
||||
}
|
||||
}
|
||||
}
|
||||
return uniqueInstance;
|
||||
}
|
||||
}
|
||||
```
|
||||
另外，需要注意 uniqueInstance 采用 volatile 关键字修饰也是很有必要。
|
||||
|
||||
uniqueInstance 采用 volatile 关键字修饰也是很有必要的， uniqueInstance = new Singleton(); 这段代码其实是分为三步执行：
|
||||
|
||||
1. 为 uniqueInstance 分配内存空间
|
||||
2. 初始化 uniqueInstance
|
||||
3. 将 uniqueInstance 指向分配的内存地址
|
||||
|
||||
但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
|
||||
|
||||
使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。
|
||||
|
||||
### 1.3. 讲一下 synchronized 关键字的底层原理
|
||||
|
||||
**synchronized 关键字底层原理属于 JVM 层面。**
|
||||
|
||||
**① synchronized 同步语句块的情况**
|
||||
|
||||
```java
|
||||
public class SynchronizedDemo {
|
||||
public void method() {
|
||||
synchronized (this) {
|
||||
System.out.println("synchronized 代码块");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
通过 JDK 自带的 javap 命令查看 SynchronizedDemo 类的相关字节码信息：首先切换到类的对应目录执行 `javac SynchronizedDemo.java` 命令生成编译后的 .class 文件，然后执行`javap -c -s -v -l SynchronizedDemo.class`。
|
||||
|
||||
|
||||
|
||||
从上面我们可以看出：
|
||||
|
||||
**synchronized 同步语句块的实现使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代码块的开始位置，monitorexit 指令则指明同步代码块的结束位置。** 当执行 monitorenter 指令时，线程试图获取锁也就是获取 monitor(monitor对象存在于每个Java对象的对象头中，synchronized 锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因) 的持有权。当计数器为0则可以成功获取，获取后将锁计数器设为1也就是加1。相应的在执行 monitorexit 指令后，将锁计数器设为0，表明锁被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到锁被另外一个线程释放为止。
|
||||
|
||||
**② synchronized 修饰方法的的情况**
|
||||
|
||||
```java
|
||||
public class SynchronizedDemo2 {
|
||||
public synchronized void method() {
|
||||
System.out.println("synchronized 方法");
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
|
||||
|
||||
synchronized 修饰的方法并没有 monitorenter 指令和 monitorexit 指令，取得代之的确实是 ACC_SYNCHRONIZED 标识，该标识指明了该方法是一个同步方法，JVM 通过该 ACC_SYNCHRONIZED 访问标志来辨别一个方法是否声明为同步方法，从而执行相应的同步调用。
|
||||
|
||||
|
||||
### 1.4. 说说 JDK1.6 之后的synchronized 关键字底层做了哪些优化，可以详细介绍一下这些优化吗
|
||||
|
||||
JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。
|
||||
|
||||
锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。
|
||||
|
||||
关于这几种优化的详细信息可以查看笔主的这篇文章：<https://gitee.com/SnailClimb/JavaGuide/blob/master/docs/java/Multithread/synchronized.md>
|
||||
|
||||
### 1.5. 谈谈 synchronized和ReentrantLock 的区别
|
||||
|
||||
|
||||
**① 两者都是可重入锁**
|
||||
|
||||
两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。
|
||||
|
||||
**② synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API**
|
||||
|
||||
synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。
|
||||
|
||||
**③ ReentrantLock 比 synchronized 增加了一些高级功能**
|
||||
|
||||
相比synchronized，ReentrantLock增加了一些高级功能。主要来说主要有三点：**①等待可中断；②可实现公平锁；③可实现选择性通知（锁可以绑定多个条件）**
|
||||
|
||||
- **ReentrantLock提供了一种能够中断等待锁的线程的机制**，通过lock.lockInterruptibly()来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。
|
||||
- **ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。** ReentrantLock默认情况是非公平的，可以通过 ReentrantLock类的`ReentrantLock(boolean fair)`构造方法来制定是否是公平的。
|
||||
- synchronized关键字与wait()和notify()/notifyAll()方法相结合可以实现等待/通知机制，ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition() 方法。Condition是JDK1.5之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），**线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。 在使用notify()/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，用ReentrantLock类结合Condition实例可以实现“选择性通知”** ，这个功能非常重要，而且是Condition接口默认提供的。而synchronized关键字就相当于整个Lock对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法 只会唤醒注册在该Condition实例中的所有等待线程。
|
||||
|
||||
如果你想使用上述功能，那么选择ReentrantLock是一个不错的选择。
|
||||
|
||||
**④ 性能已不是选择标准**
|
||||
|
||||
## 2. volatile关键字
|
||||
|
||||
### 2.1. 讲一下Java内存模型
|
||||
|
||||
|
||||
在 JDK1.2 之前，Java的内存模型实现总是从**主存**（即共享内存）读取变量，是不需要进行特别的注意的。而在当前的 Java 内存模型下，线程可以把变量保存**本地内存**（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成**数据的不一致**。
|
||||
|
||||
|
||||
|
||||
要解决这个问题，就需要把变量声明为**volatile**，这就指示 JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。
|
||||
|
||||
说白了， **volatile** 关键字的主要作用就是保证变量的可见性然后还有一个作用是防止指令重排序。
|
||||
|
||||
|
||||
|
||||
|
||||
### 2.2. 说说 synchronized 关键字和 volatile 关键字的区别
|
||||
|
||||
synchronized关键字和volatile关键字比较
|
||||
|
||||
- **volatile关键字**是线程同步的**轻量级实现**，所以**volatile性能肯定比synchronized关键字要好**。但是**volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块**。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，**实际开发中使用 synchronized 关键字的场景还是更多一些**。
|
||||
- **多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞**
|
||||
- **volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。**
|
||||
- **volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。**
|
||||
|
||||
## 3. ThreadLocal
|
||||
|
||||
### 3.1. ThreadLocal简介
|
||||
|
||||
通常情况下，我们创建的变量是可以被任何一个线程访问并修改的。**如果想实现每一个线程都有自己的专属本地变量该如何解决呢？** JDK中提供的`ThreadLocal`类正是为了解决这样的问题。 **`ThreadLocal`类主要解决的就是让每个线程绑定自己的值，可以将`ThreadLocal`类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。**
|
||||
|
||||
**如果你创建了一个`ThreadLocal`变量，那么访问这个变量的每个线程都会有这个变量的本地副本，这也是`ThreadLocal`变量名的由来。他们可以使用 `get（）` 和 `set（）` 方法来获取默认值或将其值更改为当前线程所存的副本的值，从而避免了线程安全问题。**
|
||||
|
||||
再举个简单的例子：
|
||||
|
||||
比如有两个人去宝屋收集宝物，这两个共用一个袋子的话肯定会产生争执，但是给他们两个人每个人分配一个袋子的话就不会出现这样的问题。如果把这两个人比作线程的话，那么ThreadLocal就是用来避免这两个线程竞争的。
|
||||
|
||||
### 3.2. ThreadLocal示例
|
||||
|
||||
相信看了上面的解释，大家已经搞懂 ThreadLocal 类是个什么东西了。
|
||||
|
||||
```java
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.util.Random;
|
||||
|
||||
public class ThreadLocalExample implements Runnable{
|
||||
|
||||
// SimpleDateFormat 不是线程安全的，所以每个线程都要有自己独立的副本
|
||||
private static final ThreadLocal<SimpleDateFormat> formatter = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMMdd HHmm"));
|
||||
|
||||
public static void main(String[] args) throws InterruptedException {
|
||||
ThreadLocalExample obj = new ThreadLocalExample();
|
||||
for(int i=0 ; i<10; i++){
|
||||
Thread t = new Thread(obj, ""+i);
|
||||
Thread.sleep(new Random().nextInt(1000));
|
||||
t.start();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
System.out.println("Thread Name= "+Thread.currentThread().getName()+" default Formatter = "+formatter.get().toPattern());
|
||||
try {
|
||||
Thread.sleep(new Random().nextInt(1000));
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
//formatter pattern is changed here by thread, but it won't reflect to other threads
|
||||
formatter.set(new SimpleDateFormat());
|
||||
|
||||
System.out.println("Thread Name= "+Thread.currentThread().getName()+" formatter = "+formatter.get().toPattern());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
Output:
|
||||
|
||||
```
|
||||
Thread Name= 0 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 0 formatter = yy-M-d ah:mm
|
||||
Thread Name= 1 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 2 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 1 formatter = yy-M-d ah:mm
|
||||
Thread Name= 3 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 2 formatter = yy-M-d ah:mm
|
||||
Thread Name= 4 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 3 formatter = yy-M-d ah:mm
|
||||
Thread Name= 4 formatter = yy-M-d ah:mm
|
||||
Thread Name= 5 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 5 formatter = yy-M-d ah:mm
|
||||
Thread Name= 6 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 6 formatter = yy-M-d ah:mm
|
||||
Thread Name= 7 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 7 formatter = yy-M-d ah:mm
|
||||
Thread Name= 8 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 9 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 8 formatter = yy-M-d ah:mm
|
||||
Thread Name= 9 formatter = yy-M-d ah:mm
|
||||
```
|
||||
|
||||
从输出中可以看出，Thread-0已经改变了formatter的值，但仍然是thread-2默认格式化程序与初始化值相同，其他线程也一样。
|
||||
|
||||
上面有一段代码用到了创建 `ThreadLocal` 变量的那段代码用到了 Java8 的知识，它等于下面这段代码，如果你写了下面这段代码的话，IDEA会提示你转换为Java8的格式(IDEA真的不错！)。因为ThreadLocal类在Java 8中扩展，使用一个新的方法`withInitial()`，将Supplier功能接口作为参数。
|
||||
|
||||
```java
|
||||
private static final ThreadLocal<SimpleDateFormat> formatter = new ThreadLocal<SimpleDateFormat>(){
|
||||
@Override
|
||||
protected SimpleDateFormat initialValue()
|
||||
{
|
||||
return new SimpleDateFormat("yyyyMMdd HHmm");
|
||||
}
|
||||
};
|
||||
```
|
||||
|
||||
### 3.3. ThreadLocal原理
|
||||
|
||||
从 `Thread`类源代码入手。
|
||||
|
||||
```java
|
||||
public class Thread implements Runnable {
|
||||
......
|
||||
//与此线程有关的ThreadLocal值。由ThreadLocal类维护
|
||||
ThreadLocal.ThreadLocalMap threadLocals = null;
|
||||
|
||||
//与此线程有关的InheritableThreadLocal值。由InheritableThreadLocal类维护
|
||||
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
|
||||
......
|
||||
}
|
||||
```
|
||||
|
||||
从上面`Thread`类 源代码可以看出`Thread` 类中有一个 `threadLocals` 和 一个 `inheritableThreadLocals` 变量，它们都是 `ThreadLocalMap` 类型的变量,我们可以把 `ThreadLocalMap` 理解为`ThreadLocal` 类实现的定制化的 `HashMap`。默认情况下这两个变量都是null，只有当前线程调用 `ThreadLocal` 类的 `set`或`get`方法时才创建它们，实际上调用这两个方法的时候，我们调用的是`ThreadLocalMap`类对应的 `get()`、`set() `方法。
|
||||
|
||||
`ThreadLocal`类的`set()`方法
|
||||
|
||||
```java
|
||||
public void set(T value) {
|
||||
Thread t = Thread.currentThread();
|
||||
ThreadLocalMap map = getMap(t);
|
||||
if (map != null)
|
||||
map.set(this, value);
|
||||
else
|
||||
createMap(t, value);
|
||||
}
|
||||
ThreadLocalMap getMap(Thread t) {
|
||||
return t.threadLocals;
|
||||
}
|
||||
```
|
||||
|
||||
通过上面这些内容，我们足以通过猜测得出结论：**最终的变量是放在了当前线程的 `ThreadLocalMap` 中，并不是存在 `ThreadLocal` 上，`ThreadLocal` 可以理解为只是`ThreadLocalMap`的封装，传递了变量值。** `ThrealLocal` 类中可以通过`Thread.currentThread()`获取到当前线程对象后，直接通过`getMap(Thread t)`可以访问到该线程的`ThreadLocalMap`对象。
|
||||
|
||||
**每个`Thread`中都具备一个`ThreadLocalMap`，而`ThreadLocalMap`可以存储以`ThreadLocal`为key的键值对。** 比如我们在同一个线程中声明了两个 `ThreadLocal` 对象的话，会使用 `Thread`内部都是使用仅有那个`ThreadLocalMap` 存放数据的，`ThreadLocalMap`的 key 就是 `ThreadLocal`对象，value 就是 `ThreadLocal` 对象调用`set`方法设置的值。
|
||||
|
||||
`ThreadLocal` 内部维护的是一个类似 `Map` 的`ThreadLocalMap` 数据结构，`key` 为当前对象的 `Thread` 对象，值为 Object 对象。
|
||||
|
||||
|
||||
|
||||
`ThreadLocalMap`是`ThreadLocal`的静态内部类。
|
||||
|
||||
|
||||
|
||||
### 3.4. ThreadLocal 内存泄露问题
|
||||
|
||||
`ThreadLocalMap` 中使用的 key 为 `ThreadLocal` 的弱引用,而 value 是强引用。所以，如果 `ThreadLocal` 没有被外部强引用的情况下，在垃圾回收的时候，key 会被清理掉，而 value 不会被清理掉。这样一来，`ThreadLocalMap` 中就会出现key为null的Entry。假如我们不做任何措施的话，value 永远无法被GC 回收，这个时候就可能会产生内存泄露。ThreadLocalMap实现中已经考虑了这种情况，在调用 `set()`、`get()`、`remove()` 方法的时候，会清理掉 key 为 null 的记录。使用完 `ThreadLocal`方法后 最好手动调用`remove()`方法
|
||||
|
||||
```java
|
||||
static class Entry extends WeakReference<ThreadLocal<?>> {
|
||||
/** The value associated with this ThreadLocal. */
|
||||
Object value;
|
||||
|
||||
Entry(ThreadLocal<?> k, Object v) {
|
||||
super(k);
|
||||
value = v;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**弱引用介绍：**
|
||||
|
||||
> 如果一个对象只具有弱引用，那就类似于**可有可无的生活用品**。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。
|
||||
>
|
||||
> 弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
|
||||
|
||||
## 4. 线程池
|
||||
|
||||
### 4.1. 为什么要用线程池？
|
||||
|
||||
> **池化技术相比大家已经屡见不鲜了，线程池、数据库连接池、Http 连接池等等都是对这个思想的应用。池化技术的思想主要是为了减少每次获取资源的消耗，提高对资源的利用率。**
|
||||
|
||||
**线程池**提供了一种限制和管理资源（包括执行一个任务）。 每个**线程池**还维护一些基本统计信息，例如已完成任务的数量。
|
||||
|
||||
这里借用《Java 并发编程的艺术》提到的来说一下**使用线程池的好处**：
|
||||
|
||||
- **降低资源消耗**。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
|
||||
- **提高响应速度**。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
|
||||
- **提高线程的可管理性**。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
|
||||
|
||||
### 4.2. 实现Runnable接口和Callable接口的区别
|
||||
|
||||
`Runnable`自Java 1.0以来一直存在，但`Callable`仅在Java 1.5中引入,目的就是为了来处理`Runnable`不支持的用例。**`Runnable` 接口**不会返回结果或抛出检查异常，但是**`Callable` 接口**可以。所以，如果任务不需要返回结果或抛出异常推荐使用 **`Runnable` 接口**，这样代码看起来会更加简洁。
|
||||
|
||||
工具类 `Executors` 可以实现 `Runnable` 对象和 `Callable` 对象之间的相互转换。（`Executors.callable（Runnable task`）或 `Executors.callable（Runnable task，Object resule）`）。
|
||||
|
||||
`Runnable.java`
|
||||
|
||||
```java
|
||||
@FunctionalInterface
|
||||
public interface Runnable {
|
||||
/**
|
||||
* 被线程执行，没有返回值也无法抛出异常
|
||||
*/
|
||||
public abstract void run();
|
||||
}
|
||||
```
|
||||
|
||||
`Callable.java`
|
||||
|
||||
```java
|
||||
@FunctionalInterface
|
||||
public interface Callable<V> {
|
||||
/**
|
||||
* 计算结果，或在无法这样做时抛出异常。
|
||||
* @return 计算得出的结果
|
||||
* @throws 如果无法计算结果，则抛出异常
|
||||
*/
|
||||
V call() throws Exception;
|
||||
}
|
||||
```
|
||||
|
||||
### 4.3. 执行execute()方法和submit()方法的区别是什么呢？
|
||||
|
||||
1. **`execute()`方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；**
|
||||
2. **`submit()`方法用于提交需要返回值的任务。线程池会返回一个 `Future` 类型的对象，通过这个 `Future` 对象可以判断任务是否执行成功**，并且可以通过 `Future` 的 `get()`方法来获取返回值，`get()`方法会阻塞当前线程直到任务完成，而使用 `get（long timeout，TimeUnit unit）`方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。
|
||||
|
||||
我们以**`AbstractExecutorService`**接口中的一个 `submit` 方法为例子来看看源代码：
|
||||
|
||||
```java
|
||||
public Future<?> submit(Runnable task) {
|
||||
if (task == null) throw new NullPointerException();
|
||||
RunnableFuture<Void> ftask = newTaskFor(task, null);
|
||||
execute(ftask);
|
||||
return ftask;
|
||||
}
|
||||
```
|
||||
|
||||
上面方法调用的 `newTaskFor` 方法返回了一个 `FutureTask` 对象。
|
||||
|
||||
```java
|
||||
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
|
||||
return new FutureTask<T>(runnable, value);
|
||||
}
|
||||
```
|
||||
|
||||
我们再来看看`execute()`方法：
|
||||
|
||||
```java
|
||||
public void execute(Runnable command) {
|
||||
...
|
||||
}
|
||||
```
|
||||
|
||||
### 4.4. 如何创建线程池
|
||||
|
||||
《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险
|
||||
|
||||
> Executors 返回线程池对象的弊端如下：
|
||||
>
|
||||
> - **FixedThreadPool 和 SingleThreadExecutor** ： 允许请求的队列长度为 Integer.MAX_VALUE ，可能堆积大量的请求，从而导致OOM。
|
||||
> - **CachedThreadPool 和 ScheduledThreadPool** ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致OOM。
|
||||
|
||||
**方式一：通过构造方法实现**
|
||||
|
||||
**方式二：通过Executor 框架的工具类Executors来实现**
|
||||
我们可以创建三种类型的ThreadPoolExecutor：
|
||||
|
||||
- **FixedThreadPool** ： 该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。
|
||||
- **SingleThreadExecutor：** 方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。
|
||||
- **CachedThreadPool：** 该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。
|
||||
|
||||
对应Executors工具类中的方法如图所示：
|
||||
|
||||
|
||||
### 4.5 ThreadPoolExecutor 类分析
|
||||
|
||||
`ThreadPoolExecutor` 类中提供的四个构造方法。我们来看最长的那个，其余三个都是在这个构造方法的基础上产生（其他几个构造方法说白点都是给定某些默认参数的构造方法比如默认制定拒绝策略是什么），这里就不贴代码讲了，比较简单。
|
||||
|
||||
```java
|
||||
/**
|
||||
* 用给定的初始参数创建一个新的ThreadPoolExecutor。
|
||||
*/
|
||||
public ThreadPoolExecutor(int corePoolSize,
|
||||
int maximumPoolSize,
|
||||
long keepAliveTime,
|
||||
TimeUnit unit,
|
||||
BlockingQueue<Runnable> workQueue,
|
||||
ThreadFactory threadFactory,
|
||||
RejectedExecutionHandler handler) {
|
||||
if (corePoolSize < 0 ||
|
||||
maximumPoolSize <= 0 ||
|
||||
maximumPoolSize < corePoolSize ||
|
||||
keepAliveTime < 0)
|
||||
throw new IllegalArgumentException();
|
||||
if (workQueue == null || threadFactory == null || handler == null)
|
||||
throw new NullPointerException();
|
||||
this.corePoolSize = corePoolSize;
|
||||
this.maximumPoolSize = maximumPoolSize;
|
||||
this.workQueue = workQueue;
|
||||
this.keepAliveTime = unit.toNanos(keepAliveTime);
|
||||
this.threadFactory = threadFactory;
|
||||
this.handler = handler;
|
||||
}
|
||||
```
|
||||
|
||||
**下面这些对创建 非常重要，在后面使用线程池的过程中你一定会用到！所以，务必拿着小本本记清楚。**
|
||||
|
||||
#### 4.5.1 `ThreadPoolExecutor`构造函数重要参数分析
|
||||
|
||||
**`ThreadPoolExecutor` 3 个最重要的参数：**
|
||||
|
||||
- **`corePoolSize` :** 核心线程数线程数定义了最小可以同时运行的线程数量。
|
||||
- **`maximumPoolSize` :** 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。
|
||||
- **`workQueue`:** 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。
|
||||
|
||||
`ThreadPoolExecutor`其他常见参数:
|
||||
|
||||
1. **`keepAliveTime`**:当线程池中的线程数量大于 `corePoolSize` 的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了 `keepAliveTime`才会被回收销毁；
|
||||
2. **`unit`** : `keepAliveTime` 参数的时间单位。
|
||||
3. **`threadFactory`** :executor 创建新线程的时候会用到。
|
||||
4. **`handler`** :饱和策略。关于饱和策略下面单独介绍一下。
|
||||
|
||||
#### 4.5.2 `ThreadPoolExecutor` 饱和策略
|
||||
|
||||
**`ThreadPoolExecutor` 饱和策略定义:**
|
||||
|
||||
如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任时，`ThreadPoolTaskExecutor` 定义一些策略:
|
||||
|
||||
- **`ThreadPoolExecutor.AbortPolicy`**：抛出 `RejectedExecutionException`来拒绝新任务的处理。
|
||||
- **`ThreadPoolExecutor.CallerRunsPolicy`**：调用执行自己的线程运行任务。您不会任务请求。但是这种策略会降低对于新任务提交速度，影响程序的整体性能。另外，这个策略喜欢增加队列容量。如果您的应用程序可以承受此延迟并且你不能任务丢弃任何一个任务请求的话，你可以选择这个策略。
|
||||
- **`ThreadPoolExecutor.DiscardPolicy`：** 不处理新任务，直接丢弃掉。
|
||||
- **`ThreadPoolExecutor.DiscardOldestPolicy`：** 此策略将丢弃最早的未处理的任务请求。
|
||||
|
||||
举个例子： Spring 通过 `ThreadPoolTaskExecutor` 或者我们直接通过 `ThreadPoolExecutor` 的构造函数创建线程池的时候，当我们不指定 `RejectedExecutionHandler` 饱和策略的话来配置线程池的时候默认使用的是 `ThreadPoolExecutor.AbortPolicy`。在默认情况下，`ThreadPoolExecutor` 将抛出 `RejectedExecutionException` 来拒绝新来的任务 ，这代表你将丢失对这个任务的处理。 对于可伸缩的应用程序，建议使用 `ThreadPoolExecutor.CallerRunsPolicy`。当最大池被填满时，此策略为我们提供可伸缩队列。（这个直接查看 `ThreadPoolExecutor` 的构造函数源码就可以看出，比较简单的原因，这里就不贴代码了）
|
||||
|
||||
### 4.6 一个简单的线程池Demo:`Runnable`+`ThreadPoolExecutor`
|
||||
|
||||
为了让大家更清楚上面的面试题中的一些概念，我写了一个简单的线程池 Demo。
|
||||
|
||||
首先创建一个 `Runnable` 接口的实现类（当然也可以是 `Callable` 接口，我们上面也说了两者的区别。）
|
||||
|
||||
`MyRunnable.java`
|
||||
|
||||
```java
|
||||
import java.util.Date;
|
||||
|
||||
/**
|
||||
* 这是一个简单的Runnable类，需要大约5秒钟来执行其任务。
|
||||
* @author shuang.kou
|
||||
*/
|
||||
public class MyRunnable implements Runnable {
|
||||
|
||||
private String command;
|
||||
|
||||
public MyRunnable(String s) {
|
||||
this.command = s;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
|
||||
processCommand();
|
||||
System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
|
||||
}
|
||||
|
||||
private void processCommand() {
|
||||
try {
|
||||
Thread.sleep(5000);
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return this.command;
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
编写测试程序，我们这里以阿里巴巴推荐的使用 `ThreadPoolExecutor` 构造函数自定义参数的方式来创建线程池。
|
||||
|
||||
`ThreadPoolExecutorDemo.java`
|
||||
|
||||
```java
|
||||
import java.util.concurrent.ArrayBlockingQueue;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
public class ThreadPoolExecutorDemo {
|
||||
|
||||
private static final int CORE_POOL_SIZE = 5;
|
||||
private static final int MAX_POOL_SIZE = 10;
|
||||
private static final int QUEUE_CAPACITY = 100;
|
||||
private static final Long KEEP_ALIVE_TIME = 1L;
|
||||
public static void main(String[] args) {
|
||||
|
||||
//使用阿里巴巴推荐的创建线程池的方式
|
||||
//通过ThreadPoolExecutor构造函数自定义参数创建
|
||||
ThreadPoolExecutor executor = new ThreadPoolExecutor(
|
||||
CORE_POOL_SIZE,
|
||||
MAX_POOL_SIZE,
|
||||
KEEP_ALIVE_TIME,
|
||||
TimeUnit.SECONDS,
|
||||
new ArrayBlockingQueue<>(QUEUE_CAPACITY),
|
||||
new ThreadPoolExecutor.CallerRunsPolicy());
|
||||
|
||||
for (int i = 0; i < 10; i++) {
|
||||
//创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
|
||||
Runnable worker = new MyRunnable("" + i);
|
||||
//执行Runnable
|
||||
executor.execute(worker);
|
||||
}
|
||||
//终止线程池
|
||||
executor.shutdown();
|
||||
while (!executor.isTerminated()) {
|
||||
}
|
||||
System.out.println("Finished all threads");
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
可以看到我们上面的代码指定了：
|
||||
|
||||
1. `corePoolSize`: 核心线程数为 5。
|
||||
2. `maximumPoolSize` ：最大线程数 10
|
||||
3. `keepAliveTime` : 等待时间为 1L。
|
||||
4. `unit`: 等待时间的单位为 TimeUnit.SECONDS。
|
||||
5. `workQueue`：任务队列为 `ArrayBlockingQueue`，并且容量为 100;
|
||||
6. `handler`:饱和策略为 `CallerRunsPolicy`。
|
||||
|
||||
**Output：**
|
||||
|
||||
```
|
||||
pool-1-thread-2 Start. Time = Tue Nov 12 20:59:44 CST 2019
|
||||
pool-1-thread-5 Start. Time = Tue Nov 12 20:59:44 CST 2019
|
||||
pool-1-thread-4 Start. Time = Tue Nov 12 20:59:44 CST 2019
|
||||
pool-1-thread-1 Start. Time = Tue Nov 12 20:59:44 CST 2019
|
||||
pool-1-thread-3 Start. Time = Tue Nov 12 20:59:44 CST 2019
|
||||
pool-1-thread-5 End. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-3 End. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-2 End. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-4 End. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-1 End. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-2 Start. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-1 Start. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-4 Start. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-3 Start. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-5 Start. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-2 End. Time = Tue Nov 12 20:59:54 CST 2019
|
||||
pool-1-thread-3 End. Time = Tue Nov 12 20:59:54 CST 2019
|
||||
pool-1-thread-4 End. Time = Tue Nov 12 20:59:54 CST 2019
|
||||
pool-1-thread-5 End. Time = Tue Nov 12 20:59:54 CST 2019
|
||||
pool-1-thread-1 End. Time = Tue Nov 12 20:59:54 CST 2019
|
||||
|
||||
```
|
||||
|
||||
### 4.7 线程池原理分析
|
||||
|
||||
承接 4.6 节，我们通过代码输出结果可以看出：**线程池每次会同时执行 5 个任务，这 5 个任务执行完之后，剩余的 5 个任务才会被执行。** 大家可以先通过上面讲解的内容，分析一下到底是咋回事？（自己独立思考一会）
|
||||
|
||||
现在，我们就分析上面的输出内容来简单分析一下线程池原理。
|
||||
|
||||
**为了搞懂线程池的原理，我们需要首先分析一下 `execute`方法。**在 4.6 节中的 Demo 中我们使用 `executor.execute(worker)`来提交一个任务到线程池中去，这个方法非常重要，下面我们来看看它的源码：
|
||||
|
||||
```java
|
||||
// 存放线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)
|
||||
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
|
||||
|
||||
private static int workerCountOf(int c) {
|
||||
return c & CAPACITY;
|
||||
}
|
||||
|
||||
private final BlockingQueue<Runnable> workQueue;
|
||||
|
||||
public void execute(Runnable command) {
|
||||
// 如果任务为null，则抛出异常。
|
||||
if (command == null)
|
||||
throw new NullPointerException();
|
||||
// ctl 中保存的线程池当前的一些状态信息
|
||||
int c = ctl.get();
|
||||
|
||||
// 下面会涉及到 3 步 操作
|
||||
// 1.首先判断当前线程池中之行的任务数量是否小于 corePoolSize
|
||||
// 如果小于的话，通过addWorker(command, true)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
|
||||
if (workerCountOf(c) < corePoolSize) {
|
||||
if (addWorker(command, true))
|
||||
return;
|
||||
c = ctl.get();
|
||||
}
|
||||
// 2.如果当前之行的任务数量大于等于 corePoolSize 的时候就会走到这里
|
||||
// 通过 isRunning 方法判断线程池状态，线程池处于 RUNNING 状态才会被并且队列可以加入任务，该任务才会被加入进去
|
||||
if (isRunning(c) && workQueue.offer(command)) {
|
||||
int recheck = ctl.get();
|
||||
// 再次获取线程池状态，如果线程池状态不是 RUNNING 状态就需要从任务队列中移除任务，并尝试判断线程是否全部执行完毕。同时执行拒绝策略。
|
||||
if (!isRunning(recheck) && remove(command))
|
||||
reject(command);
|
||||
// 如果当前线程池为空就新创建一个线程并执行。
|
||||
else if (workerCountOf(recheck) == 0)
|
||||
addWorker(null, false);
|
||||
}
|
||||
//3. 通过addWorker(command, false)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
|
||||
//如果addWorker(command, false)执行失败，则通过reject()执行相应的拒绝策略的内容。
|
||||
else if (!addWorker(command, false))
|
||||
reject(command);
|
||||
}
|
||||
```
|
||||
|
||||
通过下图可以更好的对上面这 3 步做一个展示，下图是我为了省事直接从网上找到，原地址不明。
|
||||
|
||||
|
||||
|
||||
现在，让我们在回到 4.6 节我们写的 Demo， 现在应该是不是很容易就可以搞懂它的原理了呢？
|
||||
|
||||
没搞懂的话，也没关系，可以看看我的分析：
|
||||
|
||||
> 我们在代码中模拟了 10 个任务，我们配置的核心线程数为 5 、等待队列容量为 100 ，所以每次只可能存在 5 个任务同时执行，剩下的 5 个任务会被放到等待队列中去。当前的 5 个任务之行完成后，才会之行剩下的 5 个任务。
|
||||
|
||||
## 5. Atomic 原子类
|
||||
|
||||
### 5.1. 介绍一下Atomic 原子类
|
||||
|
||||
Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里 Atomic 是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。
|
||||
|
||||
所以，所谓原子类说简单点就是具有原子/原子操作特征的类。
|
||||
|
||||
|
||||
并发包 `java.util.concurrent` 的原子类都存放在`java.util.concurrent.atomic`下,如下图所示。
|
||||
|
||||
|
||||
|
||||
### 5.2. JUC 包中的原子类是哪4类?
|
||||
|
||||
**基本类型**
|
||||
|
||||
使用原子的方式更新基本类型
|
||||
|
||||
- AtomicInteger：整形原子类
|
||||
- AtomicLong：长整型原子类
|
||||
- AtomicBoolean：布尔型原子类
|
||||
|
||||
**数组类型**
|
||||
|
||||
使用原子的方式更新数组里的某个元素
|
||||
|
||||
|
||||
- AtomicIntegerArray：整形数组原子类
|
||||
- AtomicLongArray：长整形数组原子类
|
||||
- AtomicReferenceArray：引用类型数组原子类
|
||||
|
||||
**引用类型**
|
||||
|
||||
- AtomicReference：引用类型原子类
|
||||
- AtomicStampedReference：原子更新引用类型里的字段原子类
|
||||
- AtomicMarkableReference ：原子更新带有标记位的引用类型
|
||||
|
||||
**对象的属性修改类型**
|
||||
|
||||
- AtomicIntegerFieldUpdater：原子更新整形字段的更新器
|
||||
- AtomicLongFieldUpdater：原子更新长整形字段的更新器
|
||||
- AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。
|
||||
|
||||
|
||||
### 5.3. 讲讲 AtomicInteger 的使用
|
||||
|
||||
**AtomicInteger 类常用方法**
|
||||
|
||||
```java
|
||||
public final int get() //获取当前的值
|
||||
public final int getAndSet(int newValue)//获取当前的值，并设置新的值
|
||||
public final int getAndIncrement()//获取当前的值，并自增
|
||||
public final int getAndDecrement() //获取当前的值，并自减
|
||||
public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
|
||||
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
|
||||
public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。
|
||||
```
|
||||
|
||||
**AtomicInteger 类的使用示例**
|
||||
|
||||
使用 AtomicInteger 之后，不用对 increment() 方法加锁也可以保证线程安全。
|
||||
```java
|
||||
class AtomicIntegerTest {
|
||||
private AtomicInteger count = new AtomicInteger();
|
||||
//使用AtomicInteger之后，不需要对该方法加锁，也可以实现线程安全。
|
||||
public void increment() {
|
||||
count.incrementAndGet();
|
||||
}
|
||||
|
||||
public int getCount() {
|
||||
return count.get();
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
### 5.4. 能不能给我简单介绍一下 AtomicInteger 类的原理
|
||||
|
||||
AtomicInteger 线程安全原理简单分析
|
||||
|
||||
AtomicInteger 类的部分源码：
|
||||
|
||||
```java
|
||||
// setup to use Unsafe.compareAndSwapInt for updates（更新操作时提供“比较并替换”的作用）
|
||||
private static final Unsafe unsafe = Unsafe.getUnsafe();
|
||||
private static final long valueOffset;
|
||||
|
||||
static {
|
||||
try {
|
||||
valueOffset = unsafe.objectFieldOffset
|
||||
(AtomicInteger.class.getDeclaredField("value"));
|
||||
} catch (Exception ex) { throw new Error(ex); }
|
||||
}
|
||||
|
||||
private volatile int value;
|
||||
```
|
||||
|
||||
AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。
|
||||
|
||||
CAS的原理是拿期望的值和原本的一个值作比较，如果相同则更新成新的值。UnSafe 类的 objectFieldOffset() 方法是一个本地方法，这个方法是用来拿到“原来的值”的内存地址，返回值是 valueOffset。另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。
|
||||
|
||||
关于 Atomic 原子类这部分更多内容可以查看我的这篇文章：并发编程面试必备：[JUC 中的 Atomic 原子类总结](https://mp.weixin.qq.com/s/joa-yOiTrYF67bElj8xqvg)
|
||||
|
||||
## 6. AQS
|
||||
|
||||
### 6.1. AQS 介绍
|
||||
|
||||
AQS的全称为（AbstractQueuedSynchronizer），这个类在java.util.concurrent.locks包下面。
|
||||
|
||||
|
||||
|
||||
AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的ReentrantLock，Semaphore，其他的诸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基于AQS的。当然，我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的同步器。
|
||||
|
||||
### 6.2. AQS 原理分析
|
||||
|
||||
AQS 原理这部分参考了部分博客，在5.2节末尾放了链接。
|
||||
|
||||
> 在面试中被问到并发知识的时候，大多都会被问到“请你说一下自己对于AQS原理的理解”。下面给大家一个示例供大家参加，面试不是背题，大家一定要加入自己的思想，即使加入不了自己的思想也要保证自己能够通俗的讲出来而不是背出来。
|
||||
|
||||
下面大部分内容其实在AQS类注释上已经给出了，不过是英语看着比较吃力一点，感兴趣的话可以看看源码。
|
||||
|
||||
#### 6.2.1. AQS 原理概览
|
||||
|
||||
**AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。**
|
||||
|
||||
> CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS是将每条请求共享资源的线程封装成一个CLH锁队列的一个结点（Node）来实现锁的分配。
|
||||
|
||||
看个AQS(AbstractQueuedSynchronizer)原理图：
|
||||
|
||||
|
||||
|
||||
|
||||
AQS使用一个int成员变量来表示同步状态，通过内置的FIFO队列来完成获取资源线程的排队工作。AQS使用CAS对该同步状态进行原子操作实现对其值的修改。
|
||||
|
||||
```java
|
||||
private volatile int state;//共享变量，使用volatile修饰保证线程可见性
|
||||
```
|
||||
|
||||
状态信息通过protected类型的getState，setState，compareAndSetState进行操作
|
||||
|
||||
```java
|
||||
|
||||
//返回同步状态的当前值
|
||||
protected final int getState() {
|
||||
return state;
|
||||
}
|
||||
// 设置同步状态的值
|
||||
protected final void setState(int newState) {
|
||||
state = newState;
|
||||
}
|
||||
//原子地（CAS操作）将同步状态值设置为给定值update如果当前同步状态的值等于expect（期望值）
|
||||
protected final boolean compareAndSetState(int expect, int update) {
|
||||
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
|
||||
}
|
||||
```
|
||||
|
||||
#### 6.2.2. AQS 对资源的共享方式
|
||||
|
||||
**AQS定义两种资源共享方式**
|
||||
|
||||
- **Exclusive**（独占）：只有一个线程能执行，如ReentrantLock。又可分为公平锁和非公平锁：
|
||||
- 公平锁：按照线程在队列中的排队顺序，先到者先拿到锁
|
||||
- 非公平锁：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的
|
||||
- **Share**（共享）：多个线程可同时执行，如Semaphore/CountDownLatch。Semaphore、CountDownLatch、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。
|
||||
|
||||
ReentrantReadWriteLock 可以看成是组合式，因为ReentrantReadWriteLock也就是读写锁允许多个线程同时对某一资源进行读。
|
||||
|
||||
不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可，至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。
|
||||
|
||||
#### 6.2.3. AQS底层使用了模板方法模式
|
||||
|
||||
同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样（模板方法模式很经典的一个应用）：
|
||||
|
||||
1. 使用者继承AbstractQueuedSynchronizer并重写指定的方法。（这些重写方法很简单，无非是对于共享资源state的获取和释放）
|
||||
2. 将AQS组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。
|
||||
|
||||
这和我们以往通过实现接口的方式有很大区别，这是模板方法模式很经典的一个运用。
|
||||
|
||||
**AQS使用了模板方法模式，自定义同步器时需要重写下面几个AQS提供的模板方法：**
|
||||
|
||||
```java
|
||||
isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。
|
||||
tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。
|
||||
tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。
|
||||
tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
|
||||
tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。
|
||||
|
||||
```
|
||||
|
||||
默认情况下，每个方法都抛出 `UnsupportedOperationException`。 这些方法的实现必须是内部线程安全的，并且通常应该简短而不是阻塞。AQS类中的其他方法都是final ，所以无法被其他类使用，只有这几个方法可以被其他类使用。
|
||||
|
||||
以ReentrantLock为例，state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。
|
||||
|
||||
再以CountDownLatch以例，任务分为N个子线程去执行，state也初始化为N（注意N要与线程个数一致）。这N个子线程是并行执行的，每个子线程执行完后countDown()一次，state会CAS(Compare and Swap)减1。等到所有子线程都执行完后(即state=0)，会unpark()主调用线程，然后主调用线程就会从await()函数返回，继续后余动作。
|
||||
|
||||
一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现`tryAcquire-tryRelease`、`tryAcquireShared-tryReleaseShared`中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如`ReentrantReadWriteLock`。
|
||||
|
||||
推荐两篇 AQS 原理和相关源码分析的文章：
|
||||
|
||||
- http://www.cnblogs.com/waterystone/p/4920797.html
|
||||
- https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html
|
||||
|
||||
### 6.3. AQS 组件总结
|
||||
|
||||
- **Semaphore(信号量)-允许多个线程同时访问：** synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量)可以指定多个线程同时访问某个资源。
|
||||
- **CountDownLatch （倒计时器）：** CountDownLatch是一个同步工具类，用来协调多个线程之间的同步。这个工具通常用来控制线程等待，它可以让某一个线程等待直到倒计时结束，再开始执行。
|
||||
- **CyclicBarrier(循环栅栏)：** CyclicBarrier 和 CountDownLatch 非常类似，它也可以实现线程间的技术等待，但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是 CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await()方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。
|
||||
|
||||
## 7 Reference
|
||||
|
||||
- 《深入理解 Java 虚拟机》
|
||||
- 《实战 Java 高并发程序设计》
|
||||
- 《Java并发编程的艺术》
|
||||
- http://www.cnblogs.com/waterystone/p/4920797.html
|
||||
- https://www.cnblogs.com/chengxiao/archive/2017/07/24/7141160.html
|
||||
- <https://www.journaldev.com/1076/java-threadlocal-example>
|
||||
|
||||
## 公众号
|
||||
|
||||
如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。
|
||||
|
||||
**《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"面试突击"** 即可免费领取！
|
||||
|
||||
**Java工程师必备学习资源:** 一些Java工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
|
||||
|
||||
|
||||
@ -0,0 +1,312 @@
|
||||
点击关注[公众号](#公众号 "公众号")及时获取笔主最新更新文章，并可免费领取本文档配套的《Java 面试突击》以及 Java 工程师必备学习资源。
|
||||
|
||||
|
||||
- [Java 并发基础常见面试题总结](#java-并发基础常见面试题总结)
|
||||
- [1. 什么是线程和进程?](#1-什么是线程和进程)
|
||||
- [1.1. 何为进程?](#11-何为进程)
|
||||
- [1.2. 何为线程?](#12-何为线程)
|
||||
- [2. 请简要描述线程与进程的关系,区别及优缺点？](#2-请简要描述线程与进程的关系区别及优缺点)
|
||||
- [2.1. 图解进程和线程的关系](#21-图解进程和线程的关系)
|
||||
- [2.2. 程序计数器为什么是私有的?](#22-程序计数器为什么是私有的)
|
||||
- [2.3. 虚拟机栈和本地方法栈为什么是私有的?](#23-虚拟机栈和本地方法栈为什么是私有的)
|
||||
- [2.4. 一句话简单了解堆和方法区](#24-一句话简单了解堆和方法区)
|
||||
- [3. 说说并发与并行的区别?](#3-说说并发与并行的区别)
|
||||
- [4. 为什么要使用多线程呢?](#4-为什么要使用多线程呢)
|
||||
- [5. 使用多线程可能带来什么问题?](#5-使用多线程可能带来什么问题)
|
||||
- [6. 说说线程的生命周期和状态?](#6-说说线程的生命周期和状态)
|
||||
- [7. 什么是上下文切换?](#7-什么是上下文切换)
|
||||
- [8. 什么是线程死锁?如何避免死锁?](#8-什么是线程死锁如何避免死锁)
|
||||
- [8.1. 认识线程死锁](#81-认识线程死锁)
|
||||
- [8.2. 如何避免线程死锁?](#82-如何避免线程死锁)
|
||||
- [9. 说说 sleep() 方法和 wait() 方法区别和共同点?](#9-说说-sleep-方法和-wait-方法区别和共同点)
|
||||
- [10. 为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？](#10-为什么我们调用-start-方法时会执行-run-方法为什么我们不能直接调用-run-方法)
|
||||
- [公众号](#公众号)
|
||||
|
||||
|
||||
# Java 并发基础常见面试题总结
|
||||
|
||||
## 1. 什么是线程和进程?
|
||||
|
||||
### 1.1. 何为进程?
|
||||
|
||||
进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。
|
||||
|
||||
在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。
|
||||
|
||||
如下图所示，在 windows 中通过查看任务管理器的方式，我们就可以清楚看到 window 当前运行的进程（.exe 文件的运行）。
|
||||
|
||||
|
||||
|
||||
### 1.2. 何为线程?
|
||||
|
||||
线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享进程的**堆**和**方法区**资源，但每个线程有自己的**程序计数器**、**虚拟机栈**和**本地方法栈**，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
|
||||
|
||||
Java 程序天生就是多线程程序，我们可以通过 JMX 来看一下一个普通的 Java 程序有哪些线程，代码如下。
|
||||
|
||||
```java
|
||||
public class MultiThread {
|
||||
public static void main(String[] args) {
|
||||
// 获取 Java 线程管理 MXBean
|
||||
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
|
||||
// 不需要获取同步的 monitor 和 synchronizer 信息，仅获取线程和线程堆栈信息
|
||||
ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
|
||||
// 遍历线程信息，仅打印线程 ID 和线程名称信息
|
||||
for (ThreadInfo threadInfo : threadInfos) {
|
||||
System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
上述程序输出如下（输出内容可能不同，不用太纠结下面每个线程的作用，只用知道 main 线程执行 main 方法即可）：
|
||||
|
||||
```
|
||||
[5] Attach Listener //添加事件
|
||||
[4] Signal Dispatcher // 分发处理给 JVM 信号的线程
|
||||
[3] Finalizer //调用对象 finalize 方法的线程
|
||||
[2] Reference Handler //清除 reference 线程
|
||||
[1] main //main 线程,程序入口
|
||||
```
|
||||
|
||||
从上面的输出内容可以看出：**一个 Java 程序的运行是 main 线程和多个其他线程同时运行**。
|
||||
|
||||
## 2. 请简要描述线程与进程的关系,区别及优缺点？
|
||||
|
||||
**从 JVM 角度说进程和线程之间的关系**
|
||||
|
||||
### 2.1. 图解进程和线程的关系
|
||||
|
||||
下图是 Java 内存区域，通过下图我们从 JVM 的角度来说一下线程和进程之间的关系。如果你对 Java 内存区域 (运行时数据区) 这部分知识不太了解的话可以阅读一下这篇文章：[《可能是把 Java 内存区域讲的最清楚的一篇文章》](https://github.com/Snailclimb/JavaGuide/blob/3965c02cc0f294b0bd3580df4868d5e396959e2e/Java%E7%9B%B8%E5%85%B3/%E5%8F%AF%E8%83%BD%E6%98%AF%E6%8A%8AJava%E5%86%85%E5%AD%98%E5%8C%BA%E5%9F%9F%E8%AE%B2%E7%9A%84%E6%9C%80%E6%B8%85%E6%A5%9A%E7%9A%84%E4%B8%80%E7%AF%87%E6%96%87%E7%AB%A0.md "《可能是把 Java 内存区域讲的最清楚的一篇文章》")
|
||||
|
||||
<div align="center">
|
||||
<img src="https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3/JVM运行时数据区域.png" width="600px"/>
|
||||
</div>
|
||||
|
||||
从上图可以看出：一个进程中可以有多个线程，多个线程共享进程的**堆**和**方法区 (JDK1.8 之后的元空间)**资源，但是每个线程有自己的**程序计数器**、**虚拟机栈** 和 **本地方法栈**。
|
||||
|
||||
**总结：** 线程 是 进程 划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。线程执行开销小，但不利于资源的管理和保护；而进程正相反
|
||||
|
||||
下面是该知识点的扩展内容！
|
||||
|
||||
下面来思考这样一个问题：为什么**程序计数器**、**虚拟机栈**和**本地方法栈**是线程私有的呢？为什么堆和方法区是线程共享的呢？
|
||||
|
||||
### 2.2. 程序计数器为什么是私有的?
|
||||
|
||||
程序计数器主要有下面两个作用：
|
||||
|
||||
1. 字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制，如：顺序执行、选择、循环、异常处理。
|
||||
2. 在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。
|
||||
|
||||
需要注意的是，如果执行的是 native 方法，那么程序计数器记录的是 undefined 地址，只有执行的是 Java 代码时程序计数器记录的才是下一条指令的地址。
|
||||
|
||||
所以，程序计数器私有主要是为了**线程切换后能恢复到正确的执行位置**。
|
||||
|
||||
### 2.3. 虚拟机栈和本地方法栈为什么是私有的?
|
||||
|
||||
- **虚拟机栈：** 每个 Java 方法在执行的同时会创建一个栈帧用于存储局部变量表、操作数栈、常量池引用等信息。从方法调用直至执行完成的过程，就对应着一个栈帧在 Java 虚拟机栈中入栈和出栈的过程。
|
||||
- **本地方法栈：** 和虚拟机栈所发挥的作用非常相似，区别是： **虚拟机栈为虚拟机执行 Java 方法 （也就是字节码）服务，而本地方法栈则为虚拟机使用到的 Native 方法服务。** 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。
|
||||
|
||||
所以，为了**保证线程中的局部变量不被别的线程访问到**，虚拟机栈和本地方法栈是线程私有的。
|
||||
|
||||
### 2.4. 一句话简单了解堆和方法区
|
||||
|
||||
堆和方法区是所有线程共享的资源，其中堆是进程中最大的一块内存，主要用于存放新创建的对象 (所有对象都在这里分配内存)，方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
|
||||
|
||||
## 3. 说说并发与并行的区别?
|
||||
|
||||
- **并发：** 同一时间段，多个任务都在执行 (单位时间内不一定同时执行)；
|
||||
- **并行：** 单位时间内，多个任务同时执行。
|
||||
|
||||
## 4. 为什么要使用多线程呢?
|
||||
|
||||
先从总体上来说：
|
||||
|
||||
- **从计算机底层来说：** 线程可以比作是轻量级的进程，是程序执行的最小单位,线程间的切换和调度的成本远远小于进程。另外，多核 CPU 时代意味着多个线程可以同时运行，这减少了线程上下文切换的开销。
|
||||
- **从当代互联网发展趋势来说：** 现在的系统动不动就要求百万级甚至千万级的并发量，而多线程并发编程正是开发高并发系统的基础，利用好多线程机制可以大大提高系统整体的并发能力以及性能。
|
||||
|
||||
再深入到计算机底层来探讨：
|
||||
|
||||
- **单核时代：** 在单核时代多线程主要是为了提高 CPU 和 IO 设备的综合利用率。举个例子：当只有一个线程的时候会导致 CPU 计算时，IO 设备空闲；进行 IO 操作时，CPU 空闲。我们可以简单地说这两者的利用率目前都是 50%左右。但是当有两个线程的时候就不一样了，当一个线程执行 CPU 计算时，另外一个线程可以进行 IO 操作，这样两个的利用率就可以在理想情况下达到 100%了。
|
||||
- **多核时代:** 多核时代多线程主要是为了提高 CPU 利用率。举个例子：假如我们要计算一个复杂的任务，我们只用一个线程的话，CPU 只会一个 CPU 核心被利用到，而创建多个线程就可以让多个 CPU 核心被利用到，这样就提高了 CPU 的利用率。
|
||||
|
||||
## 5. 使用多线程可能带来什么问题?
|
||||
|
||||
并发编程的目的就是为了能提高程序的执行效率提高程序运行速度，但是并发编程并不总是能提高程序运行速度的，而且并发编程可能会遇到很多问题，比如：内存泄漏、上下文切换、死锁还有受限于硬件和软件的资源闲置问题。
|
||||
|
||||
## 6. 说说线程的生命周期和状态?
|
||||
|
||||
Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个状态（图源《Java 并发编程艺术》4.1.4 节）。
|
||||
|
||||
|
||||
|
||||
线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变迁如下图所示（图源《Java 并发编程艺术》4.1.4 节）：
|
||||
|
||||
|
||||
|
||||
由上图可以看出：线程创建之后它将处于 **NEW（新建）** 状态，调用 `start()` 方法后开始运行，线程这时候处于 **READY（可运行）** 状态。可运行状态的线程获得了 CPU 时间片（timeslice）后就处于 **RUNNING（运行）** 状态。
|
||||
|
||||
> 操作系统隐藏 Java 虚拟机（JVM）中的 RUNNABLE 和 RUNNING 状态，它只能看到 RUNNABLE 状态（图源：[HowToDoInJava](https://howtodoinjava.com/ "HowToDoInJava")：[Java Thread Life Cycle and Thread States](https://howtodoinjava.com/java/multi-threading/java-thread-life-cycle-and-thread-states/ "Java Thread Life Cycle and Thread States")），所以 Java 系统一般将这两个状态统称为 **RUNNABLE（运行中）** 状态 。
|
||||
|
||||
|
||||
|
||||
当线程执行 `wait()`方法之后，线程进入 **WAITING（等待）** 状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而 **TIME_WAITING(超时等待)** 状态相当于在等待状态的基础上增加了超时限制，比如通过 `sleep（long millis）`方法或 `wait（long millis）`方法可以将 Java 线程置于 TIMED WAITING 状态。当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到 **BLOCKED（阻塞）** 状态。线程在执行 Runnable 的`run()`方法之后将会进入到 **TERMINATED（终止）** 状态。
|
||||
|
||||
## 7. 什么是上下文切换?
|
||||
|
||||
多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。
|
||||
|
||||
概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换回这个任务时，可以再加载这个任务的状态。**任务从保存到再加载的过程就是一次上下文切换**。
|
||||
|
||||
上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。
|
||||
|
||||
Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。
|
||||
|
||||
## 8. 什么是线程死锁?如何避免死锁?
|
||||
|
||||
### 8.1. 认识线程死锁
|
||||
|
||||
多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
|
||||
|
||||
如下图所示，线程 A 持有资源 2，线程 B 持有资源 1，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。
|
||||
|
||||
|
||||
|
||||
下面通过一个例子来说明线程死锁,代码模拟了上图的死锁的情况 (代码来源于《并发编程之美》)：
|
||||
|
||||
```java
|
||||
public class DeadLockDemo {
|
||||
private static Object resource1 = new Object();//资源 1
|
||||
private static Object resource2 = new Object();//资源 2
|
||||
|
||||
public static void main(String[] args) {
|
||||
new Thread(() -> {
|
||||
synchronized (resource1) {
|
||||
System.out.println(Thread.currentThread() + "get resource1");
|
||||
try {
|
||||
Thread.sleep(1000);
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
System.out.println(Thread.currentThread() + "waiting get resource2");
|
||||
synchronized (resource2) {
|
||||
System.out.println(Thread.currentThread() + "get resource2");
|
||||
}
|
||||
}
|
||||
}, "线程 1").start();
|
||||
|
||||
new Thread(() -> {
|
||||
synchronized (resource2) {
|
||||
System.out.println(Thread.currentThread() + "get resource2");
|
||||
try {
|
||||
Thread.sleep(1000);
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
System.out.println(Thread.currentThread() + "waiting get resource1");
|
||||
synchronized (resource1) {
|
||||
System.out.println(Thread.currentThread() + "get resource1");
|
||||
}
|
||||
}
|
||||
}, "线程 2").start();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Output
|
||||
|
||||
```
|
||||
Thread[线程 1,5,main]get resource1
|
||||
Thread[线程 2,5,main]get resource2
|
||||
Thread[线程 1,5,main]waiting get resource2
|
||||
Thread[线程 2,5,main]waiting get resource1
|
||||
```
|
||||
|
||||
线程 A 通过 synchronized (resource1) 获得 resource1 的监视器锁，然后通过`Thread.sleep(1000);`让线程 A 休眠 1s 为的是让线程 B 得到执行然后获取到 resource2 的监视器锁。线程 A 和线程 B 休眠结束了都开始企图请求获取对方的资源，然后这两个线程就会陷入互相等待的状态，这也就产生了死锁。上面的例子符合产生死锁的四个必要条件。
|
||||
|
||||
学过操作系统的朋友都知道产生死锁必须具备以下四个条件：
|
||||
|
||||
1. 互斥条件：该资源任意一个时刻只由一个线程占用。
|
||||
2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
|
||||
3. 不剥夺条件:线程已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
|
||||
4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
|
||||
|
||||
### 8.2. 如何避免线程死锁?
|
||||
|
||||
我们只要破坏产生死锁的四个条件中的其中一个就可以了。
|
||||
|
||||
**破坏互斥条件**
|
||||
|
||||
这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。
|
||||
|
||||
**破坏请求与保持条件**
|
||||
|
||||
一次性申请所有的资源。
|
||||
|
||||
**破坏不剥夺条件**
|
||||
|
||||
占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
|
||||
|
||||
**破坏循环等待条件**
|
||||
|
||||
靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。
|
||||
|
||||
我们对线程 2 的代码修改成下面这样就不会产生死锁了。
|
||||
|
||||
```java
|
||||
new Thread(() -> {
|
||||
synchronized (resource1) {
|
||||
System.out.println(Thread.currentThread() + "get resource1");
|
||||
try {
|
||||
Thread.sleep(1000);
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
System.out.println(Thread.currentThread() + "waiting get resource2");
|
||||
synchronized (resource2) {
|
||||
System.out.println(Thread.currentThread() + "get resource2");
|
||||
}
|
||||
}
|
||||
}, "线程 2").start();
|
||||
```
|
||||
|
||||
Output
|
||||
|
||||
```
|
||||
Thread[线程 1,5,main]get resource1
|
||||
Thread[线程 1,5,main]waiting get resource2
|
||||
Thread[线程 1,5,main]get resource2
|
||||
Thread[线程 2,5,main]get resource1
|
||||
Thread[线程 2,5,main]waiting get resource2
|
||||
Thread[线程 2,5,main]get resource2
|
||||
|
||||
Process finished with exit code 0
|
||||
```
|
||||
|
||||
我们分析一下上面的代码为什么避免了死锁的发生?
|
||||
|
||||
线程 1 首先获得到 resource1 的监视器锁,这时候线程 2 就获取不到了。然后线程 1 再去获取 resource2 的监视器锁，可以获取到。然后线程 1 释放了对 resource1、resource2 的监视器锁的占用，线程 2 获取到就可以执行了。这样就破坏了破坏循环等待条件，因此避免了死锁。
|
||||
|
||||
## 9. 说说 sleep() 方法和 wait() 方法区别和共同点?
|
||||
|
||||
- 两者最主要的区别在于：**sleep 方法没有释放锁，而 wait 方法释放了锁** 。
|
||||
- 两者都可以暂停线程的执行。
|
||||
- Wait 通常被用于线程间交互/通信，sleep 通常被用于暂停执行。
|
||||
- wait() 方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的 notify() 或者 notifyAll() 方法。sleep() 方法执行完成后，线程会自动苏醒。或者可以使用 wait(long timeout)超时后线程会自动苏醒。
|
||||
|
||||
## 10. 为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？
|
||||
|
||||
这是另一个非常经典的 java 多线程面试问题，而且在面试中会经常被问到。很简单，但是很多人都会答不上来！
|
||||
|
||||
new 一个 Thread，线程进入了新建状态;调用 start() 方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。 start() 会执行线程的相应准备工作，然后自动执行 run() 方法的内容，这是真正的多线程工作。 而直接执行 run() 方法，会把 run 方法当成一个 main 线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。
|
||||
|
||||
**总结： 调用 start 方法方可启动线程并使线程进入就绪状态，而 run 方法只是 thread 的一个普通方法调用，还是在主线程里执行。**
|
||||
|
||||
## 公众号
|
||||
|
||||
如果大家想要实时关注我更新的文章以及分享的干货的话，可以关注我的公众号。
|
||||
|
||||
**《Java 面试突击》:** 由本文档衍生的专为面试而生的《Java 面试突击》V2.0 PDF 版本[公众号](#公众号 "公众号")后台回复 **"面试突击"** 即可免费领取！
|
||||
|
||||
**Java 工程师必备学习资源:** 一些 Java 工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
|
||||
|
||||
|
||||
170
docs/java/Multithread/ThreadLocal.md
Normal file
170
docs/java/Multithread/ThreadLocal.md
Normal file
@ -0,0 +1,170 @@
|
||||
[ThreadLocal造成OOM内存溢出案例演示与原理分析](https://blog.csdn.net/xlgen157387/article/details/78298840)
|
||||
|
||||
[深入理解 Java 之 ThreadLocal 工作原理](<https://allenwu.itscoder.com/threadlocal-source>)
|
||||
|
||||
## ThreadLocal
|
||||
|
||||
### ThreadLocal简介
|
||||
|
||||
通常情况下，我们创建的变量是可以被任何一个线程访问并修改的。**如果想实现每一个线程都有自己的专属本地变量该如何解决呢？** JDK中提供的`ThreadLocal`类正是为了解决这样的问题。 **`ThreadLocal`类主要解决的就是让每个线程绑定自己的值，可以将`ThreadLocal`类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。**
|
||||
|
||||
**如果你创建了一个`ThreadLocal`变量，那么访问这个变量的每个线程都会有这个变量的本地副本，这也是`ThreadLocal`变量名的由来。他们可以使用 `get（）` 和 `set（）` 方法来获取默认值或将其值更改为当前线程所存的副本的值，从而避免了线程安全问题。**
|
||||
|
||||
再举个简单的例子：
|
||||
|
||||
比如有两个人去宝屋收集宝物，这两个共用一个袋子的话肯定会产生争执，但是给他们两个人每个人分配一个袋子的话就不会出现这样的问题。如果把这两个人比作线程的话，那么ThreadLocal就是用来这两个线程竞争的。
|
||||
|
||||
### ThreadLocal示例
|
||||
|
||||
相信看了上面的解释，大家已经搞懂 ThreadLocal 类是个什么东西了。
|
||||
|
||||
```java
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.util.Random;
|
||||
|
||||
public class ThreadLocalExample implements Runnable{
|
||||
|
||||
// SimpleDateFormat 不是线程安全的，所以每个线程都要有自己独立的副本
|
||||
private static final ThreadLocal<SimpleDateFormat> formatter = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMMdd HHmm"));
|
||||
|
||||
public static void main(String[] args) throws InterruptedException {
|
||||
ThreadLocalExample obj = new ThreadLocalExample();
|
||||
for(int i=0 ; i<10; i++){
|
||||
Thread t = new Thread(obj, ""+i);
|
||||
Thread.sleep(new Random().nextInt(1000));
|
||||
t.start();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
System.out.println("Thread Name= "+Thread.currentThread().getName()+" default Formatter = "+formatter.get().toPattern());
|
||||
try {
|
||||
Thread.sleep(new Random().nextInt(1000));
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
//formatter pattern is changed here by thread, but it won't reflect to other threads
|
||||
formatter.set(new SimpleDateFormat());
|
||||
|
||||
System.out.println("Thread Name= "+Thread.currentThread().getName()+" formatter = "+formatter.get().toPattern());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
Output:
|
||||
|
||||
```
|
||||
Thread Name= 0 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 0 formatter = yy-M-d ah:mm
|
||||
Thread Name= 1 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 2 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 1 formatter = yy-M-d ah:mm
|
||||
Thread Name= 3 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 2 formatter = yy-M-d ah:mm
|
||||
Thread Name= 4 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 3 formatter = yy-M-d ah:mm
|
||||
Thread Name= 4 formatter = yy-M-d ah:mm
|
||||
Thread Name= 5 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 5 formatter = yy-M-d ah:mm
|
||||
Thread Name= 6 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 6 formatter = yy-M-d ah:mm
|
||||
Thread Name= 7 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 7 formatter = yy-M-d ah:mm
|
||||
Thread Name= 8 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 9 default Formatter = yyyyMMdd HHmm
|
||||
Thread Name= 8 formatter = yy-M-d ah:mm
|
||||
Thread Name= 9 formatter = yy-M-d ah:mm
|
||||
```
|
||||
|
||||
从输出中可以看出，Thread-0已经改变了formatter的值，但仍然是thread-2默认格式化程序与初始化值相同，其他线程也一样。
|
||||
|
||||
上面有一段代码用到了创建 `ThreadLocal` 变量的那段代码用到了 Java8 的知识，它等于下面这段代码，如果你写了下面这段代码的话，IDEA会提示你转换为Java8的格式(IDEA真的不错！)。因为ThreadLocal类在Java 8中扩展，使用一个新的方法`withInitial()`，将Supplier功能接口作为参数。
|
||||
|
||||
```java
|
||||
private static final ThreadLocal<SimpleDateFormat> formatter = new ThreadLocal<SimpleDateFormat>(){
|
||||
@Override
|
||||
protected SimpleDateFormat initialValue()
|
||||
{
|
||||
return new SimpleDateFormat("yyyyMMdd HHmm");
|
||||
}
|
||||
};
|
||||
```
|
||||
|
||||
### ThreadLocal原理
|
||||
|
||||
从 `Thread`类源代码入手。
|
||||
|
||||
```java
|
||||
public class Thread implements Runnable {
|
||||
......
|
||||
//与此线程有关的ThreadLocal值。由ThreadLocal类维护
|
||||
ThreadLocal.ThreadLocalMap threadLocals = null;
|
||||
|
||||
//与此线程有关的InheritableThreadLocal值。由InheritableThreadLocal类维护
|
||||
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
|
||||
......
|
||||
}
|
||||
```
|
||||
|
||||
从上面`Thread`类 源代码可以看出`Thread` 类中有一个 `threadLocals` 和 一个 `inheritableThreadLocals` 变量，它们都是 `ThreadLocalMap` 类型的变量,我们可以把 `ThreadLocalMap` 理解为`ThreadLocal` 类实现的定制化的 `HashMap`。默认情况下这两个变量都是null，只有当前线程调用 `ThreadLocal` 类的 `set`或`get`方法时才创建它们，实际上调用这两个方法的时候，我们调用的是`ThreadLocalMap`类对应的 `get()`、`set() `方法。
|
||||
|
||||
`ThreadLocal`类的`set()`方法
|
||||
|
||||
```java
|
||||
public void set(T value) {
|
||||
Thread t = Thread.currentThread();
|
||||
ThreadLocalMap map = getMap(t);
|
||||
if (map != null)
|
||||
map.set(this, value);
|
||||
else
|
||||
createMap(t, value);
|
||||
}
|
||||
ThreadLocalMap getMap(Thread t) {
|
||||
return t.threadLocals;
|
||||
}
|
||||
```
|
||||
|
||||
通过上面这些内容，我们足以通过猜测得出结论：**最终的变量是放在了当前线程的 `ThreadLocalMap` 中，并不是存在 `ThreadLocal` 上，ThreadLocal 可以理解为只是ThreadLocalMap的封装，传递了变量值。**
|
||||
|
||||
**每个Thread中都具备一个ThreadLocalMap，而ThreadLocalMap可以存储以ThreadLocal为key的键值对。** 比如我们在同一个线程中声明了两个 `ThreadLocal` 对象的话，会使用 `Thread`内部都是使用仅有那个`ThreadLocalMap` 存放数据的，`ThreadLocalMap`的 key 就是 `ThreadLocal`对象，value 就是 `ThreadLocal` 对象调用`set`方法设置的值。`ThreadLocal` 是 map结构是为了让每个线程可以关联多个 `ThreadLocal`变量。这也就解释了ThreadLocal声明的变量为什么在每一个线程都有自己的专属本地变量。
|
||||
|
||||
```java
|
||||
public class Thread implements Runnable {
|
||||
......
|
||||
//与此线程有关的ThreadLocal值。由ThreadLocal类维护
|
||||
ThreadLocal.ThreadLocalMap threadLocals = null;
|
||||
|
||||
//与此线程有关的InheritableThreadLocal值。由InheritableThreadLocal类维护
|
||||
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
|
||||
......
|
||||
}
|
||||
```
|
||||
|
||||
`ThreadLocalMap`是`ThreadLocal`的静态内部类。
|
||||
|
||||
|
||||
|
||||
### ThreadLocal 内存泄露问题
|
||||
|
||||
`ThreadLocalMap` 中使用的 key 为 `ThreadLocal` 的弱引用,而 value 是强引用。所以，如果 `ThreadLocal` 没有被外部强引用的情况下，在垃圾回收的时候会 key 会被清理掉，而 value 不会被清理掉。这样一来，`ThreadLocalMap` 中就会出现key为null的Entry。假如我们不做任何措施的话，value 永远无法被GC 回收，这个时候就可能会产生内存泄露。ThreadLocalMap实现中已经考虑了这种情况，在调用 `set()`、`get()`、`remove()` 方法的时候，会清理掉 key 为 null 的记录。使用完 `ThreadLocal`方法后 最好手动调用`remove()`方法
|
||||
|
||||
```java
|
||||
static class Entry extends WeakReference<ThreadLocal<?>> {
|
||||
/** The value associated with this ThreadLocal. */
|
||||
Object value;
|
||||
|
||||
Entry(ThreadLocal<?> k, Object v) {
|
||||
super(k);
|
||||
value = v;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**弱引用介绍：**
|
||||
|
||||
> 如果一个对象只具有弱引用，那就类似于**可有可无的生活用品**。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。
|
||||
>
|
||||
> 弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
|
||||
781
docs/java/Multithread/java线程池学习总结.md
Normal file
781
docs/java/Multithread/java线程池学习总结.md
Normal file
@ -0,0 +1,781 @@
|
||||
<!-- TOC -->
|
||||
|
||||
- [一 使用线程池的好处](#一-使用线程池的好处)
|
||||
- [二 Executor 框架](#二-executor-框架)
|
||||
- [2.1 简介](#21-简介)
|
||||
- [2.2 Executor 框架结构(主要由三大部分组成)](#22-executor-框架结构主要由三大部分组成)
|
||||
- [1) 任务(`Runnable` /`Callable`)](#1-任务runnable-callable)
|
||||
- [2) 任务的执行(`Executor`)](#2-任务的执行executor)
|
||||
- [3) 异步计算的结果(`Future`)](#3-异步计算的结果future)
|
||||
- [2.3 Executor 框架的使用示意图](#23-executor-框架的使用示意图)
|
||||
- [三 (重要)ThreadPoolExecutor 类简单介绍](#三-重要threadpoolexecutor-类简单介绍)
|
||||
- [3.1 ThreadPoolExecutor 类分析](#31-threadpoolexecutor-类分析)
|
||||
- [3.2 推荐使用 `ThreadPoolExecutor` 构造函数创建线程池](#32-推荐使用-threadpoolexecutor-构造函数创建线程池)
|
||||
- [四 (重要)ThreadPoolExecutor 使用示例](#四-重要threadpoolexecutor-使用示例)
|
||||
- [4.1 示例代码:`Runnable`+`ThreadPoolExecutor`](#41-示例代码runnablethreadpoolexecutor)
|
||||
- [4.2 线程池原理分析](#42-线程池原理分析)
|
||||
- [4.3 几个常见的对比](#43-几个常见的对比)
|
||||
- [4.3.1 `Runnable` vs `Callable`](#431-runnable-vs-callable)
|
||||
- [4.3.2 `execute()` vs `submit()`](#432-execute-vs-submit)
|
||||
- [4.3.3 `shutdown()`VS`shutdownNow()`](#433-shutdownvsshutdownnow)
|
||||
- [4.3.2 `isTerminated()` VS `isShutdown()`](#432-isterminated-vs-isshutdown)
|
||||
- [4.4 加餐:`Callable`+`ThreadPoolExecutor`示例代码](#44-加餐callablethreadpoolexecutor示例代码)
|
||||
- [五 几种常见的线程池详解](#五-几种常见的线程池详解)
|
||||
- [5.1 FixedThreadPool](#51-fixedthreadpool)
|
||||
- [5.1.1 介绍](#511-介绍)
|
||||
- [5.1.2 执行任务过程介绍](#512-执行任务过程介绍)
|
||||
- [5.1.3 为什么不推荐使用`FixedThreadPool`？](#513-为什么不推荐使用fixedthreadpool)
|
||||
- [5.2 SingleThreadExecutor 详解](#52-singlethreadexecutor-详解)
|
||||
- [5.2.1 介绍](#521-介绍)
|
||||
- [5.2.2 执行任务过程介绍](#522-执行任务过程介绍)
|
||||
- [5.2.3 为什么不推荐使用`FixedThreadPool`？](#523-为什么不推荐使用fixedthreadpool)
|
||||
- [5.3 CachedThreadPool 详解](#53-cachedthreadpool-详解)
|
||||
- [5.3.1 介绍](#531-介绍)
|
||||
- [5.3.2 执行任务过程介绍](#532-执行任务过程介绍)
|
||||
- [5.3.3 为什么不推荐使用`CachedThreadPool`？](#533-为什么不推荐使用cachedthreadpool)
|
||||
- [六 ScheduledThreadPoolExecutor 详解](#六-scheduledthreadpoolexecutor-详解)
|
||||
- [6.1 简介](#61-简介)
|
||||
- [6.2 运行机制](#62-运行机制)
|
||||
- [6.3 ScheduledThreadPoolExecutor 执行周期任务的步骤](#63-scheduledthreadpoolexecutor-执行周期任务的步骤)
|
||||
- [七 线程池大小确定](#七-线程池大小确定)
|
||||
- [八 参考](#八-参考)
|
||||
- [九 其他推荐阅读](#九-其他推荐阅读)
|
||||
|
||||
<!-- /TOC -->
|
||||
|
||||
## 一 使用线程池的好处
|
||||
|
||||
> **池化技术相比大家已经屡见不鲜了，线程池、数据库连接池、Http 连接池等等都是对这个思想的应用。池化技术的思想主要是为了减少每次获取资源的消耗，提高对资源的利用率。**
|
||||
|
||||
**线程池**提供了一种限制和管理资源（包括执行一个任务）。 每个**线程池**还维护一些基本统计信息，例如已完成任务的数量。
|
||||
|
||||
这里借用《Java 并发编程的艺术》提到的来说一下**使用线程池的好处**：
|
||||
|
||||
- **降低资源消耗**。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
|
||||
- **提高响应速度**。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
|
||||
- **提高线程的可管理性**。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
|
||||
|
||||
## 二 Executor 框架
|
||||
|
||||
### 2.1 简介
|
||||
|
||||
Executor 框架是 Java5 之后引进的，在 Java 5 之后，通过 Executor 来启动线程比使用 Thread 的 start 方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免 this 逃逸问题。
|
||||
|
||||
> 补充：this 逃逸是指在构造函数返回之前其他线程就持有该对象的引用. 调用尚未构造完全的对象的方法可能引发令人疑惑的错误。
|
||||
|
||||
Executor 框架不仅包括了线程池的管理，还提供了线程工厂、队列以及拒绝策略等，Executor 框架让并发编程变得更加简单。
|
||||
|
||||
### 2.2 Executor 框架结构(主要由三大部分组成)
|
||||
|
||||
#### 1) 任务(`Runnable` /`Callable`)
|
||||
|
||||
执行任务需要实现的 **`Runnable` 接口** 或 **`Callable`接口**。**`Runnable` 接口**或 **`Callable` 接口** 实现类都可以被 **`ThreadPoolExecutor`** 或 **`ScheduledThreadPoolExecutor`** 执行。
|
||||
|
||||
#### 2) 任务的执行(`Executor`)
|
||||
|
||||
如下图所示，包括任务执行机制的核心接口 **`Executor`** ，以及继承自 `Executor` 接口的 **`ExecutorService` 接口。`ThreadPoolExecutor`** 和 **`ScheduledThreadPoolExecutor`** 这两个关键类实现了 **ExecutorService 接口**。
|
||||
|
||||
**这里提了很多底层的类关系，但是，实际上我们需要更多关注的是 `ThreadPoolExecutor` 这个类，这个类在我们实际使用线程池的过程中，使用频率还是非常高的。**
|
||||
|
||||
> **注意：** 通过查看 `ScheduledThreadPoolExecutor` 源代码我们发现 `ScheduledThreadPoolExecutor` 实际上是继承了 `ThreadPoolExecutor` 并实现了 ScheduledExecutorService ，而 `ScheduledExecutorService` 又实现了 `ExecutorService`，正如我们下面给出的类关系图显示的一样。
|
||||
|
||||
**`ThreadPoolExecutor` 类描述:**
|
||||
|
||||
```java
|
||||
//AbstractExecutorService实现了ExecutorService接口
|
||||
public class ThreadPoolExecutor extends AbstractExecutorService
|
||||
```
|
||||
|
||||
**`ScheduledThreadPoolExecutor` 类描述:**
|
||||
|
||||
```java
|
||||
//ScheduledExecutorService实现了ExecutorService接口
|
||||
public class ScheduledThreadPoolExecutor
|
||||
extends ThreadPoolExecutor
|
||||
implements ScheduledExecutorService
|
||||
```
|
||||
|
||||
|
||||
|
||||
#### 3) 异步计算的结果(`Future`)
|
||||
|
||||
**`Future`** 接口以及 `Future` 接口的实现类 **`FutureTask`** 类都可以代表异步计算的结果。
|
||||
|
||||
当我们把 **`Runnable`接口** 或 **`Callable` 接口** 的实现类提交给 **`ThreadPoolExecutor`** 或 **`ScheduledThreadPoolExecutor`** 执行。（调用 `submit()` 方法时会返回一个 **`FutureTask`** 对象）
|
||||
|
||||
### 2.3 Executor 框架的使用示意图
|
||||
|
||||
|
||||
|
||||
1. **主线程首先要创建实现 `Runnable` 或者 `Callable` 接口的任务对象。**
|
||||
2. **把创建完成的实现 `Runnable`/`Callable`接口的 对象直接交给 `ExecutorService` 执行**: `ExecutorService.execute（Runnable command）`）或者也可以把 `Runnable` 对象或`Callable` 对象提交给 `ExecutorService` 执行（`ExecutorService.submit（Runnable task）`或 `ExecutorService.submit（Callable <T> task）`）。
|
||||
3. **如果执行 `ExecutorService.submit（…）`，`ExecutorService` 将返回一个实现`Future`接口的对象**（我们刚刚也提到过了执行 `execute()`方法和 `submit()`方法的区别，`submit()`会返回一个 `FutureTask 对象）。由于 FutureTask` 实现了 `Runnable`，我们也可以创建 `FutureTask`，然后直接交给 `ExecutorService` 执行。
|
||||
4. **最后，主线程可以执行 `FutureTask.get()`方法来等待任务执行完成。主线程也可以执行 `FutureTask.cancel（boolean mayInterruptIfRunning）`来取消此任务的执行。**
|
||||
|
||||
## 三 (重要)ThreadPoolExecutor 类简单介绍
|
||||
|
||||
**线程池实现类 `ThreadPoolExecutor` 是 `Executor` 框架最核心的类。**
|
||||
|
||||
### 3.1 ThreadPoolExecutor 类分析
|
||||
|
||||
`ThreadPoolExecutor` 类中提供的四个构造方法。我们来看最长的那个，其余三个都是在这个构造方法的基础上产生（其他几个构造方法说白点都是给定某些默认参数的构造方法比如默认制定拒绝策略是什么），这里就不贴代码讲了，比较简单。
|
||||
|
||||
```java
|
||||
/**
|
||||
* 用给定的初始参数创建一个新的ThreadPoolExecutor。
|
||||
*/
|
||||
public ThreadPoolExecutor(int corePoolSize,//线程池的核心线程数量
|
||||
int maximumPoolSize,//线程池的最大线程数
|
||||
long keepAliveTime,//当线程数大于核心线程数时，多余的空闲线程存活的最长时间
|
||||
TimeUnit unit,//时间单位
|
||||
BlockingQueue<Runnable> workQueue,//任务队列，用来储存等待执行任务的队列
|
||||
ThreadFactory threadFactory,//线程工厂，用来创建线程，一般默认即可
|
||||
RejectedExecutionHandler handler//拒绝策略，当提交的任务过多而不能及时处理时，我们可以定制策略来处理任务
|
||||
) {
|
||||
if (corePoolSize < 0 ||
|
||||
maximumPoolSize <= 0 ||
|
||||
maximumPoolSize < corePoolSize ||
|
||||
keepAliveTime < 0)
|
||||
throw new IllegalArgumentException();
|
||||
if (workQueue == null || threadFactory == null || handler == null)
|
||||
throw new NullPointerException();
|
||||
this.corePoolSize = corePoolSize;
|
||||
this.maximumPoolSize = maximumPoolSize;
|
||||
this.workQueue = workQueue;
|
||||
this.keepAliveTime = unit.toNanos(keepAliveTime);
|
||||
this.threadFactory = threadFactory;
|
||||
this.handler = handler;
|
||||
}
|
||||
```
|
||||
|
||||
**下面这些对创建 非常重要，在后面使用线程池的过程中你一定会用到！所以，务必拿着小本本记清楚。**
|
||||
|
||||
**`ThreadPoolExecutor` 3 个最重要的参数：**
|
||||
|
||||
- **`corePoolSize` :** 核心线程数线程数定义了最小可以同时运行的线程数量。
|
||||
- **`maximumPoolSize` :** 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。
|
||||
- **`workQueue`:** 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，信任就会被存放在队列中。
|
||||
|
||||
`ThreadPoolExecutor`其他常见参数:
|
||||
|
||||
1. **`keepAliveTime`**:当线程池中的线程数量大于 `corePoolSize` 的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了 `keepAliveTime`才会被回收销毁；
|
||||
2. **`unit`** : `keepAliveTime` 参数的时间单位。
|
||||
3. **`threadFactory`** :executor 创建新线程的时候会用到。
|
||||
4. **`handler`** :饱和策略。关于饱和策略下面单独介绍一下。
|
||||
|
||||
下面这张图可以加深你对线程池中各个参数的相互关系的理解（图片来源：《Java性能调优实战》）：
|
||||
|
||||
|
||||
|
||||
**`ThreadPoolExecutor` 饱和策略定义:**
|
||||
|
||||
如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任时，`ThreadPoolTaskExecutor` 定义一些策略:
|
||||
|
||||
- **`ThreadPoolExecutor.AbortPolicy`**：抛出 `RejectedExecutionException`来拒绝新任务的处理。
|
||||
- **`ThreadPoolExecutor.CallerRunsPolicy`**：调用执行自己的线程运行任务，也就是直接在调用`execute`方法的线程中运行(`run`)被拒绝的任务，如果执行程序已关闭，则会丢弃该任务。因此这种策略会降低对于新任务提交速度，影响程序的整体性能。另外，这个策略喜欢增加队列容量。如果您的应用程序可以承受此延迟并且你不能任务丢弃任何一个任务请求的话，你可以选择这个策略。
|
||||
- **`ThreadPoolExecutor.DiscardPolicy`：** 不处理新任务，直接丢弃掉。
|
||||
- **`ThreadPoolExecutor.DiscardOldestPolicy`：** 此策略将丢弃最早的未处理的任务请求。
|
||||
|
||||
举个例子：
|
||||
|
||||
> Spring 通过 `ThreadPoolTaskExecutor` 或者我们直接通过 `ThreadPoolExecutor` 的构造函数创建线程池的时候，当我们不指定 `RejectedExecutionHandler` 饱和策略的话来配置线程池的时候默认使用的是 `ThreadPoolExecutor.AbortPolicy`。在默认情况下，`ThreadPoolExecutor` 将抛出 `RejectedExecutionException` 来拒绝新来的任务 ，这代表你将丢失对这个任务的处理。 对于可伸缩的应用程序，建议使用 `ThreadPoolExecutor.CallerRunsPolicy`。当最大池被填满时，此策略为我们提供可伸缩队列。（这个直接查看 `ThreadPoolExecutor` 的构造函数源码就可以看出，比较简单的原因，这里就不贴代码了。）
|
||||
|
||||
### 3.2 推荐使用 `ThreadPoolExecutor` 构造函数创建线程池
|
||||
|
||||
**在《阿里巴巴 Java 开发手册》“并发处理”这一章节，明确指出线程资源必须通过线程池提供，不允许在应用中自行显示创建线程。**
|
||||
|
||||
**为什么呢？**
|
||||
|
||||
> **使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源开销，解决资源不足的问题。如果不使用线程池，有可能会造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。**
|
||||
|
||||
**另外《阿里巴巴 Java 开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 构造函数的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险**
|
||||
|
||||
> Executors 返回线程池对象的弊端如下：
|
||||
>
|
||||
> - **`FixedThreadPool` 和 `SingleThreadExecutor`** ： 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致 OOM。
|
||||
> - **CachedThreadPool 和 ScheduledThreadPool** ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致 OOM。
|
||||
|
||||
**方式一：通过`ThreadPoolExecutor`构造函数实现（推荐）**
|
||||
|
||||
**方式二：通过 Executor 框架的工具类 Executors 来实现**
|
||||
我们可以创建三种类型的 ThreadPoolExecutor：
|
||||
|
||||
- **FixedThreadPool**
|
||||
- **SingleThreadExecutor**
|
||||
- **CachedThreadPool**
|
||||
|
||||
对应 Executors 工具类中的方法如图所示：
|
||||
|
||||
|
||||
## 四 (重要)ThreadPoolExecutor 使用示例
|
||||
|
||||
我们上面讲解了 `Executor`框架以及 `ThreadPoolExecutor` 类，下面让我们实战一下，来通过写一个 `ThreadPoolExecutor` 的小 Demo 来回顾上面的内容。
|
||||
|
||||
### 4.1 示例代码:`Runnable`+`ThreadPoolExecutor`
|
||||
|
||||
首先创建一个 `Runnable` 接口的实现类（当然也可以是 `Callable` 接口，我们上面也说了两者的区别。）
|
||||
|
||||
`MyRunnable.java`
|
||||
|
||||
```java
|
||||
import java.util.Date;
|
||||
|
||||
/**
|
||||
* 这是一个简单的Runnable类，需要大约5秒钟来执行其任务。
|
||||
* @author shuang.kou
|
||||
*/
|
||||
public class MyRunnable implements Runnable {
|
||||
|
||||
private String command;
|
||||
|
||||
public MyRunnable(String s) {
|
||||
this.command = s;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
|
||||
processCommand();
|
||||
System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
|
||||
}
|
||||
|
||||
private void processCommand() {
|
||||
try {
|
||||
Thread.sleep(5000);
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return this.command;
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
编写测试程序，我们这里以阿里巴巴推荐的使用 `ThreadPoolExecutor` 构造函数自定义参数的方式来创建线程池。
|
||||
|
||||
`ThreadPoolExecutorDemo.java`
|
||||
|
||||
```java
|
||||
import java.util.concurrent.ArrayBlockingQueue;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
public class ThreadPoolExecutorDemo {
|
||||
|
||||
private static final int CORE_POOL_SIZE = 5;
|
||||
private static final int MAX_POOL_SIZE = 10;
|
||||
private static final int QUEUE_CAPACITY = 100;
|
||||
private static final Long KEEP_ALIVE_TIME = 1L;
|
||||
public static void main(String[] args) {
|
||||
|
||||
//使用阿里巴巴推荐的创建线程池的方式
|
||||
//通过ThreadPoolExecutor构造函数自定义参数创建
|
||||
ThreadPoolExecutor executor = new ThreadPoolExecutor(
|
||||
CORE_POOL_SIZE,
|
||||
MAX_POOL_SIZE,
|
||||
KEEP_ALIVE_TIME,
|
||||
TimeUnit.SECONDS,
|
||||
new ArrayBlockingQueue<>(QUEUE_CAPACITY),
|
||||
new ThreadPoolExecutor.CallerRunsPolicy());
|
||||
|
||||
for (int i = 0; i < 10; i++) {
|
||||
//创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
|
||||
Runnable worker = new MyRunnable("" + i);
|
||||
//执行Runnable
|
||||
executor.execute(worker);
|
||||
}
|
||||
//终止线程池
|
||||
executor.shutdown();
|
||||
while (!executor.isTerminated()) {
|
||||
}
|
||||
System.out.println("Finished all threads");
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
可以看到我们上面的代码指定了：
|
||||
|
||||
1. `corePoolSize`: 核心线程数为 5。
|
||||
2. `maximumPoolSize` ：最大线程数 10
|
||||
3. `keepAliveTime` : 等待时间为 1L。
|
||||
4. `unit`: 等待时间的单位为 TimeUnit.SECONDS。
|
||||
5. `workQueue`：任务队列为 `ArrayBlockingQueue`，并且容量为 100;
|
||||
6. `handler`:饱和策略为 `CallerRunsPolicy`。
|
||||
|
||||
**Output：**
|
||||
|
||||
```
|
||||
pool-1-thread-2 Start. Time = Tue Nov 12 20:59:44 CST 2019
|
||||
pool-1-thread-5 Start. Time = Tue Nov 12 20:59:44 CST 2019
|
||||
pool-1-thread-4 Start. Time = Tue Nov 12 20:59:44 CST 2019
|
||||
pool-1-thread-1 Start. Time = Tue Nov 12 20:59:44 CST 2019
|
||||
pool-1-thread-3 Start. Time = Tue Nov 12 20:59:44 CST 2019
|
||||
pool-1-thread-5 End. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-3 End. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-2 End. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-4 End. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-1 End. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-2 Start. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-1 Start. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-4 Start. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-3 Start. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-5 Start. Time = Tue Nov 12 20:59:49 CST 2019
|
||||
pool-1-thread-2 End. Time = Tue Nov 12 20:59:54 CST 2019
|
||||
pool-1-thread-3 End. Time = Tue Nov 12 20:59:54 CST 2019
|
||||
pool-1-thread-4 End. Time = Tue Nov 12 20:59:54 CST 2019
|
||||
pool-1-thread-5 End. Time = Tue Nov 12 20:59:54 CST 2019
|
||||
pool-1-thread-1 End. Time = Tue Nov 12 20:59:54 CST 2019
|
||||
|
||||
```
|
||||
|
||||
### 4.2 线程池原理分析
|
||||
|
||||
承接 4.1 节，我们通过代码输出结果可以看出：**线程池每次会同时执行 5 个任务，这 5 个任务执行完之后，剩余的 5 个任务才会被执行。** 大家可以先通过上面讲解的内容，分析一下到底是咋回事？（自己独立思考一会）
|
||||
|
||||
现在，我们就分析上面的输出内容来简单分析一下线程池原理。
|
||||
|
||||
**为了搞懂线程池的原理，我们需要首先分析一下 `execute`方法。**在 4.1 节中的 Demo 中我们使用 `executor.execute(worker)`来提交一个任务到线程池中去，这个方法非常重要，下面我们来看看它的源码：
|
||||
|
||||
```java
|
||||
// 存放线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)
|
||||
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
|
||||
|
||||
private static int workerCountOf(int c) {
|
||||
return c & CAPACITY;
|
||||
}
|
||||
|
||||
private final BlockingQueue<Runnable> workQueue;
|
||||
|
||||
public void execute(Runnable command) {
|
||||
// 如果任务为null，则抛出异常。
|
||||
if (command == null)
|
||||
throw new NullPointerException();
|
||||
// ctl 中保存的线程池当前的一些状态信息
|
||||
int c = ctl.get();
|
||||
|
||||
// 下面会涉及到 3 步 操作
|
||||
// 1.首先判断当前线程池中之行的任务数量是否小于 corePoolSize
|
||||
// 如果小于的话，通过addWorker(command, true)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
|
||||
if (workerCountOf(c) < corePoolSize) {
|
||||
if (addWorker(command, true))
|
||||
return;
|
||||
c = ctl.get();
|
||||
}
|
||||
// 2.如果当前之行的任务数量大于等于 corePoolSize 的时候就会走到这里
|
||||
// 通过 isRunning 方法判断线程池状态，线程池处于 RUNNING 状态才会被并且队列可以加入任务，该任务才会被加入进去
|
||||
if (isRunning(c) && workQueue.offer(command)) {
|
||||
int recheck = ctl.get();
|
||||
// 再次获取线程池状态，如果线程池状态不是 RUNNING 状态就需要从任务队列中移除任务，并尝试判断线程是否全部执行完毕。同时执行拒绝策略。
|
||||
if (!isRunning(recheck) && remove(command))
|
||||
reject(command);
|
||||
// 如果当前线程池为空就新创建一个线程并执行。
|
||||
else if (workerCountOf(recheck) == 0)
|
||||
addWorker(null, false);
|
||||
}
|
||||
//3. 通过addWorker(command, false)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
|
||||
//如果addWorker(command, false)执行失败，则通过reject()执行相应的拒绝策略的内容。
|
||||
else if (!addWorker(command, false))
|
||||
reject(command);
|
||||
}
|
||||
```
|
||||
|
||||
通过下图可以更好的对上面这 3 步做一个展示，下图是我为了省事直接从网上找到，原地址不明。
|
||||
|
||||
|
||||
|
||||
现在，让我们在回到 4.1 节我们写的 Demo， 现在应该是不是很容易就可以搞懂它的原理了呢？
|
||||
|
||||
没搞懂的话，也没关系，可以看看我的分析：
|
||||
|
||||
> 我们在代码中模拟了 10 个任务，我们配置的核心线程数为 5 、等待队列容量为 100 ，所以每次只可能存在 5 个任务同时执行，剩下的 5 个任务会被放到等待队列中去。当前的 5 个任务之行完成后，才会之行剩下的 5 个任务。
|
||||
|
||||
### 4.3 几个常见的对比
|
||||
|
||||
#### 4.3.1 `Runnable` vs `Callable`
|
||||
|
||||
`Runnable`自 Java 1.0 以来一直存在，但`Callable`仅在 Java 1.5 中引入,目的就是为了来处理`Runnable`不支持的用例。**`Runnable` 接口**不会返回结果或抛出检查异常，但是**`Callable` 接口**可以。所以，如果任务不需要返回结果或抛出异常推荐使用 **`Runnable` 接口**，这样代码看起来会更加简洁。
|
||||
|
||||
工具类 `Executors` 可以实现 `Runnable` 对象和 `Callable` 对象之间的相互转换。（`Executors.callable（Runnable task`）或 `Executors.callable（Runnable task，Object resule）`）。
|
||||
|
||||
`Runnable.java`
|
||||
|
||||
```java
|
||||
@FunctionalInterface
|
||||
public interface Runnable {
|
||||
/**
|
||||
* 被线程执行，没有返回值也无法抛出异常
|
||||
*/
|
||||
public abstract void run();
|
||||
}
|
||||
```
|
||||
|
||||
`Callable.java`
|
||||
|
||||
```java
|
||||
@FunctionalInterface
|
||||
public interface Callable<V> {
|
||||
/**
|
||||
* 计算结果，或在无法这样做时抛出异常。
|
||||
* @return 计算得出的结果
|
||||
* @throws 如果无法计算结果，则抛出异常
|
||||
*/
|
||||
V call() throws Exception;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
#### 4.3.2 `execute()` vs `submit()`
|
||||
|
||||
1. **`execute()`方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；**
|
||||
2. **`submit()`方法用于提交需要返回值的任务。线程池会返回一个 `Future` 类型的对象，通过这个 `Future` 对象可以判断任务是否执行成功**，并且可以通过 `Future` 的 `get()`方法来获取返回值，`get()`方法会阻塞当前线程直到任务完成，而使用 `get（long timeout，TimeUnit unit）`方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。
|
||||
|
||||
我们以**`AbstractExecutorService`**接口中的一个 `submit` 方法为例子来看看源代码：
|
||||
|
||||
```java
|
||||
public Future<?> submit(Runnable task) {
|
||||
if (task == null) throw new NullPointerException();
|
||||
RunnableFuture<Void> ftask = newTaskFor(task, null);
|
||||
execute(ftask);
|
||||
return ftask;
|
||||
}
|
||||
```
|
||||
|
||||
上面方法调用的 `newTaskFor` 方法返回了一个 `FutureTask` 对象。
|
||||
|
||||
```java
|
||||
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
|
||||
return new FutureTask<T>(runnable, value);
|
||||
}
|
||||
```
|
||||
|
||||
我们再来看看`execute()`方法：
|
||||
|
||||
```java
|
||||
public void execute(Runnable command) {
|
||||
...
|
||||
}
|
||||
```
|
||||
|
||||
#### 4.3.3 `shutdown()`VS`shutdownNow()`
|
||||
|
||||
- **`shutdown（）`** :关闭线程池，线程池的状态变为 `SHUTDOWN`。线程池不再接受新任务了，但是队列里的任务得执行完毕。
|
||||
- **`shutdownNow（）`** :关闭线程池，线程的状态变为 `STOP`。线程池会终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的 List。
|
||||
|
||||
#### 4.3.2 `isTerminated()` VS `isShutdown()`
|
||||
|
||||
- **`isShutDown`** 当调用 `shutdown()` 方法后返回为 true。
|
||||
- **`isTerminated`** 当调用 `shutdown()` 方法后，并且所有提交的任务完成后返回为 true
|
||||
|
||||
### 4.4 加餐:`Callable`+`ThreadPoolExecutor`示例代码
|
||||
|
||||
`MyCallable.java`
|
||||
|
||||
```java
|
||||
|
||||
import java.util.concurrent.Callable;
|
||||
|
||||
public class MyCallable implements Callable<String> {
|
||||
@Override
|
||||
public String call() throws Exception {
|
||||
Thread.sleep(1000);
|
||||
//返回执行当前 Callable 的线程名字
|
||||
return Thread.currentThread().getName();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
`CallableDemo.java`
|
||||
|
||||
```java
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Date;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.ArrayBlockingQueue;
|
||||
import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.ExecutionException;
|
||||
import java.util.concurrent.Future;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
public class CallableDemo {
|
||||
|
||||
private static final int CORE_POOL_SIZE = 5;
|
||||
private static final int MAX_POOL_SIZE = 10;
|
||||
private static final int QUEUE_CAPACITY = 100;
|
||||
private static final Long KEEP_ALIVE_TIME = 1L;
|
||||
|
||||
public static void main(String[] args) {
|
||||
|
||||
//使用阿里巴巴推荐的创建线程池的方式
|
||||
//通过ThreadPoolExecutor构造函数自定义参数创建
|
||||
ThreadPoolExecutor executor = new ThreadPoolExecutor(
|
||||
CORE_POOL_SIZE,
|
||||
MAX_POOL_SIZE,
|
||||
KEEP_ALIVE_TIME,
|
||||
TimeUnit.SECONDS,
|
||||
new ArrayBlockingQueue<>(QUEUE_CAPACITY),
|
||||
new ThreadPoolExecutor.CallerRunsPolicy());
|
||||
|
||||
List<Future<String>> futureList = new ArrayList<>();
|
||||
Callable<String> callable = new MyCallable();
|
||||
for (int i = 0; i < 10; i++) {
|
||||
//提交任务到线程池
|
||||
Future<String> future = executor.submit(callable);
|
||||
//将返回值 future 添加到 list，我们可以通过 future 获得 执行 Callable 得到的返回值
|
||||
futureList.add(future);
|
||||
}
|
||||
for (Future<String> fut : futureList) {
|
||||
try {
|
||||
System.out.println(new Date() + "::" + fut.get());
|
||||
} catch (InterruptedException | ExecutionException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
//关闭线程池
|
||||
executor.shutdown();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Output:
|
||||
|
||||
```
|
||||
Wed Nov 13 13:40:41 CST 2019::pool-1-thread-1
|
||||
Wed Nov 13 13:40:42 CST 2019::pool-1-thread-2
|
||||
Wed Nov 13 13:40:42 CST 2019::pool-1-thread-3
|
||||
Wed Nov 13 13:40:42 CST 2019::pool-1-thread-4
|
||||
Wed Nov 13 13:40:42 CST 2019::pool-1-thread-5
|
||||
Wed Nov 13 13:40:42 CST 2019::pool-1-thread-3
|
||||
Wed Nov 13 13:40:43 CST 2019::pool-1-thread-2
|
||||
Wed Nov 13 13:40:43 CST 2019::pool-1-thread-1
|
||||
Wed Nov 13 13:40:43 CST 2019::pool-1-thread-4
|
||||
Wed Nov 13 13:40:43 CST 2019::pool-1-thread-5
|
||||
```
|
||||
|
||||
## 五 几种常见的线程池详解
|
||||
|
||||
### 5.1 FixedThreadPool
|
||||
|
||||
#### 5.1.1 介绍
|
||||
|
||||
`FixedThreadPool` 被称为可重用固定线程数的线程池。通过 Executors 类中的相关源代码来看一下相关实现：
|
||||
|
||||
```java
|
||||
/**
|
||||
* 创建一个可重用固定数量线程的线程池
|
||||
*/
|
||||
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
|
||||
return new ThreadPoolExecutor(nThreads, nThreads,
|
||||
0L, TimeUnit.MILLISECONDS,
|
||||
new LinkedBlockingQueue<Runnable>(),
|
||||
threadFactory);
|
||||
}
|
||||
```
|
||||
|
||||
另外还有一个 `FixedThreadPool` 的实现方法，和上面的类似，所以这里不多做阐述：
|
||||
|
||||
```java
|
||||
public static ExecutorService newFixedThreadPool(int nThreads) {
|
||||
return new ThreadPoolExecutor(nThreads, nThreads,
|
||||
0L, TimeUnit.MILLISECONDS,
|
||||
new LinkedBlockingQueue<Runnable>());
|
||||
}
|
||||
```
|
||||
|
||||
**从上面源代码可以看出新创建的 `FixedThreadPool` 的 `corePoolSize` 和 `maximumPoolSize` 都被设置为 nThreads，这个 nThreads 参数是我们使用的时候自己传递的。**
|
||||
|
||||
#### 5.1.2 执行任务过程介绍
|
||||
|
||||
`FixedThreadPool` 的 `execute()` 方法运行示意图（该图片来源：《Java 并发编程的艺术》）：
|
||||
|
||||
|
||||
|
||||
**上图说明：**
|
||||
|
||||
1. 如果当前运行的线程数小于 corePoolSize， 如果再来新任务的话，就创建新的线程来执行任务；
|
||||
2. 当前运行的线程数等于 corePoolSize 后， 如果再来新任务的话，会将任务加入 `LinkedBlockingQueue`；
|
||||
3. 线程池中的线程执行完 手头的任务后，会在循环中反复从 `LinkedBlockingQueue` 中获取任务来执行；
|
||||
|
||||
#### 5.1.3 为什么不推荐使用`FixedThreadPool`？
|
||||
|
||||
**`FixedThreadPool` 使用无界队列 `LinkedBlockingQueue`（队列的容量为 Intger.MAX_VALUE）作为线程池的工作队列会对线程池带来如下影响 ：**
|
||||
|
||||
1. 当线程池中的线程数达到 `corePoolSize` 后，新任务将在无界队列中等待，因此线程池中的线程数不会超过 corePoolSize；
|
||||
2. 由于使用无界队列时 `maximumPoolSize` 将是一个无效参数，因为不可能存在任务队列满的情况。所以，通过创建 `FixedThreadPool`的源码可以看出创建的 `FixedThreadPool` 的 `corePoolSize` 和 `maximumPoolSize` 被设置为同一个值。
|
||||
3. 由于 1 和 2，使用无界队列时 `keepAliveTime` 将是一个无效参数；
|
||||
4. 运行中的 `FixedThreadPool`（未执行 `shutdown()`或 `shutdownNow()`）不会拒绝任务，在任务比较多的时候会导致 OOM（内存溢出）。
|
||||
|
||||
### 5.2 SingleThreadExecutor 详解
|
||||
|
||||
#### 5.2.1 介绍
|
||||
|
||||
`SingleThreadExecutor` 是只有一个线程的线程池。下面看看**SingleThreadExecutor 的实现：**
|
||||
|
||||
```java
|
||||
/**
|
||||
*返回只有一个线程的线程池
|
||||
*/
|
||||
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
|
||||
return new FinalizableDelegatedExecutorService
|
||||
(new ThreadPoolExecutor(1, 1,
|
||||
0L, TimeUnit.MILLISECONDS,
|
||||
new LinkedBlockingQueue<Runnable>(),
|
||||
threadFactory));
|
||||
}
|
||||
```
|
||||
|
||||
```java
|
||||
public static ExecutorService newSingleThreadExecutor() {
|
||||
return new FinalizableDelegatedExecutorService
|
||||
(new ThreadPoolExecutor(1, 1,
|
||||
0L, TimeUnit.MILLISECONDS,
|
||||
new LinkedBlockingQueue<Runnable>()));
|
||||
}
|
||||
```
|
||||
|
||||
从上面源代码可以看出新创建的 `SingleThreadExecutor` 的 `corePoolSize` 和 `maximumPoolSize` 都被设置为 1.其他参数和 `FixedThreadPool` 相同。
|
||||
|
||||
#### 5.2.2 执行任务过程介绍
|
||||
|
||||
**`SingleThreadExecutor` 的运行示意图（该图片来源：《Java 并发编程的艺术》）：**
|
||||
|
||||
|
||||
**上图说明;**
|
||||
|
||||
1. 如果当前运行的线程数少于 corePoolSize，则创建一个新的线程执行任务；
|
||||
2. 当前线程池中有一个运行的线程后，将任务加入 `LinkedBlockingQueue`
|
||||
3. 线程执行完当前的任务后，会在循环中反复从` LinkedBlockingQueue` 中获取任务来执行；
|
||||
|
||||
#### 5.2.3 为什么不推荐使用`SingleThreadExecutor`？
|
||||
|
||||
`SingleThreadExecutor` 使用无界队列 `LinkedBlockingQueue` 作为线程池的工作队列（队列的容量为 Intger.MAX_VALUE）。`SingleThreadExecutor` 使用无界队列作为线程池的工作队列会对线程池带来的影响与 `FixedThreadPool` 相同。说简单点就是可能会导致 OOM，
|
||||
|
||||
### 5.3 CachedThreadPool 详解
|
||||
|
||||
#### 5.3.1 介绍
|
||||
|
||||
`CachedThreadPool` 是一个会根据需要创建新线程的线程池。下面通过源码来看看 `CachedThreadPool` 的实现：
|
||||
|
||||
```java
|
||||
/**
|
||||
* 创建一个线程池，根据需要创建新线程，但会在先前构建的线程可用时重用它。
|
||||
*/
|
||||
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
|
||||
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
|
||||
60L, TimeUnit.SECONDS,
|
||||
new SynchronousQueue<Runnable>(),
|
||||
threadFactory);
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
```java
|
||||
public static ExecutorService newCachedThreadPool() {
|
||||
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
|
||||
60L, TimeUnit.SECONDS,
|
||||
new SynchronousQueue<Runnable>());
|
||||
}
|
||||
```
|
||||
|
||||
`CachedThreadPool` 的` corePoolSize` 被设置为空（0），`maximumPoolSize `被设置为 Integer.MAX.VALUE，即它是无界的，这也就意味着如果主线程提交任务的速度高于 `maximumPool` 中线程处理任务的速度时，`CachedThreadPool` 会不断创建新的线程。极端情况下，这样会导致耗尽 cpu 和内存资源。
|
||||
|
||||
#### 5.3.2 执行任务过程介绍
|
||||
|
||||
**CachedThreadPool 的 execute()方法的执行示意图（该图片来源：《Java 并发编程的艺术》）：**
|
||||
|
||||
|
||||
**上图说明：**
|
||||
|
||||
1. 首先执行 `SynchronousQueue.offer(Runnable task)` 提交任务到任务队列。如果当前 `maximumPool` 中有闲线程正在执行 `SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)`，那么主线程执行 offer 操作与空闲线程执行的 `poll` 操作配对成功，主线程把任务交给空闲线程执行，`execute()`方法执行完成，否则执行下面的步骤 2；
|
||||
2. 当初始 `maximumPool` 为空，或者 `maximumPool` 中没有空闲线程时，将没有线程执行 `SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)`。这种情况下，步骤 1 将失败，此时 `CachedThreadPool` 会创建新线程执行任务，execute 方法执行完成；
|
||||
|
||||
#### 5.3.3 为什么不推荐使用`CachedThreadPool`？
|
||||
|
||||
`CachedThreadPool`允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致 OOM。
|
||||
|
||||
## 六 ScheduledThreadPoolExecutor 详解
|
||||
|
||||
**`ScheduledThreadPoolExecutor` 主要用来在给定的延迟后运行任务，或者定期执行任务。** 这个在实际项目中基本不会被用到，所以对这部分大家只需要简单了解一下它的思想。关于如何在Spring Boot 中 实现定时任务，可以查看这篇文章[《5分钟搞懂如何在Spring Boot中Schedule Tasks》](https://github.com/Snailclimb/springboot-guide/blob/master/docs/advanced/SpringBoot-ScheduleTasks.md)。
|
||||
|
||||
### 6.1 简介
|
||||
|
||||
**`ScheduledThreadPoolExecutor` 使用的任务队列 `DelayQueue` 封装了一个 `PriorityQueue`，`PriorityQueue` 会对队列中的任务进行排序，执行所需时间短的放在前面先被执行(`ScheduledFutureTask` 的 `time` 变量小的先执行)，如果执行所需时间相同则先提交的任务将被先执行(`ScheduledFutureTask` 的 `squenceNumber` 变量小的先执行)。**
|
||||
|
||||
**`ScheduledThreadPoolExecutor` 和 `Timer` 的比较：**
|
||||
|
||||
- `Timer` 对系统时钟的变化敏感，`ScheduledThreadPoolExecutor`不是；
|
||||
- `Timer` 只有一个执行线程，因此长时间运行的任务可以延迟其他任务。 `ScheduledThreadPoolExecutor` 可以配置任意数量的线程。 此外，如果你想（通过提供 ThreadFactory），你可以完全控制创建的线程;
|
||||
- 在`TimerTask` 中抛出的运行时异常会杀死一个线程，从而导致 `Timer` 死机:-( ...即计划任务将不再运行。`ScheduledThreadExecutor` 不仅捕获运行时异常，还允许您在需要时处理它们（通过重写 `afterExecute` 方法`ThreadPoolExecutor`）。抛出异常的任务将被取消，但其他任务将继续运行。
|
||||
|
||||
**综上，在 JDK1.5 之后，你没有理由再使用 Timer 进行任务调度了。**
|
||||
|
||||
> **备注：** Quartz 是一个由 java 编写的任务调度库，由 OpenSymphony 组织开源出来。在实际项目开发中使用 Quartz 的还是居多，比较推荐使用 Quartz。因为 Quartz 理论上能够同时对上万个任务进行调度，拥有丰富的功能特性，包括任务调度、任务持久化、可集群化、插件等等。
|
||||
|
||||
### 6.2 运行机制
|
||||
|
||||
|
||||
|
||||
**`ScheduledThreadPoolExecutor` 的执行主要分为两大部分：**
|
||||
|
||||
1. 当调用 `ScheduledThreadPoolExecutor` 的 **`scheduleAtFixedRate()`** 方法或者**`scheduleWirhFixedDelay()`** 方法时，会向 `ScheduledThreadPoolExecutor` 的 **`DelayQueue`** 添加一个实现了 **`RunnableScheduledFuture`** 接口的 **`ScheduledFutureTask`** 。
|
||||
2. 线程池中的线程从 `DelayQueue` 中获取 `ScheduledFutureTask`，然后执行任务。
|
||||
|
||||
**`ScheduledThreadPoolExecutor` 为了实现周期性的执行任务，对 `ThreadPoolExecutor `做了如下修改：**
|
||||
|
||||
- 使用 **`DelayQueue`** 作为任务队列；
|
||||
- 获取任务的方不同
|
||||
- 执行周期任务后，增加了额外的处理
|
||||
|
||||
### 6.3 ScheduledThreadPoolExecutor 执行周期任务的步骤
|
||||
|
||||
|
||||
|
||||
1. 线程 1 从 `DelayQueue` 中获取已到期的 `ScheduledFutureTask（DelayQueue.take()）`。到期任务是指 `ScheduledFutureTask `的 time 大于等于当前系统的时间；
|
||||
2. 线程 1 执行这个 `ScheduledFutureTask`；
|
||||
3. 线程 1 修改 `ScheduledFutureTask` 的 time 变量为下次将要被执行的时间；
|
||||
4. 线程 1 把这个修改 time 之后的 `ScheduledFutureTask` 放回 `DelayQueue` 中（`DelayQueue.add()`)。
|
||||
|
||||
## 七 线程池大小确定
|
||||
|
||||
**线程池数量的确定一直是困扰着程序员的一个难题，大部分程序员在设定线程池大小的时候就是随心而定。我们并没有考虑过这样大小的配置是否会带来什么问题，我自己就是这大部分程序员中的一个代表。**
|
||||
|
||||
由于笔主对如何确定线程池大小也没有什么实际经验，所以，这部分内容参考了网上很多文章/书籍。
|
||||
|
||||
**首先，可以肯定的一点是线程池大小设置过大或者过小都会有问题。合适的才是最好，貌似在 95 % 的场景下都是合适的。**
|
||||
|
||||
如果阅读过我的上一篇关于线程池的文章的话，你一定知道：
|
||||
|
||||
**如果我们设置的线程池数量太小的话，如果同一时间有大量任务/请求需要处理，可能会导致大量的请求/任务在任务队列中排队等待执行，甚至会出现任务队列满了之后任务/请求无法处理的情况，或者大量任务堆积在任务队列导致 OOM。这样很明显是有问题的！ CPU 根本没有得到充分利用。**
|
||||
|
||||
**但是，如果我们设置线程数量太大，大量线程可能会同时在争取 CPU 资源，这样会导致大量的上下文切换，从而增加线程的执行时间，影响了整体执行效率。**
|
||||
|
||||
> 上下文切换：
|
||||
>
|
||||
> 多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换回这个任务时，可以再加载这个任务的状态。**任务从保存到再加载的过程就是一次上下文切换**。
|
||||
>
|
||||
> 上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。
|
||||
>
|
||||
> Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。
|
||||
|
||||
有一个简单并且适用面比较广的公式：
|
||||
|
||||
- **CPU 密集型任务(N+1)：** 这种任务消耗的主要是 CPU 资源，可以将线程数设置为 N（CPU 核心数）+1，比 CPU 核心数多出来的一个线程是为了防止线程偶发的缺页中断，或者其它原因导致的任务暂停而带来的影响。一旦任务暂停，CPU 就会处于空闲状态，而在这种情况下多出来的一个线程就可以充分利用 CPU 的空闲时间。
|
||||
- **I/O 密集型任务(2N)：** 这种任务应用起来，系统会用大部分的时间来处理 I/O 交互，而线程在处理 I/O 的时间段内不会占用 CPU 来处理，这时就可以将 CPU 交出给其它线程使用。因此在 I/O 密集型任务的应用中，我们可以多配置一些线程，具体的计算方法是 2N。
|
||||
|
||||
## 八 参考
|
||||
|
||||
- 《Java 并发编程的艺术》
|
||||
- [Java Scheduler ScheduledExecutorService ScheduledThreadPoolExecutor Example](https://www.journaldev.com/2340/java-scheduler-scheduledexecutorservice-scheduledthreadpoolexecutor-example "Java Scheduler ScheduledExecutorService ScheduledThreadPoolExecutor Example")
|
||||
- [java.util.concurrent.ScheduledThreadPoolExecutor Example](https://examples.javacodegeeks.com/core-java/util/concurrent/scheduledthreadpoolexecutor/java-util-concurrent-scheduledthreadpoolexecutor-example/ "java.util.concurrent.ScheduledThreadPoolExecutor Example")
|
||||
- [ThreadPoolExecutor – Java Thread Pool Example](https://www.journaldev.com/1069/threadpoolexecutor-java-thread-pool-example-executorservice "ThreadPoolExecutor – Java Thread Pool Example")
|
||||
|
||||
## 九 其他推荐阅读
|
||||
|
||||
- [Java 并发（三）线程池原理](https://www.cnblogs.com/warehouse/p/10720781.html "Java并发（三）线程池原理")
|
||||
- [如何优雅的使用和理解线程池](https://github.com/crossoverJie/JCSprout/blob/master/MD/ThreadPoolExecutor.md "如何优雅的使用和理解线程池")
|
||||
@ -1,6 +1,4 @@
|
||||
以下内容摘自我的 Gitchat ：[Java 程序员必备：并发知识系统总结](https://gitbook.cn/gitchat/activity/5bc2b6af56f0425673d299bb)，欢迎订阅！
|
||||
|
||||
Github 地址：[https://github.com/Snailclimb/JavaGuide/edit/master/Java相关/synchronized.md](https://github.com/Snailclimb/JavaGuide/edit/master/Java相关/synchronized.md)
|
||||
|
||||
|
||||
|
||||
@ -12,7 +10,7 @@ Github 地址：[https://github.com/Snailclimb/JavaGuide/edit/master/Java相关/
|
||||
|
||||
下面我已一个常见的面试题为例讲解一下 synchronized 关键字的具体使用。
|
||||
|
||||
面试中面试官经常会说：“单例模式了解吗？来给我手写一下！给我解释一下双重检验锁方式实现单利模式的原理呗！”
|
||||
面试中面试官经常会说：“单例模式了解吗？来给我手写一下！给我解释一下双重检验锁方式实现单例模式的原理呗！”
|
||||
|
||||
|
||||
|
||||
@ -48,7 +46,7 @@ uniqueInstance 采用 volatile 关键字修饰也是很有必要的， uniqueIns
|
||||
2. 初始化 uniqueInstance
|
||||
3. 将 uniqueInstance 指向分配的内存地址
|
||||
|
||||
但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出先问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
|
||||
但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1->3->2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T1 执行了 1 和 3，此时 T2 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。
|
||||
|
||||
使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。
|
||||
|
||||
@ -141,7 +139,7 @@ JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、
|
||||
|
||||
**⑤ 锁粗化**
|
||||
|
||||
原则上，我们再编写代码的时候，总是推荐将同步快的作用范围限制得尽量小——只在共享数据的实际作用域才进行同步，这样是为了使得需要同步的操作数量尽可能变小，如果存在锁竞争，那等待线程也能尽快拿到锁。
|
||||
原则上，我们在编写代码的时候，总是推荐将同步块的作用范围限制得尽量小，——直在共享数据的实际作用域才进行同步，这样是为了使得需要同步的操作数量尽可能变小，如果存在锁竞争，那等待线程也能尽快拿到锁。
|
||||
|
||||
大部分情况下，上面的原则都是没有问题的，但是如果一系列的连续操作都对同一个对象反复加锁和解锁，那么会带来很多不必要的性能消耗。
|
||||
|
||||
@ -168,4 +166,4 @@ synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团
|
||||
|
||||
**④ 性能已不是选择标准**
|
||||
|
||||
在JDK1.6之前，synchronized 的性能是比 ReenTrantLock 差很多。具体表示为：synchronized 关键字吞吐量岁线程数的增加，下降得非常严重。而ReenTrantLock 基本保持一个比较稳定的水平。我觉得这也侧面反映了， synchronized 关键字还有非常大的优化余地。后续的技术发展也证明了这一点，我们上面也讲了在 JDK1.6 之后 JVM 团队对 synchronized 关键字做了很多优化。**JDK1.6 之后，synchronized 和 ReenTrantLock 的性能基本是持平了。所以网上那些说因为性能才选择 ReenTrantLock 的文章都是错的！JDK1.6之后，性能已经不是选择synchronized和ReenTrantLock的影响因素了！而且虚拟机在未来的性能改进中会更偏向于原生的synchronized，所以还是提倡在synchronized能满足你的需求的情况下，优先考虑使用synchronized关键字来进行同步！优化后的synchronized和ReenTrantLock一样，在很多地方都是用到了CAS操作**。
|
||||
在JDK1.6之前，synchronized 的性能是比 ReenTrantLock 差很多。具体表示为：synchronized 关键字吞吐量随线程数的增加，下降得非常严重。而ReenTrantLock 基本保持一个比较稳定的水平。我觉得这也侧面反映了， synchronized 关键字还有非常大的优化余地。后续的技术发展也证明了这一点，我们上面也讲了在 JDK1.6 之后 JVM 团队对 synchronized 关键字做了很多优化。**JDK1.6 之后，synchronized 和 ReenTrantLock 的性能基本是持平了。所以网上那些说因为性能才选择 ReenTrantLock 的文章都是错的！JDK1.6之后，性能已经不是选择synchronized和ReenTrantLock的影响因素了！而且虚拟机在未来的性能改进中会更偏向于原生的synchronized，所以还是提倡在synchronized能满足你的需求的情况下，优先考虑使用synchronized关键字来进行同步！优化后的synchronized和ReenTrantLock一样，在很多地方都是用到了CAS操作**。
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user