进程与线程

概述

一个正在运行过程中的程序，就是一个进程，也称一个任务。进程是一个重要的软件资源，是由操作系统内核管理和组织的。

并行：微观上同一个时刻，两个核心上的进程，就是同时进行的。

并发：微观上同一个时刻，一个核心只能运行一个进程，但是它能够对进程进行快速的切换。

在计算机领域，引入进程这个概念，最主要就是为了解决并发编程。对于并发编程，则是因为CPU进入了多核心时代，要想进一步提高程序的执行速度，就要充分利用CPU的核心资源。虽然多进程编程能够解决并发编程的问题，但是进程在创建、销毁以及调度时消耗的资源是比较多的（尤其体现于资源的分配和回收上），因此为了解决该问题，线程这个概念就被提及，线程其实也称为轻量级进程。线程在能解决并发编程问题的前提下，让创建、销毁和调度的速度都提高了不少。对于提高其速度的原因，主要就是因为线程把申请资源和释放资源的操作给省略了。

关系

一个进程可以包含一个线程，也可以包含多个线程，但是不能没有。对于一个进程而言，只有开启第一个线程时消耗的资源较大，后续开启其他线程时消耗的资源都相对较少。主要原因就是后续线程开启时的某些资源都可以复用。

操作系统在实际调度时，是以线程为调度的基本单位。操作系统在资源分配时，则是以进程为资源分配的基本单位。

所以说，对于线程模型来说，天然就是资源共享的，会导致多个线程争抢同一个资源，从而引发一定的安全问题。对于进程模型来说，天然就是资源隔离的，不容易触发问题，只有当进程间进行通信的时候，才会出现多个进程访问同一个资源，从而导致一定的安全问题。

综上所述，对于线程来说，最大的特定就是抢占式执行，随即调度。

在Java中如何进行多线程编程

Java操作多线程，最核心的类是：Thread

简单案例

在使用Thread之前，要明白在Java中，执行main函数时就相当于开启了一个进程，并且main线程属于是主线程。并且，创建线程，是希望线程成为一个独立的执行流去执行一块代码。简单来说，就是创建线程之后，新的线程和main线程是可以并行执行的。

需求：使用非main线程的线程输出一个“shello World！”

class MyThread extends Thread {
    
    @Override
    public void run() {
        System.out.println("hello world！");
    }
    
}

public class SimpleThreadTest {

    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();
    }

}

方法介绍

start方法的工作是创建一个新的线程，新的线程负责执行run方法。本质来说，start方法是调用了操作系统的API，通过操作系统内核去创建新线程的PCB，并且把要执行的指令交给PCB。当PCB调度到CPU上执行的时候，也就执行到了run方法中的代码了。

run方法就是描述了线程要干的活是啥，如果直接在main线程中执行run方法，那么此时并不会创建新线程，而是main线程在干活。

start和run方法的区别是前者是开启线程，后者是描述线程要干的活。

对于一个线程来说，start方法只能执行一次，而且在run方法执行完毕之后，新的线程自然销毁。

 创建多线程的方法

继承Thread类，并重写run方法

class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println("hello csdn！");
    }

}

public class SimpleThreadTest {

    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();
    }

}

实现Runnable接口，并重写run方法

继承Runnable接口就能创建多线程的原因是因为：底层源码中，Thread实现了Runnable接口。

class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("hello world");
    }

}

public class Demo2 {

    public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }

}

使用匿名内部类，继承Thread

    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        };
        thread.start();
    }

使用匿名内部类，实现Runnable

    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        });
        thread.start();
    }

使用Lambda表达式

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("hello world");
        });
        thread.start();
    }

构造方法和常见属性

构造方法

常见属性

• tid（getId）：线程唯一标识。
• 名称（getName）：线程的名称，开发者可以在构造方法或使用set方法设置，如果没有设置，也会默认生成一个名称。
• 状态（getState）：线程的状态（后续会进行详细介绍）。
• 优先级（getPriority）：虽然线程中有优先级这一概念，并且也可以进行设置和获取，但其实设置了也没啥大用，很鸡肋的一个属性。
• 前后台线程（isDaemon）：前台线程会阻止进程结束，假设前台线程任务没有结束，那么进程是结束不了的；在代码中手动创建的线程，默认都是前台线程。后台线程不会阻止进程的结束，即使后台线程任务没有结束，进程也是可以结束的；像其他的JVM自带的线程都是后台的。在Thread的操作中，也可以将线程设置成后台线程，而所谓的后台线程也是守护线程。
• 存活（isAlive）：线程在调用start之前，就处于存活状态；在调用start之后，就处于死亡状态太。

常见方法

获取当前线程的引用：在哪个方法中进行调用，就能获取到哪个线程的实例。

等待一个线程：由于线程是一个随机调度的过程，无法判断哪个线程先调度，哪个线程后调度。等待一个线程的意思就是控制两个线程的顺序。

public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
           for (int i = 0; i < 3; i++) {
               System.out.println("hello thread");
           }
        });
        thread.start();
        System.out.println("join之前");
        thread.join();
        System.out.println("join之后");
        // 本来main线程执行完start之后，main线程和start线程就会分头行动
        // main线程继续向下执行，start线程也继续向下
        // 但是加入join之后，main线程就会发送阻塞
        // 一直阻塞带thread线程结束之后，main线程才会继续向下执行
    }

    /**
     * 简单案例
     * a、b、main线程三个线程
     * 阻塞b线程直到a线程结束之后
     */
    public static void main(String[] args) throws InterruptedException {
        Thread a = new Thread(() -> {
            for(int i = 0; i < 3; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("aaa");
            }
        });
        a.start();

        Thread b = new Thread(() -> {
            try {
                a.join();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("bbb");
        });
        b.start();
    }

休眠当前线程：让线程休眠，也就是让线程不参与调度了（或者说也就是不去CPU上执行了）。

对于操作系统内核来说，当线程A调用sleep时，线程A就会进入休眠状态。此时就会把A放入一个链表中，这个链表当中的PCB，都是处于阻塞状态，暂时都不会去参加CPU的调度。此时，其他可以运行的PCB则处于另一个链表上，处于一种随叫随到的状态，也就是就绪状态。

第一类链表称作阻塞队列，第二类链表则称作就绪队列。在计算机运行过程中，操作系统每次需要调度一个线程去执行，那么就直接从就绪队列中选取一个即可。