进程与线程

概念

进程和线程做为必知必会的知识，想来读者们也都是耳熟能详了，但真的是这样嘛？今天咱们就来从新捋一捋，看看有没有什么知识点欠缺的。java

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

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

正好里面有个奇形怪状的App，咱们就拿爱优腾中的爱举例。编程

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

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

你是否看到爱奇艺中的数据加载上并非一次性的，这些任务的进行就是依靠咱们的线程来进行执行的，你能够把这样的一个个数据加载过程认为是一条条线程。bash

生命周期

不论是进程仍是线程，生和死是他们必然要去经历的过程。markdown

进程	线程

你能看到进程中少了两个状态，也就是他的出生和他的死亡，不过这是一样是为了方便咱们去进行记忆。 进程因建立而产生，因调度而执行，因得不到资源而阻塞，因得不到资源而阻塞，因撤销而消亡。 图中表明的4个值：多线程

获得CPU的时间片 / 调度。
时间片用完，等待下一个时间片。
等待 I/O 操做 / 等待事件发生。
I/O操做结束 / 事件完成。

而对于线程，他在Java的Thread类中对应了6种状态，能够自行进行查看。并发

多线程编程入门

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

废话很少说，咱们赶忙入门一下。

// 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）
       （存在线程争夺）         （自旋必定次数仍是拿不到锁）
复制代码

三种加锁对象：

实例方法
静态方法
代码块

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){

        }
    }
}
复制代码

线程池

让咱们先来正题感觉一下线程池的工做流程

五大参数

任务队列（workQueue）
核心线程数（coolPoolSize）： 即便处于空闲状态，也会被保留下来的线程
最大线程数（maximumPoolSize）： 核心线程数 + 非核心线程数。控制能够建立的线程的数量。
饱和策略（RejectedExecutionHandler）
存活时间（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吗？若是建立了，那回收又要花多久的时间？

控制线程的并发数

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

线程的管理

协程

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个参数CoroutineContext、CoroutineStart、block。

CoroutineContext：
- Dispatchers.Default - 默认
- Dispatchers.IO - 适用于IO操做的线程
- Dispatchers.Main - 主线程
- Dispatchers.Unconfined - 没指定，就是在当前线程
CoroutineStart：
- DEAFAULT - 默认模式
- ATOMIC - 这种模式下协程执行以前不能被取消
- UNDISPATCHED - 当即在当前线程执行协程体，遇到第一个suspend函数调用
- LAZY - 懒加载模式，须要的时候开启
block： 写一些你要用的方法。

// 固然还有async、runBlocking等用法
GlobalScope.launch(Dispatchers.Default,
            CoroutineStart.ATOMIC,
            { Log.e("Main", "run") }
        )
复制代码

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

关于多线程，你必须知道的那些玩意儿