Java 线程基础

时间  2021-08-14
标签 html java git 程序员 github 编程 安全 markdown 网络 并发 栏目 Java 繁體版
原文   原文链接

1、线程简介

什么是进程

简言之，进程可视为一个正在运行的程序。它是系统运行程序的基本单位，所以进程是动态的。进程是具备必定独立功能的程序关于某个数据集合上的一次运行活动。进程是操做系统进行资源分配的基本单位。html

什么是线程

线程是操做系统进行调度的基本单位。线程也叫轻量级进程（Light Weight Process），在一个进程里能够建立多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，而且可以访问共享的内存变量。java

进程和线程的区别

  • 一个程序至少有一个进程，一个进程至少有一个线程。
  • 线程比进程划分更细，因此执行开销更小，并发性更高。
  • 进程是一个实体，拥有独立的资源；而同一个进程中的多个线程共享进程的资源。

2、线程基本用法

线程（Thread）基本方法清单：git

方法 描述
run 线程的执行实体。
start 线程的启动方法。
currentThread 返回对当前正在执行的线程对象的引用。
setName 设置线程名称。
getName 获取线程名称。
setPriority 设置线程优先级。Java 中的线程优先级的范围是 [1,10]，通常来讲，高优先级的线程在运行时会具备优先权。能够经过 thread.setPriority(Thread.MAX_PRIORITY) 的方式设置，默认优先级为 5。
getPriority 获取线程优先级。
setDaemon 设置线程为守护线程。
isDaemon 判断线程是否为守护线程。
isAlive 判断线程是否启动。
interrupt 中断另外一个线程的运行状态。
interrupted 测试当前线程是否已被中断。经过此方法能够清除线程的中断状态。换句话说，若是要连续调用此方法两次，则第二次调用将返回 false（除非当前线程在第一次调用清除其中断状态以后且在第二次调用检查其状态以前再次中断）。
join 可使一个线程强制运行，线程强制运行期间，其余线程没法运行，必须等待此线程完成以后才能够继续执行。
Thread.sleep 静态方法。将当前正在执行的线程休眠。
Thread.yield 静态方法。将当前正在执行的线程暂停，让其余线程执行。

建立线程

建立线程有三种方式：程序员

  • 继承 Thread 类
  • 实现 Runnable 接口
  • 实现 Callable 接口

继承 Thread 类

经过继承 Thread 类建立线程的步骤：github

  1. 定义 Thread 类的子类，并覆写该类的 run 方法。run 方法的方法体就表明了线程要完成的任务，所以把 run 方法称为执行体。
  2. 建立 Thread 子类的实例，即建立了线程对象。
  3. 调用线程对象的 start 方法来启动该线程。
public class ThreadDemo {

    public static void main(String[] args) {
        // 实例化对象
        MyThread tA = new MyThread("Thread 线程-A");
        MyThread tB = new MyThread("Thread 线程-B");
        // 调用线程主体
        tA.start();
        tB.start();
    }

    static class MyThread extends Thread {

        private int ticket = 5;

        MyThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            while (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticket + " 张票");
                ticket--;
            }
        }

    }

}
复制代码

实现 Runnable 接口

实现 Runnable 接口优于继承 Thread 类，由于：编程

  • Java 不支持多重继承，全部的类都只容许继承一个父类，但能够实现多个接口。若是继承了 Thread 类就没法继承其它类，这不利于扩展。
  • 类可能只要求可执行就行，继承整个 Thread 类开销过大。

经过实现 Runnable 接口建立线程的步骤：安全

  1. 定义 Runnable 接口的实现类，并覆写该接口的 run 方法。该 run 方法的方法体一样是该线程的线程执行体。
  2. 建立 Runnable 实现类的实例，并以此实例做为 Thread 的 target 来建立 Thread 对象，该 Thread 对象才是真正的线程对象。
  3. 调用线程对象的 start 方法来启动该线程。
public class RunnableDemo {

    public static void main(String[] args) {
        // 实例化对象
        Thread tA = new Thread(new MyThread(), "Runnable 线程-A");
        Thread tB = new Thread(new MyThread(), "Runnable 线程-B");
        // 调用线程主体
        tA.start();
        tB.start();
    }

    static class MyThread implements Runnable {

        private int ticket = 5;

        @Override
        public void run() {
            while (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticket + " 张票");
                ticket--;
            }
        }

    }

}
复制代码

实现 Callable 接口

继承 Thread 类 和 实现 Runnable 接口这两种建立线程的方式都没有返回值。因此，线程执行完后，没法获得执行结果。但若是指望获得执行结果该怎么作？markdown

为了解决这个问题，Java 1.5 后，提供了 Callable 接口和 Future 接口，经过它们，能够在线程执行结束后，返回执行结果。网络

经过实现 Callable 接口建立线程的步骤：并发

  1. 建立 Callable 接口的实现类，并实现 call 方法。该 call 方法将做为线程执行体，而且有返回值。
  2. 建立 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call 方法的返回值。
  3. 使用 FutureTask 对象做为 Thread 对象的 target 建立并启动新线程。
  4. 调用 FutureTask 对象的 get 方法来得到线程执行结束后的返回值。
public class CallableDemo {

    public static void main(String[] args) {
        Callable<Long> callable = new MyThread();
        FutureTask<Long> future = new FutureTask<>(callable);
        new Thread(future, "Callable 线程").start();
        try {
            System.out.println("任务耗时：" + (future.get() / 1000000) + "毫秒");
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

    static class MyThread implements Callable<Long> {

        private int ticket = 10000;

        @Override
        public Long call() {
            long begin = System.nanoTime();
            while (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticket + " 张票");
                ticket--;
            }

            long end = System.nanoTime();
            return (end - begin);
        }

    }

}
复制代码

FAQ

start 和 run 方法有什么区别
  • run 方法是线程的执行体。
  • start 方法会启动线程，而后 JVM 会让这个线程去执行 run 方法。
能够直接调用 Thread 类的 run 方法么
  • 能够。可是若是直接调用 Thread 的 run 方法，它的行为就会和普通的方法同样。
  • 为了在新的线程中执行咱们的代码，必须使用 Thread 的 start 方法。

线程休眠

使用 Thread.sleep 方法可使得当前正在执行的线程进入休眠状态。

使用 Thread.sleep 须要向其传入一个整数值，这个值表示线程将要休眠的毫秒数。

Thread.sleep 方法可能会抛出 InterruptedException，由于异常不能跨线程传播回 main 中，所以必须在本地进行处理。线程中抛出的其它异常也一样须要在本地进行处理。

public class ThreadSleepDemo {

    public static void main(String[] args) {
        new Thread(new MyThread("线程A", 500)).start();
        new Thread(new MyThread("线程B", 1000)).start();
        new Thread(new MyThread("线程C", 1500)).start();
    }

    static class MyThread implements Runnable {

        /** 线程名称 */
        private String name;

        /** 休眠时间 */
        private int time;

        private MyThread(String name, int time) {
            this.name = name;
            this.time = time;
        }

        @Override
        public void run() {
            try {
                // 休眠指定的时间
                Thread.sleep(this.time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.name + "休眠" + this.time + "毫秒。");
        }

    }

}
复制代码

线程礼让

Thread.yield 方法的调用声明了当前线程已经完成了生命周期中最重要的部分，能够切换给其它线程来执行 。

该方法只是对线程调度器的一个建议，并且也只是建议具备相同优先级的其它线程能够运行。

public class ThreadYieldDemo {

    public static void main(String[] args) {
        MyThread t = new MyThread();
        new Thread(t, "线程A").start();
        new Thread(t, "线程B").start();
    }

    static class MyThread implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "运行，i = " + i);
                if (i == 2) {
                    System.out.print("线程礼让：");
                    Thread.yield();
                }
            }
        }
    }
}
复制代码

终止线程

Thread 中的 stop 方法有缺陷，已废弃。

使用 Thread.stop 中止线程会致使它解锁全部已锁定的监视器（因为未经检查的 ThreadDeath 异常会在堆栈中传播，这是天然的结果）。 若是先前由这些监视器保护的任何对象处于不一致状态，则损坏的对象将对其余线程可见，从而可能致使任意行为。Thread.stop 的许多用法应由仅修改某些变量以指示目标线程应中止运行的代码代替。 目标线程应按期检查此变量，若是该变量指示要中止运行，则应按有序方式从其运行方法返回。若是目标线程等待很长时间（例如，在条件变量上），则应使用中断方法来中断等待。

当一个线程运行时，另外一个线程能够直接经过 interrupt 方法中断其运行状态。

public class ThreadInterruptDemo {

    public static void main(String[] args) {
        MyThread mt = new MyThread(); // 实例化Runnable子类对象
        Thread t = new Thread(mt, "线程"); // 实例化Thread对象
        t.start(); // 启动线程
        try {
            Thread.sleep(2000); // 线程休眠2秒
        } catch (InterruptedException e) {
            System.out.println("三、休眠被终止");
        }
        t.interrupt(); // 中断线程执行
    }

    static class MyThread implements Runnable {

        @Override
        public void run() {
            System.out.println("一、进入run()方法");
            try {
                Thread.sleep(10000); // 线程休眠10秒
                System.out.println("二、已经完成了休眠");
            } catch (InterruptedException e) {
                System.out.println("三、休眠被终止");
                return; // 返回调用处
            }
            System.out.println("四、run()方法正常结束");
        }
    }
}
复制代码

若是一个线程的 run 方法执行一个无限循环，而且没有执行 sleep 等会抛出 InterruptedException 的操做，那么调用线程的 interrupt 方法就没法使线程提早结束。

可是调用 interrupt 方法会设置线程的中断标记，此时调用 interrupted 方法会返回 true。所以能够在循环体中使用 interrupted 方法来判断线程是否处于中断状态，从而提早结束线程。

安全地终止线程有两种方法：

  • 定义 volatile 标志位，在 run 方法中使用标志位控制线程终止
  • 使用 interrupt 方法和 Thread.interrupted 方法配合使用来控制线程终止

示例：使用 volatile 标志位控制线程终止

public class ThreadStopDemo2 {

    public static void main(String[] args) throws Exception {
        MyTask task = new MyTask();
        Thread thread = new Thread(task, "MyTask");
        thread.start();
        TimeUnit.MILLISECONDS.sleep(50);
        task.cancel();
    }

    private static class MyTask implements Runnable {

        private volatile boolean flag = true;

        private volatile long count = 0L;

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 线程启动");
            while (flag) {
                System.out.println(count++);
            }
            System.out.println(Thread.currentThread().getName() + " 线程终止");
        }

        /** * 经过 volatile 标志位来控制线程终止 */
        public void cancel() {
            flag = false;
        }

    }

}
复制代码

示例：使用 interrupt 方法和 Thread.interrupted 方法配合使用来控制线程终止

public class ThreadStopDemo3 {

    public static void main(String[] args) throws Exception {
        MyTask task = new MyTask();
        Thread thread = new Thread(task, "MyTask");
        thread.start();
        TimeUnit.MILLISECONDS.sleep(50);
        thread.interrupt();
    }

    private static class MyTask implements Runnable {

        private volatile long count = 0L;

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 线程启动");
            // 经过 Thread.interrupted 和 interrupt 配合来控制线程终止
            while (!Thread.interrupted()) {
                System.out.println(count++);
            }
            System.out.println(Thread.currentThread().getName() + " 线程终止");
        }
    }
}
复制代码

守护线程

什么是守护线程？

  • 守护线程（Daemon Thread）是在后台执行而且不会阻止 JVM 终止的线程。当全部非守护线程结束时，程序也就终止，同时会杀死全部守护线程。
  • 与守护线程（Daemon Thread）相反的，叫用户线程（User Thread），也就是非守护线程。

为何须要守护线程？

  • 守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。典型的应用就是垃圾回收器。

如何使用守护线程？

  • 可使用 isDaemon 方法判断线程是否为守护线程。
  • 可使用 setDaemon 方法设置线程为守护线程。
    • 正在运行的用户线程没法设置为守护线程，因此 setDaemon 必须在 thread.start 方法以前设置，不然会抛出 llegalThreadStateException 异常；
    • 一个守护线程建立的子线程依然是守护线程。
    • 不要认为全部的应用均可以分配给守护线程来进行服务，好比读写操做或者计算逻辑。
public class ThreadDaemonDemo {

    public static void main(String[] args) {
        Thread t = new Thread(new MyThread(), "线程");
        t.setDaemon(true); // 此线程在后台运行
        System.out.println("线程 t 是不是守护进程：" + t.isDaemon());
        t.start(); // 启动线程
    }

    static class MyThread implements Runnable {

        @Override
        public void run() {
            while (true) {
                System.out.println(Thread.currentThread().getName() + "在运行。");
            }
        }
    }
}
复制代码

参考阅读：Java 中守护线程的总结

FAQ

sleep、yield、join 方法有什么区别

  • yield 方法
    • yield 方法会 让线程从 Running 状态转入 Runnable 状态。
    • 当调用了 yield 方法后，只有与当前线程相同或更高优先级的Runnable 状态线程才会得到执行的机会。
  • sleep 方法
    • sleep 方法会 让线程从 Running 状态转入 Waiting 状态。
    • sleep 方法须要指定等待的时间，超过等待时间后，JVM 会将线程从 Waiting 状态转入 Runnable 状态。
    • 当调用了 sleep 方法后，不管什么优先级的线程均可以获得执行机会。
    • sleep 方法不会释放“锁标志”，也就是说若是有 synchronized 同步块，其余线程仍然不能访问共享数据。
  • join
    • join 方法会 让线程从 Running 状态转入 Waiting 状态。
    • 当调用了 join 方法后，当前线程必须等待调用 join 方法的线程结束后才能继续执行。

为何 sleep 和 yield 方法是静态的

Thread 类的 sleep 和 yield 方法将处理 Running 状态的线程。

因此在其余处于非 Running 状态的线程上执行这两个方法是没有意义的。这就是为何这些方法是静态的。它们能够在当前正在执行的线程中工做，并避免程序员错误的认为能够在其余非运行线程调用这些方法。

Java 线程是否按照线程优先级严格执行

即便设置了线程的优先级，也没法保证高优先级的线程必定先执行。

缘由在于线程优先级依赖于操做系统的支持，然而，不一样的操做系统支持的线程优先级并不相同，不能很好的和 Java 中线程优先级一一对应。

3、线程间通讯

当多个线程能够一块儿工做去解决某个问题时，若是某些部分必须在其它部分以前完成，那么就须要对线程进行协调。

wait/notify/notifyAll

  • wait - wait 方法使得线程释放其占有的对象锁，让线程从 Running 状态转入 Waiting 状态，并等待 notify / notifyAll 来唤醒 。若是没有释放锁，那么其它线程就没法进入对象的同步方法或者同步控制块中，那么就没法执行 notify 或者 notifyAll 来唤醒挂起的线程，形成死锁。
  • notify - 唤醒一个正在 Waiting 状态的线程，并让它拿到对象锁，具体唤醒哪个线程由 JVM 控制 。
  • notifyAll - 唤醒全部正在 Waiting 状态的线程，接下来它们须要竞争对象锁。

注意：

  • wait、notify、notifyAll 都是 Object 类中的方法，而非 Thread。
  • wait、notify、notifyAll 只能用在 synchronized 方法或者 synchronized 代码块中使用，不然会在运行时抛出 IllegalMonitorStateException。

为何 wait、notify、notifyAll 不定义在 Thread 中？为何 wait、notify、notifyAll 要配合 synchronized 使用？

首先，须要了解几个基本知识点：

  • 每个 Java 对象都有一个与之对应的 监视器（monitor）
  • 每个监视器里面都有一个 对象锁 、一个 等待队列、一个 同步队列

了解了以上概念，咱们回过头来理解前面两个问题。

为何这几个方法不定义在 Thread 中？

因为每一个对象都拥有对象锁，让当前线程等待某个对象锁，天然应该基于这个对象（Object）来操做，而非使用当前线程（Thread）来操做。由于当前线程可能会等待多个线程的锁，若是基于线程（Thread）来操做，就很是复杂了。

为何 wait、notify、notifyAll 要配合 synchronized 使用？

若是调用某个对象的 wait 方法，当前线程必须拥有这个对象的对象锁，所以调用 wait 方法必须在 synchronized 方法和 synchronized 代码块中。

生产者、消费者模式是 wait、notify、notifyAll 的一个经典使用案例：

public class ThreadWaitNotifyDemo02 {

    private static final int QUEUE_SIZE = 10;
    private static final PriorityQueue<Integer> queue = new PriorityQueue<>(QUEUE_SIZE);

    public static void main(String[] args) {
        new Producer("生产者A").start();
        new Producer("生产者B").start();
        new Consumer("消费者A").start();
        new Consumer("消费者B").start();
    }

    static class Consumer extends Thread {

        Consumer(String name) {
            super(name);
        }

        @Override
        public void run() {
            while (true) {
                synchronized (queue) {
                    while (queue.size() == 0) {
                        try {
                            System.out.println("队列空，等待数据");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notifyAll();
                        }
                    }
                    queue.poll(); // 每次移走队首元素
                    queue.notifyAll();
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 从队列取走一个元素，队列当前有：" + queue.size() + "个元素");
                }
            }
        }
    }

    static class Producer extends Thread {

        Producer(String name) {
            super(name);
        }

        @Override
        public void run() {
            while (true) {
                synchronized (queue) {
                    while (queue.size() == QUEUE_SIZE) {
                        try {
                            System.out.println("队列满，等待有空余空间");
                            queue.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            queue.notifyAll();
                        }
                    }
                    queue.offer(1); // 每次插入一个元素
                    queue.notifyAll();
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " 向队列取中插入一个元素，队列当前有：" + queue.size() + "个元素");
                }
            }
        }
    }
}
复制代码

join

在线程操做中，可使用 join 方法让一个线程强制运行，线程强制运行期间，其余线程没法运行，必须等待此线程完成以后才能够继续执行。

public class ThreadJoinDemo {

    public static void main(String[] args) {
        MyThread mt = new MyThread(); // 实例化Runnable子类对象
        Thread t = new Thread(mt, "mythread"); // 实例化Thread对象
        t.start(); // 启动线程
        for (int i = 0; i < 50; i++) {
            if (i > 10) {
                try {
                    t.join(); // 线程强制运行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Main 线程运行 --> " + i);
        }
    }

    static class MyThread implements Runnable {

        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                System.out.println(Thread.currentThread().getName() + " 运行，i = " + i); // 取得当前线程的名字
            }
        }
    }
}
复制代码

管道

管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不一样之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。 管道输入/输出流主要包括了以下 4 种具体实现：PipedOutputStream、PipedInputStream、PipedReader 和 PipedWriter，前两种面向字节，然后两种面向字符。

public class Piped {

    public static void main(String[] args) throws Exception {
        PipedWriter out = new PipedWriter();
        PipedReader in = new PipedReader();
        // 将输出流和输入流进行链接，不然在使用时会抛出IOException
        out.connect(in);
        Thread printThread = new Thread(new Print(in), "PrintThread");
        printThread.start();
        int receive = 0;
        try {
            while ((receive = System.in.read()) != -1) {
                out.write(receive);
            }
        } finally {
            out.close();
        }
    }

    static class Print implements Runnable {

        private PipedReader in;

        Print(PipedReader in) {
            this.in = in;
        }

        public void run() {
            int receive = 0;
            try {
                while ((receive = in.read()) != -1) {
                    System.out.print((char) receive);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
复制代码

4、线程状态

java.lang.Thread.State 中定义了 6 种不一样的线程状态，在给定的一个时刻，线程只能处于其中的一个状态。

如下是各状态的说明，以及状态间的联系：

  • 新建（New） - 还没有调用 start 方法的线程处于此状态。此状态意味着：建立的线程还没有启动。

  • 可运行（Runnable） - 已经调用了 start 方法的线程处于此状态。此状态意味着：线程已经在 JVM 中运行。可是在操做系统层面，它可能处于运行状态，也可能等待资源调度（例如处理器资源），资源调度完成就进入运行状态。因此该状态的可运行是指能够被运行，具体有没有运行要看底层操做系统的资源调度。

  • 阻塞（Blocked） - 请求获取 monitor lock 从而进入 synchronized 函数或者代码块，可是其它线程已经占用了该 monitor lock，因此处于阻塞状态。要结束该状态进入 Runnable，从而须要其余线程释放 monitor lock。此状态意味着：线程处于被阻塞状态。

  • 等待（Waiting） - 此状态意味着：线程等待被其余线程显式地唤醒。 阻塞和等待的区别在于，阻塞是被动的，它是在等待获取 monitor lock。而等待是主动的，经过调用 Object.wait 等方法进入。

    进入方法 退出方法
    没有设置 Timeout 参数的 Object.wait 方法 Object.notify / Object.notifyAll
    没有设置 Timeout 参数的 Thread.join 方法 被调用的线程执行完毕
    LockSupport.park 方法 LockSupport.unpark

  • 定时等待（Timed waiting） - 此状态意味着：无需等待其它线程显式地唤醒，在必定时间以后会被系统自动唤醒。

    进入方法 退出方法
    Thread.sleep 方法 时间结束
    设置了 Timeout 参数的 Object.wait 方法 时间结束 / Object.notify / Object.notifyAll
    设置了 Timeout 参数的 Thread.join 方法 时间结束 / 被调用的线程执行完毕
    LockSupport.parkNanos 方法 LockSupport.unpark
    LockSupport.parkUntil 方法 LockSupport.unpark

  • 终止(Terminated) - 线程 run 方法执行结束，或者因异常退出了 run 方法。此状态意味着：线程结束了生命周期。

参考资料

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程