征服Android面试官路漫漫（一）：线程攻略，夯实基础很重要！

最新推荐文章于 2024-06-04 00:57:45 发布
最新推荐文章于 2024-06-04 00:57:45 发布
阅读量728 收藏 15
点赞数 10
分类专栏： 程序员 文章标签： android java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84149785/article/details/138991188
版权

要注意的是，需要获取到该共享变量的监视器锁才能调用wait方法，否则会抛出IllegalMonitorStateException异常，可以使用以下两种方式获得对象的监视器锁：

调用被关键字synchronized修饰的方法，代码如下所示：

Object object = new Object();

private synchronized void test() {
try {
// 调用变量object的wait()方法
object.wait();
} catch(InterruptedException e) {
e.printStackTrace();
}
}

执行同步代码块，代码如下所示：

Object object = new Object();

synchronized(object) {
try {
// 调用变量object的wait()方法
object.wait();
} catch(InterruptedException e) {
e.printStackTrace();
}
}

wait()

源码如下所示：

// Object.java
public final void wait() throws InterruptedException {
wait(0L);
}

这个方法实际上调用了wait(long timeoutMillis)方法，参数timeoutMillis的值是0L。它的行为和调用wait(0L, 0)方法是一致的。

wait(long timeoutMillis)

源码如下所示：

// Object.java
public final native void wait(long timeoutMillis) throws InterruptedException;

参数timeoutMillis是等待的最大时间，也就是超时时间，单位是毫秒。它的行为和调用wait(timeoutMillis, 0)方法是一致的。

要注意的是，如果传入了负数的timeoutMillis，就会抛出IllegalArgumentException异常。

wait(long timeoutMillis, int nanos)

源码如下所示：

// Object.java
public final void wait(long timeoutMillis, int nanos) throws InterruptedException {
if (timeoutMillis < 0) {
throw new IllegalArgumentException(“timeoutMillis value is negative”);
}

if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
“nanosecond timeout value out of range”);
}

if (nanos > 0 && timeoutMillis < Long.MAX_VALUE) {
timeoutMillis++;
}

wait(timeoutMillis);
}

这个方法实际上调用了wait(long timeoutMillis)方法；参数timeoutMillis是等待的最大时间，也就是超时时间，单位是毫秒；参数nanos是额外的时间，单位是纳秒，范围是0~999999（包括999999）。

只有在参数nanos大于0的时候，参数timeoutMillis才会自增。

notify系列方法

在一个线程上调用共享变量的notify方法后，会唤醒这个共享变量上调用wait系列方法后进入等待状态的线程。要注意的是，一个共享变量可能有多个线程在等待，具体唤醒哪个等待的线程是随机的。

被唤醒的线程不能立即从wait系列方法返回后继续执行，它需要获取到该共享变量的监视器锁才能返回，也就是说，唤醒它的线程释放了该共享变量的监视器锁，被唤醒的线程不一定能获取到该共享变量的监视器锁，因为该线程还需要和其他线程去竞争这个监视器锁，只有竞争到这个监视器锁后才能继续执行。

只有当前线程获取到该共享变量的监视器锁后，才能调用该共享变量的notify系列方法，否则会抛出IllegalMonitorStateException异常。

notify()方法

源码如下所示：

// Object.java
@HotSpotIntrinsicCandidate
public final native void notify();

notifyAll()方法

源码如下所示：

// Object.java
@HotSpotIntrinsicCandidate
public final native void notifyAll();

notifyAll()方法可以唤醒所有在该共享变量上因为调用wait系列方法而进入等待状态的线程。

sleep()方法–让线程睡眠

sleep()方法是Thread类的一个静态方法。当一个正在执行的线程调用了这个方法后，调用线程会暂时让出指定睡眠时间的执行权，不参与CPU的调度，但是不会让出该线程所拥有的监视器锁。指定的睡眠时间到了后，sleep()方法会正常返回，线程处于就绪状态，然后参与CPU调度，获取到CPU资源后继续运行。

要注意的是，如果在睡眠期间其他线程调用了该线程的interrupt()方法中断了该线程，就会在调用sleep方法的地方抛出InterruptedException异常而返回。

源码如下所示：

// Thread.java
public static native void sleep(long millis) throws InterruptedException;

下面来看一个生产者消费者问题（Producer-Consumer Problem）的例子：
Repository类是一个存储库，存放产品，代码如下所示：

package producerconsumerproblem;

import java.util.LinkedList;
import java.util.Queue;

/**

  • Created by TanJiaJun on 2020/8/30.
    */
    class Repository {

// 队列的最大容量是10
private static final int MAX_SIZE = 10;
// 创建队列
private final Queue queue = new LinkedList<>();

void produce() {
synchronized (queue) {
while (queue.size() == MAX_SIZE) {
try {
System.out.println(“生产者（线程名字：” + Thread.currentThread().getName() + “）：存储库已满”);
// 当队列满了后，调用变量queue的wait()方法，生产者线程，并且释放Queue对象的监视器锁
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 如果队列还没满，就创建新的Object对象，并且在队尾入列
queue.offer(new Object());
System.out.println(“生产者（线程名字：” + Thread.currentThread().getName() + “）：生产了一个产品”);
// 通知其他生产者线程和消费者线程
queue.notifyAll();
}
}

void consume() {
synchronized (queue) {
while (queue.size() == 0) {
try {
System.out.println(“消费者（线程名字：” + Thread.currentThread().getName() + “）：存储库是空”);
// 当队列空了后，调用变量queue的wait()方法，消费者线程进入等待状态，并且释放Queue对象的监视器锁
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 如果队列存在元素，就将队头元素出列
queue.poll();
System.out.println(“消费者（线程名字：” + Thread.currentThread().getName() + “）：消费了一个产品”);
// 通知其他消费者线程和生产者线程
queue.notifyAll();
}
}

}

以下是测试代码，我先把生产者所在的线程睡眠（sleep）一秒，把消费者所在的线程睡眠三秒，这样就可以制造出生产速度大于消费速度的场景，代码如下所示：

package producerconsumerproblem;

/**

  • Created by TanJiaJun on 2020/8/30.
    */
    class ProducerConsumerProblemTest {

// 生产者线程
private static class Producer implements Runnable {

private Repository repository;

Producer(Repository repository) {
this.repository = repository;
}

@Override
public void run() {
// 循环执行
while (true) {
try {
// 让生产者线程睡眠一秒
Thread.sleep(1000);
// 调用存储库的produce()方法，生产者生产产品
repository.produce();
} catch (InterruptedException e) {
e.printStackTrace();
break;
}
}
}

}

// 消费者线程
private static class Consumer implements Runnable {

private Repository repository;

Consumer(Repository repository) {
this.repository = repository;
}

@Override
public void run() {
// 循环执行
while (true) {
try {
// 让消费者线程睡眠三秒
Thread.sleep(3000);
// 调用存储库的consume()方法，消费者消费产品
repository.consume();
} catch (InterruptedException e) {
e.printStackTrace();
break;
}
}
}

}

public static void main(String[] args) {
// 创建存储库
Repository repository = new Repository();

// 创建三个生产者线程，并且让它们运行
for (int i = 0; i < 3; i++) {
new Thread(new Producer(repository)).start();
}

// 创建三个消费者线程，并且让它们运行
for (int i = 0; i < 3; i++) {
new Thread(new Consumer(repository)).start();
}
}

}

运行上面的代码，大约十秒后手动结束进程，结果如下所示：

/Library/Java/JavaVirtualMachines/jdk-13.jdk/Contents/Home/bin/java “-javaagent:/Applications/IntelliJ IDEA CE.app/Contents/lib/idea_rt.jar=63240:/Applications/IntelliJ IDEA CE.app/Contents/bin” -Dfile.encoding=UTF-8 -classpath /Users/tanjiajun/IdeaProjects/ThreadDemo/out/production/ThreadDemo producerconsumerproblem.ProducerConsumerProblemTest
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
消费者（线程名字：Thread-3）：消费了一个产品
消费者（线程名字：Thread-5）：消费了一个产品
消费者（线程名字：Thread-4）：消费了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-2）：存储库已满
生产者（线程名字：Thread-1）：存储库已满
消费者（线程名字：Thread-3）：消费了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-1）：存储库已满
消费者（线程名字：Thread-5）：消费了一个产品
消费者（线程名字：Thread-4）：消费了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-2）：存储库已满
生产者（线程名字：Thread-1）：存储库已满
生产者（线程名字：Thread-0）：存储库已满
消费者（线程名字：Thread-3）：消费了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-0）：存储库已满
生产者（线程名字：Thread-1）：存储库已满
消费者（线程名字：Thread-4）：消费了一个产品
消费者（线程名字：Thread-5）：消费了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-2）：存储库已满
生产者（线程名字：Thread-0）：存储库已满
生产者（线程名字：Thread-1）：存储库已满

Process finished with exit code 130 (interrupted by signal 2: SIGINT)

然后我把生产者所在的线程睡眠三秒，把消费者所在的线程睡眠一秒，这样就可以制造出生产速度小于消费速度的场景，代码如下所示：

package producerconsumerproblem;

/**

  • Created by TanJiaJun on 2020/8/30.
    */
    class ProducerConsumerProblemTest {

// 生产者线程
private static class Producer implements Runnable {

private Repository repository;

Producer(Repository repository) {
this.repository = repository;
}

@Override
public void run() {
// 循环执行
while (true) {
try {
// 让生产者线程睡眠三秒
Thread.sleep(3000);
// 调用存储库的produce()方法，生产者生产产品
repository.produce();
} catch (InterruptedException e) {
e.printStackTrace();
break;
}
}
}

}

// 消费者线程
private static class Consumer implements Runnable {

private Repository repository;

Consumer(Repository repository) {
this.repository = repository;
}

@Override
public void run() {
// 循环执行
while (true) {
try {
// 让消费者线程睡眠一秒
Thread.sleep(1000);
// 调用存储库的consume()方法，消费者消费产品
repository.consume();
} catch (InterruptedException e) {
e.printStackTrace();
break;
}
}
}

}

public static void main(String[] args) {
// 创建存储库
Repository repository = new Repository();

// 创建三个生产者线程，并且让它们运行
for (int i = 0; i < 3; i++) {
new Thread(new Producer(repository)).start();
}

// 创建三个消费者线程，并且让它们运行
for (int i = 0; i < 3; i++) {
new Thread(new Consumer(repository)).start();
}
}

}

运行上面的代码，大约十秒后手动结束进程，结果如下所示：

/Library/Java/JavaVirtualMachines/jdk-13.jdk/Contents/Home/bin/java “-javaagent:/Applications/IntelliJ IDEA CE.app/Contents/lib/idea_rt.jar=63256:/Applications/IntelliJ IDEA CE.app/Contents/bin” -Dfile.encoding=UTF-8 -classpath /Users/tanjiajun/IdeaProjects/ThreadDemo/out/production/ThreadDemo producerconsumerproblem.ProducerConsumerProblemTest
消费者（线程名字：Thread-3）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
消费者（线程名字：Thread-5）：存储库是空
生产者（线程名字：Thread-0）：生产了一个产品
消费者（线程名字：Thread-3）：消费了一个产品
消费者（线程名字：Thread-5）：存储库是空
生产者（线程名字：Thread-1）：生产了一个产品
消费者（线程名字：Thread-4）：消费了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
消费者（线程名字：Thread-5）：消费了一个产品
消费者（线程名字：Thread-3）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
消费者（线程名字：Thread-5）：存储库是空
生产者（线程名字：Thread-0）：生产了一个产品
消费者（线程名字：Thread-3）：消费了一个产品
消费者（线程名字：Thread-5）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
生产者（线程名字：Thread-1）：生产了一个产品
消费者（线程名字：Thread-5）：消费了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
消费者（线程名字：Thread-4）：消费了一个产品
消费者（线程名字：Thread-3）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
消费者（线程名字：Thread-5）：存储库是空
生产者（线程名字：Thread-0）：生产了一个产品
消费者（线程名字：Thread-3）：消费了一个产品
消费者（线程名字：Thread-5）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
消费者（线程名字：Thread-4）：消费了一个产品
消费者（线程名字：Thread-5）：消费了一个产品
消费者（线程名字：Thread-3）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
消费者（线程名字：Thread-5）：存储库是空
生产者（线程名字：Thread-0）：生产了一个产品
消费者（线程名字：Thread-3）：消费了一个产品
消费者（线程名字：Thread-5）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
消费者（线程名字：Thread-4）：消费了一个产品
消费者（线程名字：Thread-5）：消费了一个产品

Process finished with exit code 130 (interrupted by signal 2: SIGINT)

上面的结果都符合预期，我解释一下，当发现队列满了后，就会调用变量queue的wait()方法，该生产者线程就会被进入等待状态，并且释放Queue对象的监视器锁，让其他生产者线程和消费者线程去竞争这个监视器锁，打破了死锁产生的四个条件中的请求并持有条件，避免发生死锁，同样的，当发现队列空了后，也会调用变量queue的wait()方法，该消费者线程会进入等待状态，并且释放Queue对象的监视器锁，让其他消费者线程和生产者线程去竞争这个监视器锁，打破了死锁的四个条件中的请求并持有条件，避免发生死锁。

join系列方法–等待线程执行终止

join系列方法是Thread类的一个普通方法。它可以处理一些需要等待某几个任务完成后才能继续往下执行的场景。

join()方法

源码如下所示：

// Thread.java
public final void join() throws InterruptedException {
join(0);
}

这个方法实际上调用了join(final long millis)方法，参数millis的值是0。

join(final long millis)方法

源码如下所示：

// Thread.java
public final synchronized void join(final long millis)
throws InterruptedException {
if (millis > 0) {
if (isAlive()) {
final long startTime = System.nanoTime();
long delay = millis;
do {
wait(delay);
} while (isAlive() && (delay = millis -
TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime)) > 0);
}
} else if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
throw new IllegalArgumentException(“timeout value is negative”);
}
}

参数millis是等待时间，单位是毫秒。

要注意的是，如果传入了负数的millis，就会抛出IllegalArgumentException异常。

join(long millis, int nanos)方法

源码如下所示：

// Thread.java
public final synchronized void join(long millis, int nanos)
throws InterruptedException {

if (millis < 0) {
throw new IllegalArgumentException(“timeout value is negative”);
}

if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
“nanosecond timeout value out of range”);
}

if (nanos > 0 && millis < Long.MAX_VALUE) {
millis++;
}

join(millis);
}

这个方法实际上调用了join(final long millis)方法；参数millis是等待时间，单位是毫秒；参数nanos是额外的时间，单位是纳秒，范围是0~999999（包括999999）。

只有在参数nanos大于0的时候，参数millis才会自增。

我在写深入了解volatile关键字这篇文章的时候，其中一个例子使用到了这个方法，代码如下所示：

/**

  • Created by TanJiaJun on 2020-08-16.
    */
    class VolatileDemo {

private static final int THREADS_COUNT = 10;

private static volatile int value = 0;

private static void increase() {
// 对value变量进行自增操作
value++;
}

public static void main(String[] args) {
// 创建10个线程
Thread[] threads = new Thread[THREADS_COUNT];
for (int i = 0; i < THREADS_COUNT; i++) {
threads[i] = new Thread(() -> {
for (int j = 0; j < 1000; j++)
// 每个线程对value变量进行1000次自增操作
increase();
});
threads[i].start();
}
// 主线程等待子线程运行结束
for (Thread thread : threads) {
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(“value的值：” + value);
}

}

在这个示例代码中调用join()方法目的是为了让这十个子线程运行结束后，主线程才结束，保证这十个子线程都能全部运行结束。

yield()–让出CPU执行权

yield()方法是Thread类的一个静态方法。当一个线程调用这个方法后，当前线程告诉线程调度器让出CPU执行权，但是线程调度器可以无条件忽略这个请求，如果成功让出后，线程处于就绪状态，它会从线程就绪队列中获取一个线程优先级最高的线程，当然也有可能调度到刚刚让出CPU执行权的那个线程来获取CPU执行权。源码如下所示：

// Thread.java
public static native void yield();

它和sleep()方法的区别是：当线程调用sleep()方法时，它会被阻塞指定的时间，在这个期间线程调度器不会去调度其他线程，而当线程调用yield()方法时，线程只是让出自己剩余的CPU时间片，线程还是处于就绪状态，并没有被阻塞，线程调度器在下一次调度时可能还会调度到这个线程执行。

线程中断

在Java中，线程中断是一种线程间的协作模式。

要注意的是，通过设置线程的中断标志并不能立刻终止线程的执行，而是通过被中断的线程的中断标志自行处理。

interrupt()方法

interrupt()方法可以中断线程，如果是在其他线程调用该线程的interrupt()方法，会通过checkAccess()方法检查权限，这有可能抛出SecurityException异常。假设有两个线程，分别是线程A和线程B，当线程A正在运行时，线程B可以调用线程A的interrupt()方法来设置线程A的中断标志为true并且立即返回，前面也提到过，设置标志仅仅是设置标志而已，线程A实际上还在运行，还没被中断；如果线程A因为调用了wait系列方法、join()方法或者sleep()方法而被阻塞，这时候线程B调用线程A的interrupt()方法，线程A会在调用这些方法的地方抛出InterruptedException异常。源码如下所示：

// Thread.java
public void interrupt() {
if (this != Thread.currentThread()) {
checkAccess();

// 线程可能在IO操作中阻塞
synchronized (blockerLock) {
Interruptible b = blocker;
if (b != null) {
interrupt0(); // 设置中断标志
b.interrupt(this);
return;
}
}
}

// 设置中断标志
interrupt0();
}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此我收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助**。

因此我收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-hPYWFbVf-1715906413073)]

[外链图片转存中…(img-ux6GfFWt-1715906413075)]

[外链图片转存中…(img-cEDK5YfA-1715906413076)]

[外链图片转存中…(img-5xIhUYJ0-1715906413077)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

2401_84149785
关注
  • 10
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
广州路面考试-广汕路,华官路,化龙东路
05-16
包含灯光操作，广汕路路线图，华官路路线图，化龙东路考试经验分享。
蛀干类害虫引诱剂诱虫谱及诱集的主要昆虫种群动态1) (2010年)
04-24
为了弄清蛀干类害虫引诱剂林间诱捕马尾松蛀干类昆虫的效果，于2006-2008年每年的4-11月蛀干类昆虫活动期，在浙江省仙居县官路镇大北地溪林场应用蛀干类害虫引诱剂诱捕马尾松蛀干类昆虫。结果表明：蛀干类害虫引诱剂...
征服Android面试官路漫漫（一）：线程攻略，夯实基础很重要！(2)
2401_84132176的博客
04-20 764
各行各样都会淘汰一些能力差的，不仅仅是IT这个行业，所以，不要被程序猿是吃青春饭等等这类话题所吓倒，也不要觉得，找到一份工作，就享受安逸的生活，你在安逸的同时，别人正在奋力的向前跑，这样与别人的差距也就会越来越遥远，加油，希望，我们每一个人，成为更好的自己。BAT大厂面试题、独家面试工具包,资料包括 数据结构、Kotlin、计算机网络、Framework源码、数据结构与算法、小程序、NDK、Flutter《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取。
征服Android面试官路漫漫（一）：线程攻略，夯实基础很重要！(3)
2401_84520377的博客
05-02 842
【Android 详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然 Android 没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪资真的特别高（钱多也不一定能找到合适的），所以努力让自己成为高级工程师才是最重要的。
征服Android面试官路漫漫（一）：线程攻略，夯实基础很重要！(1)
2401_84279169的博客
04-20 812
相信大多数从事Android开发的朋友们越来越发现，找工作越来越难了，面试的要求越来越高了除了基础扎实的java知识，数据结构算法，设计模式还要求会底层源码，NDK技术，性能调优，还有会些小程序和跨平台，比如说flutter，以思维脑图的方式展示在下图；《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！315107)]既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化。
征服Android面试官路漫漫（一）：线程攻略，夯实基础很重要！(4)
2401_84520401的博客
05-02 20
最后为了帮助大家深刻理解Android相关知识点的原理以及面试相关知识，这里放上相关的我搜集整理的Android开发中高级必知必会核心笔记，共计2968页PDF、58w字，囊括Android开发648个知识点，我把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包知识脉络 + 诸多细节。网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。
2024年Android最新征服Android面试官路漫漫（一）：线程攻略，夯实基础很重要，2024年最新阿里面试的问题
2401_84562768的博客
05-14 960
那我们该怎么做才能做到年薪60万+呢，对于程序员来说，只有不断学习，不断提升自己的实力。我之前有篇文章提到过，感兴趣的可以看看，到底要学习哪些知识才能达到年薪60万+。通过职友集数据可以查看，以北京 Android 相关岗位为例，其中 【20k-30k】 薪酬的 Android 工程师，占到了整体从业者的 30.8%！北京 Android 工程师「工资收入水平 」今天重点内容是怎么去学，怎么提高自己的技术。1.合理安排时间2.找对好的系统的学习资料3.有老师带，可以随时解决问题。
【《神奇的花香（16分）》阅读答案】官路花香全文免费阅读.docx
11-13
【《神奇的花香（16分）》阅读答案】官路花香全文免费阅读.docx
分散性土的鉴别及改性试验 (2010年)
05-20
大屯水库、岭落水库、官路水库为比较典型的分散性土，为保证堤坝安全，需要鉴定其分散性等级并进行改性加固。采用双密度计、针孔试验、碎块试验对几个工程的分散性图进行鉴别，确定了分散性等级。取该分散性土试样...
Qt6.7 Android第一次尝试
m0_69086552的博客
06-03 415
安装qt online installer https://mirrors.tuna.tsinghua.edu.cn/qt/official_releases/online_installers/qt-unified-windows-x64-online.exe 选择Android 和 Desktop, 然后默认安装 安装完成后设置Android Sdk, 这里可以直接使用在线下载(因为我也不会怎么配置Android SDK和NDK) 注意android-openssl是可选的, 我可以不要它 测
Android中focusableInTouchMode会导致第一次点击事件失效
Ung8023
05-31 342
我们很多时候会对某些View设置点击事件，但是，当对这个View同时设置了。，在Activity代码中对View设置点击事件。会被消费为为此View获取焦点。创建一个View，并同时指定了。
Android约束布局ConstraintLayout的使用
最新发布
跟着哆啦学Android
06-04 1078
Android引入约束布局的目的是为了减少布局层级的嵌套，从而提升渲染性能。约束布局综合线性布局、相对布局、帧布局的部分功能，缺点也很明显，就是可能要多写几行代码。所以约束布局使用时，还得综合考虑代码量。提升性能也并不一定非得使用约束布局，也可以在ViewGroup上dispatchDraw。你需要根据业务的具体情况选择最合适的实现方式。我知道很多人一开始很不习惯使用约束布局，但既然你诚心诚意问我怎么使用了？于是我就大发慈悲告诉你怎么使用呗。
Android基础-内存泄漏
层楼终究误少年
06-01 1178
在Android开发中，内存泄漏是一个常见且重要的问题，它不仅影响应用的性能，还可能导致应用崩溃。因此，分析和解决内存泄漏问题对于提升应用的稳定性和用户体验至关重要。内存泄漏是Android开发中常见且重要的问题之一。通过合理的内存管理、使用适当的工具进行内存泄漏分析和解决常见的内存泄漏原因，我们可以有效地提升Android应用的稳定性和用户体验。内存泄漏是指在程序运行过程中，由于错误的内存管理导致无法释放已经不再使用的内存资源，从而造成内存消耗过大或者内存溢出的问题。二、内存泄漏的常见原因。
Android WebView升级
帅次的博客
05-31 938
WevView内核升级解决方案
android recyclerView緩存數量 recycleview的缓存
hcgeng的专栏
05-31 673
1.上下滑动，底部和顶部的Item会添加，这时会先根据viewHolder的position，从二级缓存中查找，存在，直接使用，不用重新绑定数据，直接将ViewHolder放入一级缓存。2.根据二级缓存数（不做设置，默认2），如果小于缓存数，直接放入二级缓存，否则，将二级缓存中最先放入的item，移出放入四级缓存，再将其放入二级缓存。第一次加载，1、2、4级缓存均无数据，所以会创建适配器，并从中绑定数据，再根据界面需显示的数据项，并将其viewholder设置到一级缓存中。并由内部类Recycle来管理。
【Android】点击图片获取点击位置在图片中的位置
每天不是在写bug就是在写bug的路上
05-31 440
android图片点击获取位置
Android输入法IME（二）之 客户端（IMM）启动流程
薛文旺
05-31 548
Android输入法IME（二）之 客户端启动流程。
jadx-gui-1.5 反编译工具使用教程 反混淆 Java android 查看签名
chenhao0568的专栏
06-03 273
JADX：JADX是一个强大的反编译工具，它支持命令行和图形界面操作。除了基本的反编译功能外，JADX还提供了反混淆功能，有助于提高反编译后代码的可读性。
Android关闭硬件加速对PorterDuffXfermode的影响
Zhang Phil
06-02 1140
CPU返回后，会直接将GraphicBuffer提交给SurfaceFlinger，告诉SurfaceFlinger进行合成，但是这个时候GPU可能并未完成之前的图像渲染，这时候就牵扯到一个同步，Android中，用的是Fence机制，SurfaceFlinger合成前会查询Fence，如果GPU渲染没有结束，则等待GPU渲染结束，GPU结束后，会通知SurfaceFlinger进行合成，SF合成后，提交显示，最终完成图像的渲染显示。跑的版本minSdk=33。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值