美文网首页
Java线程基础

Java线程基础

作者: 谭嘉俊 | 来源:发表于2020-08-31 02:32 被阅读0次

    本文章已授权微信公众号郭霖（guolin_blog）转载。

    本文章讲解的内容是Java线程，建议对着示例项目阅读文章，示例项目链接如下：

    ThreadDemo

    本文章分析的相关的源码基于Java Development Kit（JDK） 13。

    概述

    在说线程的概念之前，先说下进程的概念，进程是代码在数据集合上的一次运行活动，它是系统进行资源分配和调度的基本单位。一个进程至少有一个线程，线程是进程中的实体，线程本身是不会独立存在的，进程中的多个线程可以共享进程的资源（例如：内存地址、文件I/O等），也可以独立调度。

    有以下三种方式实现线程：

    • 使用内核线程实现
    • 使用用户线程实现
    • 使用用户线程和轻量级线程混合实现

    Java语言统一处理了不同硬件和操作系统平台的线程操作，一个线程是一个已经执行start()方法而且还没结束的java.lang.Thread类的实例，其中Thread类的所有关键方法都是本地方法（Native Method）来的，这意味着这些方法没有使用或者无法使用平台相关的手段来实现。

    线程状态切换

    Java语言定义了六种线程状态，要注意的是，在任意一个时间点，一个线程有且只有五种线程状态的其中一种，这五种线程状态如下所示：

    • 新建（New）：线程创建后尚未启动的状态。
    • 运行（Runable）：线程正在等待着CPU为它分配执行时间，进入就绪（Ready）状态，等到CPU分配执行时间后，线程才真正执行，进入正在运行（Running）状态。
    • 无限期等待（Waiting）：这种状态下的线程不会被CPU分配执行时间，它们需要其他线程显示地唤醒。以下方法会让线程进入这种状态：
      • 没有设置参数Timeout的Object.wait()方法
      • 没有设置参数Timeout的Thread.join()方法
      • LockSupport.park方法
    • 限期等待（Timed Waiting）：这种状态下的线程不会被CPU分配执行时间，但是它无需其他线程显示地唤醒，会在一定时间内由系统自动唤醒。以下方法会让线程进入这种状态：
      • Thread.sleep()方法
      • 有设置参数Timeout的Object.wait()方法
      • 有设置参数Timeout的Thread.join()方法
      • LockSupport.parkNanos()方法
      • LockSupport.parkUntil()方法
    • 阻塞（Block）：线程被阻塞的状态，在等待着一个排他锁。
    • 结束（Terminated）：线程已终止，并且已经结束执行的状态。

    线程创建和运行

    Java语言提供了三种创建线程的方式，如下所示：

    继承Thead类并且重写run方法

    代码如下所示：

    /**
 * Created by TanJiaJun on 2020/8/30.
 */
class TanJiaJunThreadTest {

    private static class TanJiaJunThread extends Thread {

        @Override
        public void run() {
            super.run();
            System.out.println("谭嘉俊");
        }

    }

    public static void main(String[] args) {
        // 创建线程
        TanJiaJunThread thread = new TanJiaJunThread();
        // 启动线程
        thread.start();
    }

}

    这种方式的优点是在run方法内可以使用this获取当前线程，无须使用Thread.currentThread方法；缺点是因为Java的类只能继承一个类，所以继承Thread类之后，就不能继承其他类了，而且因为任务和代码没有分离，如果多个线程执行相同的任务时，需要多份任务代码。

    要注意的是，调用了start方法后，线程正在等待着CPU为它分配执行时间，进入就绪（Ready）状态，等到CPU分配执行时间后，线程才真正执行，进入正在运行（Running）状态。

    实现Runnable接口的run方法

    代码如下所示：

    /**
 * Created by TanJiaJun on 2020/8/30.
 */
class TanJiaJunRunnableTest {

    private static class TanJiaJunRunnable implements Runnable {

        @Override
        public void run() {
            System.out.println("谭嘉俊");
        }

    }

    public static void main(String[] args) {
        // 创建TanJiaJunRunnable对象
        TanJiaJunRunnable runnable = new TanJiaJunRunnable();
        // 创建线程
        Thread thread = new Thread(runnable);
        // 启动线程
        thread.start();
    }

}

    这种方式的优点是因为Java的类可以实现多个接口，所以这个类就可以继承自己需要的类了，而且任务和代码分离，如果多个线程执行相同的任务时，可以公用同一个任务的代码，如果需要对它们区分，可以添加参数进行区分。

    使用FutureTask类

    代码如下所示：

    import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * Created by TanJiaJun on 2020/8/30.
 */
class TanJiaJunFutureTaskTest {

    private static class TanJiaJunCallable implements Callable<String> {

        @Override
        public String call() {
            return "谭嘉俊";
        }

    }

    public static void main(String[] args) {
        // 创建FutureTask对象
        FutureTask<String> futureTask = new FutureTask<>(new TanJiaJunCallable());
        // 创建线程
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
            // 等待任务执行完毕，并且得到返回值
            String result = futureTask.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

}

    前面两种方式都没有返回值，FutureTask可以有返回值。

    wait系列方法和notify系列方法——线程等待和通知

    wait()方法、wait(long timeoutMillis)方法、wait(long timeoutMillis, int nanos)方法、notify()方法和notifyAll()方法都是Object类的方法。

    wait系列方法

    当一个线程调用共享变量的wait系列方法时，这个线程进入等待状态，直到使用下面两种方式才会被唤醒：

    • 其他线程调用该共享变量的notify系列方法（notify()方法或者notifyAll()方法）。
    • 其他线程调用该共享变量所在的线程的interrupt()方法后，该线程抛出InterruptedException异常返回。

    要注意的是，需要获取到该共享变量的监视器锁才能调用wait方法，否则会抛出IllegalMonitorStateException异常，可以使用以下两种方式获得对象的监视器锁：

    • 调用被关键字synchronized修饰的方法，代码如下所示：

      Object object = new Object();

private synchronized void test() {
    try {
        // 调用变量object的wait()方法
        object.wait();
    } catch(InterruptedException e) {
         e.printStackTrace();
    }
}

    • 执行同步代码块，代码如下所示：

      Object object = new Object();

synchronized(object) {
    try {
        // 调用变量object的wait()方法
        object.wait();
    } catch(InterruptedException e) {
         e.printStackTrace();
    }
}

    wait()

    源码如下所示：

    // Object.java
public final void wait() throws InterruptedException {
    wait(0L);
}

    这个方法实际上调用了wait(long timeoutMillis)方法，参数timeoutMillis的值是0L。它的行为和调用wait(0L, 0)方法是一致的。

    wait(long timeoutMillis)

    源码如下所示：

    // Object.java
public final native void wait(long timeoutMillis) throws InterruptedException;

    参数timeoutMillis是等待的最大时间，也就是超时时间，单位是毫秒。它的行为和调用wait(timeoutMillis, 0)方法是一致的。

    要注意的是，如果传入了负数的timeoutMillis，就会抛出IllegalArgumentException异常。

    wait(long timeoutMillis, int nanos)

    源码如下所示：

    // Object.java
public final void wait(long timeoutMillis, int nanos) throws InterruptedException {
    if (timeoutMillis < 0) {
        throw new IllegalArgumentException("timeoutMillis value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos > 0 && timeoutMillis < Long.MAX_VALUE) {
        timeoutMillis++;
    }

    wait(timeoutMillis);
}

    这个方法实际上调用了wait(long timeoutMillis)方法；参数timeoutMillis是等待的最大时间，也就是超时时间，单位是毫秒；参数nanos是额外的时间，单位是纳秒，范围是0~999999（包括999999）。

    只有在参数nanos大于0的时候，参数timeoutMillis才会自增。

    notify系列方法

    在一个线程上调用共享变量的notify方法后，会唤醒这个共享变量上调用wait系列方法后进入等待状态的线程。要注意的是，一个共享变量可能有多个线程在等待，具体唤醒哪个等待的线程是随机的。

    被唤醒的线程不能立即从wait系列方法返回后继续执行，它需要获取到该共享变量的监视器锁才能返回，也就是说，唤醒它的线程释放了该共享变量的监视器锁，被唤醒的线程不一定能获取到该共享变量的监视器锁，因为该线程还需要和其他线程去竞争这个监视器锁，只有竞争到这个监视器锁后才能继续执行。

    只有当前线程获取到该共享变量的监视器锁后，才能调用该共享变量的notify系列方法，否则会抛出IllegalMonitorStateException异常。

    notify()方法

    源码如下所示：

    // Object.java
@HotSpotIntrinsicCandidate
public final native void notify();

    notifyAll()方法

    源码如下所示：

    // Object.java
@HotSpotIntrinsicCandidate
public final native void notifyAll();

    notifyAll()方法可以唤醒所有在该共享变量上因为调用wait系列方法而进入等待状态的线程。

    sleep()方法——让线程睡眠

    sleep()方法是Thread类的一个静态方法。当一个正在执行的线程调用了这个方法后，调用线程会暂时让出指定睡眠时间的执行权，不参与CPU的调度，但是不会让出该线程所拥有的监视器锁。指定的睡眠时间到了后，sleep()方法会正常返回，线程处于就绪状态，然后参与CPU调度，获取到CPU资源后继续运行。

    要注意的是，如果在睡眠期间其他线程调用了该线程的interrupt()方法中断了该线程，就会在调用sleep方法的地方抛出InterruptedException异常而返回。

    源码如下所示：

    // Thread.java
public static native void sleep(long millis) throws InterruptedException;

    下面来看一个生产者消费者问题（Producer-Consumer Problem）的例子：

    Repository类是一个存储库，存放产品，代码如下所示：

    package producerconsumerproblem;

import java.util.LinkedList;
import java.util.Queue;

/**
 * Created by TanJiaJun on 2020/8/30.
 */
class Repository {

    // 队列的最大容量是10
    private static final int MAX_SIZE = 10;
    // 创建队列
    private final Queue<Object> queue = new LinkedList<>();

    void produce() {
        synchronized (queue) {
            while (queue.size() == MAX_SIZE) {
                try {
                    System.out.println("生产者（线程名字：" + Thread.currentThread().getName() + "）：存储库已满");
                    // 当队列满了后，调用变量queue的wait()方法，生产者线程，并且释放Queue对象的监视器锁
                    queue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 如果队列还没满，就创建新的Object对象，并且在队尾入列
            queue.offer(new Object());
            System.out.println("生产者（线程名字：" + Thread.currentThread().getName() + "）：生产了一个产品");
            // 通知其他生产者线程和消费者线程
            queue.notifyAll();
        }
    }

    void consume() {
        synchronized (queue) {
            while (queue.size() == 0) {
                try {
                    System.out.println("消费者（线程名字：" + Thread.currentThread().getName() + "）：存储库是空");
                    // 当队列空了后，调用变量queue的wait()方法，消费者线程进入等待状态，并且释放Queue对象的监视器锁
                    queue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 如果队列存在元素，就将队头元素出列
            queue.poll();
            System.out.println("消费者（线程名字：" + Thread.currentThread().getName() + "）：消费了一个产品");
            // 通知其他消费者线程和生产者线程
            queue.notifyAll();
        }
    }

}

    以下是测试代码，我先把生产者所在的线程睡眠（sleep）一秒，把消费者所在的线程睡眠三秒，这样就可以制造出生产速度大于消费速度的场景，代码如下所示：

    package producerconsumerproblem;

/**
 * Created by TanJiaJun on 2020/8/30.
 */
class ProducerConsumerProblemTest {

    // 生产者线程
    private static class Producer implements Runnable {

        private Repository repository;

        Producer(Repository repository) {
            this.repository = repository;
        }

        @Override
        public void run() {
            // 循环执行
            while (true) {
                try {
                    // 让生产者线程睡眠一秒
                    Thread.sleep(1000);
                    // 调用存储库的produce()方法，生产者生产产品
                    repository.produce();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
        }

    }

    // 消费者线程
    private static class Consumer implements Runnable {

        private Repository repository;

        Consumer(Repository repository) {
            this.repository = repository;
        }

        @Override
        public void run() {
            // 循环执行
            while (true) {
                try {
                    // 让消费者线程睡眠三秒
                    Thread.sleep(3000);
                    // 调用存储库的consume()方法，消费者消费产品
                    repository.consume();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
        }

    }

    public static void main(String[] args) {
        // 创建存储库
        Repository repository = new Repository();

        // 创建三个生产者线程，并且让它们运行
        for (int i = 0; i < 3; i++) {
            new Thread(new Producer(repository)).start();
        }

        // 创建三个消费者线程，并且让它们运行
        for (int i = 0; i < 3; i++) {
            new Thread(new Consumer(repository)).start();
        }
    }

}

    运行上面的代码，大约十秒后手动结束进程，结果如下所示：

    /Library/Java/JavaVirtualMachines/jdk-13.jdk/Contents/Home/bin/java "-javaagent:/Applications/IntelliJ IDEA CE.app/Contents/lib/idea_rt.jar=63240:/Applications/IntelliJ IDEA CE.app/Contents/bin" -Dfile.encoding=UTF-8 -classpath /Users/tanjiajun/IdeaProjects/ThreadDemo/out/production/ThreadDemo producerconsumerproblem.ProducerConsumerProblemTest
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
消费者（线程名字：Thread-3）：消费了一个产品
消费者（线程名字：Thread-5）：消费了一个产品
消费者（线程名字：Thread-4）：消费了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-2）：存储库已满
生产者（线程名字：Thread-1）：存储库已满
消费者（线程名字：Thread-3）：消费了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-1）：存储库已满
消费者（线程名字：Thread-5）：消费了一个产品
消费者（线程名字：Thread-4）：消费了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-2）：存储库已满
生产者（线程名字：Thread-1）：存储库已满
生产者（线程名字：Thread-0）：存储库已满
消费者（线程名字：Thread-3）：消费了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-0）：存储库已满
生产者（线程名字：Thread-1）：存储库已满
消费者（线程名字：Thread-4）：消费了一个产品
消费者（线程名字：Thread-5）：消费了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
生产者（线程名字：Thread-0）：生产了一个产品
生产者（线程名字：Thread-2）：存储库已满
生产者（线程名字：Thread-0）：存储库已满
生产者（线程名字：Thread-1）：存储库已满

Process finished with exit code 130 (interrupted by signal 2: SIGINT)

    然后我把生产者所在的线程睡眠三秒，把消费者所在的线程睡眠一秒，这样就可以制造出生产速度小于消费速度的场景，代码如下所示：

    package producerconsumerproblem;

/**
 * Created by TanJiaJun on 2020/8/30.
 */
class ProducerConsumerProblemTest {

    // 生产者线程
    private static class Producer implements Runnable {

        private Repository repository;

        Producer(Repository repository) {
            this.repository = repository;
        }

        @Override
        public void run() {
            // 循环执行
            while (true) {
                try {
                    // 让生产者线程睡眠三秒
                    Thread.sleep(3000);
                    // 调用存储库的produce()方法，生产者生产产品
                    repository.produce();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
        }

    }

    // 消费者线程
    private static class Consumer implements Runnable {

        private Repository repository;

        Consumer(Repository repository) {
            this.repository = repository;
        }

        @Override
        public void run() {
            // 循环执行
            while (true) {
                try {
                    // 让消费者线程睡眠一秒
                    Thread.sleep(1000);
                    // 调用存储库的consume()方法，消费者消费产品
                    repository.consume();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
        }

    }

    public static void main(String[] args) {
        // 创建存储库
        Repository repository = new Repository();

        // 创建三个生产者线程，并且让它们运行
        for (int i = 0; i < 3; i++) {
            new Thread(new Producer(repository)).start();
        }

        // 创建三个消费者线程，并且让它们运行
        for (int i = 0; i < 3; i++) {
            new Thread(new Consumer(repository)).start();
        }
    }

}

    运行上面的代码，大约十秒后手动结束进程，结果如下所示：

    /Library/Java/JavaVirtualMachines/jdk-13.jdk/Contents/Home/bin/java "-javaagent:/Applications/IntelliJ IDEA CE.app/Contents/lib/idea_rt.jar=63256:/Applications/IntelliJ IDEA CE.app/Contents/bin" -Dfile.encoding=UTF-8 -classpath /Users/tanjiajun/IdeaProjects/ThreadDemo/out/production/ThreadDemo producerconsumerproblem.ProducerConsumerProblemTest
消费者（线程名字：Thread-3）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
消费者（线程名字：Thread-5）：存储库是空
生产者（线程名字：Thread-0）：生产了一个产品
消费者（线程名字：Thread-3）：消费了一个产品
消费者（线程名字：Thread-5）：存储库是空
生产者（线程名字：Thread-1）：生产了一个产品
消费者（线程名字：Thread-4）：消费了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
消费者（线程名字：Thread-5）：消费了一个产品
消费者（线程名字：Thread-3）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
消费者（线程名字：Thread-5）：存储库是空
生产者（线程名字：Thread-0）：生产了一个产品
消费者（线程名字：Thread-3）：消费了一个产品
消费者（线程名字：Thread-5）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
生产者（线程名字：Thread-1）：生产了一个产品
消费者（线程名字：Thread-5）：消费了一个产品
生产者（线程名字：Thread-2）：生产了一个产品
消费者（线程名字：Thread-4）：消费了一个产品
消费者（线程名字：Thread-3）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
消费者（线程名字：Thread-5）：存储库是空
生产者（线程名字：Thread-0）：生产了一个产品
消费者（线程名字：Thread-3）：消费了一个产品
消费者（线程名字：Thread-5）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
消费者（线程名字：Thread-4）：消费了一个产品
消费者（线程名字：Thread-5）：消费了一个产品
消费者（线程名字：Thread-3）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
消费者（线程名字：Thread-5）：存储库是空
生产者（线程名字：Thread-0）：生产了一个产品
消费者（线程名字：Thread-3）：消费了一个产品
消费者（线程名字：Thread-5）：存储库是空
消费者（线程名字：Thread-4）：存储库是空
生产者（线程名字：Thread-2）：生产了一个产品
生产者（线程名字：Thread-1）：生产了一个产品
消费者（线程名字：Thread-4）：消费了一个产品
消费者（线程名字：Thread-5）：消费了一个产品

Process finished with exit code 130 (interrupted by signal 2: SIGINT)

    上面的结果都符合预期，我解释一下，当发现队列满了后，就会调用变量queue的wait()方法，该生产者线程就会被进入等待状态，并且释放Queue对象的监视器锁，让其他生产者线程和消费者线程去竞争这个监视器锁，打破了死锁产生的四个条件中的请求并持有条件，避免发生死锁，同样的，当发现队列空了后，也会调用变量queue的wait()方法，该消费者线程会进入等待状态，并且释放Queue对象的监视器锁，让其他消费者线程和生产者线程去竞争这个监视器锁，打破了死锁的四个条件中的请求并持有条件，避免发生死锁。

    上文提到的死锁产生的四个条件会在后面详细讲解。

    join系列方法——等待线程执行终止

    join系列方法是Thread类的一个普通方法。它可以处理一些需要等待某几个任务完成后才能继续往下执行的场景。

    join()方法

    源码如下所示：

    // Thread.java
public final void join() throws InterruptedException {
    join(0);
}

    这个方法实际上调用了join(final long millis)方法，参数millis的值是0。

    join(final long millis)方法

    源码如下所示：

    // Thread.java
public final synchronized void join(final long millis)
throws InterruptedException {
    if (millis > 0) {
        if (isAlive()) {
            final long startTime = System.nanoTime();
            long delay = millis;
            do {
                wait(delay);
            } while (isAlive() && (delay = millis -
                    TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime)) > 0);
        }
    } else if (millis == 0) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        throw new IllegalArgumentException("timeout value is negative");
    }
}

    参数millis是等待时间，单位是毫秒。

    要注意的是，如果传入了负数的millis，就会抛出IllegalArgumentException异常。

    join(long millis, int nanos)方法

    源码如下所示：

    // Thread.java
public final synchronized void join(long millis, int nanos)
throws InterruptedException {

    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos > 0 && millis < Long.MAX_VALUE) {
        millis++;
    }

    join(millis);
}

    这个方法实际上调用了join(final long millis)方法；参数millis是等待时间，单位是毫秒；参数nanos是额外的时间，单位是纳秒，范围是0~999999（包括999999）。

    只有在参数nanos大于0的时候，参数millis才会自增。

    我在写深入了解volatile关键字这篇文章的时候，其中一个例子使用到了这个方法，代码如下所示：

    /**
 * Created by TanJiaJun on 2020-08-16.
 */
class VolatileDemo {

    private static final int THREADS_COUNT = 10;

    private static volatile int value = 0;

    private static void increase() {
        // 对value变量进行自增操作
        value++;
    }

    public static void main(String[] args) {
        // 创建10个线程
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++)
                    // 每个线程对value变量进行1000次自增操作
                    increase();
            });
            threads[i].start();
        }
        // 主线程等待子线程运行结束
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("value的值：" + value);
    }

}

    在这个示例代码中调用join()方法目的是为了让这十个子线程运行结束后，主线程才结束，保证这十个子线程都能全部运行结束。

    yield()方法——让出CPU执行权

    yield()方法是Thread类的一个静态方法。当一个线程调用这个方法后，当前线程告诉线程调度器让出CPU执行权，但是线程调度器可以无条件忽略这个请求，如果成功让出后，线程处于就绪状态，它会从线程就绪队列中获取一个线程优先级最高的线程，当然也有可能调度到刚刚让出CPU执行权的那个线程来获取CPU执行权。源码如下所示：

    // Thread.java
public static native void yield();

    它和sleep()方法的区别是：当线程调用sleep()方法时，它会被阻塞指定的时间，在这个期间线程调度器不会去调度其他线程，而当线程调用yield()方法时，线程只是让出自己剩余的CPU时间片，线程还是处于就绪状态，并没有被阻塞，线程调度器在下一次调度时可能还会调度到这个线程执行。

    线程中断

    在Java中，线程中断是一种线程间的协作模式。

    要注意的是，通过设置线程的中断标志并不能立刻终止线程的执行，而是通过被中断的线程的中断标志自行处理。

    interrupt()方法

    interrupt()方法可以中断线程，如果是在其他线程调用该线程的interrupt()方法，会通过checkAccess()方法检查权限，这有可能抛出SecurityException异常。假设有两个线程，分别是线程A和线程B，当线程A正在运行时，线程B可以调用线程A的interrupt()方法来设置线程A的中断标志为true并且立即返回，前面也提到过，设置标志仅仅是设置标志而已，线程A实际上还在运行，还没被中断；如果线程A因为调用了wait系列方法、join()方法或者sleep()方法而被阻塞，这时候线程B调用线程A的interrupt()方法，线程A会在调用这些方法的地方抛出InterruptedException异常。源码如下所示：

    // Thread.java
public void interrupt() {
    if (this != Thread.currentThread()) {
        checkAccess();

        // 线程可能在IO操作中阻塞
        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0(); // 设置中断标志
                b.interrupt(this);
                return;
            }
        }
    }

    // 设置中断标志
    interrupt0();
}

    isInterrupted()方法

    isInterrupted()方法可以用来检测当前线程是否被中断，如果是就返回true，否则返回false。源码如下所示：

    // Thread.java
public boolean isInterrupted() {
    return isInterrupted(false);
}

    interrupted()方法

    interrupted()方法是Thread类的一个静态方法。它可以用来检测当前线程是否被中断，如果是就返回true，否则返回false。它和上面提到的isInterrupted()方法的不同的是：如果发现当前线程被中断，就会清除中断标志，并且这个方法是静态方法，可以直接调用Thread.interrupted()使用。源码如下所示：

    // Thread.java
public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}

    isInterrupted()方法和interrupted()方法都是调用了isInterrupted(boolean ClearInterrupted)方法，源码如下所示：

    // Thread.java
@HotSpotIntrinsicCandidate
private native boolean isInterrupted(boolean ClearInterrupted);

    参数ClearInterrupted是用来判断是否需要重置中断标志。

    从源码可得知，interrupted()方法是通过获取当前线程的中断标志，而不是获取调用interrupted()方法的实例对象的中断标志。

    线程上下文切换

    在多线程编程中，线程的个数一般大于CPU的个数，但是每一个CPU只能被一个线程使用，为了让用户感觉多个线程在同时执行，CPU的资源分配策略采用的是时间片轮换策略，时间片轮换策略是指给每个线程分配一个时间片，线程会在时间片内占用CPU执行任务。

    线程上下文切换是指当前线程使用完时间片后，处于就绪状态，并且让出CPU给其他线程占用，同时保存当前线程的执行现场，用于再次执行时恢复执行现场。

    线程死锁

    线程死锁是指两个或者两个以上的线程在执行的过程中，因为互相竞争资源而导致互相等待的现象，如果没有外力的情况下，它们会一直互相等待，导致无法继续执行下去。

    死锁的产生必须具备以下四个条件：

    • 互斥条件：指资源只能由一个线程占用，如果其他线程要请求使用该资源，就只能等待，直到占用资源的线程释放该资源。
    • 请求并持有条件：指一个线程已经占有至少一个资源，但是还想请求占用新的资源，而新的资源被其他线程占用，所以当前线程会被阻塞，但是阻塞的同时不释放自己获取的资源。
    • 不可剥夺条件：指线程获取到的资源在自己使用完毕之前不能被其他线程占用，只有在自己使用完毕后才会释放该资源。
    • 环路等待条件：指发生在死锁时，必然存在一个线程——资源的环形链，举个例子：有一个线程集合{Thead0, Thread1, Thread2, ……, Threadn)，其中Thread0等待Thread1占用的资源，Thread1等待Thread2占用的资源，Thread2等待Thread3占用的资源，……，Threadn等待Thread0占用的资源。

    那如何避免死锁呢？只要打破其中一个条件就可以避免死锁，不过基于操作系统的特性，只有请求并持有条件和环路等待条件是可以破坏的。

    用户线程和守护线程

    Java中的线程分为两类：用户线程（User Thread）和守护线程（Daemon Thread）。在Java虚拟机启动的时候会调用main方法，main方法所在的线程就是一个用户线程，同时Java虚拟机还会启动很多守护线程，例如：垃圾回收线程。

    只需要调用Thread类的setDaemon(boolean on)方法，并且参数on设为true，就可以使该线程成为守护线程。

    用户线程和守护线程的区别是当最后一个用户线程结束后，Java虚拟机进程才会正常结束，而守护线程是否结束不影响Java虚拟机进程的结束。

    总结一下：如果我们希望在主线程结束后，子线程继续工作，等到子线程结束后才让Java虚拟机进程结束，我们可以把线程设为用户线程；如果我们希望在主线程结束后，Java虚拟机进程也立即结束，我们可以把线程设为守护线程。

    我的GitHub：TanJiaJunBeyond

    Android通用框架：Android通用框架

    我的掘金：谭嘉俊

    我的简书：谭嘉俊

    我的CSDN：谭嘉俊

    相关文章

      网友评论

          本文标题：Java线程基础

          本文链接：https://www.haomeiwen.com/subject/qjiysktx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|Java线程基础|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！