Java中的线程同步：synchronized关键字、volatile关键字

翻滚的胖子
2023-05-28 13:56:51
后端技术
Java

Java线程同步是Java多线程编程中非常重要的一部分，可以保证线程安全，避免出现数据竞争等问题。本文将介绍Java中线程同步的两种常用方法：synchronized关键字和volatile关键字。

synchronized关键字

synchronized关键字用于实现Java中的线程同步，可以保证同一时刻只有一个线程访问共享资源。synchronized关键字可以用在方法上或代码块上。

方法同步

在Java中，可以使用synchronized关键字修饰方法来实现方法同步。方法同步可以保证同一时刻只有一个线程执行这个方法，其他线程需要等待。

public synchronized void method() {
    // 方法体
}

上述代码中，使用synchronized关键字修饰了method()方法，这样就可以保证同一时刻只有一个线程执行这个方法。

代码块同步

在Java中，也可以使用synchronized关键字修饰代码块来实现代码块同步。代码块同步可以保证同一时刻只有一个线程访问代码块中的代码。

public void method() {
    // 代码块
    synchronized (this) {
        // 代码块中的代码
    }
}

上述代码中，使用synchronized关键字修饰了代码块，这样就可以保证同一时刻只有一个线程访问代码块中的代码。

volatile关键字

volatile关键字用于保证线程之间的可见性，即一个线程修改了共享变量的值，其他线程可以立即看到这个修改。

public class VolatileDemo {
    private volatile int count = 0;
    public void increase() {
        count++;
    }
}

上述代码中，使用volatile关键字修饰了count变量，这样就可以保证线程之间的可见性。

代码案例

下面是一个使用synchronized关键字实现方法同步的代码案例：

public class SynchronizedDemo {
    private int count = 0;
    public synchronized void increase() {
        count++;
    }
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    demo.increase();
                }
            }).start();
        }
        System.out.println(demo.count);
    }
}

上述代码中，使用synchronized关键字修饰了increase()方法，这样就可以保证同一时刻只有一个线程执行这个方法。在main()方法中，创建了10个线程，每个线程执行1000次increase()方法，最终输出count的值。

下面是一个使用volatile关键字保证线程可见性的代码案例：

public class VolatileDemo {
    private volatile int count = 0;
    public void increase() {
        count++;
    }
    public static void main(String[] args) {
        VolatileDemo demo = new VolatileDemo();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    demo.increase();
                }
            }).start();
        }
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println(demo.count);
    }
}

上述代码中，使用volatile关键字修饰了count变量，这样就可以保证线程之间的可见性。在main()方法中，创建了10个线程，每个线程执行1000次increase()方法，最终输出count的值。

通过本文的教学，相信大家已经掌握了Java中的线程同步，包括synchronized关键字和volatile关键字的使用方法和细节，以及对应的代码案例。希望本文能够帮助到编程小白更好地理解和掌握Java多线程编程中的线程同步。

本文为翻滚的胖子原创文章,转载无需和我联系,但请注明来自猿教程iskeys.com