Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.

이 글은 스레드 설치, 스레드 잠금 및 스레드 불안전성, 표준 스레드 안전 클래스 등 멀티스레딩과 관련된 문제를 주로 소개하는 java에 대한 관련 지식을 제공합니다. 내용, 모든 사람에게 도움이 되기를 바랍니다. .

추천 연구: "java 비디오 튜토리얼"

이 기사에서는 Java 멀티스레딩의 스레드 안전 문제를 소개합니다. 여기서 말하는 보안 문제는 해커로 인한 보안 문제를 의미하지 않습니다. 다중 스레드 선점 실행으로 인해 발생하는 프로그램.

1. 스레드 안전성 개요

1.1 스레드 안전성 문제란 무엇입니까

우선, 운영 체제의 스레드 스케줄링은 선점적 또는 무작위이므로 스레드 스케줄링 시 스레드의 실행 순서가 결정된다는 점을 이해해야 합니다. 일부 코드의 실행 순서는 프로그램의 실행 결과에 영향을 미치지 않지만, 실행 순서를 변경하는 코드도 있으며 이로 인해 프로그램에 버그가 발생할 수 있습니다. 다중 스레드 동시성의 경우 프로그램에 버그를 일으키는 코드를 스레드 안전하지 않은 코드라고 합니다.

아래에서는 스레드 안전성 문제의 대표적인 예인 정수 자기증가 문제를 소개하겠습니다.

1.2 스레드 안전 문제가 있는 프로그램

어느 날 교사는 다음과 같은 문제를 내놓았습니다. 두 개의 스레드를 사용하여 매번 변수 count를 10번씩 증가시키는 것입니다. 스레드는 자동 증가 작업을 5번 수행하고 count 변수의 초기 값은 0입니다.
이 질문은 매우 간단합니다. 최종 결과를 말로 계산할 수도 있습니다. 답은 1억입니다.
Xiao Ming은 매우 빠르게 작업하여 다음 코드를 작성했습니다. count自增10万次，每个线程承担5万次的自增任务，变量count的初始值为0。
这个问题很简单，最终的结果我们也能够口算出来，答案就是10万。
小明同学做事非常迅速，很快就写出了下面的一段代码：

class Counter {
    private int count;
    public void increase() {
        ++this.count;
    }
    public int getCount() {
        return this.count;
    }}public class Main11 {
    private static final int CNT = 50000;
    private static final Counter counter = new Counter();
    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i  {
            for (int j = 0; j <p>按理来说，结果应该是<code>10</code>万，我们来看看Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.：<br><img src="https://img.php.cn/upload/article/000/000/067/5a3746e6458021f78f91292b5a885487-1.png" alt="Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다."><br> 运行的结果比<code>10</code>万要小，你可以试着运行该程序你会发现每次运行的结果都不一样，但绝大部分情况，结果都会比预期的值要小，下面我们就来分析分析为什么会这样。</p><h2><strong>2.线程Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.与线程不安全的原因</strong></h2><h2>2.1案例分析</h2><p>上面我们使用多线程运行了一个程序，将一个变量值为0的变量自增10万次，但是最终实际结果比我们预期结果要小，原因就是线程调度的顺序是随机的，造成线程间自增的指令集交叉，导致运行时出现两次自增但值只自增一次的情况，所以得到的结果会偏小。</p><p>我们知道一次自增操作可以包含以下几条指令：</p><ol>
<li>将内存中变量的值加载到寄存器，不妨将该操作记为<code>load</code>。</li>
<li>在寄存器中执行自增操作，不妨将该操作记为<code>add</code>。</li>
<li>将寄存器的值保存至内存中，不妨将该操作记为<code>save</code>。</li>
</ol><p>我们来画一条时间轴，来总结一下常见的几种情况：</p><p><strong>Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.：</strong> 线程间指令集，无交叉，Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.与预期相同，图中寄存器A表示线程1所用的寄存器，寄存器B表示线程2所用的寄存器，后续情况同理。<br><img src="https://img.php.cn/upload/article/000/000/067/1a7f0bb1b7c2552a80983e04b900dc15-2.png" alt="Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다."><br><strong>Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.：</strong> 线程间指令集存在交叉，Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.低于预期结果。<br><img src="https://img.php.cn/upload/article/000/000/067/1a7f0bb1b7c2552a80983e04b900dc15-3.png" alt="Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다."><br><strong>Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.：</strong> 线程间指令集完全交叉，实际结果低于预期。<br><img src="https://img.php.cn/upload/article/000/000/067/4e482e48ea6191128516ca82417af3cf-4.png" alt="Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다."><br> 根据上面我们所列举的情况，发现线程运行时没有交叉指令的时候Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.是正常的，但是一旦有了交叉会导致自增操作的结果会少<code>1</code></p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:php;toolbar:false">class Counter {
    private int count;
    synchronized public void increase() {
        ++this.count;
    }
    public int getCount() {
        return this.count;
    }}

로그인 후 복사

논리적으로 말하면 결과는 10백만이어야 합니다. 실행 결과를 살펴보겠습니다.

실행 결과는 10보다 작습니다. 프로그램을 실행해 보면 결과가 매번 달라지는 것을 알 수 있습니다. 그러나 대부분의 경우 결과는 예상한 값보다 작습니다. 왜 그런 것인지 분석해 보세요.

2. 스레드 잠금 및 스레드 불안전의 이유

2.1 사례 분석

위에서는 멀티스레딩을 사용하여 프로그램을 실행하고 변수에 0의 값을 100,000번 증가시켰지만 최종 실제 결과는 다음과 같습니다. 그 이유는 스레드 스케줄링의 순서가 무작위이기 때문에 스레드의 자체 증가 명령 세트가 겹쳐서 런타임 동안 두 번의 자체 증가가 발생하지만 결과는 한 번만 발생하기 때문입니다. 편견을 가지세요.

증분 작업에는 다음 지침이 포함될 수 있다는 것을 알고 있습니다. 🎜

1. 메모리의 변수 값을 레지스터에 로드합니다. 이 작업을 load로 기록할 수 있습니다. .
2. 레지스터에서 자동 증가 작업을 수행하려면 해당 작업을 add로 기록할 수 있습니다.
3. 레지스터 값을 메모리에 저장합니다. 이 작업을 save로 기록할 수 있습니다.

🎜몇 가지 일반적인 상황을 요약하는 타임라인을 그려 보겠습니다. 🎜🎜🎜사례 1: 🎜 스레드 간 명령어 세트, 크로스오버 없음, 작동 결과가 예상과 동일, 그림에 A 등록 레지스터는 스레드 1이 사용하는 레지스터이고, 레지스터 B는 스레드 2가 사용하는 레지스터를 나타냅니다. 후속 상황에도 동일하게 적용됩니다.

🎜사례 2 :🎜 스레드 간 명령 집합이 겹치고 실행 결과가 예상보다 낮습니다.

🎜사례 3 :🎜 명령어 세트가 스레드 간에 완전히 교차되어 실제 결과가 예상보다 낮습니다.

위에 나열된 상황에서 스레드가 실행 중일 때 교차 명령이 없으면 실행 결과가 정상이지만 일단 교차가 있으면 자동 증가 연산의 결과는 1보다 적습니다. 를 요약하면 자동 증가 작업이 원자적이지 않고 여러 스레드를 동시에 실행하면 명령어 실행이 중복되어 스레드 안전 문제가 발생할 수 있다는 결론을 내릴 수 있습니다. 🎜🎜그렇다면 위의 스레드 안전하지 않은 문제를 해결하는 방법은 무엇일까요? 물론 개체를 잠그는 것이 있습니다. 🎜🎜2.2 스레드 잠금🎜🎜🎜2.2.1 잠금이란 무엇입니까🎜🎜🎜"선제 실행"으로 인한 스레드 안전성 문제를 해결하기 위해 스레드가 개체가 잠긴 후 작업 개체를 잠글 수 있습니다. , 개체가 잠깁니다. 다른 스레드가 개체의 작업을 수행해야 하는 경우 해당 스레드가 개체의 작업 실행을 완료할 때까지 기다려야 개체를 수행할 수 있습니다. 🎜

举个例子，假设要你去银行的ATM机存钱或者取款，每台ATM机一般都在一间单独的小房子里面，这个小房子有一扇门一把锁，你进去使用ATM机时，门会自动的锁上，这个时候如果有人要来取款，那它得等你使用完并出来它才能进去使用ATM，那么这里的“你”相当于线程，ATM相当于一个对象，小房子相当于一把锁，其他的人相当于其他的线程。


在java中最常用的Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.操作就是使用synchronized关键字进行Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.。

2.2.2如何Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.

synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待。
线程进入 synchronized 修饰的代码块, 相当于Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.，退出 synchronized 修饰的代码块, 相当于 解锁。

java中的Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.操作可以使用synchronized关键字来实现，它的常见使用方式如下：

方式1： 使用synchronized关键字修饰普通方法，这样会使方法所在的对象加上一把锁。
例如，就以上面自增的程序为例，尝试使用synchronized关键字进行Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.，如下我对increase方法进行了Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.，实际上是对某个对象Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.，此锁的对象就是this，本质上Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.操作就是修改this对象头的标记位。

class Counter {
    private int count;
    synchronized public void increase() {
        ++this.count;
    }
    public int getCount() {
        return this.count;
    }}

多线程自增的main方法如下，后面会以相同的栗子介绍synchronized的其他用法，后面就不在列出这段代码了。

public class Main11 {
    private static final int CNT = 50000;
    private static final Counter counter = new Counter();
    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i  {
            for (int j = 0; j <p>看看Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.：<br><img src="https://img.php.cn/upload/article/000/000/067/6e6c80338fcb268f141a907ecdcadb51-7.png" alt="Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다."><br><strong>方式2：</strong> 使用<code>synchronized</code>关键字对代码段进行Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.，但是需要显式指定Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.的对象。<br> 例如：</p><pre class="brush:php;toolbar:false">class Counter {
    private int count;
    public void increase() {
        synchronized (this){
            ++this.count;
        }
    }
    public int getCount() {
        return this.count;
    }}

Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.：

方式3： 使用synchronized关键字修饰静态方法，相当于对当前类的类对象进行Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.。

class Counter {
    private static int count;
    synchronized public static void increase() {
        ++count;
    }
    public int getCount() {
        return this.count;
    }}

Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.：

常见的用法差不多就是这些，对于线程Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.（线程拿锁），如果两个线程同时拿一个对象的锁，就会产生锁竞争，两个线程同时拿两个不同对象的锁不会产生锁竞争。
对于synchronized这个关键字，它的英文意思是同步，但是同步在计算机中是存在多种意思的，比如在多线程中，这里同步的意思是“互斥”；而在IO或网络编程中同步指的是“异步”，与多线程没有半点的关系。

synchronized 的工作过程:

1. 获得互斥锁lock
2. 从主内存拷贝变量的最新副本到工作的内存
3. 执行代码
4. 将更改后的共享变量的值刷新到主内存
5. 释放互斥锁unlock

synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题，即死锁问题，关于死锁后续文章再做介绍。

综上，synchronized关键字Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.有如下性质：互斥性，刷新内存性，可重入性。

synchronized关键字也相当于一把监视器锁monitor lock，如果不Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.，直接使用wait方法（一种线程等待的方法，后面细说），会抛出Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.，引发这个异常的原因就是没有Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.。

2.2.3再析案例

对自增那个代码上锁后，我们再来分析一下为什么加上了所就线程安全了，先列代码：

class Counter {
    private int count;
    synchronized public void increase() {
        ++this.count;
    }
    public int getCount() {
        return this.count;
    }}public class Main11 {
    private static final int CNT = 50000;
    private static final Counter counter = new Counter();
    public static void main(String[] args) throws InterruptedException {

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i  {
            for (int j = 0; j <p>多线程并发执行时，上一次就分析过没有指令集交叉就不会出现问题，因此这里我们只讨论指令交叉后，Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.操作是如何保证线程安全的，不妨记Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.为<code>lock</code>，解锁为<code>unlock</code>，两个线程运行过程如下：<br> 线程1首先拿到目标对象的锁，对对象进行Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.，处于<code>lock</code>状态，当线程2来执行自增操作时会发生阻塞，直到线程1的自增操作完毕，处于<code>unlock</code>状态，线程2才会就绪取执行线程2的自增操作。<br><img src="https://img.php.cn/upload/article/000/000/067/aacb0e52e264f65d74e598d37852834f-10.png" alt="Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다."><br> Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.后线程就是串行执行，与单线程其实没有很大的区别，那多线程是不是没有用了呢？但是对方法Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.后，线程运行该方法才会Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.，运行完该方法就会自动解锁，况且大部分操作并发执行是不会造成线程安全的，只有少部分的修改操作才会有可能导致线程安全问题，因此整体上多线程运行效率还是比单线程高得多。</p><h2>2.3线程不安全的原因</h2><p>首先，线程不安全根源是线程间的调度充满随机性，导致原有的逻辑被改变，造成线程不安全，这个问题无法解决，无可奈何。</p><p>多个线程针对同一资源进行写（修改）操作，并且针对资源的修改操作不是原子性的，可能会导致线程不安全问题，类似于数据库的事务。</p><p>由于编译器的优化，内存可见性无法保证，就是当线程频繁地对同一个变量进行读操作时，会直接从寄存器上读值，不会从内存上读值，这样内存的值修改时，线程就感知不到该变量已经修改，会导致线程安全问题（这是编译器优化的结果，现代的编译器都有类似的优化不止于Java），因为相比于寄存器，从内容中读取数据的效率要小的多，所以编译器会尽可能地在逻辑不变的情况下对代码进行优化，单线程情况下是不会翻车的，但是多线程就不一定了，比如下面一段代码：</p><pre class="brush:php;toolbar:false">import java.util.Scanner;public class Main12 {
    private static int isQuit;
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (isQuit == 0) {

            }
            System.out.println("线程thread执行完毕!");
        });
        thread.start();

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入isQuit的值，不为0线程thread停止执行!");
        isQuit = sc.nextInt();
        System.out.println("main线程执行完毕!");
    }}

Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.：

我们从Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.可以知道，输入isQuit后，线程thread没有停止，这就是编译器优化导致线程感知不到内存可见性，从而导致线程不安全。
我们可以使用Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.关键字保证内存可见性。
我们可以使用Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.关键字修饰isQuit来保证内存可见性。

import java.util.Scanner;public class Main12 {
    Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다. private static int isQuit;
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (isQuit == 0) {

            }
            System.out.println("线程thread执行完毕!");
        });
        thread.start();

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入isQuit的值，不为0线程thread停止执行!");
        isQuit = sc.nextInt();
        System.out.println("main线程执行完毕!");
    }}

Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.：

synchronized与Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.关键字的区别：
synchronized关键字能保证原子性，但是是否能够保证内存可见性要看情况（上面这个栗子是不行的），而Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.关键字只能保证内存可见性不能保证原子性。
保证内存可见性就是禁止编译器做出如上的优化而已。

import java.util.Scanner;public class Main12 {
    private static int isQuit;
    //锁对象
    private static final Object lock = new Object();
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
                synchronized (lock) {
                    while (isQuit == 0) {

                    }
                    System.out.println("线程thread执行完毕!");
                }
        });
        thread.start();

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入isQuit的值，不为0线程thread停止执行!");
        isQuit = sc.nextInt();
        System.out.println("main线程执行完毕!");
    }}

Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.：

编译器优化除了导致内存可见性感知不到的问题，还有指令重排序也会导致线程安全问题，指令重排序也是编译器优化之一，就是编译器会智能地（保证原有逻辑不变的情况下）调整代码执行顺序，从而提高程序运行的效率，单线程没问题，但是多线程可能会翻车，这个原因了解即可。

3.线程安全的标准类

Java 标准库中很多都是线程不安全的。这些类可能会涉及到多线程修改共享数据, 又没有任何Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.措施。例如，ArrayList，LinkedList，HashMap，TreeMap，HashSet，TreeSet，StringBuilder。
但是还有一些是线程安全的，使用了一些锁机制来控制，例如，Vector (不推荐使用)，HashTable (不推荐使用)，ConcurrentHashMap (推荐)，StringBuffer。
还有的虽然没有Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다., 但是不涉及 “修改”, 仍然是线程安全的，例如String。

在线程安全问题中可能你还会遇到JMM模型，在这里补充一下，JMM其实就是把操作系统中的寄存器，缓存和内存重新封装了一下，其中在JMM中寄存器和缓存称为工作内存，内存称为主内存。
其中缓存分为一级缓存L1，二级缓存L2和三级缓存L3，从L1到L3空间越来越大，最大也比内存空间小，最小也比寄存器空间大，访问速度越来越慢，最慢也比内存的访问速度快，最快也没有寄存器访问快。

4.Object类提供的线程等待方法

除了Thread类中的能够实现线程等待的方法，如join,sleep，在Object类中也提供了相关线程等待的方法。

序号	方法	说明
1	public final void wait() throws InterruptedException	释放锁并使线程进入WAITING状态
2	public final native void wait(long timeout) throws InterruptedException;	相比于方法1，多了一个最长等待时间
3	public final void wait(long timeout, int nanos) throws InterruptedException	相比于方法2，等待的最长时间精度更大
4	public final native void notify();	唤醒一个WAITING状态的线程，并Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.，搭配wait方法使用
5	public final native void notifyAll();	唤醒所有处于WAITING状态的线程，并Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.（很可能产生锁竞争），搭配wait方法使用

上面介绍synchronized关键字的时候，如果不对线程Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.会产生非法监视异常，我们来验证一下：

public class TestDemo12 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("执行完毕！");
        });

        thread.start();
        System.out.println("wait前");
        thread.wait();
        System.out.println("wait后");
    }}

看看Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.：

果然抛出了一个IllegalMonitorStateException，因为wait方法的执行步骤为：先释放锁，再使线程等待，你现在都没有Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.，那如何释放锁呢？所以会抛出这个异常，但是执行notify是无害的。

wait方法常常搭配notify方法搭配一起使用，前者能够释放锁，使线程等待，后者能获取锁，使线程继续执行，这套组合拳的流程图如下：

现在有两个任务由两个线程执行，假设线程2比线程1先执行，请写出一个多线程程序使任务1在任务2前面完成，其中线程1执行任务1，线程2执行任务2。
这个需求可以使用wait/notify来实现。

class Task{
    public void task(int i) {
        System.out.println("任务" + i + "完成！");
    }}public class WiteNotify {
    //锁对象
    private static final Object lock = new Object();
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                Task task1 = new Task();
                task1.task(1);
                //通知线程2线程1的任务完成
                System.out.println("notify前");
                lock.notify();
                System.out.println("notify后");
            }
        });
        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                Task task2 = new Task();
                //等待线程1的任务1执行完毕
                System.out.println("wait前");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                task2.task(2);
                System.out.println("wait后");
            }
        });
        thread2.start();
        Thread.sleep(10);
        thread1.start();
    }}

Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.：

推荐学习：《java视频教程》

위 내용은 Java 멀티스레딩의 스레드 안전 문제에 대해 이야기해 보겠습니다.의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!