专栏首页Android技术分享【Android面试】关于多线程,你必须知道的那些玩意儿
原创

【Android面试】关于多线程,你必须知道的那些玩意儿

进程与线程

概念

进程和线程作为必知必会的知识,想来读者们也都是耳熟能详了,但真的是这样嘛?今天我们就来重新捋一捋,看看有没有什么知识点欠缺的。

先来一张我随手截的活动监视器的图,分清一下什么叫做进程,什么叫做线程。

想来很多面试官会问,你对进程和线程的理解是什么,他们有什么样的区别呢?其实不用死记硬背,记住上面的图就OK了。

正好里面有个奇形怪状的App,我们就拿爱优腾中的爱举例。

先来插个题外话,今天突然看到爱奇艺给我的推送,推出了新的会员机制 —— 星钻VIP会员,超前点播、支持 五台 设备在线、。。我预计之后可能还会推出新的VIP等级会员,那我先给他安排一下名字,你看星钻是不是星耀+钻石,那下一个等级我们就叫做耀王VIP会员(荣耀王者)。哇!!太赞了把,爱奇艺运营商过来打钱。🙄🙄🙄🙄,作为爱奇艺的老黄金VIP用户了,女朋友用一下,分享给室友用一下,我自己要么没得看到了,要么只能夜深人静的时候,🤔🤔🤔🤔,点到为止好吧,轮到你发挥无限的想象力了。。

收!!回到我们的正题,我们不是讲到了进程和线程嘛,那进程是什么,显而易见嘛这不是,上面已经写了一个 进程名称 了,那显然就是爱奇艺这整一只庞然大物嘛。 那线程呢?

你是否看到爱奇艺中的数据加载上并不是一次性的,这些任务的进行就是依靠我们的线程来进行执行的,你可以把这样的一个个数据加载过程认为是一条条线程。

生命周期

不管是进程还是线程,生和死是他们必然要去经历的过程。

进程

线程

你能看到进程中少了两个状态,也就是他的出生和他的死亡,不过这是同样是为了方便我们去进行记忆。 进程因创建而产生,因调度而执行,因得不到资源而阻塞,因得不到资源而阻塞,因撤销而消亡。 图中代表的4个值:

  1. 得到CPU的时间片 / 调度。
  2. 时间片用完,等待下一个时间片。
  3. 等待 I/O 操作 / 等待事件发生。
  4. I/O操作结束 / 事件完成。

而对于线程,他在JavaThread类中对应了6种状态,可以自行进行查看。

多线程编程入门

多线程编程就好像我们这样生活,周末我呆在家里边烧开水,边让洗衣机洗衣服,边炒菜,一秒钟干三件事,你是不是也有点心动呢?

废话不多说,我们赶紧入门一下。

// 1
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("this is a Runnable");
    }
}
// 2
public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("this is thread");
    }
}

// 具体使用
public class Main {
    public static void main(String[] args) {
        // 第一种
        Thread thread1 = new Thread(new MyRunnable());
        thread1.start();
        // 第二种
        MyThread thread2 = new MyThread();
        thread2.start();
    }
}

一般来说推荐第一种写法,也就是重写Runnable了。不过这样的玩意儿存在他全是好事嘛???显然作为高手的你们肯定知道他有问题存在了。我们以一段代码为例。

public class Main {
    public int i = 0;
    public void increase(){
        I++;
    }

    public static void main(String[] args) {
        final Main main = new Main();
        for(int i=0; i< 10; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int j=0; j<1000; j++){
                        main.increase();
                    }
                }
            }).start();
        }
        while(Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println(main.i);
    }
}

这样的一段程序,你觉得最后跑出来的数据是什么?他会是10000嘛?

以答案作为标准,显然不是,他甚至说可能下次跑出来也不是我给你的这个数值,但是这是为什么呢?这就牵扯到我们的线程同步问题了。

线程同步

一般情况下,我们可以通过三种方式来实现。

  • Synchronized
  • Lock
  • Volatile

在操作系统中,有这么一个概念,叫做临界区。其实就是同一时间只能允许存在一个任务访问的代码区间。代码模版如下:

Lock lock = new ReentrantLock();
public void lockModel(){
    lock.lock();
    // 用于书写共同代码,比如说卖同一辆动车的车票等等。
    lock.unlock();
}

// 上述模版近似等价于下面的函数
public synchronized void lockModel(){}

其实这就是大家常说的锁机制,通过加解锁的方法,来保证数据的正确性。

但是锁的开销还是我们需要考虑的范畴,在不太必要时,我们更频繁的会使用是volatile关键词来修饰变量,来保证数据的准确性。

对上述的共享变量内存而言,如果线程A和B之间要通信,则必须先更新主内存中的共享变量,然后由另外一个线程去主内存中去读取。但是普通变量一般是不可见的。而volatile关键词就将这件事情变成了可能。

打个比方,共享变量如果使用了volatile关键词,这个时候线程B改变了共享变量副本,线程A就能够感知到,然后经历上述的通信步骤。

这个时候就保障了可见性。

但是另外两种特性,也就是有序性和原子性中,原子性是无法保障的。拿我们最开始的Main的类做例子,就只改变一个变量。

public volatile int i = 0;

他最后的数值终究不是10000,这是为什么呢?其实对代码进行反编译,你能够注意到这样的一个问题。

iconst_0  //把数值0 push到操作数栈
istore_1 // 把操作数栈写回到本地变量第2个位置
iinc 1,1  // 把本地变量表第2个位置加1     
iload_1 // 把本地变量第2个位置的值push到操作数栈
istore_1 // 把操作数据栈写回本地变量第2个位置

一个++i的操作被反编译后出现的结果如上,给人的感觉是啥,你还会觉得它是原子操作吗?

Synchronized

这个章节的最后来简单介绍一下synchronized这个老大哥,他从过去的版本被优化后性能高幅度提高。

在他的内部结构依旧和我们Lock类似,但是存在了这样的三种锁。

偏向锁   --------->   轻量锁(栈帧)   --------->   重量锁(Monitor)
       (存在线程争夺)         (自旋一定次数还是拿不到锁)

三种加锁对象:

  1. 实例方法
  2. 静态方法
  3. 代码块
public class SyncDemo {
    // 对同一个实例加锁
    private synchronized void fun(){}
    // 对同一个类加锁
    private synchronized static void fun_static(){}
    // 视情况而定
    // 1\. this:实例加锁
    // 2\. SyncDemo.class:类加锁
    private void fun_inner(){
        synchronized(this){

        }
        synchronized(SyncDemo.class){

        }
    }
}

线程池

让我们先来正题感受一下线程池的工作流程

五大参数

  1. 任务队列(workQueue)
  2. 核心线程数(coolPoolSize): 即使处于空闲状态,也会被保留下来的线程
  3. 最大线程数(maximumPoolSize): 核心线程数 + 非核心线程数。控制可以创建的线程的数量。
  4. 饱和策略(RejectedExecutionHandler)
  5. 存活时间(keepAliveTime): 设定非核心线程空闲下来后将被销毁的时间

任务队列

  • 基于数组的有界阻塞队列(ArrayBlockingQueue): 放入的任务有限,到达上限时会触发拒绝策略。
  • 基于链表的无界阻塞队列(LinkedBlockingQuene): 可以放入无限多的任务。
  • 不缓存的队列(SynchronousQuene): 一次只能进行一个任务的生产和消费。
  • 带优先级的阻塞队列(PriorityBlockingQueue): 可以设置任务的优先级。
  • 带时延的任务队列(DelayedWorkQueue)

饱和策略

  • CallerRunsPolicy
public static class CallerRunsPolicy implements RejectedExecutionHandler {
        // 如果线程池还没关闭,就在调用者线程中直接执行Runnable
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }
  • AbortPolicy
public static class AbortPolicy implements RejectedExecutionHandler {
        // 拒绝任务,并且抛出RejectedExecutionException异常
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }
  • DiscardPolicy
 public static class DiscardPolicy implements RejectedExecutionHandler {
        // 拒绝任务,但是啥也不干
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }
  • DiscardOldestPolicy
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        // 如果线程池还没有关闭,就把队列中最早的任务抛弃,把当前的线程插入
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }

五种线程池

FixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

固定线程池 , 最大线程数和核心线程数的数量相同,也就意味着只有核心线程了,多出的任务,将会被放置到LinkedBlockingQueue中。

CachedThreadPool

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}

没有核心线程,最大线程数为无穷,适用于频繁IO的操作,因为他们的任务量小,但是任务基数非常庞大,使用核心线程处理的话,数量创建方面就很成问题。

ScheduledThreadPool

public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory) {
        // 最后对应的还是 ThreadPoolExecutor                                   
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), threadFactory);
}

SingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
}

核心线程数和最大线程数相同,且都为1,也就意味着任务是按序工作的。

WorkStealingPool

public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(), // 可用的处理器数
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

这是JDK1.8以后才加入的线程池,引入了抢占式,虽然这个概念挺早就有了。本质上就是如果当前有两个核在工作,一个核的任务已经处理完成,而另一个还有大量工作积压,那我们的这个空闲核就会赶紧冲过去帮忙。

优势

  • 线程的复用

每次使用线程我们是不是需要去创建一个Thread,然后start(),然后就等结果,最后的销毁就等着垃圾回收机制来了。 但是问题是如果有1000个任务呢,你要创建1000个Thread吗?如果创建了,那回收又要花多久的时间?

  • 控制线程的并发数

存在核心线程和非核心线程,还有任务队列,那么就可以保证资源的使用和争夺是处于一个可控的状态的。

  • 线程的管理

【Android进阶学习视频】、【全套Android面试秘籍】关注我【主页简介】查看免费领取方式!

协程

Q1:什么是协程? 一种比线程更加轻量级的存在,和进程还有线程不同的地方时他的掌权者不再是操作系统,而是程序了。但是你要注意,协程不像线程,线程最后会被CPU进行操作,但是协程是一种粒度更小的函数,我们可以对其进行控制,他的开始和暂停操作我们可以认为是C中的goto

我们通过引入Kotlin的第三方库来完成一些使用上的讲解。

implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.2.1"

引入完成后我们以launch()为例来讲解。

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
)

你可以看到3个参数CoroutineContextCoroutineStartblock

  1. CoroutineContext:
    • Dispatchers.Default - 默认
    • Dispatchers.IO - 适用于IO操作的线程
    • Dispatchers.Main - 主线程
    • Dispatchers.Unconfined - 没指定,就是在当前线程
  2. CoroutineStart:
    • DEAFAULT - 默认模式
    • ATOMIC - 这种模式下协程执行之前不能被取消
    • UNDISPATCHED - 立即在当前线程执行协程体,遇到第一个suspend函数调用
    • LAZY - 懒加载模式,需要的时候开启
  3. block: 写一些你要用的方法。
// 当然还有async、runBlocking等用法
GlobalScope.launch(Dispatchers.Default,
            CoroutineStart.ATOMIC,
            { Log.e("Main", "run") }
        )

Q2:他的优势是什么? 其实我们从Q1中已经进行过了回答,协程的掌权者是程序,那我们就不会再有经过用户态到内核态的切换,节省了很多的系统开销。同时我们说过他用的是类似于goto跳转方式,就类似于将我们的堆栈空间拆分,这就是我所说的更小粒度的函数,假如我们有3个协程ABC在运行,放在主函数中时假如是这样的压栈顺序,ABC。那从C想要返回A时势必要经过B,而协程我们可以直接去运行A,这就是协程所带来的好处。

原创声明,本文系作者授权云+社区发表,未经许可,不得转载。

如有侵权,请联系 yunjia_community@tencent.com 删除。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Android高级面试题之SDK源码分析:通过线程提升性能

    善于在 Android 上利用线程可以帮助您提升应用的性能。本页从以下几个方面讨论线程的使用:使用界面线程(即主线程);应用生命周期与线程优先级之间的关系;以及...

    Android技术干货分享
  • JAVA\Android 多线程实现方式及并发与同步

    说到线程,就不得不先说线程和进程的关系,这里先简单解释一下,进程是系统的执行单位,一般一个应用程序即是一个进程,程序启动时系统默认有一个主线程,即是UI线程,我...

    Android技术干货分享
  • Android性能优化之启动加速35%

    随着项目版本的迭代,App的性能问题会逐渐暴露出来,而好的用户体验与性能表现紧密相关,从本篇文章开始,我将开启一个Android应用性能优化的专题,从理论到实战...

    Android技术干货分享
  • java 线程 Thread 使用介绍,包含wait(),notifyAll() 等函数使用介绍

    (原创,转载请说明出处!谢谢--https://cloud.tencent.com/developer/user/1148436/activities)  此文...

    林冠宏-指尖下的幽灵
  • 关于多线程,你必须知道的那些玩意儿

    进程和线程作为必知必会的知识,想来读者们也都是耳熟能详了,但真的是这样嘛?今天我们就来重新捋一捋,看看有没有什么知识点欠缺的。

    字节流动
  • java基础thread——多线程的纷争(循序渐进)

    正在运行的程序,是系统进行资源分配和调用的独立单位。 每一个进程都有它自己的内存空间和系统资源。

    100000860378
  • 深入理解多线程

    多线程是java中比较重要的一部分内容,使用多线程有许多的优点: - 提高应用程序的响应。对图形化界面更有意义,可增强用户体验。 - 程序需要实现一些需...

    栋先生
  • BATJ面试必会之并发篇

    调用 Thread.sleep() 方法使线程进入限期等待状态时,常常用“使一个线程睡眠”进行描述。

    乔戈里
  • 深读 JDK 源码丨Java Thread

    线程是系统资源分配的最小单位,它被包含在进程之中,是进程中的实际运作单位。JVM 允许应用程序同时运行、执行多个线程,每个线程都有优先权,具有较高优先级的线程优...

    码脑
  • 详解Hystrix资源隔离

    在货船中,为了防止漏水和火灾的扩散,一般会将货仓进行分割,避免了一个货仓出事导致整艘船沉没的悲剧。同样的,在Hystrix中,也采用了这样的舱壁模式,将系统中的...

    aoho求索

扫码关注云+社区

领取腾讯云代金券