多线程相关问题-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_50775835/article/details/123389888

本文通过示例介绍了Java中使用wait/notify进行线程间通信，展示了如何让两个线程交替打印ab。接着讨论了volatile关键字在多线程通信中的作用，并给出一个例子。最后，通过一个三线程按顺序打印的案例，阐述了线程间的协作和join方法的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

两个线程循环打印ab

public class WaitAndNotify {
    private static Object lock = new Object();
    static class ThreadA implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadA: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }
    static class ThreadB implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadB: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(1000);
        new Thread(new ThreadB()).start();
    }
}
      输出：
//        ThreadA: 0
//        ThreadB: 0
//        ThreadA: 1
//        ThreadB: 1
//        ThreadA: 2
//        ThreadB: 2
//        ThreadA: 3
//        ThreadB: 3
//        ThreadA: 4
//        ThreadB: 4

需要注意的是等待/通知机制使⽤的是使⽤同⼀个对象锁，如果你两个线程使⽤的是不同的对象锁，那它们之间是不能⽤等待/通知机制通信的。

多个线程（超过2个）需要相互合作，我们⽤简单的“锁”和“等待通知机制”就不那么⽅便了。这个时候就可以⽤到信号量。

基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想，大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候，线程能够感知并执行相应的业务。这也是最简单的一种实现方式

package com.example.demo;

import java.util.ArrayList;
import java.util.List;

class TestSync {
    // 定义一个共享变量来实现通信，它需要是volatile修饰，否则线程不能及时感知
    static volatile boolean notice = false;

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        // 实现线程A
        Thread threadA = new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                list.add("abc");
                System.out.println("线程A向list中添加一个元素，此时list中的元素个数为：" + list.size());
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (list.size() == 5)
                    notice = true;
            }
        });
        // 实现线程B
        Thread threadB = new Thread(() -> {
            while (true) {
                if (notice) {
                    System.out.println("线程B收到通知，开始执行自己的业务...");
                    break;
                }
            }
        });
        //　需要先启动线程B
        threadB.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 再启动线程A
        threadA.start();
    }
}

在这里插入图片描述

三个线程按顺序打印

package com.example.demo;

class Join {

    static int state = 0;

    static class ThreadA implements Runnable {
        @Override
        public void run() {
                while (true){ //要一直监听state的值
                    if(state%3==0) {
                        System.out.println("ThreadA " + state);
                        state++;
                    }
                }
        }
    }
    static class ThreadB implements Runnable {
        @Override
        public void run() {
            while (true){
                if(state%3==1) {
                    System.out.println("ThreadB " + state);
                    state++;
                }
            }
        }
    }
    static class ThreadC implements Runnable {
        @Override
        public void run() {
            while (true){
                if(state%3==2) {
                    System.out.println("ThreadC " + state);
                    state++;
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread threada = new Thread(new ThreadA());
        Thread threadb = new Thread(new ThreadB());
        Thread threadc = new Thread(new ThreadC());

        threada.start();
        threadb.start();
        threadc.start();

    }
}