架构师筑基包括哪些内容
我花了将近半个月时间将:深入 Java 泛型.、注解深入浅出、并发编程.、数据传输与序列化、Java 虚拟机原理、反射与类加载、高效 IO、Kotlin项目实战等等Android架构师筑基必备技能整合成了一套系统知识笔记PDF,相信看完这份文档,你将会对这些Android架构师筑基必备技能有着更深入、更系统的理解。
由于文档内容过多,为了避免影响到大家的阅读体验,在此只以截图展示部分内容
注:资料与上面思维导图一起看会更容易学习哦!每个点每个细节分支,都有对应的目录内容与知识点!
这份资料就包含了所有Android初级架构师所需的所有知识!
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
其实除了程序计数器,其他的部分都会发生OOM。
- 堆。通常发生的OOM都会发生在堆中,最常见的可能导致OOM的原因就是内存泄漏。
- JVM虚拟机栈和本地方法栈。当我们写一个递归方法,这个递归方法没有循环终止条件,最终会导致StackOverflow的错误。当然,如果栈空间扩展失败,也是会发生OOM的。
- 方法区。方法区现在基本上不太会发生OOM,但在早期内存中加载的类信息过多的情况下也是会发生OOM的。
3.类加载过程,双亲委派模型
Java中类加载分为3个步骤:加载、链接、初始化。
加载。加载是将字节码数据从不同的数据源读取到JVM内存,并映射为JVM认可的数据结构,也就是Class对象的过程。数据源可以是Jar文件、Class文件等等。如果数据的格式并不是ClassFile的结构,则会报ClassFormatError。
链接。链接是类加载的核心部分,这一步分为3个步骤:验证、准备、解析。
- 验证。验证是保证JVM安全的重要步骤。JVM需要校验字节信息是否符合规范,避免恶意信息和不规范数据危害JVM运行安全。如果验证出错,则会报VerifyError。
- 准备。这一步会创建静态变量,并为静态变量开辟内存空间。
- 解析。这一步会将符号引用替换为直接引用。
初始化。初始化会为静态变量赋值,并执行静态代码块中的逻辑。
双亲委派模型。
类加载器大致分为3类:启动类加载器、扩展类加载器、应用程序类加载器。
启动类加载器主要加载 jre/lib下的jar文件。
扩展类加载器主要加载 jre/lib/ext 下的jar文件。
应用程序类加载器主要加载 classpath下的文件。
所谓的双亲委派模型就是当加载一个类时,会优先使用父类加载器加载,当父类加载器无法加载时才会使用子类加载器去加载。这么做的目的是为了避免类的重复加载。
4.HashMap的原理
HashMap的内部可以看做数组+链表的复合结构。数组被分为一个个的桶(bucket)。哈希值决定了键值对在数组中的寻址。具有相同哈希值的键值对会组成链表。需要注意的是当链表长度超过阈值(默认是8)的时候会触发树化,链表会变成树形结构。
把握HashMap的原理需要关注4个方法:hash、put、get、resize。
hash方法。将key的hashCode值的高位数据移位到低位进行异或运算。这么做的原因是有些key的hashCode值的差异集中在高位,而哈希寻址是忽略容量以上高位的,这种做法可以有效避免哈希冲突。
put方法。put方法主要有以下几个步骤:
- 通过hash方法获取hash值,根据hash值寻址。
- 如果未发生碰撞,直接放到桶中。
- 如果发生碰撞,则以链表形式放在桶后。
- 当链表长度大于阈值后会触发树化,将链表转换为红黑树。
- 如果数组长度达到阈值,会调用resize方法扩展容量。
get方法。get方法主要有以下几个步骤:
- 通过hash方法获取hash值,根据hash值寻址。
- 如果与寻址到桶的key相等,直接返回对应的value。
- 如果发生冲突,分两种情况。如果是树,则调用getTreeNode获取value;如果是链表则通过循环遍历查找对应的value。
resize方法。resize做了两件事:
- 将原数组扩展为原来的2倍
- 重新计算index索引值,将原节点重新放到新的数组中。这一步可以将原先冲突的节点分散到新的桶中。
5.什么情况下Java会产生死锁,如何定位、修复,手写死锁
答案略
6.sleep和wait的区别
- sleep方法是Thread类中的静态方法,wait是Object类中的方法
- sleep并不会释放同步锁,而wait会释放同步锁
- sleep可以在任何地方使用,而wait只能在同步方法或者同步代码块中使用
- sleep中必须传入时间,而wait可以传,也可以不传,不传时间的话只有notify或者notifyAll才能唤醒,传时间的话在时间之后会自动唤醒
7.join的用法
join方法通常是保证线程间顺序调度的一个方法,它是Thread类中的方法。比方说在线程A中执行线程B.join(),这时线程A会进入等待状态,直到线程B执行完毕之后才会唤醒,继续执行A线程中的后续方法。
join方法可以传时间参数,也可以不传参数,不传参数实际上调用的是join(0)。它的原理其实是使用了wait方法,join的原理如下:
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException(“timeout value is negative”);
}
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
8.volatile和synchronize的区别
9.Java中的线程池
10.线程通信
11.Java中的并发集合****12.Java中生产者与消费者模式
生产者消费者模式要保证的是当缓冲区满的时候生产者不再生产对象,当缓冲区空时,消费者不再消费对象。实现机制就是当缓冲区满时让生产者处于等待状态,当缓冲区为空时让消费者处于等待状态。当生产者生产了一个对象后会唤醒消费者,当消费者消费一个对象后会唤醒生产者。
三种种实现方式:wait和notify、await和signal、BlockingQueue。
- wait和notify
//wait和notify
import java.util.LinkedList;
public class StorageWithWaitAndNotify {
private final int MAX_SIZE = 10;
private LinkedList list = new LinkedList();
public void produce() {
synchronized (list) {
while (list.size() == MAX_SIZE) {
System.out.println(“仓库已满:生产暂停”);
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
list.add(new Object());
System.out.println(“生产了一个新产品,现库存为:” + list.size());
list.notifyAll();
}
}
public void consume() {
synchronized (list) {
while (list.size() == 0) {
System.out.println(“库存为0:消费暂停”);
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
list.remove();
System.out.println(“消费了一个产品,现库存为:” + list.size());
list.notifyAll();
}
}
}
- await和signal
import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
class StorageWithAwaitAndSignal {
private final int MAX_SIZE = 10;
private ReentrantLock mLock = new ReentrantLock();
private Condition mEmpty = mLock.newCondition();
private Condition mFull = mLock.newCondition();
private LinkedList mList = new LinkedList();
public void produce() {
mLock.lock();
while (mList.size() == MAX_SIZE) {
System.out.println(“缓冲区满,暂停生产”);
try {
mFull.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
mList.add(new Object());
System.out.println(“生产了一个新产品,现容量为:” + mList.size());
mEmpty.signalAll();
mLock.unlock();
}
public void consume() {
mLock.lock();
while (mList.size() == 0) {
System.out.println(“缓冲区为空,暂停消费”);
try {
mEmpty.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
mList.remove();
System.out.println(“消费了一个产品,现容量为:” + mList.size());
mFull.signalAll();
mLock.unlock();
}
}
- BlockingQueue
import java.util.concurrent.LinkedBlockingQueue;
public class StorageWithBlockingQueue {
private final int MAX_SIZE = 10;
private LinkedBlockingQueue list = new LinkedBlockingQueue(MAX_SIZE);
public void produce() {
if (list.size() == MAX_SIZE) {
System.out.println(“缓冲区已满,暂停生产”);
}
try {
list.put(new Object());
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(“生产了一个产品,现容量为:” + list.size());
}
public void consume() {
if (list.size() == 0) {
System.out.println(“缓冲区为空,暂停消费”);
}
try {
list.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(“消费了一个产品,现容量为:” + list.size());
}
}
13.final、finally、finalize区别
final可以修饰类、变量和方法。修饰类代表这个类不可被继承。修饰变量代表此变量不可被改变。修饰方法表示此方法不可被重写(override)。
finally是保证重点代码一定会执行的一种机制。通常是使用try-finally或者try-catch-finally来进行文件流的关闭等操作。
finalize是Object类中的一个方法,它的设计目的是保证对象在垃圾收集前完成特定资源的回收。finalize机制现在已经不推荐使用,并且在JDK 9已经被标记为deprecated。
14.Java中单例模式
Java中常见的单例模式实现有这么几种:饿汉式、双重判断的懒汉式、静态内部类实现的单例、枚举实现的单例。
这里着重讲一下双重判断的懒汉式和静态内部类实现的单例。
双重判断的懒汉式:
public class SingleTon {
//需要注意的是volatile
private static volatile SingleTon mInstance;
private SingleTon() {
}
public static SingleTon getInstance() {
if (mInstance == null) {
synchronized (SingleTon.class) {
if (mInstance == null) {
mInstance=new SingleTon();
}
}
}
return mInstance;
}
}
双重判断的懒汉式单例既满足了延迟初始化,又满足了线程安全。通过synchronized包裹代码来实现线程安全,通过双重判断来提高程序执行的效率。这里需要注意的是单例对象实例需要有volatile修饰,如果没有volatile修饰,在多线程情况下可能会出现问题。原因是这样的,mInstance=new SingleTon() 这一句代码并不是一个原子操作,它包含三个操作:
- 给mInstance分配内存
- 调用SingleTon的构造方法初始化成员变量
- 将mInstance指向分配的内存空间(在这一步mInstance已经不为null了)
我们知道JVM会发生指令重排,正常的执行顺序是1-2-3,但发生指令重排后可能会导致1-3-2。我们考虑这样一种情况,当线程A执行到1-3-2的3步骤暂停了,这时候线程B调用了getInstance,走到了最外层的if判断上,由于最外层的if判断并没有synchronized包裹,所以可以执行到这一句,这时候由于线程A已经执行了步骤3,此时mInstance已经不为null了,所以线程B直接返回了mInstance。但其实我们知道,完整的初始化必须走完这三个步骤,由于线程A只走了两个步骤,所以一定会报错的。
解决的办法就是使用volatile修饰mInstance,我们知道volatile有两个作用:保证可见性和禁止指令重排,在这里关键在于禁止指令重排,禁止指令重排后保证了不会发生上述问题。
静态内部类实现的单例:
class SingletonWithInnerClass {
private SingletonWithInnerClass() {
}
private static class SingletonHolder{
private static SingletonWithInnerClass INSTANCE=new SingletonWithInnerClass();
}
public SingletonWithInnerClass getInstance() {
return SingletonHolder.INSTANCE;
}
}
由于外部类的加载并不会导致内部类立即加载,只有当调用getInstance的时候才会加载内部类,所以实现了延迟初始化。由于类只会被加载一次,并且类加载也是线程安全的,所以满足我们所有的需求。静态内部类实现的单例也是最为推荐的一种方式。
15.Java中引用类型的区别,具体的使用场景
Java中引用类型分为四类:强引用、软引用、弱引用、虚引用。
强引用:强引用指的是通过new对象创建的引用,垃圾回收器即使是内存不足也不会回收强引用指向的对象。
软引用:软引用是通过SoftRefrence实现的,它的生命周期比强引用短,在内存不足,抛出OOM之前,垃圾回收器会回收软引用引用的对象。软引用常见的使用场景是存储一些内存敏感的缓存,当内存不足时会被回收。
弱引用:弱引用是通过WeakRefrence实现的,它的生命周期比软引用还短,GC只要扫描到弱引用的对象就会回收。弱引用常见的使用场景也是存储一些内存敏感的缓存。
虚引用:虚引用是通过FanttomRefrence实现的,它的生命周期最短,随时可能被回收。如果一个对象只被虚引用引用,我们无法通过虚引用来访问这个对象的任何属性和方法。它的作用仅仅是保证对象在finalize后,做某些事情。虚引用常见的使用场景是跟踪对象被垃圾回收的活动,当一个虚引用关联的对象被垃圾回收器回收之前会收到一条系统通知。
16.Exception和Error的区别
Exception和Error都继承于Throwable,在Java中,只有Throwable类型的对象才能被throw或者catch,它是异常处理机制的基本组成类型。
Exception和Error体现了Java对不同异常情况的分类。Exception是程序正常运行中,可以预料的意外情况,可能并且应该被捕获,进行相应的处理。
Error是指在正常情况下,不大可能出现的情况,绝大部分Error都会使程序处于非正常、不可恢复的状态。既然是非正常,所以不便于也不需要捕获,常见的OutOfMemoryError就是Error的子类。
Exception又分为checked Exception和unchecked Exception。checked Exception在代码里必须显式的进行捕获,这是编译器检查的一部分。unchecked Exception也就是运行时异常,类似空指针异常、数组越界等,通常是可以避免的逻辑错误,具体根据需求来判断是否需要捕获,并不会在编译器强制要求。
17.volatile
一般提到volatile,就不得不提到内存模型相关的概念。我们都知道,在程序运行中,每条指令都是由CPU执行的,而指令的执行过程中,势必涉及到数据的读取和写入。程序运行中的数据都存放在主存中,这样会有一个问题,由于CPU的执行速度是要远高于主存的读写速度,所以直接从主存中读写数据会降低CPU的效率。为了解决这个问题,就有了高速缓存的概念,在每个CPU中都有高速缓存,它会事先从主存中读取数据,在CPU运算之后在合适的时候刷新到主存中。
最后
分享一份工作1到5年以上的Android程序员架构进阶学习路线体系,希望能对那些还在从事Android开发却还不知道如何去提升自己的,还处于迷茫的朋友!
-
阿里P7级Android架构师技术脑图;查漏补缺,体系化深入学习提升
-
**全套体系化高级架构视频;**七大主流技术模块,视频+源码+笔记
有任何问题,欢迎广大网友一起来交流
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
术脑图;查漏补缺,体系化深入学习提升
[外链图片转存中…(img-O4WIaBeO-1715001008223)]
- **全套体系化高级架构视频;**七大主流技术模块,视频+源码+笔记
[外链图片转存中…(img-kThH9oVY-1715001008223)]
有任何问题,欢迎广大网友一起来交流
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!