多线程入门秘籍

公众号：不颓废的程序员

前言：无论是在工作中还是面试中，多线程都属于非常常见的一个知识，那接下来让我们一起探讨一下多线程的世界吧

一、进程与线程

• 进程是程序的一次执行过程，是系统运行程序的基本单位，进程是动态的，即每次运行一个程序，是一个进程从创建、运行到消亡的过程。

• 线程与进程相似，但线程是比进程更小的运行单位，在一个进程里可以创建多个线程，与进程不同的是，这些线程都拥有各自的程序计数器、虚拟机栈、本地方法栈和局部变量等属性，同类的多个线程可以共享进程的堆和方法区资源，由于各个线程之间可以切换工作，负担要比进程小，所以线程也被称为轻量级进程。

二、并行与并发

• 并行是指同一时刻内发生两个或多个事件，比如：你吃饭吃到一半，电话来了，你一边打电话一边吃饭，这说明你支持并行，并行的关键是你有同时处理多个任务的能力。

• 并发是指同一时间间隔内发生两个或多个事件，比如：你吃饭吃到一半，电话来了，你停了下来接了电话，接完后继续吃饭，这说明你支持并发， 并发的关键是你有处理多个任务的能力，不一定要同时。

三、线程的生命周期

1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
3. 阻塞(BLOCKED)：表示线程阻塞于锁。
4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
5. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
6. 终止(TERMINATED)：表示该线程已经执行完毕。

下面用一幅图大致描述了线程的状态变换

四、线程的三种实现方式

• 继承Thread类，重写run方法
• 实现Runnable接口，重写run方法
• 实现Callable接口，重写call方法，通过FutureTask包装器获取返回值

1、继承Thread类，重写run方法

自定义线程类继承Thread类

重写run()方法，编写线程执行体

创建线程对象，调用start()方法启动线程

public class MyThread extends Thread{

    public MyThread() {}

    //重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(currentThread().getName());
        }
    }

    public static void main(String[] args) {
        //创建线程对象
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        //调用start()方法启动线程
        thread1.start();
        thread2.start();
    }
}

2、实现Runnable接口，重写run方法

定义MyRunnable类实现Runnable接口

实现run()方法，编写线程执行体

创建线程对象，调用start()方法启动线程

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("我在跑步->"+i);
        }
    }

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

        thread.start();
    }
}

3、实现Callable接口，重写call方法

定义MyCallable类实现Callable接口

实现call()方法，编写线程执行体

创建FutureTask对象，并将Callable对象传入FutureTask的构造方法中

创建线程对象，调用start()方法启动线程

获取到执行结果

public class MyCallable implements Callable {
    
    //实现call()方法，编写线程执行体
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            System.out.println("我在计数->"+i);
            sum += i;
        }
        return sum;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建一个实现了Callable接口的类的实例对象
        MyCallable callable = new MyCallable();
        //创建FutureTask对象，并将Callable对象传入FutureTask的构造方法中
        FutureTask task = new FutureTask<Integer>(callable);
        //实例化Thread对象，并在构造方法中传入FurureTask对象，启动线程, 执行任务
        new Thread(task).start();
        //得到call()方法的执行结果
        Object result = task.get();
        //打印结果为:5050
        System.out.println(result);
    }
}

五、线程中需要注意的几个点

1、wait()和sleep()方法的区别

2、 run()和start()方法的区别

run()：仅仅是封装被线程执行的代码，直接调用的是普通方法。 如果直接调用Run方法，程序中依然只有主线 程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到多线程的目的 。

start()：而执行start()方法，首先是先启动了线程，然后再由jvm去调用该线程的run()方法 。通过调用Thread类的 start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法 run()称为线程体，它包含了要执行的这个线程的内容，run()方法运行结束，此线程随即终止 ，这样就达到了多线程的目的。

3、守护线程

守护线程是为其他线程服务的线程（比如垃圾回收线程就是守护线程），如果其他的线程（即用户自定义线程）都执行完毕，连main线程也执行完毕，那么jvm就会退出（即停止运行）,此时，连jvm都停止运行了，守护线程当然也就停止执行了 。

我们可以在线程启动之前，设置该线程为守护线程，方法是setDaemon(boolean on)

4、线程的优先级

在源码中我们可以看到 Java提供的优先级默认是5，最低是1，最高是10

/**
 * 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;

也可以看到设置线程优先级的方法，我们可以使用setPriority(int newPriority)来给线程设置优先级

public final void setPriority(int newPriority) {
    ThreadGroup g;
    checkAccess();
    if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
        throw new IllegalArgumentException();
    }
    if((g = getThreadGroup()) != null) {
        if (newPriority > g.getMaxPriority()) {
            newPriority = g.getMaxPriority();
        }
        setPriority0(priority = newPriority);
    }
}

六、总结

一般我们很少使用直接继承Thread类的方法去实现多线程， 因为这样会有java中的单继承的限制 ，所以一般我们是使用最多的是实现Runnable接口 ，如果需要返回执行结果的，那就选择实现Callable接口这种方式。