并发编程-02 多线程与线程池底层原理

一、进程基础知识

1.1 线程与进程

1.1.1 进程

• 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的 。
  当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
• 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器 等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等）。
• 操作系统会以进程为单位，分配系统资源（CPU时间片、内存等资源），进程是资源分配的最小单位。

1.1.2 线程

• 线程是进程中的实体，一个进程可以拥有多个线程，一个线程必须有一个父进程。
• 一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行。
• 线程，有时被称为轻量级进程(Lightweight Process，LWP），是操作系统调度（CPU调度）执行的最小单位。

1.1.3 线程与进程的区别

• 进程基本上相互独立的，而线程存在于进程内，是进程的一个子集
• 进程拥有共享的资源，如内存空间等，供其内部的线程共享
• 进程间通信较为复杂

同一台计算机的进程通信称为 IPC（Inter-process communication）
不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，例如 HTTP

• 线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量
• 线程更轻量，线程上下文切换成本一般上要比进程上下文切换低

1.1.4 进程间通信方式

• 管道（pipe）及有名管道（named pipe）：管道可用于具有亲缘关系的父子进程间的通信，有名管道除了具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。
• 信号（signal）：信号是在软件层次上对中断机制的一种模拟，它是比较复杂的通信方式，用于通知进程有某事件发生，一个进程收到一个信号与处理器收到一个中断请求效果上可以说是一致的。
• 消息队列（message queue）：消息队列是消息的链接表，它克服了上两种通信方式中信号量有限的缺点，具有写权限得进程可以按照一定得规则向消息队列中添加新信息；对消息队列有读权限得进程则可以从消息队列中读取信息。
• 共享内存（shared memory）：可以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间，不同进程可以及时看到对方进程中对共享内存中数据得更新。这种方式需要依靠某种同步操作，如互斥锁和信号量等。
• 信号量（semaphore）：主要作为进程之间及同一种进程的不同线程之间得同步和互斥手段。
• 套接字（socket）：这是一种更为一般得进程间通信机制，它可用于网络中不同机器之间的进程间通信，应用非常广泛。

1.2 线程的同步互斥

• 线程同步是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。
• 线程互斥是指对于共享的进程系统资源，在各单个线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。线程互斥可以看成是一种特殊的线程同步。

1.3 上下文切换(Context switch)

上下文切换是指CPU(中央处理单元)从一个进程或线程到另一个进程或线程的切换。

1、暂停一个进程的处理，并将该进程的CPU状态(即上下文)存储在内存中的某个地方
2、从内存中获取下一个进程的上下文，并在CPU的寄存器中恢复它
3、返回到程序计数器指示的位置(即返回到进程被中断的代码行)以恢复进程。

• 上下文切换只能在内核模式下发生。内核模式是CPU的特权模式，其中只有内核运行，并提供对所有内存位置和所有其他系统资源的访问。其他程序(包括应用程序)最初在用户模式下运行，但它们可以通过系统调用运行部分内核代码。

应用程序一般会在以下几种情况下切换到内核模式：
1． 系统调用。
2． 异常事件。当发生某些预先不可知的异常时，就会切换到内核态，以执行相关的异常事件。
3． 设备中断。在使用外围设备时，如外围设备完成了用户请求，就会向CPU发送一个中断信号，此时，CPU就会暂停执行原本的下一条指令，转去处理中断事件。此时，如果原来在用户态，则自然就会切换到内核态。

• 上下文切换是多任务操作系统的一个基本特性。在多任务操作系统中，多个进程似乎同时在一个CPU上执行，彼此之间互不干扰。这种并发的错觉是通过快速连续发生的上下文切换(每秒数十次或数百次)来实现的。这些上下文切换发生的原因是进程自愿放弃它们在CPU中的时间，或者是调度器在进程耗尽其CPU时间片时进行切换的结果。
• 上下文切换通常是计算密集型的。就CPU时间而言，上下文切换对系统来说是一个巨大的成本，实际上，它可能是操作系统上成本最高的操作。因此，操作系统设计中的一个主要焦点是尽可能地避免不必要的上下文切换。

1.4 操作系统层面线程生命周期

• 初始状态，指的是线程已经被创建，但是还不允许分配 CPU 执行。这个状态属于编程语言特有的，不过这里所谓的被创建，仅仅是在编程语言层面被创建，而在操作系统层面，真正的线程还没有创建。(new Thread)
• 可运行状态，指的是线程可以分配 CPU 执行。在这种状态下，真正的操作系统线程已经被成功创建了，所以可以分配 CPU 执行。
  当有空闲的 CPU 时，操作系统会将其分配给一个处于可运行状态的线程，被分配到 CPU 的线程的状态就转换成了运行状态。
  运行状态的线程如果调用一个阻塞的 API（例如以阻塞方式读文件）或者等待某个事件（例如条件变量），那么线程的状态就会转换到休眠状态，同时释放 CPU 使用权，休眠状态的线程永远没有机会获得 CPU 使用权。当等待的事件出现了，线程就会从休眠状态转换到可运行状态。
  线程执行完或者出现异常就会进入终止状态，终止状态的线程不会切换到其他任何状态，进入终止状态也就意味着线程的生命周期结束了

二、Java线程详解

2.1 Java线程实现方式

实际下面多种创建线程的方式，都是通过new Thread().start()创建线程，并通过执行#start() -> run()

public class ThreadCreateTest {
    public static void main(String[] args) {
        //创建线程方式一 使用或继承Thread
        Thread thread1 = new Thread(){
            @Override
            public void run() {
                System.out.println("直接创建线程1");
            }
        };
        thread1.start();

        //创建线程方式二 实现Runnable() (Public class Thread implements Runnable{})
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("创建");
            }
        };
        Thread thread2 = new Thread(runnable);
        thread2.start();

        //创建线程方式三 使用有返回值的Callable
        ExecutorService service = Executors.newFixedThreadPool(10);
        Future<Object> submit = service.submit(new CallableTest());

        //方式四 匿名的创建线程和运行
        new Thread(() -> System.out.println(Thread.currentThread().getName())).start();
    }
    
    static class CallableTest implements Callable<Object> {
        @Override
        public Object call() throws Exception {
            return null;
        }
    }
}

Callable与Thread的Runnable区别：

• Callable#call()会抛出异常throws Exception，而Runnable#run()不会抛出异常
• Callable#call()传入V类型入参，则返回V中类型的值。Runnable#run()返回void

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

2.2 Java线程实现原理

start()源码分析

start()方法源码脑图

Java线程属于内核级线程(java线程重的原因)

• Java创建线程后调用start()，JVM会调用JVM_StartThread，调用内核的API,os::create_thread(this,thr_type,stack_sz)真正的操作系统创建线程。
• native_thread -> prepare(jthread) 本地线程与os线程深度绑定。
• 用户程序的调用 —> 内核态多线程调用
• run()方法 —> os::start_thread()
• 归根结底Java线程不是用户级线程，而是内核级线程。

线程创建和启动的流程总结：
1）使用new Thread()创建一个线程，然后调用start()方法进行java层面的线程启动；
2）调用本地方法start0()，去调用jvm中的JVM_StartThread方法进行线程创建和启动；
3）调用new JavaThread(&thread_entry, sz)进行线程的创建，并根据不同的操作系统平台调用对应的os::create_thread方法进行线程创建；
4）新创建的线程状态为Initialized，调用了sync->wait()的方法进行等待，等到被唤醒才继续执行thread->run();
5）调用Thread::start(native_thread);方法进行线程启动，此时将线程状态设置为RUNNABLE，接着调用os::start_thread(thread)，根据不同的操作系统选择不同的线程启动方式；
6）线程启动之后状态设置为RUNNABLE, 并唤醒第4步中等待的线程，接着执行thread->run()的方法；
7）JavaThread::run()方法会回调第1步new Thread中复写的run()方法。

协程概念

协程，英文Coroutines, 是一种基于线程之上，但又比线程更加轻量级的存在，协程不是被操作系统内核所管理，而完全是由程序所控制（也就是在用户态执行），有对内核不可见的特性。
Go语言中，有协程的存在(用户级线程或轻量级线程)。不在内核态下就能完成一些用户请求处理的操作，对Java来说更适合处理用户请求。
协程的特点在于一个线程执行，和多线程相比，优势？

• 线程的切换由操作系统调度，协程由用户自己进行调度，因此减少了上下文切换，提高了效率。
• 线程的默认stack大小是1M，而协程更轻量，接近1k。因此可以在相同的内存中开启更多的协程。
• 不需要多线程的锁机制：因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。
• 协程适用于被阻塞的，且需要大量并发的场景（网络io）。不适合大量计算的场景。

2.3 Java线程调度机制

Java线程调度属于抢占式调度
尽管java在线程中，默认存在低、中、高三种的线程优先级，但实际使用时，并不会非常明显。即使低优先级的线程也可能在高优先级前执行。

    /**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

2.4 Java线程生命周期

Java中Thread的状态枚举值如下:

    public enum State {
        /**
         * Thread state for a thread which has not yet started.
         * Java层面new普通对象，并未调用start() -> jvm尚未调用os:pthread
         */
        NEW,

        /**
         * Thread state for a runnable thread. 
         * 可运行状态的线程(Jvm已完成创建可使用，可以在等CPU时间片)
         * runbale实际包含两种状态：Ready、running  
         * Ready表示时间片用完，等待时间片运行
         * running表示正在运行
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * 线程已经被synchronized阻塞(竞争锁对象但没有争抢到，状态只针对synchronized阻塞)
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * LockSupport.park、Thread.join、Object.wait 无时间限制的等待
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * Thread.sleep(times)、Object.wait(times)、Thread.join(long)、LockSupport.parkNanos(times) 有时间限制的等待
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * 线程被终止了
         */
        TERMINATED;
    }

2.5 Thread常用方法

sleep方法

• 调用sleep会让当前线程从 Running 进入TIMED_WAITING状态，不会释放对象锁
• 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException，并且会清除中断标志
• 睡眠结束后的线程未必会立刻得到执行
• sleep当传入参数为0时，和yield相同

yield方法

• yield会释放CPU资源，让当前线程从 Running 进入 Runnable状态，让优先级更高（至少是相同）的线程获得执行机会，不会释放对象锁；
• 假设当前进程只有main线程，当调用yield之后，main线程会继续运行，因为没有比它优先级更高的线程；
• 具体的实现依赖于操作系统的任务调度器

join方法

• 等待调用join方法的线程结束之后，程序再继续执行，一般用于等待异步线程执行完结果之后才能继续运行的场景。

stop方法

• stop()方法已经被jdk废弃，原因就是stop()方法太过于暴力，强行把执行到一半的线程终止。

2.7 Java线程的中断机制(优雅中断)

API的使用
interrupt()： 将线程的中断标志位设置为true，不会停止线程
isInterrupted(): 判断当前线程的中断标志位是否为true，不会清除中断标志位
Thread.interrupted()：判断当前线程的中断标志位是否为true，并清除中断标志位，重置为fasle

优雅中断前完成前面的逻辑代码

while (!Thread.currentThread().isInterrupted() && more work to do) {
    do more work

2.8 Java线程间通信方式

LockSupport是JDK中用来实现线程阻塞和唤醒的工具，线程调用park则等待“许可”，调用unpark则为指定线程提供“许可”

public class LockSupportTest {

    public static void main(String[] args) {
        Thread parkThread = new Thread(new ParkThread());
        parkThread.start();

        System.out.println("唤醒parkThread");
        LockSupport.unpark(parkThread);
    }

    static class ParkThread implements Runnable {

        @Override
        public void run() {
            System.out.println("ParkThread开始执行");
            LockSupport.park();
            System.out.println("ParkThread执行完成");
        }
    }
}

三、Java原生线程池底层原理

3.1 Executor组织结构

拒绝策略

submit() 和 execute()的区别

• submit()实现了execute()方法
• void execute() 和 Future submit() 返回值不同

线程池和多线程的核心区别：
线程池的run()方法最终是通过Worker.run()方法。

3.2 原生线程池

3.2.1 newCachedThreadPool()

参数定义：

• corePoolSize: 0 (无核心线程)
• maximumPoolSize:max (需要的话可以创建2^32-1个线程)[无休止的创建线程会导致OOM和CPU100%]
• keepAliveTime ：60L(非核心线程的闲置时间)
• TimeUnit unit：秒(时间级别)
• BlockingQueue workQueue：new SynchronousQueue<>()[同步队列器，只能]

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
    //同步队列器
    public SynchronousQueue(boolean fair) {
        transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
    }

3.2.2 newFixedThreadPool()

参数定义：

• corePoolSize: 用户指定n
• maximumPoolSize:用户指定n
• keepAliveTime ：0
• TimeUnit unit：毫秒(时间级别)
• BlockingQueue workQueue：new LinkedBlockingQueue()[队列长度可以2^32-1]

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
    //阻塞队列
    public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }
    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null);
    }

3.2.3 newSingleThreadExecutor()

参数同上(核心线程数为1)

        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

四、自定义线程池

4.1 自行指定线程的参数

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20,
            0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(10));//自定义线程

4.2 线程池核心执行流程

最后

以上就是呆萌吐司为你收集整理的并发编程-02 多线程与线程池底层原理的全部内容，希望文章能够帮你解决并发编程-02 多线程与线程池底层原理所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。