Java多线程（02）—— 线程等待，线程安全

已于 2024-06-05 10:16:08 修改
阅读量1.7k 收藏 15
点赞数 42
分类专栏： Java多线程 文章标签： java 多线程 线程安全 终止线程 volatile synchronized
于 2024-05-28 19:34:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2201_75456895/article/details/139246469
版权

一、如何终止线程

终止线程就是要让 run 方法尽快执行结束

1. 手动创建标志位

可以通过在代码中手动创建标志位的方式，来作为 run 方法的执行结束条件；

    public static void main(String[] args) throws InterruptedException {
        boolean flag = true;
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (flag){
                    System.out.println("线程执行中 ");
                }
            }
        });
        t.start();
        Thread.sleep(100);
        flag = false;
    }

如果将标志位定义在方法内部，这样编译器会报错，原因涉及到一个语法规则：匿名内部类的变量捕获， 匿名内部类可以使用方法中定义的变量，但这个变量必须是 final 的或者是 "事实" final 的；

所以要将标志位定义在类中，即类的属性，那这样又为什么不报错了呢？这又涉及到内部类 访问外部类的成员问题，内部类可以直接访问外部类的成员，不会受到变量捕获的影响；

public class Demo3 {
    private static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (flag) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("线程执行中 ");
                }
            }
        });
        t.start();
        Thread.sleep(10);
        flag = false;
    }
}

bdbe6a6652d64a4ba9bb69d4887c7f7f.png

可以看出上述方法确实终止了线程 t，但是如果，但如果线程 t 在 sleep 时，主线程再修改变量，那么 线程 t 就不能及时响应了；例如如下代码：

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (flag) {
                    System.out.println("t线程执行中 " + System.currentTimeMillis());
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("t线程执行结束 " + System.currentTimeMillis());
                }
            }
        });
        t.start();
        Thread.sleep(100);
        flag = false;
        System.out.println("主线程通知 t线程 执行结束" + System.currentTimeMillis());
    }

f7a49260bfe64dcba74c818a4d873625.png

可以看出主线程修改了标志位之后，在休眠状态下的 t 线程没有立即结束； 

2. 使用 Thread 类提供的方法

使用 Thread.currentThread().isInterrupted() 方法作为内部标志位，使用 t.interrupt() 方法终止线程；

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("t线程正在执行 ");
                }
            }
        });
        t.start();
        Thread.sleep(1);
        t.interrupt();
    }

76dc157ee909437dbe99734b5f9da0ca.png

 上述代码中，t 线程执行了 1 ms 之后自动结束了；

那如果主线程调用 t.interrupt() 方法的时候 t 线程正在 sleep 呢？看看下面这个例子：

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("t线程正在执行 ");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t.start();
        Thread.sleep(100);
        t.interrupt();
    }

6ab43b1596444a7cb20a248dcf09693b.png 可以看到，t 线程直接抛出了一个 InterruptedException，同时对应到 使用 sleep 方法必须进行手动的处理异常，防止了在 sleep 的时候，调用 interrupt 方法而没有及时感知；

二、线程等待

线程等待就是让一个线程等待另一个线程执行结束，再继续执行；实现线程等待的方式有 join 和 wait，sleep 也算一种吧；

1. join

join 在哪个线程内调用，哪个线程就阻塞等待，默认死等待，不释放锁资源，也可以设置一个最长的等待时间；通过影响线程结束的先后顺序实现线程等待，join 是 Thread 类提供的方法，；

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("线程执行中 i = " + i);
                }
            }
        });
        t.start();
        System.out.println("开始等待");
        t.join();
        System.out.println("等待结束");
    }

087b5c89e37649c0a2debcae93fb11e0.png

但如果 t 线程要执行很久，也可以通过设置最长等待时间再继续执行主线程；例如，通过 t.join(1000);  设置最多等待 1 秒，但当这个时间到了，t 线程不一定执行完了，而是主线程该执行了；

2. wait 与 notify

wait 让指定的线程进入阻塞状态，wait 方法也可以指定超时时间，其他线程调用该等待线程的 interrupted 方法时，会导致 wait 抛出 InterruptedException 异常

wait 方法执行要做的事：1）释放锁资源；2）让线程进入阻塞状态；3）当线程被重新唤醒时，重新获取到锁；

wait 结束等待的条件：1）其他线程调用该锁对象的 notify 方法（前提是，使用 synchronized 加上锁）；2）wait 等待时间超时(如果 wait 方法指定了超时时间)；3）其他线程调用该等待线程的 interrupted 方法，导致 wait 抛出 InterruptedException 异常

notify 用来唤醒处在 wait 等待中的线程，并使它们重新获取该对象的对象锁；

如果有多个线程等待，则由线程调度器随机挑选出⼀个 wait 状态的线程。(并不会 "先来后到")；在在执行 notify() 方法之后，当前线程不会立刻就释放该对象的锁，而要等到执行 notify() 方法的线程将当前 synchronized 代码块执行完，才会释放对象锁；   

notifyAll() 方法用来唤醒所有处在 wait 状态的线程，不是立刻就全部唤醒，而是一个接一个唤醒；

wait，notify，notifyAll 都是 Object 类的方法，在使用时都必须放在 synchronized 块中；

public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (object) {
                    for (int i = 0; i < 5; i++) {
                        System.out.println("线程执行中 i = " + i);
                    }
                    object.notify();
                }
            }
        });
        t.start();
        System.out.println("开始等待");
        synchronized (object) {
            object.wait();
        }
        System.out.println("等待结束");
    }

5b589deab4fb4178adc8ed67439c1efc.png

使用 wait / notify 不会出现 "线程饿死" 问题；

线程饿死：一个线程释放锁的时候，又去竞争锁，由于该线程已经在 cpu 上执行，故没有调度的过程，进而更容易拿到锁，反复进行此操作，后续线程就无法拿到锁，就会出现 "线程饿死" 问题；使用 wait 时，该线程会释放锁，并进入阻塞，不会参与后续的锁竞争；

三、线程安全 

public class Demo4 {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                count++;
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                count++;
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

针对上述代码，执行多次的结果是不一样的，这就是线程安全问题； 

产生线程安全问题的原因：

1. 操作系统中，线程的调度方式是随机的（抢占式执行）；

此种情况是操作系统内核决定的，是无法避免的；

2. 两个或多个线程对同一个变量进行修改，并且修改操作不是原子的；

为了避免线程不安全问题，可以尽量减少多个线程对同一个变量的修改，但是有时候就是需要对同一个变量修改，这时候就需要保证修改操作是原子的，那就可以使用 synchronized 来加锁了；

synchronized 在使用时，要搭配一个代码块和一个对象，进入代码块中就会加锁，出了代码块就会解锁，在已经加锁的状态下，另一个线程尝试对该代码块中同一个对象加锁，就会产生 "锁竞争/ 锁冲突"，后一个线程就会阻塞等待，直到前一个线程释放锁为止；

现使用 synchronized 对上述代码进行修改，由于是 count++ 操作是非原子的，故要对 count++ 操作进行加锁；（也可以使用 Integer 的原子类 AtomicInteger 实现原子操作 详细介绍 点击这里）

public class Demo4 {
    public static int count = 0;
    public static final Object o = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized (o) {
                    count++;
                }
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized (o) {
                    count++;
                }
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

7fee4df2c79244c685ae0906cc3f8964.png

上述代码中是针对同一个对象 o 进行加锁，若是针对不同的对象加锁，则不会有锁竞争，仍然是并发；

当 synchronized 修饰成员方法时，相当于对 this 对象进行加锁，当 synchronized 修饰类方法时，相当于对 类对象 进行加锁；

可重入锁的概念：指一个线程连续针对一把锁加锁两次不会出现死锁，满足该要求就是可重入锁；

死锁问题：

1）一个线程针对同一把锁，连续加锁两次，如果是不可重入锁，就会产生死锁；

第一次加锁会成功，第二次加锁就需要等待第一次加的锁释放，但此时第二次加锁的操作在第一次锁的代码块中，第一次加锁要释放，就又得第二次加锁成功，这样就产生了死锁；但如果能让锁记录是哪个线程对它加的锁，并记录加了几层，这样后续再加锁的时候，判断加锁线程是否为持有锁的线程，如果是，则直接加锁成功，此时就可以避免死锁；

    public static void main(String[] args) {
        synchronized (o1){
            synchronized (o2){
                System.out.println("加锁成功");
            }
        }
    }

 813eb8da13ba48d6ad18867c0ca92b3b.png

由于 synchronized 是 可重入锁，故此时不会产生死锁； 

2）两个线程两把锁，例如有 t1，t2 线程，o1，o2 对象，t1 已经对 o1 加锁，t2 已经对 o2 加锁，此时 t1 又尝试对 o2 加锁，t2 尝试对 o1 加锁；（此时一定会产生死锁）；

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (o1){
                System.out.println("t1 对 o1 加锁成功");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (o2){
                    System.out.println("t1 对 o2 加锁成功");
                }
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (o2){
                System.out.println("t2 对 o2 加锁成功");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (o1){
                    System.out.println("t2 对 o1 加锁成功");
                }
            }
        });
        t1.start();
        t2.start();
    }

8bb5547f3a7b402bb9bc5ae12ba240f2.png

可以看到并没有打印 "t1 对 o2 加锁成功" 和 "t2 对 o1 加锁成功"，此时已经产生死锁了；

3）多个线程，对应多把锁，更容易产生死锁；

3. 内存可见性问题 

public class Demo5 {
    public static int flag = 0;
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (flag == 0){
            }
            System.out.println("t1 线程执行结束");
        });
        Thread t2 = new Thread(() -> {
            System.out.println("请输入 flag: ");
            Scanner in = new Scanner(System.in);
            flag = in.nextInt();
        });
        t1.start();
        t2.start();
    }
}

147937081b5942bf987402a48e7e5ffc.png

可以看到在上述代码中， 当 flag 为 0 时，t1 线程会循环执行；t2 线程可以让用户输入一个数来改变 flag 的值，按理来说用户输入非 0，t1 线程应该会终止循环，并打印 "t1 线程执行结束"，然后 t1 线程结束，但运行结果并非这样，这就是内存可见性引起的问题；

t1 线程判断循环的条件 while(flag == 0) 具体操作为：1）load 读取内存中 flag 的值到 cpu 寄存器中；2）使用寄存器中的值和 0 进行比较；

由于这个循环体内没有任何操作（编译器可以检测到），所以这个循环的执行速度是非常快的，所以 编译器为了提高效率，会将读内存优化为读寄存器：编译器只在第一次循环时，才读了内存，并将读到的结果放入寄存器中，后续会直接从寄存器中取值，这样后续 t2 线程修改了 flag 的值（内存中的值），t1 线程并没有感知到，这时 t1 线程自然就不会退出循环了，因为它还用的是寄存器中的值，这时候就要 使用到 volatile 关键字，告诉编译器不要优化，此时会强制读取内存；

public static volatile int flag = 0;

在 flag 定义时使用 volatile 关键字，再次执行程序：

0bc8bece92c449a598cabf39fb58405d.png

 注意 volatile 保证了内存可见性，不保证原子性，如果两个线程同时对 同一个带有 volatile 修饰的变量进行修改，此时仍会产生线程安全问题；

4. 指令重排序问题

指令重排序也是编译器优化的一种方式：调整原有代码的执行顺序，保证逻辑不变的前提下，提高程序的效率；点这里查看指令重排序的线程安全问题

java 当前线程 等待_Java 多线程等待
weixin_35683330的博客
02-12 3214
背景在一些场景中，我们需要获取多份数据，而这些数据获取的先后顺序是无关的，我们只需要把数据收集齐，然后再对这些数据统一处理。比如：执行两个任务 task1 和 task2，都执行完毕后，再把两个任务的结果相加。例如执行 task1 需要 1s，执行 task2 需要 2s，顺序执行，那么总时间是 1s + 2s = 3s。而如果我们用异步的方式，task1 和 task2 同时执行，则能减少响应的...
Java多线程运用——模拟接力赛
Alcaibur的博客
11-13 818
运用Thread和Runnable的两种线程，模拟接力赛。
Java中线程等待（同步）的五种方法
热门推荐
11-07 1万+
在面试时，经常会有面试官问道，如何将
Java多线程--让主线程等待所有子线程执行完毕
09-09
Java多线程--让主线程等待所有子线程执行完毕
JAVA-多线程join()等待一个线程
最新发布
Lizhihao_的博客
03-19 529
我们知道线程是随机调度执行的，但是有时候我们需要另一个任务完成了，我们才能继续，这个时候我们就可以使用join去等待线程结束。谁调用join谁就等，在主线程中调用 t.join() ，就是main线程等待 “t” 线程结束。第三种了解就可以了，普通的计算机很难精确到纳秒，精确到毫秒就不错了。这里着重讲一下第三种，只要时间到就继续执行，不会等到 t 线程结束。例如：别人向我转100万，需要转完了我再看是否接收到了100万。任意线程都可以进行等待，不是只有主线程可以去等待别的线程。
java中的线程等待
weixin_53714478的博客
04-18 1445
使用.join方法时需要进行加锁，当线程调用.join()方法时，调用此方法的线程会被阻塞在方法调用处，等到等待的线程执行完毕或者运行超时的时候，便会会释放掉锁，调用此方法的线程才会继续执行。
java线程等待_Java线程等待值
weixin_28950415的博客
02-21 433
小编典典创建一些共享存储来保存x每个线程的值，或者如果足够的话，只存储总和。使用aCountDownLatch等待线程终止。每个线程完成后都会调用CountDownLatch.countDown()，您的myAlgorithm方法将使用该CountDownLatch.await()方法来等待它们。编辑： 这是我建议的方法的完整示例。它创建了39个工作线程，每个工作线程都将一个随机数添加到一个共享总...
JAVA 线程等待
baidu_36415076的博客
01-12 574
CyclicBarrier只要有一个线程没完成，所有线程等待 CountDownLatch监听线程操作（比如初始化），等待操作完成之后，通知其他线程 Created with Raphaël 2.1.0主线程主线程CountDownLatch对象CountDownLatch对象子线程子线程子线程子线程主线程主线程1.创建CountDownLatch(1)对象,计数为12.创建一个子线程,长时间
Java多线程系列——-多线程的风险问题
01-08
这篇文章，我想说明一下关于Java多线程中会遇到的几种风险以及它们的 概念 1.死锁: 死锁的含义是指一组线程在执行过程中竞争资源导致的一种阻塞的现象，其原因是其中的每一个线程都在等待仅由该组中其他线程才可以...
java多线程案例——未完成
08-21
Java多线程是Java编程中的一个重要领域，它允许程序同时执行多个任务，从而提高系统效率和资源利用率。在这个未完成的案例中，我们可能正在探讨如何在Java中创建和管理线程，以及处理多线程环境下的并发问题。下面是...
Java多线程--等待所有子线程执行完的五种方法.docx
09-14
Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法
Java多线程————定时器
m0_72786443的博客
09-21 667
定时器 多线程
线程等待（java）
weixin_30478619的博客
04-26 191
定义一个对象： private Object objWaiter = new Object(); 在需要等待的地方加等待锁： synchronized (objWaiter) { objWaiter.wait(1000);//这里可以不用加入超时，也就是会无限期等待下去，建议是加个超时。 } 在另外一个线程撒上进行释放锁： syn...
Java多线程(wait等待通知机制)
2302_80113478的博客
11-09 821
系统内部。线程是抢占式执行，随机调度，程序员也是有手段干预的，通过“等待”的方式，能够让线程一定程度的按照预期来执行，无法主动让某个线程被调度，但是可以主动让某个线程等待等待通知机制，就能够解决上述问题通过条件，判定看当前逻辑是否能够执行，如果不能执行，就主动wait（主动进行阻塞）就把执行的机会让给别的线程了，避免该线程进行一些无意义的重试。
java 多线程 等待返回
飞雨飞羽飞鱼
08-14 1310
方法1： import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Main { public static void main(String[]
Java多线程之线程安全
faster
11-04 386
Java线程安全概念反例正例总结 概念   当多个线程访问某一个类（对象或方法时），这个类始终都能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。 反例    public class Mythread extends Thread{ private int count = 5; @Override public void run() { wh...
多线程线程安全_JAVA
Jesaiahu的博客
04-26 230
多线程同步 当多个线程共享同一个资源,不会受到其他线程的干扰。 线程安全问题 当多个线程同时共享同一个全局变量或静态变量，做写的操作时，可能会发生数据冲突问题。 解决办法 使用多线程之间同步synchronized或使用锁(lock)。 将可能会发生数据冲突问题(线程不安全问题)，只能让当前一个线程进行执行；代码执行完成后释放锁，然后才能让其他线程进行执行。 内置的锁 Java提供了一种内置的锁机...
Java多线程开发之------多线程等待
男儿不展风云志，空有天生八尺躯
03-28 550
我们在开发过程中，会有这样的场景： 我有两个线程，一个线程去获取一个网络数据，我要等待两个线程回来之后，结合他们的数据去展示到ui里面。怎么实现： 面试被问到这个问题，我的回答是： 设置两个boolean 变量，一个线程OK 之后，就把这个线程的变量置为true,两个都OK 了就更新Ui. 面试官说这是最基本的，有没有更好的方法。 CountDownLatch 使用CountDownLatch 看...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Rcnhtin

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值