文章目录
1 方法的参数传递
实例:
class Test {
public static void main(String[] args) {
String str = "hello";
Integer num = 100;
int[] array = {1,2,3,4};
MyData myData = new MyData();
change(str, num, array, myData);
System.out.println(str);
System.out.println(num);
System.out.println(Arrays.toString(array));
System.out.println(myData.a);
}
public static void change(String str2, Integer num2, int[] array2, MyData myData2) {
str2 += " world";
num2 = 200;
array2[0] = 9;
myData2.a = 20;
}
}
class MyData {
int a = 10;
}
运行结果为:
分析:
- 形参是基本数据类型,则传递一个值的拷贝。本例未涉及
- 型参是引用数据类型:
传递地址值
String类、包装类等对象具有不可变性,一变化就会产生新的对象。
例如str
存放的是指向常量池中hello
字符串的地址0x1234
,
此时形参str2
中存放的也是0x1234
(传递了地址值)
在执行str2 += " world";
时,新建了一个hello world
字符串,并修改str2
的值,使之存放了这个新生成的字符串的地址0x1235
但是原来的hello
字符串依然存在并且没有变化,str
依然指向0x1234
。
2 抽象类和接口
接口和抽象类都不能被实例化。
4 集合类相关
Java集合源码分析详解系列
注意Map不属于Collection!
4.1 ArrayList
参考:
先看这个:Java集合源码分析(一)ArrayList
size是数组中数据的实际个数。
手写简易ArrayList
public class MyArrayList {
// 整个集合中最关键的部分,用来保存数据
private Object[] elementData;
// 数组已经存放的元素的个数
private int size;
// 构造方法
public MyArrayList() {
elementData = new Object[10];
}
public void add(Object obj) {
// 要注意扩容的问题
if (size >= elementData.length) {
Object[] temp = new Object[(int) (elementData.length * 1.5)];
// 不能丢掉原先的数据
System.arraycopy(elementData, 0, temp, 0, size);
elementData = temp;
}
// 先把元素添加进去再给size增值
elementData[size++] = obj;
}
}
4.2 LinkedList
基于双向链表。双向链表是包含两个指针的,pre指向前一个节点,next指向后一个节点,但是第一个节点head的pre指向null,最后一个节点的tail指向null。
非线程安全的(异步)。
能够当作队列来使用,LinkedList是双端队列的一种实现,所以,基于双端队列的操作在LinkedList中全部有效。
手写简易ArrayList
class MyLinkedList {
private Node first; // 链表的头结点
private Node last; //链表的尾节点
private int size; // 链表已经存放的元素的个数
public void add(Object obj) {
Node node = new Node();
if (first == null) { // 节点为空的情况
node.prev = null;
node.next = null;
node.obj = obj;
first = node;
last = node;
} else { // 节点不为空的情况
node.obj = obj;
node.prev = last;
last.next = node;
node.next =null;
last = node;
}
}
// 内部类
class Node {
Object obj;// 核心变量,保存当前节点的数据
Node prev;
Node next;
// 构造方法
public Node(Object obj, Node prev, Node next) {
this.obj = obj;
this.prev = prev;
this.next = next;
}
public Node() {
}
}
}
4.3 HashSet
可以添加一个null。不允许重复。
底层结构维护了一个HashMap对象,也就是和HashMap的底层一样,基于哈希表。
添加元素obj的去重原理
- 一个数组加链表存放数据(类似散列表中的拉链法)。
- 首先获取obj的哈希值,之后通过运算获取一个整数索引,代表数组下标。
如果该索引处没有元素,则直接添加。
如果有其他元素,则需要进行equals判断。不相等则以链表的形式追加到已有元素的后面;相等则直接覆盖,返回false。
4.4 TreeSet
不可以添加null。不允许重复。
底层结构维护了一个TreeMap对象,而TreeMap底层是红黑树结构。
可以实现两种排序:
- 自然排序:必须让添加元素的类型实现Comparable接口,实现里面的compareTo方法。
- 指定Comparator的定制排序:创建TreeSet对象时传入一个Comparator接口的对象,实现里面的compare方法。
去重原理:通过比较方法的返回值是否为0.
4.5 HashMap
允许null作为键值。
capacity
是HashMap的桶的个数。
load factor
是HashTable在增长(内部数据结构重构)之前,允许有多满。
底层结构是哈希表:jdk7是数组+链表,jdk8是数组+链表+红黑树。接下来的思路都属于jdk8
HashMap种维护了一个Node类型的数组table
,当创建HashMap对象时,只是将loadFactor初始化为0.75,table保持为null。
第一次添加时,将初始table容量设为16,临界值`threshold`为12。
每次添加调用putVal方法:
1. 先获取key的二次哈希值并进行求与运算,得到了table的存放位置。
2. 判断该位置上是否有元素,如果没有则直接存放。如果有则继续判断:
2.1 如果和当前元素相等则直接覆盖
2.2 不相等则继续判断是链表结构还是树状结构,按照对应结构的判断方式来判断先等。
3. 将size++,如果超过threshold则需要resize()进行2倍扩容,并且打乱原来的顺序重新排列。
4. 当一个桶中节点数>=8 && 桶的总数>=64时,会将链表转为红黑树。
5 Java多线程
参考:Java 视频教程全集(376P) | 80 小时从入门到精通
线程是进程的内部的部分。进程看作一个容器
内存是逻辑内存。
TLS是thread local storage,存放线程的独有数据。
5.1 同步和互斥
相交进程的关系主要有两种:同步和互斥。
同步: 散布在不同进程之间的若干程序片断,它们的运行必须严格按照规定的某种先后次序来运行,这种先后次序依赖于要完成的特定的任务。
互斥: 散布在不同进程之间的若干程序片断,当某个进程运行其中一个程序片段时,其它进程就不能运行它们之中的任一程序片段,只能等到该进程运行完这个程序片段后才可以运行。
同步是一种更为复杂的互斥,而互斥是一种特殊的同步。
5.2 线程状态
-
新建(New)
创建后尚未启动。
Thread t = new Thread();
-
可运行(Runnable)
可能正在运行,也可能正在等待 CPU 时间片。
包含了操作系统线程状态中的Running 和 Ready
。
就绪状态:调用start()方法就进入就绪状态,但不是立即执行。
运行状态:由CPU调度进入运行态。 -
阻塞(Blocked)
当调用sleep() wait() 或者同步锁定时。线程进入阻塞状态。阻塞事件结束后,重新进入就绪状态。 -
死亡(Terminated)
可以是线程结束任务之后自己结束,或者产生了异常而结束。
进入就绪态的四种方式
- start方法
- 解除阻塞
- yield方法(注意sleep是进入了阻塞状态)
- jvm调度
进入阻塞态的四种方式
- sleep方法(注意yield是进入了就绪状态)
- wait
- join:在线程中调用另一个线程的 join() 方法,会将当前线程挂起,而不是忙等待,直到目标线程结束。让目标线程来“插自己的队”。
- 一些操作。例如IO read write
5.3 Runnable和Thread
实现接口 VS 继承 Thread
实现接口会更好一些,因为:
- Java 不支持多重继承,因此继承了 Thread 类就无法继承其它类,但是可以实现多个接口;
- 类可能只要求可执行就行,继承整个 Thread 类开销过大。
5.4 synchronized
并发:同一个对象
被多个线程
同时操作
。
当一个线程获得对象的排他锁,独占资源,其他线程必须等待。
synchronized方法(同步方法)
synchronized块(同步块)
synchronized (obj){}
obj
称为同步监视器。- obj可以是任何对象,但是推荐使用共享资源作为同步监视器。
- 同步方法中无需指定同步监视器,因为同步方法的同步监视器是this即该对象本身,或者Class对象。
使用synchronized不当容易引起死锁。
5.5 wait() notify()
调用 wait()
使得线程等待某个条件满足,线程在等待时会被挂起,当其他线程的运行使得这个条件满足时,其它线程会调用 notify()
或者 notifyAll()
来唤醒挂起的线程。
- 它们都属于 Object 的一部分,而不属于 Thread。
- 只能用在同步方法或者同步控制块中使用,否则会在运行时抛出 IllegalMonitorStateException。
- 使用
wait()
挂起期间,线程会释放锁(sleep()
不会释放锁)。这是因为如果没有释放锁,那么其它线程就无法进入对象的同步方法或者同步控制块中,那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程,造成死锁。
生产者消费者示例(管程法,借助缓冲区)
class TestConsumerProductor {
public static void main(String[] args) {
SynContainer synContainer = new SynContainer();
new Productor(synContainer).start();
new Consumer(synContainer).start();
}
}
// 生产者
class Productor extends Thread {
SynContainer container;
public Productor(SynContainer synContainer) {
this.container = synContainer;
}
public void run() {
// 假设生产10个
for (int i = 0; i < 10; i++) {
System.out.println("produce No." + i + "production");
container.push(new Production(i));
}
}
}
// 消费者
class Consumer extends Thread {
SynContainer container;
public Consumer(SynContainer synContainer) {
this.container = synContainer;
}
public void run() {
// 假设消费20个
for (int i = 0; i < 20; i++) {
// 注意此时程序不能自己停止。因为生产者生产完10个以后已经停止了,消费者还在阻塞等待
System.out.println("consume No." + container.pop().id + "production");
}
}
}
// 缓冲区
class SynContainer extends Thread {
// 只能存放5个产品
Production[] productions = new Production[5];
int count = 0; // 指向最后一个产品的下一个位置
// 存 操作
public synchronized void push(Production p) {
if (count == productions.length) {
try {
this.wait();// 线程阻塞,消费者通知则解除阻塞
} catch (InterruptedException e) {
e.printStackTrace();
}
}
productions[count] = p;
count++;
this.notifyAll();
}
// 取 操作
public synchronized Production pop() {
if (count == 0) {
try {
this.wait();// 线程阻塞,生产者通知则解除阻塞
} catch (InterruptedException e) {
e.printStackTrace();
}
}
count--;
this.notifyAll();
return productions[count];
}
}
// 产品
class Production {
int id;
public Production(int id) {
this.id = id;
}
}
5.6 volatile
1分钟读懂java中的volatile关键字
volatile
修饰的变量就是通知系统这个变量不稳定,随时会被其他线程所修改。
使用volatile
修饰的变量会强制将修改的值立即写入主存,主存中值的更新会使缓存(每个线程的工作空间)中的值失效(非volatile变量不具备这样的特性,非volatile变量的值会被缓存,线程A更新了这个值,线程B读取这个变量的值时可能读到的并不是是线程A更新后的值)。
volatile会禁止指令重排。
volatile具有可见性、有序性,不具备原子性。
5.7 单例模式
双重检验锁(DCL double checked locking)
class Singleton {
// 懒汉式,此时的 volatile是为了禁止指令重拍
private static volatile Singleton instance;
private Singleton() {
}
public Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
5.8 可重入锁
当线程请求一个由其它线程持有的对象锁时,该线程会阻塞,而当线程请求由自己持有的对象锁时,如果该锁是重入锁,请求就会成功,否则阻塞。
synchronized就是一种可重用锁。
测试是不是可重入锁:
class TestReentrantLock {
public void test() {
// 第一次获取锁
synchronized (this) {
System.out.println("第一次取得了锁!");
synchronized (this) {
System.out.println("第二次取得锁,这是ReentrantLock!");
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
new TestReentrantLock().test();
}
}
可重入锁的实现原理:
每一个锁关联一个线程持有者和计数器,当计数器为 0 时表示该锁没有被任何线程持有,那么任何线程都可能获得该锁而调用相应的方法;当某一线程请求成功后,JVM会记下锁的持有线程,并且将计数器置为 1;此时其它线程请求该锁,则必须等待;而该持有锁的线程如果再次请求这个锁,就可以再次拿到这个锁,同时计数器会递增;当线程退出同步代码块时,计数器会递减,如果计数器为 0,则释放该锁。
5.9 悲观锁 乐观锁
- 悲观锁:每次获取数据的时候,都会担心数据被修改,所以每次获取数据的时候都会进行加锁。synchronized是独占锁即悲观锁,会导致其他所有需要锁的线程挂起,等待持有锁的线程释放锁。
- 乐观锁:每次获取数据时,并不会加锁。只在更新数据的时候判断该数据是不是被其他人修改过。如果被其他线程修改则不进行数据的更新。由于不及所,所以其他线程也可以进行读写操作。这种乐观的并发策略的许多实现都不需要将线程阻塞,因此这种同步操作称为非阻塞同步。一般使用version方式和CAS方式。
乐观锁的实现 CAS比较并交换
- 有三个值:当前的内存值
V
,原来的值A
,将要更新的值B
。 - 首先线程从内存V中读取值A,当且仅当预期值A和内存值V相同时,将内存值V修改为B,否则返回V。这是一种乐观锁的思路,它相信在它修改V之前,没有其他线程会去修改V值;而Synchronized是一种悲观锁,它认为在它修改V之前,一定会有其它线程去修改V,悲观锁效率很低。
- CAS是一组原子操作,不会被外界打断,属于硬件级别的操作。
使用场景
- 乐观锁的使用场景:适合大量读取。如果大量写入的话,冲突的可能性大。为了数据一致,需要不断查询新的数据,占用了吞吐量。
- 悲观锁的使用场景:写入频繁。如果读取频繁会造成浪费。
6 ISO/OSI参考模型
- 物理层:传输单位是比特,任务是透明的传输数据。
- 数据链路层:传输单位是帧,任务是将网络层传下来的IP数据报封装成帧。功能概括为成帧、差错控制、流量控制等。(注意没有拥塞控制)。
- 网络层:传输单位是数据报,关心的是通信子网的运行控制。功能概括为差错控制、流量控制、拥塞控制等。
- 运输层:传输单位是TCP报文段或者用户数据报(UDP)。负责主机中两个进程的通信。
- 会话层:向表示层实体提供建立连接并在连接上有序地传输数据。负责管理主机间的会话进程,包括建立、管理以及终止会话。
- 表示层:处理两个通信系统中交换数据的表示方式。
- 应用层:用户和网络的界面,最为复杂。
物理层、数据链路层和网络层统称为通信子网,它是为了联网而加上去的通信设备。
运输层承上启下。
会话层、表示层和应用层统称为资源子网,相当于计算机系统,完成数据的处理。
7 三范式
- 第一范式:属性值不可再分。例如电话应该被分为手机和座机。
- 第二范式:每个非主属性 应该完全依赖于R的每一个候选关键属性,而不是部份依赖。例如选课成绩表(学号,课程号,成绩,姓名)中,关键字为组合关键字(学号,课程号),但是姓名仅仅依赖于学号,所以冗余,需要拆解。
- 第三范式:非主属性 不传递依赖于R的每一个候选关键属性。例如选课成绩表(学号,课程号,成绩,姓名)中,此时假设姓名不会重复。该表有两个候选码:(学号,课程号)和(姓名,课程号)。存在依赖:
学号->姓名,(学号,课程号)->成绩,(姓名,课程号)->成绩
,唯一的非主属性成绩不存在部份依赖,也不存在传递依赖,所以属于第三范式。
8 系统变慢的可能原因
- 数据库原因
数据库的表设计复杂,需要的关联查询较多。随着数据量的增大这个问题越来越凸显。
数据库有的表被死锁。
索引不够全,可能有很多查询的条件为不存在索引的属性。 - 服务器
配置低。
受到攻击,比如DDos - 其他
许多资源没有及时的释放,重启服务器。没有及时关闭已打开并提交过的记录集对象和连接对象
垃圾文件太多。
9 内连接和外连接
- 内链接也被称为自然连接,两个表中只有符合条件的行才能放入结果集。
- 左外连接是在自然连接的基础上,再检查左表的值是不是都出现在结果集之中了,如果没有,则将未出现的该行放入结果集,再将对应右表对应的部分设置为null。
10 聚集索引,非聚集索引,创建索引考虑的因素
10.1 聚集索引
数据行的物理顺序与列值(一般是主键的那一列)的逻辑顺序相同,一个表中只能拥有一个聚集索引。即:只要索引是相邻的,那么对应的数据一定也是相邻地存放在磁盘上的。
叶子节点存的是整行数据,直接通过这个聚集索引的键值找到某行
10.2 非聚集索引
数据行的物理顺序与索引的逻辑顺序不同的逻辑顺序不同,一个表中可以拥有多个非聚集索引。
叶子节点存的是字段的值,通过这个非聚集索引的键值找到对应的聚集索引字段的值,再通过聚集索引键值找到表的某行,类似oracle通过键值找到rowid,再通过rowid找到行。
10.3 创建索引考虑的因素
- 考虑在WHERE和ORDER BY命令上涉及的列建立索引
- 值分布很稀少的字段不适合建索引,例如“性别”这种只有两三个值的字段;
- 不要建立太多索引
- 频繁进行数据操作的表,不要建立太多的索引;
- 经常与其他表进行连接的表,在连接字段上应该建立索引
11 TCP连接管理
11.1 三次握手建立连接
- 客户机的TCP向服务器的TCP发送一个连接请求报文,不含应用层数据。SYN=1,seq=x。
- 服务器的TCP收到连接请求报文段后,发回确认,并为该连接设置TCP缓存和变量。不含应用层数据。SYN=1,ACK=1,seq=y,ack=x+1。
- 客户机向服务器发出确认,同时为连接分配缓存和变量。SYN=0,ACK=1,seq=x+1,ack=y+1。可以携带数据。
- 由于服务器的资源是在第二次握手时分配的,而客户端的资源是在第三次握手时分配,使得服务器容易受到SYN洪泛攻击。
- 为什么三次?
防止已经失效的连接请求报文段到达服务器。例如此时采取二次握手,客户端A向服务器B发送了第一次请求报文,但是在某个中间节点长时间滞留。A超时后重发第二次请求报文,B收到后发送给A确认,此时连接就建立了。等数据传输完之后,连接断开。此时失效的第一次请求报文到达B,B就会直接建立连接,浪费资源。
11.1 四次握手释放连接
- 客户机的TCP向服务器的TCP发送一个连接释放报文,并停止发送数据,主动关闭TCP连接。FIN=1,seq=u。(TCP是全双工的)
- 服务器的TCP收到连接释放报文段后,发回确认,此时TCP处于半关闭,如果服务器还需要发送数据,那么客户端还是得接收。ACK=1,seq=v,ack=u+1。
- 如果服务器没有可发送的数据了,就向客户端发出连接释放报文段。FIN=1。
- 客户机向服务器发出确认,且等待
2MSL
(最长报文段寿命)后,A才进入连接关闭状态。
- 为什么四次,且等待2MSL?
- 两个原因
- 保证A的最后确认报文段可以到达B,如果最后的确认报文段丢失了,那么B无法正常关闭连接,就要向A重发释放连接报文段。
- 防止出现已经失效的连接请求报文。情形同“三次握手建立连接“一样。
12 数据库 分表
当一个表的数据不断增多时,切分是必然选择,因为数据量太大查询效果会很差,维护索引也会变得困难。将数据分散到集群中的不同节点上,从而缓存单个数据库的压力。
- 垂直拆分:将有很多字段的表拆分为多个表,每个表的结构不一样且包含原表的部分字段。将访问频率搞得放到一个表中,低的放到另外一个表里去。
- 水平拆分:把一个表的数据拆分到多个库的多个表里去,但是每个新表的结构都是一样的。每个新表的数据量加起来就是原表的数据量。
13 数据库优化
13.1 创建并使用正确的索引
见10.3 创建索引考虑的因素
- 考虑在WHERE和ORDER BY命令上涉及的列建立索引
- 值分布很稀少的字段不适合建索引,例如“性别”这种只有两三个值的字段;
- 不要建立太多索引
- 频繁进行数据操作的表,不要建立太多的索引;
- 经常与其他表进行连接的表,在连接字段上应该建立索引
13.2 只返回需要的字段
- 减少数据在网络上的传输开销
- 减少服务器处理数据开销
- 减少内存占用
13.3 减少交互次数
采用批处理,比如每一千条数据提交一次。
14 常见的三种缓存策略,缓存可能产生的错误
- FIFO First In First out 先进先出
- 新访问的数据插入FIFO队列尾部,数据在FIFO队列中顺序移动;
- 淘汰FIFO队列头部的数据;
- LRU Least recently used 最近最少使用
核心思想“如果数据最近被访问过,那么将来被访问的几率也更高”。
- 新数据插入到链表头部;
- 每当缓存命中(即缓存数据被访问),则将数据移到链表头部;
- 当链表满的时候,将链表尾部的数据丢弃。
- LFU Least frequently used 最近使用次数最少
核心思想“如果数据过去被访问多次,那么将来被访问的频率也更高”。
- 新加入数据插入到队列尾部(因为引用计数为1);
- 队列中的数据被访问后,引用计数增加,队列重新排序;
- 当需要淘汰数据时,将已经排序的列表最后的数据块删除。
可能的错误:
缓存与数据库双存储双写导致的数据一致性。
Cache Aside Pattern:
最经典的缓存+数据库读写的模式,就是 Cache Aside Pattern。
- 读的时候,先读缓存,缓存没有的话,就读数据库,然后取出数据后放入缓存,同时返回响应。
- 更新的时候,先更新数据库,然后再删除缓存。
15 如何设计一个高并发系统?
参考:如何设计一个高并发系统?
15.1 系统拆分
将一个系统拆分为多个子系统,之后每个系统连接一个数据库。
之所以拆分系统,是为了降低耦合性,将具有不同功能的服务分别部署到不同的服务器上。
15.2 缓存
大多数的高并发场景都是读多写少,在数据库和缓存里都写一份,高并发读的时候去读取缓存。
15.3 消息队列MQ
应对高并发写的情况,大量的写请求灌入 MQ ,后边系统消费后慢慢写。
存放消息的容器,需要使用消息的时候就取出消息,是分布式系统中的重要的组件。通过异步处理提高下性能,降低耦合性。
15.4 分库分表
可能到了最后数据库层面还是免不了抗高并发的要求,那么就将一个数据库拆分为多个库,多个库来扛更高的并发;然后将一个表拆分为多个表,每个表的数据量保持少一点,提高 sql 跑的性能。
15.5 读写分离
主从架构,主库写入,从库读取,搞一个读写分离。读流量太多的时候,还可以加更多的从库。
15.6 ElasticSearch
16 在浏览器地址栏输入URL
参考: 在浏览器地址栏输入URL,按下回车后究竟发生了什么?
16.1 域名到IP的转换
- 首先查找浏览器的缓存
- 查找系统的缓存,host文件
- 如果还没有找到,那么使用域名解析协议。网络服务提供商的DNS服务器会进行递归查询或者迭代查询来查找IP。
16.2 利用IP地址建立浏览器和服务器之间的TCP链接
三次握手。见第11节
。
16.3 浏览器通过HTTP协议发送请求
浏览器向主机发起一个HTTP-GET方法报文请求。请求中包含访问的URL,KeepAlive,长连接,还有User-Agent等。
16.4 某些服务器会做永久重定向响应
对于大型网站存在多个主机站点,为了了负载均衡或者导入流量,提高SEO排名,往往不会直接返回请求页面,而是重定向。返回的状态码就不是200OK,而是301,302以3开头的重定向码,浏览器在获取了重定向响应后,在响应报文中Location项找到重定向地址,浏览器重新第一步域名解析或者建立TCP链接,再访问即可。
16.5 浏览器跟踪重定向地址
当浏览器知道了重定向后最终的访问地址之后,重新发送一个http请求,发送内容同上。
16.6 服务器处理请求
服务器接收到获取请求,然后处理并返回一个响应。返回状态码200 OK,表示服务器可以响应请求。
16.7 释放TCP链接
四次握手。见第11节
。
16.8 浏览器显示页面
尚没有完整接受完全部文件内容时便开始渲染。但有一些图片、js文件等的url,还可能需要利用这些url重新发送请求,走一个完整的流程。
16 部分设计模式
16.1 观察者模式
定义对象之间的一对多的依赖关系,使得每当一个对象改变状态,则所有依赖于该对象的对象都会得到通知并且自动更新。
- Subject:被观察的角色。将所有的观察者的引用保存到一个集合之中。
- Observer:抽象的“观察者”,定义了一个更新接口,使用被观察者的状态改变时通知自己。
- ConcreteObserver:具体的观察者。