最后
文章不易，如果大家喜欢这篇文章，或者对你有帮助希望大家多多点赞转发关注哦。文章会持续更新的。绝对干货！！！
- Android进阶学习全套手册
关于实战，我想每一个做开发的都有话要说，对于小白而言，缺乏实战经验是通病，那么除了在实际工作过程当中，我们如何去更了解实战方面的内容呢？实际上，我们很有必要去看一些实战相关的电子书。目前，我手头上整理到的电子书还算比较全面，HTTP、自定义view、c++、MVP、Android源码设计模式、Android开发艺术探索、Java并发编程的艺术、Android基于Glide的二次封装、Android内存优化——常见内存泄露及优化方案、.Java编程思想 （第4版）等高级技术都囊括其中。
-
Android高级架构师进阶知识体系图
关于视频这块，我也是自己搜集了一些，都按照Android学习路线做了一个分类。按照Android学习路线一共有八个模块，其中视频都有对应，就是为了帮助大家系统的学习。接下来看一下导图和对应系统视频吧！！！
-
Android对标阿里P7学习视频
- BATJ大厂Android高频面试题
这个题库内容是比较多的，除了一些流行的热门技术面试题，如Kotlin，数据库，Java虚拟机面试题，数组，Framework ，混合跨平台开发，等
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
final class SegmentPool {
static final long MAX_SIZE = 64 * 1024; // 64 KiB.最大容量64K
static @Nullable Segment next;//通过一个单链表存储回收的Segment
static long byteCount;//当前SegmentPool容量
private SegmentPool() {
}
static Segment take() {
synchronized (SegmentPool.class) {
if (next != null) {//如果当前有回收的Segment
Segment result = next;
next = result.next;
result.next = null;
byteCount -= Segment.SIZE;
return result;
}
}
return new Segment(); //否则直接创建
}
static void recycle(Segment segment) {
if (segment.next != null || segment.prev != null) throw new IllegalArgumentException();
if (segment.shared) return; //当前Segment如果有共享数据不能回收（这个后面说）
synchronized (SegmentPool.class) {
if (byteCount + Segment.SIZE > MAX_SIZE) return; //当前SegmentPool满了的话则不能回收
byteCount += Segment.SIZE;//容量增加
segment.next = next;//加到链表中
segment.pos = segment.limit = 0;//可写和可读位置都清零
next = segment;
}
}
SegmentPool#take就是看当前的池子中有缓存的Segment的么，有直接使用，没有则创建一个。ok在回到最前面RealBufferedSource#read。
@Override
public int read(byte[] sink, int offset, int byteCount) throws IOException {
checkOffsetAndCount(sink.length, offset, byteCount);
if (buffer.size == 0) {
long read = source.read(buffer, Segment.SIZE);//先将数据读到Buffer
if (read == -1) return -1;
}
int toRead = (int) Math.min(byteCount, buffer.size);
return buffer.read(sink, offset, toRead);//再从Buffer读取数据
}
第一块source#read(buffer, Segment.SIZE)已经梳理了一遍就是通过FileInputStream将数据读到Buffer的Segment中，然后再来buffer#read将数据读到byte数组中。
@Override
public int read(byte[] sink, int offset, int byteCount) {
checkOffsetAndCount(sink.length, offset, byteCount);
Segment s = head;//拿到第一个Segment
if (s == null) return -1;
int toCopy = Math.min(byteCount, s.limit - s.pos);//判断要读取的数据量，取byteCount和当前segment可读的数据量s.limit - s.pos
System.arraycopy(s.data, s.pos, sink, offset, toCopy);//将数据拷贝到数组中
s.pos += toCopy;//移动Segment已经读过的数据指针pos
size -= toCopy;//当前Buffer容量减去读过数据量
if (s.pos == s.limit) {//如果当前Segment已经读完
head = s.pop();//从链表中脱离
SegmentPool.recycle(s);//SegmentPool尝试回收
}
return toCopy;
}
将Buffer中Segment数据拷贝到数组中，如果Segment数据已经读完则从Buffer链表中脱离，SegmentPool尝试回收。ok，那读流程就讲完了，我们回顾下大体流程：
BufferedSource source = Okio.buffer(Okio.source(file));
byte[] array = new byte[1024];
source.read(array);
source.close();
Okio.Source()：是创建了一个Source实现类，提供read的能力，需要传入一个Buffer来获取数据，数据读取是通过FileInputStream来读取的，写入到Buffer的Segment中。
Okio.buffer()：则创建了一个Buffer实现类RealBufferedSource，内部维护了一个环形双向链表Segment，是我们真正用来读取数据的对象。
BufferedSource.read()：读取数据操作，流程是先将数据读到buffer中，然后再从buffer中读取数据。
写流程
写流程是读流程反过来，先将数据写到buffer，然后在从buffer写到文件中，大体跟前面差不多我们快速说一下。
byte[] array = new byte[1024];
BufferedSink sink = Okio.buffer(Okio.sink(file));
sink.write(array);
sink.close();
Okio.sink()
先看Okio#sink(file)。
public static Sink sink(File file) throws FileNotFoundException {
if (file == null) throw new IllegalArgumentException(“file == null”);
return sink(new FileOutputStream(file));//创建FileOutputStream
}
public static Sink sink(OutputStream out) {
return sink(out, new Timeout());
}
private static Sink sink(final OutputStream out, final Timeout timeout) {
if (out == null) throw new IllegalArgumentException(“out == null”);
if (timeout == null) throw new IllegalArgumentException(“timeout == null”);
return new Sink() {
@Override
public void write(Buffer source, long byteCount) throws IOException {
checkOffsetAndCount(source.size, 0, byteCount);
while (byteCount > 0) {//遍历将Buffer中数据都写入到文件中
timeout.throwIfReached();
Segment head = source.head;//获取buffer中的segment
int toCopy = (int) Math.min(byteCount, head.limit - head.pos);
out.write(head.data, head.pos, toCopy);//写入到文件
head.pos += toCopy;
byteCount -= toCopy;
source.size -= toCopy;
if (head.pos == head.limit) {
source.head = head.pop();//segment脱链
SegmentPool.recycle(head);//回收
}
}
}
@Override
public void flush() throws IOException {
out.flush();
}
@Override
public void close() throws IOException {
out.close();
}
@Override
public Timeout timeout() {
return timeout;
}
@Override
public String toString() {
return “sink(” + out + “)”;
}
};
内部通过FileOutputStream进行io操作，通过一个while循环将Buffer中Segment数据统统写入到文件中。
Okio.buffer()
public static BufferedSink buffer(Sink sink) {
return new RealBufferedSink(sink);
}
创建一个RealBufferedSink。
final class RealBufferedSink implements BufferedSink {
public final Buffer buffer = new Buffer();//创建缓冲区
public final Sink sink;//真正的io操作对象
boolean closed;
RealBufferedSink(Sink sink) {
if (sink == null) throw new NullPointerException(“sink == null”);
this.sink = sink;
}
@Override
public BufferedSink write(byte[] source) throws IOException {
if (closed) throw new IllegalStateException(“closed”);
buffer.write(source);//写流程第一步是将数据写到buffer
return emitCompleteSegments();//然后将Buffer数据写到文件中
}
@Override
public BufferedSink emitCompleteSegments() throws IOException {
if (closed) throw new IllegalStateException(“closed”);
long byteCount = buffer.completeSegmentByteCount();
if (byteCount > 0) sink.write(buffer, byteCount);//然后将Buffer数据写到文件中
return this;
}
}
内部创建了一个Buffer作为缓存区，并将Sink通过成员变量存储起来，写数据则是先将数据写到buffer中，在由Buffer通过FileOutputStream写到文件中。
接下来看看 buffer#write(source)是如何将数据写入Buffer的。
@Override
public Buffer write(byte[] source) {
if (source == null) throw new IllegalArgumentException(“source == null”);
return write(source, 0, source.length);
}
@Override
public Buffer write(byte[] source, int offset, int byteCount) {
if (source == null) throw new IllegalArgumentException(“source == null”);
checkOffsetAndCount(source.length, offset, byteCount);
int limit = offset + byteCount;//byte数组需要写到的最后一位下标
while (offset < limit) {
Segment tail = writableSegment(1);//获取可写的Segment
int toCopy = Math.min(limit - offset, Segment.SIZE - tail.limit);
System.arraycopy(source, offset, tail.data, tail.limit, toCopy);//数据拷贝到Segment中
offset += toCopy;
tail.limit += toCopy;
}
size += byteCount;
return this;
}
循环的获取一个可写的Segment将数据写到当中，直到byte数组中写完。然后就是RealBufferedSink#emitCompleteSegments将Buffer数据写到文件中。
@Override
public BufferedSink emitCompleteSegments() throws IOException {
if (closed) throw new IllegalStateException(“closed”);
long byteCount = buffer.completeSegmentByteCount();//获取写完的Segment中byte数
if (byteCount > 0) sink.write(buffer, byteCount);//然后将Buffer数据写到文件中
return this;
}
buffer#completeSegmentByteCount()。
public long completeSegmentByteCount() {
long result = size;
if (result == 0) return 0;
// Omit the tail if it’s still writable.
Segment tail = head.prev;
if (tail.limit < Segment.SIZE && tail.owner) {//最后一个Segment如果没装满则暂不写入文件
result -= tail.limit - tail.pos;
}
return result;
}
获取写满的Segment字节数。
/ Buffer精华操作 /
除了前面看到的对缓冲区的优化接下来看看Okio对于输入流流到输出流的优化。
try {
BufferedSource source = Okio.buffer(Okio.source(file));
BufferedSink sink = Okio.buffer(Okio.sink(file));
sink.writeAll(source);
sink.close();
source.close();
} catch (Exception e) {
e.printStackTrace();
}
先看sink#writeAll()。
@Override
public long writeAll(Source source) throws IOException {
if (source == null) throw new IllegalArgumentException(“source == null”);
long totalBytesRead = 0;
for (long readCount; (readCount = source.read(buffer, Segment.SIZE)) != -1; ) {//for循环将数据读到输出流的buffer中
totalBytesRead += readCount;
emitCompleteSegments();//在把数据从buffer写入文件
}
return totalBytesRead;
}
调用了source.read()将数据读到BufferedSink的buffer中。
@Override
public long read(Buffer sink, long byteCount) {
if (sink == null) throw new IllegalArgumentException(“sink == null”);
if (byteCount < 0) throw new IllegalArgumentException("byteCount < 0: " + byteCount);
if (size == 0) return -1L;
if (byteCount > size) byteCount = size;
sink.write(this, byteCount);
return byteCount;
}
调用输出流buffer.write()将数据写入，前方高能重点来了。
@Override
public void write(Buffer source, long byteCount) {
if (source == null) throw new IllegalArgumentException(“source == null”);
if (source == this) throw new IllegalArgumentException(“source == this”);
checkOffsetAndCount(source.size, 0, byteCount);
while (byteCount > 0) {
if (byteCount < (source.head.limit - source.head.pos)) {//如果只需要当前Segment部分数据，或者说读到最后一个Segment了
Segment tail = head != null ? head.prev : null;
if (tail != null && tail.owner
&& (byteCount + tail.limit - (tail.shared ? 0 : tail.pos) <= Segment.SIZE)) {//如果要写的数据byteCount+limit+（如果当前不是共享Segment，则可以覆盖前面已读数据所以+pos，如果是共享Segment则不能覆盖已读数据所以为0）<= Segment.SIZE，证明写Buffer的Segment装得下
source.head.writeTo(tail, (int) byteCount);//把读buffer中Segment数据写到Segment中
source.size -= byteCount;
size += byteCount;
return;//return
} else {//如果装不下则分割读buffer的Segment为两个，将我们需要数据的部分放在头部
source.head = source.head.split((int) byteCount);
}
}
//下面就是把读buffer中segment从链表取出，拼接到写buffer的segment链表中
Segment segmentToMove = source.head;
long movedByteCount = segmentToMove.limit - segmentToMove.pos;
source.head = segmentToMove.pop();//从读buffer中断链
if (head == null) {
head = segmentToMove;
head.next = head.prev = head;
} else {
Segment tail = head.prev;
tail = tail.push(segmentToMove);//拼接到写buffer的链表中
tail.compact();//尝试压缩Segment数据，移除多余Segment对象
}
source.size -= movedByteCount;
size += movedByteCount;
byteCount -= movedByteCount;
}
}
接下来我们梳理下上面的流程：
先判断当前是不是读到最后一个Segment了，如果是在判断写buffer中最后一个Segment写不写的下，写的下的话就写入然后return结束了，否则把要读的那个Segment拆分成两段，将我们需要数据的部分放在头部
如果第一个判断中没return，证明有整段的Segment数据需要拷贝，为了提高效率则直接将读buffer中Segment脱链，直接接到写buffer中提高效率，然后尝试压缩Segment链表的数据，移除多余的Segment
流程说了，接下来我们看上面没分析的几个方法
source.head.writeTo(tail, (int) byteCount)
source.head.split((int) byteCount)
tail.compact()
先看source.head.writeTo(tail, (int) byteCount)。
public void writeTo(Segment sink, int byteCount) {
if (!sink.owner) throw new IllegalArgumentException();
if (sink.limit + byteCount > SIZE) {//如果limit+byteCount>Size即装不下所以需要把数据往前移覆盖已读数据
if (sink.shared) throw new IllegalArgumentException();//当前Segment是共享数组的则报错，至于shared属性在split方法的时候会说
if (sink.limit + byteCount - sink.pos > SIZE) throw new IllegalArgumentException();
System.arraycopy(sink.data, sink.pos, sink.data, 0, sink.limit - sink.pos);//将数据向前移覆盖已读数据腾出空间
sink.limit -= sink.pos;
sink.pos = 0;
}
System.arraycopy(data, pos, sink.data, sink.limit, byteCount);//数据写入
sink.limit += byteCount;
pos += byteCount;
}
可以看到Segment#writeTo()是将数据写入传入的Segment中，如果sink写不下的话则会将已读数据覆盖腾出空间在写入。
再来source.head.split((int) byteCount)。
public Segment split(int byteCount) {
if (byteCount <= 0 || byteCount > limit - pos) throw new IllegalArgumentException();
Segment prefix;
if (byteCount >= SHARE_MINIMUM) {//如果要分割的数据量大于1024即1K则共享数组而不是数据拷贝
prefix = sharedCopy();//共享数组
} else {//数据量小于1K
prefix = SegmentPool.take();//创建一个新的Segment
System.arraycopy(data, pos, prefix.data, 0, byteCount);//拷贝数据
}
prefix.limit = prefix.pos + byteCount;
pos += byteCount;
prev.push(prefix);//插入分割出的Segment
return prefix;
}
Segment sharedCopy() {
shared = true;
return new Segment(data, pos, limit, true, false);//共享同一个data数组
}
split则是先判断要分割的数据量大于1K么，如果大于则使用共享数组的方式创建Segment减少拷贝，否则创建一个新的Segment通过数组拷贝的方式将数据传入。而前面判断的shared就是这里赋值的，使用数组共享方式创建的Segment，是不能为了写入数据将数据前移覆盖已读数据腾出位置，因为持有的是数组引用会影响到别的Segment。最后tail.compact()：
public void compact() {
if (prev == this) throw new IllegalStateException();
if (!prev.owner) return; // Cannot compact: prev isn’t writable.
int byteCount = limit - pos;//计算当前Segment数据量
int availableByteCount = SIZE - prev.limit + (prev.shared ? 0 : prev.pos);
if (byteCount > availableByteCount) return; //判断前一个Segment装得下么，装不下return
writeTo(prev, byteCount);//将当前Segment数据写到前一个Segment中
pop();//将当前Segment脱链
SegmentPool.recycle(this);//回收
}
判断当前Segment中数据能放到前一个Segment么，如果可以则将数据写入，移除当前Segment。这里总结下Buffer的精髓操作。
对于输入流流到输出流是将输入流Buffer的数据直接转移到输出流Buffer中，转移分为两种情况：
整段的Segment数据转移则是直接从输出Buffer中脱链然后插入输出Buffer中，直接修改指针效率非常高
非整段的Segment数据转移是判断输出Buffer最后一个Segment是否写的下，写的下的话是数组拷贝，写不下的话则将输入Segment一分为二，将要转移数据的Segment放第一个，然后按照1方式整段Segment转移到写buffer中
并且对于Segment分割的时候有做优化，当需要转移数据量小于1K的时候是通过数组拷贝的方式将数据写到新Segment中，大于1K的时候是共享同一个数组，只是修改pos和limit来控制读取区间。
/ Timeout超时处理 /
okio的超时分为两种
同步超时TimeOut
异步超时AsyncTimeout
同步超时TimeOut
同步超时比较简单前面看到过，以写为例：
public static Sink sink(OutputStream out) {
return sink(out, new Timeout());//创建同步超时对象
}
private static Sink sink(final OutputStream out, final Timeout timeout) {
if (out == null) throw new IllegalArgumentException(“out == null”);
if (timeout == null) throw new IllegalArgumentException(“timeout == null”);
return new Sink() {
@Override
public void write(Buffer source, long byteCount) throws IOException {
checkOffsetAndCount(source.size, 0, byteCount);
while (byteCount > 0) {
timeout.throwIfReached();//每次写的时候判断是否超时
Segment head = source.head;
int toCopy = (int) Math.min(byteCount, head.limit - head.pos);
out.write(head.data, head.pos, toCopy);
head.pos += toCopy;
byteCount -= toCopy;
source.size -= toCopy;
if (head.pos == head.limit) {
source.head = head.pop();
SegmentPool.recycle(head);
}
}
}
};
}
在每次写之前调用throwIfReached()方法检测是否超时。
public void throwIfReached() throws IOException {
if (Thread.interrupted()) {
throw new InterruptedIOException(“thread interrupted”);
}
if (hasDeadline && deadlineNanoTime - System.nanoTime() <= 0) {
throw new InterruptedIOException(“deadline reached”);
}
}
如果超时则抛出异常，当然如果循环中某次写操作进行了很长时间是没法立即停止的，只能等到下次while循环的时候才会抛出异常停止，很明显这样是有缺陷的，于是还有异步超时。
异步超时AsyncTimeout
Okio给通过Socket方式创建的流提供的就是异步超时处理，以写操作为例。
public static Sink sink(Socket socket) throws IOException {
if (socket == null) throw new IllegalArgumentException(“socket == null”);
if (socket.getOutputStream() == null) throw new IOException(“socket’s output stream == null”);
AsyncTimeout timeout = timeout(socket);//创建了一个异步超时对象
Sink sink = sink(socket.getOutputStream(), timeout);
return timeout.sink(sink);//用AsyncTimeout.sink给sink包装了一层
}
再看到AsyncTimeout#sink。
public final Sink sink(final Sink sink) {
return new Sink() {
@Override
public void write(Buffer source, long byteCount) throws IOException {
checkOffsetAndCount(source.size, 0, byteCount);
boolean throwOnTimeout = false;
enter();//在进行写操作的时候会调用一下enter方法
try {
sink.write(source, toWrite);
byteCount -= toWrite;
throwOnTimeout = true;
} catch (IOException e) {
throw exit(e);
} finally {
exit(throwOnTimeout);//结束的时候会调用exit
}
}
}
再看超时开始的enter()和结束的exit()。
public final void enter() {
if (inQueue) throw new IllegalStateException(“Unbalanced enter/exit”);
long timeoutNanos = timeoutNanos();//超时时间
boolean hasDeadline = hasDeadline();//是否有设置截止时间
if (timeoutNanos == 0 && !hasDeadline) {
return; // No timeout and no deadline? Don’t bother with the queue.
}
inQueue = true;
scheduleTimeout(this, timeoutNanos, hasDeadline);//开始超时任务
}
private static synchronized void scheduleTimeout(
AsyncTimeout node, long timeoutNanos, boolean hasDeadline) {
if (head == null) {//如果head为null创建一个AsyncTimeout作为head站个位置没有实际意义
head = new AsyncTimeout();
new Watchdog().start();//开启一个Watchdog线程进行超时监听
}
long now = System.nanoTime();
//计算超时时间赋值给timeoutAt属性
if (timeoutNanos != 0 && hasDeadline) {
node.timeoutAt = now + Math.min(timeoutNanos, node.deadlineNanoTime() - now);
} else if (timeoutNanos != 0) {
node.timeoutAt = now + timeoutNanos;
} else if (hasDeadline) {
node.timeoutAt = node.deadlineNanoTime();
} else {
throw new AssertionError();
}
long remainingNanos = node.remainingNanos(now);//获取超时剩余时间
for (AsyncTimeout prev = head; true; prev = prev.next) {//遍历链表将剩余时间少的排在链表头部
if (prev.next == null || remainingNanos < prev.next.remainingNanos(now)) {
node.next = prev.next;
prev.next = node;
if (prev == head) {//如果是第一次notify唤醒watchdog
AsyncTimeout.class.notify();
}
break;
}
}
}
那梳理下上面代码就是将AsyncTimeOut根据剩余超时时间排序，即将超时的排在链表头部，然后启动了一个WatchDog线程去检查超时情况，接下来看看WatchDog。
private static final class Watchdog extends Thread {
Watchdog() {
super(“Okio Watchdog”);
setDaemon(true);
}
public void run() {
while (true) {
try {
AsyncTimeout timedOut;
synchronized (AsyncTimeout.class) {
timedOut = awaitTimeout();//获取即将超时的AsyncTimeout
if (timedOut == null) continue;
if (timedOut == head) {//如果获取到的为head代表超时队列没有任务了return
head = null;
return;//return
}
}
timedOut.timedOut();//调用timeout.timeout()方法
} catch (InterruptedException ignored) {
}
}
}
}
WatchDog则是通过awaitTimeout获取即将超时的AsyncTimeout对象，如果AsyncTimeout为head则代表队列中没有任务了可以return，否则执行AsyncTimeout.timeout()方法触发超时。
static @Nullable AsyncTimeout awaitTimeout() throws InterruptedException {
AsyncTimeout node = head.next;//拿到即将超时的AsyncTimeout
if (node == null) {
long startNanos = System.nanoTime();
AsyncTimeout.class.wait(IDLE_TIMEOUT_MILLIS);
return head.next == null && (System.nanoTime() - startNanos) >= IDLE_TIMEOUT_NANOS
? head // The idle timeout elapsed.
: null; // The situation has changed.
}
重要知识点
下面是有几位Android行业大佬对应上方技术点整理的一些进阶资料。
高级进阶篇——高级UI，自定义View（部分展示）
UI这块知识是现今使用者最多的。当年火爆一时的Android入门培训，学会这小块知识就能随便找到不错的工作了。不过很显然现在远远不够了，拒绝无休止的CV,亲自去项目实战，读源码，研究原理吧！
- 面试题部分合集
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
}
重要知识点
下面是有几位Android行业大佬对应上方技术点整理的一些进阶资料。
[外链图片转存中…(img-lR5rlbMp-1715764268133)]
高级进阶篇——高级UI，自定义View（部分展示）
UI这块知识是现今使用者最多的。当年火爆一时的Android入门培训，学会这小块知识就能随便找到不错的工作了。不过很显然现在远远不够了，拒绝无休止的CV,亲自去项目实战，读源码，研究原理吧！
[外链图片转存中…(img-ZuwgZEUJ-1715764268134)]
- 面试题部分合集
[外链图片转存中…(img-vuyjOdpJ-1715764268134)]
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
869
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
