多线程：使用同步措施解决并发引起的可见性问题

本文链接：https://blog.youkuaiyun.com/wxd772113786/article/details/118633513

本文详细介绍了Java中解决线程并发问题的synchronized关键字，包括其保证的可见性和串行执行特性。通过示例展示了如何在多线程环境下使用synchronized实现写线程和读线程的同步，确保写入后才能读取，读取后才能写入。同时，解释了yield、wait、notify和notifyAll、sleep以及join这些线程控制方法的用途和工作原理。

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

解决线程并发问题的常用方法：

1.volatile关键字

2.synchronized关键字(它也是锁，而且是可重入锁)

3.锁(synchronized以外的锁，比如ReentrantLock等)

下面主要介绍下synchronized关键字这种方式。

多线程可见性问题，具体可以参看另一篇文章：

点击这里

另外，插一嘴，多个线程访问同一个类的不同synchronized方法时, 都是串行执行的 ! 就算有多个cpu也不例外 ! synchronized方法使用了java的内置锁, 即锁住的是方法所属对象本身。什么意思呢？就是多个线程不能同时（并发）访问同一个同步方法，也不能同时（并发）访问不同的同步方法。

还有，关于多线程有几个常用的方法，分别如下：
yield(): 礼让。它能够让当前线程从“运行状态”进入到“就绪状态”，让出cpu执行权，从而让其他等待线程可以执行，但是也有可能重新调度到自己。
waite(): 等待。将当前运行的线程挂起（即让其进入阻塞状态，将执行机会让给其他线程），直到被notify或notifyAll方法唤醒，继续执行。[会释放锁]
notify(): 单一通知。只能随机唤醒一个等待的线程，让其继续执行。
notifyAll(): 全部通知。唤醒所有等待的线程，让他们继续执行。
sleep(): 睡眠。让当前线程睡眠指定的时长，会暂时让出指定时长的CPU执行权，苏醒后，线程就处于就绪状态(可运行状态)，然后参与CPU的调度，获取到CPU资源后就可以继续执行了。也就是说，当前线程睡眠完以后，一定会执行，但是不一定会立刻执行。[不会释放锁]
join(): 插队。让一个插队线程强制运行，此时，被插队的线程无法运行，必须等待插队线程执行完之后才可以继续执行。比如在主线程中执行t1.join()，那么子线程t1优先执行，执行完以后，主线程继续执行，同时不影响处在运行状态的其他线程（非主线程）。简单的说，就是插队线程因为插队而优先执行，它只影响被插队线程的执行，不影响其他线程的执行。

示例

缓存类

public class MyCache {
    public String key;
    public String value;
    /**
     * 标记cache是否为空
     */
    public boolean isEmpty = true;

    @Override
    public String toString() {
        return "MyCache{" +
                "key='" + key + '\'' +
                ", value='" + value + '\'' +
                ", isEmpty=" + isEmpty +
                '}';
    }
}

写线程

/**
 * 写线程
 */
public class InputThread extends Thread {
    private int count = 0;
    private int nums = 0;
    private MyCache myCache;

    /**
     * 初始化缓存
     */
    public InputThread(MyCache myCache) {
        this.myCache = myCache;
    }

    /**
     * 任务
     */
    @Override
    public void run() {
        /**
         * 往cache写入内容
         * 0: 写入用户名
         * 1: 写入密码
         */
        while (true) {
            //同步代码块，使用myCache作为锁，保证只能进入写逻辑或读逻辑[线程并发执行，但同步代码块是串行执行的]
            synchronized (myCache) {
                if (!myCache.isEmpty) {
                    try {
                        //如果myCache不为空，就将当前运行的线程挂起（即让其进入阻塞状态，将执行机会让给其他线程），直到被notify或notifyAll方法唤醒[会释放锁]
                        //保证了写入的时候，myCache必须为空，即已经被读出才能再次写入（有可能写入完毕后，没有等待的读线程，重新进入写线程，就会阻塞等待读出，然后强制执行读出）
                        myCache.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (count == 0) {
                    myCache.key = "username";
                    myCache.value = "用户名";
                } else {
                    myCache.key = "password";
                    myCache.value = "密码";
                }
                /**
                 * 0->1 1->0 0->1 1->0
                 * ...
                 */
                count = (count + 1) % 2;
                //写入后，标记isEmpty不为空
                myCache.isEmpty = false;

                //写入完毕后，接着去通知正在等待读取的线程（当前线程既然执行到这里了，说明它没有处于等待状态，一般来说就是指当前线程唤醒其它所有等待线程）
                myCache.notifyAll();
            }
        }
    }
}

读线程

/**
 * 读线程
 */
public class OutputThread extends Thread {
    private MyCache myCache;
    private int num = 0;

    /**
     * 初始化缓存
     */
    public OutputThread(MyCache myCache) {
        this.myCache = myCache;
    }

    /**
     * 任务
     */
    @Override
    public void run() {
        /**
         * 从cache读出内容
         */
        while (true) {
            //同步代码块，使用myCache作为锁，保证只能进入写逻辑或读逻辑[线程并发执行，但同步代码块是串行执行的]
            synchronized (myCache) {
                if (myCache.isEmpty) {
                    try {
                        //如果cache为空，就将当前运行的线程挂起（即让其进入阻塞状态，将执行机会让给其他线程），直到被notify或notifyAll方法唤醒[会释放锁]
                        //保证了读出的时候，myCache必须不为空，即已经被写入才能再次读出（有可能读出完毕后，没有等待的写线程，重新进入读线程，就会阻塞等待写入，然后强制执行写入）
                        //疑问：对象.wait()，什么意思?
                        //解惑：首先要理解notify()和wait()，这两个方法原本就不属于Thread类,而是属于最底层的object基础类的，也就是说不光是Thread，每一个对象都有notify和wait的功能。
                        //每一个对象都有锁，锁是每一个对象的基础，既然锁是基础的,那么操纵锁的方法固然也是基础的，所以通过对象来操作就很好理解了。
                        //调用某个对象的wait()方法，相当于让当前线程交出此对象的monitor（即锁），然后进入等待状态，等待后续再次获得此对象的锁。
                        myCache.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(myCache);
                //读出后，标记isEmpty为空
                myCache.isEmpty = true;

                //读取完毕后，接着去通知正在等待写入的进程（当前线程既然执行到这里了，说明它没有处于等待状态，一般来说就是指当前线程唤醒其它所有等待线程）
                myCache.notifyAll();
            }
        }
    }
}

测试类

/**
 * 测试类：模拟两个线程，Input进程负责往cache中写入信息，Output进程负责读出cache中的信息。
 * 实现逻辑：只有Input进程往cache中写入了内容，Output进程才能进行读取信息，同样只有Output进程读出了信息，Input进程才能继续写入信息到cache。
 * 常用方法：
 * yield(): 礼让。它能够让当前线程从“运行状态”进入到“就绪状态”，让出cpu执行权，从而让其他等待线程可以执行，但是也有可能重新调度到自己。
 * waite(): 等待。将当前运行的线程挂起（即让其进入阻塞状态，将执行机会让给其他线程），直到被notify或notifyAll方法唤醒，继续执行。[会释放锁]
 * notify(): 单一通知。只能随机唤醒一个等待的线程，让其继续执行。
 * notifyAll(): 全部通知。唤醒所有等待的线程，让他们继续执行。
 * sleep(): 睡眠。让当前线程睡眠指定的时长，会暂时让出指定时长的CPU执行权，苏醒后，线程就处于就绪状态(可运行状态)，然后参与CPU的调度，获取到CPU资源后就可以继续执行了。也就是说，当前线程睡眠完以后，一定会执行，但是不一定会立刻执行。[不会释放锁]
 * join(): 插队。让一个插队线程强制运行，此时，被插队的线程无法运行，必须等待插队线程执行完之后才可以继续执行。比如在主线程中执行t1.join()，那么子线程t1优先执行，执行完以后，主线程继续执行，同时不影响处在运行状态的其他线程（非主线程）。简单的说，就是插队线程因为插队而优先执行，它只影响被插队线程的执行，不影响其他线程的执行。
 */
public class Test {
    public static void main(String[] args) {
        //创建一个公共cache
        MyCache myCache = new MyCache();
        //创建写线程
        InputThread inputThread = new InputThread(myCache);
        //创建读线程
        OutputThread outputThread = new OutputThread(myCache);
        /**
         * 启动基于同一个缓存的两个线程
         * 写->读->写
         * 打印内容：
         * ...
         *
         * 结果：在synchronized的加持下，不会出现一直阻塞的情况。但会一直处于循环写->读->写的状态。
         */
        inputThread.start();
        outputThread.start();
    }
}