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

最新推荐文章于 2024-11-02 10:50:29 发布
最新推荐文章于 2024-11-02 10:50:29 发布
阅读量908 收藏 12
点赞数 23
分类专栏： 程序员 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84279169/article/details/138005614
版权

/**

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

private static class TanJiaJunCallable implements Callable {

@Override
public String call() {
return “谭嘉俊”;
}

}

public static void main(String[] args) {
// 创建FutureTask对象
FutureTask futureTask = new FutureTask<>(new TanJiaJunCallable());
// 创建线程
Thread thread = new Thread(futureTask);
thread.start();
try {
// 等待任务执行完毕，并且得到返回值
String result = futureTask.get();
System.out.println(result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}

}

前面两种方式都没有返回值，FutureTask可以有返回值。

wait和notify

wait()方法、wait(long timeoutMillis)方法、wait(long timeoutMillis, int nanos)方法、notify()方法和notifyAll()方法都是Object类的方法。

wait系列方法

当一个线程调用共享变量的wait系列方法时，这个线程进入等待状态，直到使用下面两种方式才会被唤醒：

  • 其他线程调用该共享变量的notify系列方法（notify()方法或者notifyAll()方法）。
  • 其他线程调用该共享变量所在的线程的interrupt()方法后，该线程抛出InterruptedException异常返回。

要注意的是，需要获取到该共享变量的监视器锁才能调用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);
}
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

img

img

img

img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

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

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

Android开发除了flutter还有什么是必须掌握的吗？

相信大多数从事Android开发的朋友们越来越发现，找工作越来越难了，面试的要求越来越高了

除了基础扎实的java知识，数据结构算法，设计模式还要求会底层源码，NDK技术，性能调优，还有会些小程序和跨平台，比如说flutter，以思维脑图的方式展示在下图；

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

315107)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

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

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

Android开发除了flutter还有什么是必须掌握的吗？

相信大多数从事Android开发的朋友们越来越发现，找工作越来越难了，面试的要求越来越高了

除了基础扎实的java知识，数据结构算法，设计模式还要求会底层源码，NDK技术，性能调优，还有会些小程序和跨平台，比如说flutter，以思维脑图的方式展示在下图；

[外链图片转存中…(img-96Shddu8-1713606315109)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

2401_84279169
关注
专栏目录
Java学习四-常用类
天天向上
04-11 178
文章目录Object类Object()getClass()hashCode()equals()clone()toString()notify()notifyAll()wait()wait(long timeoutMillis)wait(long timeoutMillis, int nanos)finalize()包装类基本数据类型和包装类Integer类Math类日期时间类Data类SimpleDateFormat类Calendar类其他printf输出日期的方法休眠String类底层维护构造函数与创建
征服Android面试官路漫漫（三），rrxjava原理
m0_65320833的博客
01-31 1148
调用了 ContextImpl.createActivityContext() 方法。 static ContextImpl createActivityContext(ActivityThread mainThread, LoadedApk packageInfo, ActivityInfo activityInfo, IBinder activityToken, int displayId, Configuration overrideConfiguration) { … // 创建
Java线程基础
qq_20417381的博客
08-31 201
本文章讲解的内容是Java线程，建议对着示例项目阅读文章，示例项目链接如下： ThreadDemo 概述 在说线程的概念之前，先说下进程的概念，进程是代码在数据集合上的一次运行活动，它是系统进行资源分配和调度的基本单位。一个线程至少有一个线程，线程是进程中的实体，线程本身是不会独立存在的，进程中的多个线程可以共享进程的资源（例如：内存地址、文件I/O等），也可以独立调度。 有以下三种方式实现线程： 使用内核线程实现 使用用户线程实现 使用用户线程和轻量级线程混合实现 Java语言统一处理了不同硬件和操作
线程攻略，夯实基础很重要！
郭霖
10-27 664
/ 今日科技快讯 /近日，美国旧金山地方法院法官劳雷尔·比勒驳回了司法部的最新请求，维持其在9月初的裁定，即禁止将微信从苹果和谷歌等美国应用商店中移除。 比勒法官表示，政府提交的...
wait(long timeout, int nanos)
遥不可及的博客
11-12 5585
学习javaApi第十一天java.lang.Object - jdk版本:1.0 - 类型:class方法public final void wait(long timeout, int nanos) throws InterruptedException在其他线程调用此对象的 notify() 方法或 noti
4-11_java.lang.Object_wait(long timeout, int nanos)方法的作用
Ricky_Monarch的博客
08-21 759
timeout - 要等待的最长时间（以毫秒为单位）。 nanos - 额外时间（以毫微秒为单位，范围是 0-999999）。 public final void wait(long timeout, int nanos) throws InterruptedException { if (timeout < 0) { throw new IllegalArgumen...
征服Android面试官路漫漫（一）：线程攻略，夯实基础很重要！
2401_84132204的博客
04-20 917
*其实上面说了这么多，钱是永远赚不完的，在这个知识付费的时代，知识技能提升才是是根本！我作为一名8年的高级工程师，知识技能已经学习的差不多。**在看这篇文章的可能有刚刚入门，刚刚开始工作，或者大佬级人物。像刚刚开始学Android开发小白想要快速提升自己，最快捷的方式，就是有人可以带着你一起分析，这样学习起来最为高效，所以这里分享一套高手学习的源码和框架视频等精品Android架构师教程，保证你学了以后保证薪资上升一个台阶。这么重要的事情说三遍啦！
征服Android面试官路漫漫（一）：线程攻略，夯实基础很重要！(2)
2401_84132176的博客
04-20 852
各行各样都会淘汰一些能力差的，不仅仅是IT这个行业，所以，不要被程序猿是吃青春饭等等这类话题所吓倒，也不要觉得，找到一份工作，就享受安逸的生活，你在安逸的同时，别人正在奋力的向前跑，这样与别人的差距也就会越来越遥远，加油，希望，我们每一个人，成为更好的自己。BAT大厂面试题、独家面试工具包,资料包括 数据结构、Kotlin、计算机网络、Framework源码、数据结构与算法、小程序、NDK、Flutter《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取。
征服Android面试官路漫漫（一）：线程攻略，夯实基础很重要！(3)
2401_84520377的博客
05-02 924
【Android 详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然 Android 没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪资真的特别高（钱多也不一定能找到合适的），所以努力让自己成为高级工程师才是最重要的。
征服Android面试官路漫漫（四），看这一篇就够了
m0_66265031的博客
01-21 150
第一行中，service表示Zygote进程以服务的形式来启动，zygote则是进程的名字，/system/bin/app_process是执行程序的路径，后面几项则是传给执行程序的参数，其中--start-system-server表示在Zygote进程启动后需要启动SystemServer进程。 然后是最后一行，Zygote进程是使用socket来进行跨进程通信的，所以会创建一个名为zygote的socket，660表示访问权限rw-rw----，表示文件拥有者和同一群组用户具有读写权限。 init进程
【《神奇的花香（16分）》阅读答案】官路花香全文免费阅读.docx
11-13
《神奇的花香》这篇文章揭示了植物花香的多种作用，包括它们在植物自身生存繁衍中的重要性以及对人类的益处。首先，植物花朵的香味是它们吸引昆虫进行授粉的一种策略，花的鲜艳色彩和香气共同作用，使得昆虫如蜂蝶被...
征服Android面试官路漫漫（二）：OutOfMemoryError 可以被 try catch 吗 ？
weixin_44339238的博客
11-02 967
问题由来： 这是一家公司的面试题目，感觉有点意思，所以面试回来准备测试下什么情况。 问题论点： 对于这个问题，主要讨论两种OutOfMemory可能性，一种是突然使用了大量内存，比如加载了特别巨大的图片，第二是内存泄漏。 然后还有个问题是，一旦发生OOM，引发OOM的操作是否会成功，如果会成功赋值是否会成功呢？理论上操作和赋值都不会成功的，但是我觉得有必要尝试一下。 目录 OutOfMemoryError 可以被 try catch 吗？ 捕获 OutOfMemoryError 有什么意义？
征服Android面试官路漫漫（三）：从源码深扒一下四大组件和 Context
weixin_44339238的博客
11-03 191
目录 什么是 Context？ 四大组件和 Context Application 和 Context 为什么 Application 的 Context 不可以创建 Dialog ？ 未完待续... 文章开头，先来看一段代码： public class ContextActivity extends AppCompatActivity { @Override protected void onCreate(@Nullable Bundle savedInstanceSt..
安卓设备adb执行AT指令控制电话卡
最新发布
zmlovelx(帅得不敢出门 程序员群31843264)
11-02 502
AT 指令通常以 “AT” 作为开头，后面跟着具体的指令参数，以回车换行符（\r\n）结尾。例如，发送 “AT” 指令后，如果设备正常响应，会返回 “OK”。在 Wi-Fi 模块、蓝牙模块等其他通信模块中，也有相应的 AT 指令集来控制其功能，如 ESP32 模块的 AT 指令集可用于配置 Wi-Fi 连接、蓝牙连接等。获取到控制sim卡的/dev/xxx设备后，就可以用adb向它发送AT指令控制SIM 电话卡，发送AT指令。
集成旺店通旗舰版售后单至MySQL数据库
vincent067的博客
11-01 986
高效分页抓取：通过合理设置分页大小和循环抓取机制，实现大规模数据高效获取。自定义转换逻辑：利用平台提供的自定义转换功能，应对复杂业务需求，实现精准的数据映射与转换。实时监控与告警：借助集中监控系统，实时掌握集成任务状态，提高整体运维效率。以上步骤展示了如何利用轻易云平台调用旺店通·旗舰奇门接口获取并加工售后订单数据，为后续的数据分析奠定坚实基础。在实际应用中，根据具体业务需求，还可以进一步优化各环节，提高整体集成效率。
android 12 禁止三方APP 使用API 直接打开wifi的修改方法
wed110的专栏
10-30 286
log 提示：setWifiEnabled not allowed for uid ....三方APP 需要申请下面的权限。修改源码之后，全编译即可。
第2章 Android App开发基础
L念安dd的博客
10-29 1085
本章介绍基于Android系统的App开发常识，包括以下几个方面：App开发与其他软件开发有什么不一 样，App工程是怎样的组织结构又是怎样配置的，App开发的前后端分离设计是如何运作实现的，App的活动页面是如何创建又是如何跳转的。
Android 快捷方式
xiaoerbuyu1233的博客
10-29 325
【代码】Android 快捷方式。
Android 蓝牙各版本差异
weixin_44780781的博客
11-01 598
随着 Android 版本的迭代，蓝牙功能的开发和管理变得越来越简化与高效。尤其是在 Android 9.0 及更高版本中，权限管理和用户交互的加强为用户提供了更安全的体验。同时，源代码的变化为开发者提供了更强大的蓝牙功能支持。了解这些变化将帮助开发者更好地利用蓝牙功能并提升应用的用户体验。
warmup
W286734的博客
10-30 379
查看源代码发现,source.php。访问source.php,显而易见，php代码审计。$pos。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值