Android 面试必备 - 线程，2024年最新三个月没找到工作面试怎么说

最新推荐文章于 2024-06-04 00:57:45 发布

2301_82243769

最新推荐文章于 2024-06-04 00:57:45 发布

阅读量825

点赞数 12

分类专栏： 2024年程序员学习文章标签： android 面试职场和发展

本文链接：https://blog.csdn.net/2301_82243769/article/details/137934667

版权

2024年程序员学习专栏收录该内容

188 篇文章 0 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

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

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注Android）

正文

Thread.sleep(60 * 1000); // 为测试，占用了就不放

}

} catch (Exception e) {

e.printStackTrace();

}

class LockB implements Runnable{

public void run() {

try {

System.out.println(new Date().toString() + " LockB 开始执行");

while(true){

synchronized (LockTest.obj2) {

System.out.println(new Date().toString() + " LockB 锁住 obj2");

Thread.sleep(3000); // 此处等待是给A能锁住机会

synchronized (LockTest.obj1) {

System.out.println(new Date().toString() + " LockB 锁住 obj1");

Thread.sleep(60 * 1000); // 为测试，占用了就不放

}

} catch (Exception e) {

e.printStackTrace();

}

java 生产者消费者

生产者/消费者问题的多种Java实现方式

wait() / nofity()方法是基类Object的两个方法，也就意味着所有Java类都会拥有这两个方法，这样，我们就可以为任何对象实现同步机制。

wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。

notify()方法：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态。

光看文字可能不太好理解，咱来段代码就明白了：

import java.util.LinkedList;

/**

仓库类Storage实现缓冲区
Email:530025983@qq.com
@author MONKEY.D.MENG 2011-03-15

public class Storage

{

// 仓库最大存储量

private final int MAX_SIZE = 100;

// 仓库存储的载体

private LinkedList list = new LinkedList();

// 生产num个产品

public void produce(int num)

{

// 同步代码段

synchronized (list)

{

// 如果仓库剩余容量不足

while (list.size() + num > MAX_SIZE)

{

System.out.println(“【要生产的产品数量】:” + num + “/t【库存量】:”

list.size() + “/t暂时不能执行生产任务!”);

try

{

// 由于条件不满足，生产阻塞

list.wait();

}

catch (InterruptedException e)

{

e.printStackTrace();

}

// 生产条件满足情况下，生产num个产品

for (int i = 1; i <= num; ++i)

{

list.add(new Object());

}

System.out.println(“【已经生产产品数】:” + num + “/t【现仓储量为】:” + list.size());

list.notifyAll();

}

// 消费num个产品

public void consume(int num)

{

// 同步代码段

synchronized (list)

{

// 如果仓库存储量不足

while (list.size() < num)

{

System.out.println(“【要消费的产品数量】:” + num + “/t【库存量】:”

list.size() + “/t暂时不能执行生产任务!”);

try

{

// 由于条件不满足，消费阻塞

list.wait();

}

catch (InterruptedException e)

{

e.printStackTrace();

}

// 消费条件满足情况下，消费num个产品

for (int i = 1; i <= num; ++i)

{

list.remove();

}

System.out.println(“【已经消费产品数】:” + num + “/t【现仓储量为】:” + list.size());

list.notifyAll();

}

// get/set方法

public LinkedList getList()

{

return list;

}

public void setList(LinkedList list)

{

this.list = list;

}

public int getMAX_SIZE()

{

return MAX_SIZE;

}

/**

生产者类Producer继承线程类Thread
Email:530025983@qq.com
@author MONKEY.D.MENG 2011-03-15

public class Producer extends Thread

{

// 每次生产的产品数量

private int num;

// 所在放置的仓库

private Storage storage;

// 构造函数，设置仓库

public Producer(Storage storage)

{

this.storage = storage;

}

// 线程run函数

public void run()

{

produce(num);

}

// 调用仓库Storage的生产函数

public void produce(int num)

{

storage.produce(num);

}

// get/set方法

public int getNum()

{

return num;

}

public void setNum(int num)

{

this.num = num;

}

public Storage getStorage()

{

return storage;

}

public void setStorage(Storage storage)

{

this.storage = storage;

}

/**

消费者类Consumer继承线程类Thread
Email:530025983@qq.com
@author MONKEY.D.MENG 2011-03-15

public class Consumer extends Thread

{

// 每次消费的产品数量

private int num;

// 所在放置的仓库

private Storage storage;

// 构造函数，设置仓库

public Consumer(Storage storage)

{

this.storage = storage;

}

// 线程run函数

public void run()

{

consume(num);

}

// 调用仓库Storage的生产函数

public void consume(int num)

{

storage.consume(num);

}

// get/set方法

public int getNum()

{

return num;

}

public void setNum(int num)

{

this.num = num;

}

public Storage getStorage()

{

return storage;

}

public void setStorage(Storage storage)

{

this.storage = storage;

}

/**

测试类Test
Email:530025983@qq.com
@author MONKEY.D.MENG 2011-03-15

public class Test

{

public static void main(String[] args)

{

// 仓库对象

Storage storage = new Storage();

// 生产者对象

Producer p1 = new Producer(storage);

Producer p2 = new Producer(storage);

Producer p3 = new Producer(storage);

Producer p4 = new Producer(storage);

Producer p5 = new Producer(storage);

Producer p6 = new Producer(storage);

Producer p7 = new Producer(storage);

// 消费者对象

Consumer c1 = new Consumer(storage);

Consumer c2 = new Consumer(storage);

Consumer c3 = new Consumer(storage);

// 设置生产者产品生产数量

p1.setNum(10);

p2.setNum(10);

p3.setNum(10);

p4.setNum(10);

p5.setNum(10);

p6.setNum(10);

p7.setNum(80);

// 设置消费者产品消费数量

c1.setNum(50);

c2.setNum(20);

c3.setNum(30);

// 线程开始执行

c1.start();

c2.start();

c3.start();

p1.start();

p2.start();

p3.start();

p4.start();

p5.start();

p6.start();

p7.start();

}

在JDK5.0之后，Java提供了更加健壮的线程处理机制，包括同步、锁定、线程池等，它们可以实现更细粒度的线程控制。await()和signal()就是其中用来做同步的两种方法，它们的功能基本上和wait() / nofity()相同，完全可以取代它们，但是它们和新引入的锁定机制Lock直接挂钩，具有更大的灵活性。通过在Lock对象上调用newCondition()方法，将条件变量和一个锁对象进行绑定，进而控制并发程序访问竞争资源的安全。下面来看代码：

import java.util.LinkedList;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

/**

仓库类Storage实现缓冲区
Email:530025983@qq.com
@author MONKEY.D.MENG 2011-03-15

public class Storage

{

// 仓库最大存储量

private final int MAX_SIZE = 100;

// 仓库存储的载体

private LinkedList list = new LinkedList();

// 锁

private final Lock lock = new ReentrantLock();

// 仓库满的条件变量

private final Condition full = lock.newCondition();

// 仓库空的条件变量

private final Condition empty = lock.newCondition();

// 生产num个产品

public void produce(int num)

{

// 获得锁

lock.lock();

// 如果仓库剩余容量不足

while (list.size() + num > MAX_SIZE)

{

System.out.println(“【要生产的产品数量】:” + num + “/t【库存量】:” + list.size()

“/t暂时不能执行生产任务!”);

try

{

// 由于条件不满足，生产阻塞

full.await();

}

catch (InterruptedException e)

{

e.printStackTrace();

}

// 生产条件满足情况下，生产num个产品

for (int i = 1; i <= num; ++i)

{

list.add(new Object());

}

System.out.println(“【已经生产产品数】:” + num + “/t【现仓储量为】:” + list.size());

// 唤醒其他所有线程

full.signalAll();

empty.signalAll();

// 释放锁

lock.unlock();

}

// 消费num个产品

public void consume(int num)

{

// 获得锁

lock.lock();

// 如果仓库存储量不足

while (list.size() < num)

{

System.out.println(“【要消费的产品数量】:” + num + “/t【库存量】:” + list.size()

“/t暂时不能执行生产任务!”);

try

{

// 由于条件不满足，消费阻塞

empty.await();

}

catch (InterruptedException e)

{

e.printStackTrace();

}

// 消费条件满足情况下，消费num个产品

for (int i = 1; i <= num; ++i)

{

list.remove();

}

System.out.println(“【已经消费产品数】:” + num + “/t【现仓储量为】:” + list.size());

// 唤醒其他所有线程

full.signalAll();

empty.signalAll();

// 释放锁

lock.unlock();

}

// set/get方法

public int getMAX_SIZE()

{

return MAX_SIZE;

}

public LinkedList getList()

最后

我见过很多技术leader在面试的时候，遇到处于迷茫期的大龄程序员，比面试官年龄都大。这些人有一些共同特征：可能工作了7、8年，还是每天重复给业务部门写代码，工作内容的重复性比较高，没有什么技术含量的工作。问到这些人的职业规划时，他们也没有太多想法。

其实30岁到40岁是一个人职业发展的黄金阶段，一定要在业务范围内的扩张，技术广度和深度提升上有自己的计划，才有助于在职业发展上有持续的发展路径，而不至于停滞不前。

不断奔跑，你就知道学习的意义所在！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注Android）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

for (int i = 1; i <= num; ++i)

{

list.remove();

}

System.out.println(“【已经消费产品数】:” + num + “/t【现仓储量为】:” + list.size());

// 唤醒其他所有线程

full.signalAll();

empty.signalAll();

// 释放锁

lock.unlock();

}

// set/get方法

public int getMAX_SIZE()

{

return MAX_SIZE;

}

public LinkedList getList()

最后

不断奔跑，你就知道学习的意义所在！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注Android）
[外链图片转存中…(img-Ls0yHveb-1713440712698)]

2301_82243769

关注

12
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
Android 面试必备 - 线程，2024年最新三个月没找到工作面试怎么说

我见过很多技术leader在面试的时候，遇到处于迷茫期的大龄程序员，比面试官年龄都大。这些人有一些共同特征：可能工作了7、8年，还是每天重复给业务部门写代码，工作内容的重复性比较高，没有什么技术含量的工作。问到这些人的职业规划时，他们也没有太多想法。其实30岁到40岁是一个人职业发展的黄金阶段，一定要在业务范围内的扩张，技术广度和深度提升上有自己的计划，才有助于在职业发展上有持续的发展路径，而不至于停滞不前。不断奔跑，你就知道学习的意义所在！
复制链接

扫一扫