java多线程入门

July 16, 2022

多线程基础

创建新的线程的方法主要有两个。

继承 Thread 类，覆写 run() 实例方法 （该方法将由新线程运行）
Thread 构造函数中传入 Runnable 接口，实现 Runnable 接口的 run() 方法

https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Thread.html

java

public class Main {
    public static void main(String[] args) {
        // https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html
        Thread t1 = new MyThread();
        Thread t2 = new Thread(new MyRunnable());
        Thread t3 = new Thread(() -> System.out.println("Lambda"));
        t1.start();
        t2.start();
        t3.start();
        // 注意是 start() 方法启动线程，调用run()方法仅在当前线程执行，不会创建线程

        // 下面演示一些实例对象方法
        t1.setPriority(3);// 优先级。范围从 MIN_PRIORITY 到 MAX_PRIORITY
        t1.join(); // 调用此方法的线程等待该线程执行完毕再继续执行，即 await
        t1.interrupt(); // 将该线程设置为interrupted，在该线程中通过Thread.interrupted()或isInterrupted()方法返回是否interrupted
        t1.isInterrupted(); // 返回该线程是否interrupted
        t1.setDaemon(true); // 设置该线程为守护线程，守护线程在其他线程执行完毕后自动退出
        t1.getState(); // 返回运行状态，字符串
    }

    Runnable example = () -> {
        // Thread类的静态方法，不建议在实例对象上调用
        // 这些静态方法用于控制调用该方法的线程
        Thread.sleep(1000); // ms
        Thread.interrupted(); // 返回是否当前线程被调用了interrupt()方法
    };
}

class Counter {// 多个线程之间共享内存，所以此对象在所有线程中共享，皆可以访问
    public static final Object lock = new Object();
    public static int count = 0;
}

class MyThread extends Thread {
    public volatile int syncValue = 123; // volatile 关键字确保变量在不同线程同步
    public int asyncValue = 456; // 非 volatile 变量需要加锁才能保证不出异常

    public synchronized void syncMethod() {
        // synchronized 修饰的方法，是 synchronized(this) {/* 函数体 */} 的语法糖
        // 加锁的对象是 this，即当前对象
    };
    public static synchronized void syncStaticMethod(){
        // synchronized 修饰的静态方法，是 synchronized(当前类.class) {/* 函数体 */} 的语法糖
        // 例如，这里相当于 synchronized(MyThread.class){}
    }

    @Override
    public void run() {
        synchronized (Counter.lock) { // 线程锁，通过给定锁保证（非原子）操作是同步的
            Counter.count += 1;
        }
        // 死锁产生的原因及四个必要条件
        // https://zhuanlan.zhihu.com/p/25677118

        System.out.println("MyThread");
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("MyRunnable");
    }
}

中断线程

注意：当前线程若处于 wait() sleep() join() 方法的等待状态，而被触发了 interrupt() ，则抛出 InterruptedException 异常

java

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        t.start();
        Thread.sleep(10); // 当前线程暂停10毫秒
        t.interrupt(); // 中断t线程
        t.join(); // 等待t线程结束
        System.out.println("end");
    }
}

class MyThread extends Thread {
    public void run() {
        int n = 0;
        while (!isInterrupted())
            System.out.println("loop " + (++n) + " times!");
    }
}

上面的代码相当于主线程允许 MyThread 线程执行 10ms，然后向 MyThread 线程发出中断信号。
MyThread 线程循环检测自身来决定是否继续运行。

此外，还可以通过设置标志位来实现线程中断。
注意 volatile 关键字，表示标识的变量在线程间实时共享（即：变量在不同的线程中是一致的，否则可能会获取到缓存的值，导致不一致）
细节上，注意由于 running 标志位附加在 MyThread 实例上，需要声明MyThread t = new MyThread()而非Thread t = new MyThread()

java

public class Main {
    public static void main(String[] args) throws InterruptedException {
        MyThread t = new MyThread();
        t.start();
        Thread.sleep(10);
        t.running = false; // 标志位置为false
        System.out.println("end!");
    }
}

class MyThread extends Thread {
    public volatile boolean running = true;

    public void run() {
        int n = 0;
        while (running)
            System.out.println("loop " + (++n) + " times!");
    }
}

守护线程

jvm 将在所有非守护线程执行完后，自动退出。此时所有守护线程也立即停止。
同理，若存在守护线程，守护线程将只能在任意非守护线程运行时运行。

因此，守护线程一般用于服务非守护线程运行。
并且，守护线程不应持有需要关闭的资源，因为守护线程没有机会执行关闭操作。

对某一线程执行实例方法 setDaemon(true) 即可将该线程指定为守护线程

线程同步，线程锁

在执行非原子操作时，我们一般需要进行线程同步，以保证数据一致

原子操作可简单理解为单独的 CPU 指令 （在多核处理器中，情况更为复杂）

线程锁的声明：

java

synchronized(LOCK) {
    // 临界区（Critical Section）
}

临界区最多只有一个线程能执行，因此可保证其内部操作的原子性（前提是正确使用锁）。

synchronized 标识则是 synchronized(){} 的语法糖，具体见第一节演示。

可重入锁

在 jvm 中，对于同一个锁，synchronized(){} 也允许嵌套使用（不同的锁当然允许嵌套）。
可重入锁在所有嵌套的锁都释放后释放。

例如：

java

synchronized(LOCK){
    // 未释放
    synchronized(LOCK){
        // 未释放
    }
    // 未释放
}
// 释放

死锁，活锁

死锁是线程都在等待对方先释放资源活锁则是线程彼此释放资源又同时占用对方释放的资源

wait notify

位于 Object 类上的实例方法 wait() notify() 将在调用这些方法的线程中生效，控制锁的行为（这个锁即是该 Object 实例对象）

在某一线程中，对一对象调用 wait() 实例方法，线程将会暂停（直至其它线程中调用这个对象的 notify() 实例方法唤醒该线程）
wait() 实例方法可指定等待时间作为参数，参见https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html notify() 实例方法随机唤醒一个处于 wait() 状态的线程
notifyAll() 实例方法唤醒所有处于 wait() 状态的线程，一般情况下都使用 notifyAll

示例：

java

import java.util.*;

class TaskQueue {
    private final Queue<String> queue = new LinkedList<>();

    public synchronized void addTask(String s) {
        queue.add(s);
        notifyAll(); // 通知所有 wait() 状态的线程
    }

    public synchronized String getTask() {
        while (queue.isEmpty()) // 循环执行
            try {
                wait(); // 此方法可能抛出 InterruptedException，因为在等待期间可能触发 interrupt()
            } catch (InterruptedException e) {
                e.printStackTrace(); // 处于演示目的，可以忽略此处的错误处理
            }
        return queue.remove();
    }
}

在主线程中：

java

public class Main {
    public static void main(String[] args) throws InterruptedException {
        TaskQueue task = new TaskQueue();
        Thread t1 = new Thread(() -> System.out.println("Got Task: " + task.getTask()));
        Thread t2 = new Thread(() -> task.addTask("new task"));
        t1.start(); // t1 先运行，等待有任务才输出
        t2.start(); // t2 后运行，添加任务
    }
}

←Back to home