Java多线程基础

Posted 2021-01-29

一、简介

1、操作系统

在早起的裸机时代，计算机非常地昂贵，而且也没有操作系统的概念，计算机从头到尾只能执行一个程序。如果程序在执行一个耗时的操作，那么在这个过程中，计算机就有大量的资源闲置在那里，这是非常浪费的。

而这个时候，操作系统的概念被提出了。在操作系统的控制下，一个计算机可以执行很多的程序。计算机的资源由操作系统进行分配，程序之间获得计算机资源并执行各自的任务，相互独立。操作系统的出现使得计算机资源的利用率大大增加。

你也可以将操作系统理解为，运行程序的程序。类比AI是一种产生算法的算法。

2、进程和线程

操作系统可以执行多个程序，每个程序在计算机中即是一个“进程”。进程的执行是并行的，实际上这里的“并行”并不完全是物理意义上的并行。操作系统会给每个进程分配一定的执行时间，并且CPU在这些进程之间快速地切换执行，从而近似地达到了一种并行执行的效果。当然，现代CPU也从早期的单核发展为4核、8核，可以从物理上同时执行。即使是单核，也能够控制多个执行流达到物理上并发的目的。

操作系统使得程序得以并发执行，但随着需求的增加，我们希望每个程序也能够并发多个任务。所以，线程的概念就应运而生了。线程是依赖于进程的，共享进程的计算机资源。一个进程可以拥有一到多个线程。线程的并行执行和进程的理念是一样的，共享进程的时间片，快速地执行切换。

3、Java多线程

Java编程语言为帮助开发者开发多线程的应用程序设计了一套简单的语义，你可以利用Java的内置支持来构建多线程程序，充分利用CPU资源，提高程序的响应速度。

二、Java线程的生命周期

下图，摘录自菜鸟教程：http://www.runoob.com/java/java-multithreading.html

这个图相信大家都很熟悉，它是表达了线程的生命周期，包含了几个状态，如下：

1）创建：当我们在程序中new出来一个线程实例对象的时候，线程便处于创建状态；

2）就绪：当我们调用了start()方法，表示该线程即将等待JVM的native方法去调用我们的线程，也就是就绪状态；

3）运行：如果JVM调用了我们的线程，线程实例执行中，它就处于运行状态；

4）阻塞：运行过程中可能出现sleep、wait或者其它IO操作等，这个时候当前的线程就处于阻塞状态，让出CPU的资源，而不是继续占用。

5）死亡：如果线程正常执行完毕，手动退出或者意外结束，那么线程就进入了死亡状态，该线程占用的资源也会被自动回收。

三、使用示例

Java显示创建线程有两种实现：

1）继承Thread类

public class ThreadDemo extends Thread {

    @Override
    public void run() {
        System.out.println("执行了" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        new ThreadDemo().start();
        System.out.println("主线程执行了" + Thread.currentThread().getName());
    }
    
}

事实上，Thread类实现了Runnable接口，而我们重写了Runnable的run方法，当调用start()方法的时候，该线程会调用native方法，从而JVM会去异步执行线程实例的run方法。

2）实现了Runnable接口

public class RunnableDemo implements Runnable {
    @Override
    public void run() {
        System.out.println("线程执行" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        new Thread(new RunnableDemo()).start();
        System.out.println("主线程执行" + Thread.currentThread().getName());
    }
}

实现Runnable接口的方式，也需要将Runnable作为Thread实例的构造入参，然后通过start()将线程转换为就绪状态。如果你直接调用run方法是不会异步运行的。

以上两种实现，其实都是基于Runnable接口和Thread类，只是写法不同。

四、常用API

1. currentThread()：静态方法，返回当前线程的引用
2. getId()：返回当前线程的标识符
3. getName()：返回当前线程的引用
4. getPriority()：返回当前线程的优先级
5. getState()：返回当前线程的状态
6. interrupt()：中断线程（仅是打上中断标识，无法强制停止线程）
7. interrupted()：静态方法，返回是否中断
8. isAlive()：是否存活
9. isDaemon()：是否守护线程
10. isInterrupted()：是否中断
11. yield()：静态方法，暂停当前线程，执行其它线程
12. start()：使线程进入就绪状态
13. sleep(long millis)：静态方法，使线程休眠
14. setPriority(int priority)：设置优先级，优先级高的会先执行
15. setName()：设置名字
16. setDaemon()：设置为守护线程
17. join()：等待其它线程中止以后再继续执行
18. wait()：等待notify唤醒
19. notify()：唤醒wait线程

yield示例

yield执行的时候暂停当前线程执行，让出CPU资源，去执行其它线程

public class YieldDemo {

    private static volatile boolean isReady = false;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "让主线程执行");
            while (!isReady) {
                Thread.yield();
            }
            System.out.println(Thread.currentThread().getName() + "执行完毕");
        }).start();
        Thread.sleep(5000);
        isReady = true;
        System.out.println(Thread.currentThread().getName() + "执行完毕");
    }
}

join示例

join的作用是让将某个线程插入到当前线程的执行位置，并等待该线程执行完毕以后再执行当前线程。

public class JoinDemo {

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "开始执行");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "执行完毕");
        });
        thread.start();
        System.out.println(Thread.currentThread().getName() + "等待子线程执行完毕");
        thread.join();
        System.out.println(Thread.currentThread().getName() + "执行完毕");
    }
}

notify/wait示例

notify和wait使用比较特殊，需要获得同步锁资源

notify和wait方法是Object对象的方法，任何对象都会有。它的作用是什么呢？我们举一个场景示例：

1）存在两个线程A和B；

2）我们希望A执行完毕以后通知B去执行，而B在A通知之前一直等待

代码示例如下：

public class WaitDemo {

    private static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                // 要先获得同步锁
                synchronized (lock) {
                    try {
                        System.out.println(Thread.currentThread().getName() + " waiting");
                        // 等待notify
                        lock.wait();
                        System.out.println(Thread.currentThread().getName() + " end waiting");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
        System.out.println("sleep");
        Thread.sleep(5000);
        // 要先获得同步锁
        synchronized (lock) {
            System.out.println("notify");
            // 执行notify
            lock.notifyAll();
            System.out.println("finished");
        }
    }
}

这里随意建立了一个lock对象作为锁对象，子线程拿到这个锁以后执行等待。而主线程拿到锁以后，发送通知，执行结果如下：

sleep
Thread-0 waiting
Thread-1 waiting
Thread-2 waiting
notify
finished
Thread-2 end waiting
Thread-1 end waiting
Thread-0 end waiting

注意：如果notifyAll()在wait()之前执行了，那么子线程将无线等待下去，你可以给wait设置超时时间

更多API示例，参考JDK文档：http://tool.oschina.net/uploads/apidocs/jdk-zh/java/lang/Thread.html