Java多线程的使用-阿里云开发者社区

2.3 线程的操作

2.3.1 线程的休眠

public static void sleep(long millis)：让当前线程睡眠指定的毫秒数

测试代码：

package com.dfbz.demo02_线程的操作;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_线程的休眠 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                // 如果线程休眠了,会把CPU的执行权限让出来
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("t1...");
            }
        });
        t1.start();
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("main...");
        }
    }
}

在JDK1.5推出了TimeUnit类，该类可以根据时间单位来对线程进行睡眠操作；

示例代码：

public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 100; i++) {
            try {
                // 睡眠1s
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("t1...");
        }
    });
    t1.start();
    for (int i = 0; i < 100; i++) {
        try {
            // 睡眠1s
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("main...");
    }
}

2.3.2 线程的加入

多条线程时，当指定线程调用join方法时，线程执行权交给该线程，必须等到调用join方法的线程执行完全部任务后才会释放线程的执行权，其他线程才有可能争抢到线程执行权；

public final void join()：让调用join方法的线程在当前线程优先执行，直至调用join方法的线程执行完毕时，再执行本线程；
public final void join(long millis)：让线程执行millis毫秒，然后将线程执行权抛出，给其他线程争抢

1） join方法示例

【示例代码】：

package com.dfbz.demo02_线程的操作;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02_join_使用示例 {
    public static void main(String[] args) {
        //创建线程1
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("线程1:" + i);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        //创建线程2
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("线程2:" + i);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (i == 5) {
                        try {
                            //当i等于5的时候,让t1线程加入执行,直至执行完毕
                            t1.join();
                            //当i等于500的时候,让t1线程加入执行,执行10毫秒之后交出执行权
//                            t1.join(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
        t1.start();
        t2.start();
    }
}

执行效果：

2） join方法的应用场景

【join方法小案例】：

static int num = 0;
public static void main(String[] args) {
    Thread t1 = new Thread() {
        @Override
        public void run() {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num=10;
        }
    };
    t1.start();
    
    System.out.println(num);            // ?
}

我们在main线程中开启了一个新的线程（t1），t1线程对num进行赋值，然后在main线程中进行打印，很显然num的值为0，因为t1线程的阻塞不会让main线程也阻塞，当t1线程阻塞时，main线程会继续往下执行；

【使用join方法改造】：

package com.dfbz.demo02_线程的操作;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo03_join_应用场景 {
    static int num = 0;
    // 使用join改造
    public static void main(String[] args) {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                num = 10;
            }
        };
        t1.start();
        try {
            // 必须让t1线程执行完毕才能执行下面的代码
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(num);            // 10
    }
}

Tips：join方法一般应用于线程2依赖于线程1执行的返回结果时；

3） join方法注意事项

【注意事项1】：当线程执行join方法传递时间参数时，如果join线程任务执行完毕，则不必等待join时间结束；

package com.dfbz.demo02_线程的操作;
/**
 * @author lscl
 * @version 1.0
 * @intro: 当线程执行join方法传递时间参数时，如果join线程任务执行完毕，则不必等待join时间结束；
 */
public class Demo04_join_注意事项_01 {
    static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count = 10;
            }
        };
        long startTime = System.currentTimeMillis();
        t1.start();
        // 让t1线程执行完毕
//    t1.join();
        // 让t1线程执行1s,然后代码继续往下执行
//        t1.join(1000);
        // 让t1线程执行3s,但如果t1线程执行完毕了,该方法也会结束
        t1.join(3000);
        long endTime = System.currentTimeMillis();
        // count【10】,time【2011】
        System.out.println("count【" + count + "】,time【" + (endTime - startTime) + "】");
    }
}

执行效果如下：

t1.join();
count【10】,time【2003】
----------------------------------------
t1.join(1000);
count【0】,time【1005】
----------------------------------------
t1.join(3000);
count【10】,time【2006】

【注意事项2】：当线程执行join方法时，优先执行join线程的任务，等到join线程任务执行完毕时才会执行本线程。但如果还有其他线程与执行join方法的线程同时存在时，则其他线程与join线程交替执行；

package com.dfbz.demo02_线程的操作;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo05_join_注意事项_02 {
    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName());
                }
            }
        };
        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                while (true) {
                    System.out.println("t2");
                    try {
                        
                        // 让t1优先执行,但是如果还有其他线程和t1线程同时存在,那么其他线程将和t1线程交替执行
                        t1.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        Thread t3 = new Thread("t3") {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName());
                }
            }
        };
        t1.start();
        t2.start();
        t3.start();
    }
}

执行代码，发现t1和t3线程交替执行；

2.3.3 守护线程

1）守护线程的使用

public final void setDaemon(boolean on)：设置线程是否为守护线程

当用户线程（非守护线程）运行完毕时，守护线程也会停止执行，但由于CPU运行速度太快，当用户线程执行完毕时，将信息传递给守护线程，会有点时间差，而这些时间差会导致还会执行一点守护线程；

守护线程的主要用途是在后台执行一些辅助任务，如清理工作、监控状态等。因为它们没有影响应用程序主要功能的能力，所以它们可以随时被中断和终止。

【示例代码】

package com.dfbz.demo02_线程的操作;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo06_守护线程的使用 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 2000000; i++) {
                    System.out.println("守护线程: " + i);
                }
            }
        });
        //将t1设置为守护线程
        t1.setDaemon(true);
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("用户线程: " + i);
                }
            }
        });
        t1.start();
        t2.start();
    }
}

2）守护线程的退出

当一个用户线程（也称为非守护线程）结束其运行后，其他用户线程和守护线程仍将继续运行，直到所有用户线程都已结束其运行为止。 ==只有当没有任何用户线程处于活动状态（即所有用户线程都已经结束其运行）时，JVM才会退出，并在此过程中终止任何剩余的守护线==程。因此，如果有多个用户线程正在运行，即使其中一个用户线程结束了其运行，只要还有至少一个用户线程处于活动状态，那么所有的守护线程都将继续运行。

【示例代码】

package com.dfbz.demo02_线程的操作;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo07_守护线程的退出 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 2000000; i++) {
                System.out.println("守护线程: " + i);
            }
        });
        //将t1设置为守护线程
        t1.setDaemon(true);
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println("用户线程1: " + i);
            }
        });
        Thread t3 = new Thread(()->{
            for (int i = 0; i < 1000000; i++) {
                System.out.println("用户线程2: " + i);
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }
}

执行代码，发现【用户线程1】执行完毕后，守护线程并不会被退出；而是要等到所有的用户线程执行完毕后守护线程才会退出。

2.3.4 线程优先级

默认情况下，所有的线程优先级默认为5，最高为10，最低为1。优先级高的线程更容易让线程在抢到线程执行权；

通过如下方法可以设置指定线程的优先级：

public final void setPriority(int newPriority)：设置线程的优先级。

示例代码：

package com.dfbz.demo02_线程的操作;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo08_线程优先级 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i <= 10000; i++) {
                System.out.println("线程2: " + i);
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i <= 10000; i++) {
                System.out.println("线程2: " + i);
            }
        });
        // 设置优先级
        t1.setPriority(1);
        t2.setPriority(10);
        t1.start();
        t2.start();
    }
}

2.3.5 线程礼让

在多线程执行时，线程礼让，告知当前线程可以将执行权礼让给其他线程，礼让给优先级相对高一点的线程，==但仅仅是一种告知，并不是强制将执行权转让给其他线程，当前线程将CPU执行权礼让出去后，也有可能下次的执行权还在原线程这里；==如果想让原线程强制让出执行权，可以使用join()方法

public static void yield()：将当前线程的CPU执行权礼让出来；

示例代码：

package com.dfbz.demo02_线程的操作;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo09_线程礼让 {
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 100; i++) {
                System.out.println("线程1: " + i);
                if (i == 10) {
                    // 当i等于10的时候该线程礼让(礼让之后有可能下次线程执行权还被线程2抢到了)
                    Thread.yield();
                }
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("线程2: " + i);
            }
        });
        t1.start();
        t2.start();
    }
}

2.3.6 线程中断

当一个线程接收到中断请求后，它的中断状态将会被设置为“已中断”，并且如果该线程正在睡眠、等待某个锁、I/O事件或其他同步对象，则它将收到一个InterruptedException异常。

需要注意的是：中断并不是立即停止线程的执行，而是通知线程它已经被中断，并给出一个机会让它自己去处理这个中断请求。具体的响应方式由开发者自行定义。

1） interrupt中断线程

public void interrupt()：发送一个中断请求给指定线程。将线程的中断状态设置为true；如果被中断的线程正在sleep、wait、join等操作，那么将会出现InterruptedException异常，并且重置中断状态（重置为false），相当于中断失败；
public boolean isInterrupted()：获取当前线程的中断状态；
public static boolean interrupted()：获取当前线程的中断状态，并清空中断状态（设置为false）

示例代码：

package com.dfbz.demo03_线程的中断;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_线程中断 {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            while (true) {
                // 模拟任务
            }
        }, "t1");
        t1.start();
        System.out.println(t1.isInterrupted());         // false
        t1.interrupt();         // 中断线程,将中断状态设置为true
        System.out.println(t1.isInterrupted());         // true
    }
}

Tips：中断线程并且不是将线程停止，只是将线程的中断状态设置为true；

借助中断状态，我们可以采用如下的方式来停止线程：

package com.dfbz.demo03_线程的中断;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02_使用中断来停止线程 {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            while (true) {
                // 获取当前线程的中断状态
                boolean interrupted = Thread.currentThread().isInterrupted();
                if (interrupted) {
                    System.out.println("线程被中断【" + interrupted + "】....");
                    System.out.println("释放资源....");
                    break;
                } else {
                    System.out.println("执行任务【" + interrupted + "】.....");
                }
            }
        }, "t1");
        t1.start();
        Thread.sleep(10);           // 让t1线程执行10ms
        t1.interrupt();         // 中断线程,将中断状态设置为true
    }
}

2） isInterrupted和interrupted方法

isInterrupted和interrupted方法都可以获取当前线程的中断状态，但不同的是isInterrupted只会返回线程的中断状态，并不会对中断状态发送改变，interrupted方法首先返回线程的中断状态，然后将线程的中断状态设置为false（清除中断状态）

【小案例】

需求：一个生产线程一直生产菜包，生产一定时间后生产一个肉包，然后在继续生产菜包；

package com.dfbz.demo03_线程的中断;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo03_中断线程小案例 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            long startTime = System.currentTimeMillis();
            // 让while循环执行5ms
            while (System.currentTimeMillis() - startTime < 5) {
                /*
                1. 一开始中断状态为false,执行生产菜包
                2. 1ms过去之后,main线程对生产线程进行中断,中断状态设置为true
                3. 执行Thread.interrupted()语句返回true,然后把中断状态设置为false,生产线程开始生产肉包
                 */
                if (Thread.currentThread().isInterrupted()) {         // 如果使用isInterrupted方法只是获取线程的中断状态,并不会清除中断状态
//                if (Thread.interrupted()) {
                    System.out.println(System.currentTimeMillis() + ": 生产肉包...");
                } else {
                    System.out.println(System.currentTimeMillis() + ": 生产菜包...");
                }
            }
        });
        t1.start();
        // 生产线程执行3ms后对线程进行中断
        Thread.sleep(3);
        // 对线程进行中断
        t1.interrupt();
    }
}

2.3.7 中断sleep线程

1）中断sleep线程

需要注意的是，被中断的线程如果正在处于sleep、wait、join等操作中，将会抛出InterruptedException异常，然后重置中断状态（重置为false）；

package com.dfbz.demo03_线程的中断;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo04_中断sleep线程 {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t1");
        // 启动线程
        t1.start();
        Thread.sleep(50);       // 确保t1线程首先运行
        // 中断t1线程,将中断标记设置为true(但此时t1线程正在sleep,因此线程会出现异常,并且中断标记还是false)
        t1.interrupt();
        // 让main线程睡眠一小会再去查看中断状态,否则有可能出现中断状态还未设置为false就被main线程抢先打印了中断状态
        Thread.sleep(10);
        System.out.println(t1.isInterrupted());     // false(相当于中断失败)
    }
}

2）中断sleep线程注意事项

中断sleep、wait、join等状态的线程都将会抛出InterruptedException异常，然后重置中断状态（重置为false），相当于中断失败，同时InterruptedException异常的出现相当于重新唤醒了线程；

package com.dfbz.demo03_线程的中断;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo05_中断sleep线程注意事项 {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            while (true) {
                try {
                    System.out.println("t1线程...");
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1");
        // 启动线程
        t1.start();
        Thread.sleep(50);       // 确保t1线程首先运行
        // 中断t1线程,将中断标记设置为true(但此时t1线程正在sleep,因此线程会出现异常,并且中断标记还是false)
        t1.interrupt();
        // 让main线程睡眠一小会再去查看中断状态,否则有可能出现中断状态还未设置为false就被main线程抢先打印了中断状态
        Thread.sleep(10);
        System.out.println(t1.isInterrupted());         // false(相当于中断失败)
    }
}

2.3.8 线程的其他方法

1）线程退出

public final void stop()：退出当前线程

stop()方法曾经是用来强制停止一个正在运行的线程的方法，但是这个方法现在已经过时，并且被强烈反对使用。这是因为，强制停止一个线程可能会导致一些不可预料的结果，例如数据损坏、资源泄漏和其他并发问题。

此外，stop()方法还可能会抛出未经检查的安全异常，这可能会破坏程序的健壮性和安全性。

由于以上原因，从Java 1.1开始，stop()方法就被正式废弃，并不再推荐使用。取而代之的是，开发者应该使用更安全和可控的方式来进行线程的中断，例如使用interrupt()方法和适当的同步机制来实现线程间的协作。

示例代码：

package com.dfbz.demo04_线程的其他操作;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_线程的退出 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("hello【" + i + "】");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1");
        t1.start();
        Thread.sleep(2000);     // 让t1线程执行2s
        // 退出线程(这个做法是非常不可取的,好端端运行的线程被强制终止了)
        t1.stop();
        System.out.println("end");
    }
}

2）线程挂起

public final void suspend()：暂停当前线程的执行；
public final void resume()：恢复被暂停的线程；

suspend()和resume()方法曾经是用来暂时挂起和恢复线程运行的方法，但是这两个方法现在也已经过时，并且被强烈反对使用。

这是因为，挂起一个线程可能会导致一些不可预料的结果，例如死锁、数据损坏和其他并发问题。此外，suspend()和resume()方法的操作也不能保证原子性，这可能会导致竞态条件和数据不一致等问题。

由于以上原因，从Java 1.2开始，suspend()和resume()方法就被正式废弃，并不再推荐使用。取而代之的是，开发者应该使用更安全和可控的方式来进行线程的控制和同步，例如使用interrupt()方法和适当的同步机制来实现线程间的协作。

示例代码：

package com.dfbz.demo04_线程的其他操作;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02_线程的挂起与恢复 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true){
                System.out.println("hello");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.start();
        Thread.sleep(2000);     // 让t1线程执行2s
        // 挂起线程
        t1.suspend();
        System.out.println("线程挂起...");
        Thread.sleep(2000);             // main线程睡眠2s,t1线程被挂起,此时没有线程在执行
        t1.resume();
        System.out.println("线程恢复....");
    }
}

Java多线程的使用

2.3 线程的操作

2.3.1 线程的休眠

2.3.2 线程的加入

1） join方法示例

2） join方法的应用场景

3） join方法注意事项

2.3.3 守护线程

1）守护线程的使用

2）守护线程的退出

2.3.4 线程优先级

2.3.5 线程礼让

2.3.6 线程中断

1） interrupt中断线程

2） isInterrupted和interrupted方法

2.3.7 中断sleep线程

1）中断sleep线程

2）中断sleep线程注意事项

2.3.8 线程的其他方法

1）线程退出

2）线程挂起

热门文章

最新文章

相关课程

相关电子书

相关实验场景

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

Java多线程的使用

2.3 线程的操作

2.3.1 线程的休眠

2.3.2 线程的加入

1） join方法示例

2） join方法的应用场景

3） join方法注意事项

2.3.3 守护线程

1） 守护线程的使用

2） 守护线程的退出

2.3.4 线程优先级

2.3.5 线程礼让

2.3.6 线程中断

1） interrupt中断线程

2） isInterrupted和interrupted方法

2.3.7 中断sleep线程

1） 中断sleep线程

2） 中断sleep线程注意事项

2.3.8 线程的其他方法

1） 线程退出

2） 线程挂起

热门文章

最新文章

相关课程

相关电子书

相关实验场景

1）守护线程的使用

2）守护线程的退出

1）中断sleep线程

2）中断sleep线程注意事项

1）线程退出

2）线程挂起