如何在JAVA中使用Synchronized

当多个线程尝试访问共享资源时，会造成数据竞争的问题，导致程序出现意想不到的结果。Java的Synchronized关键字可以协调多个线程之间对共享资源的访问，保证线程的安全性。下面是如何使用Synchronized关键字的攻略。

为什么需要使用Synchronized

当多个线程同时访问共享资源时，由于竞争条件的存在，可能会导致数据的不一致和计算结果的错误，这就是著名的“数据竞争”问题，也称为“并发缺陷”。

如果程序的操作不是原子操作（分解成多个步骤执行），因为各个线程执行操作的时机不一致，可能会造成在某个线程还没执行完操作时，另外一个线程已经开始了操作，从而导致出现数据竞争的情况。

因此，当多个线程同时访问共享资源时，我们需要保证原子性、可见性和有序性，以避免出现数据竞争问题。

Java的Synchronized关键字可以解决这个问题，它可以将多个并发访问共享资源的操作变成一个原子操作，从而确保线程的安全性。

Synchronized关键字的使用方式

Synchronized有两种用法：使用在方法上和使用在代码块上。

方法上的Synchronized

当一个方法用Synchronized关键字修饰时，它变成了一个同步方法，只有一个线程可以访问它。

下面是一个示例：

public synchronized void synMethod() {
    //操作共享资源的代码
}

当一个线程调用synMethod方法时，其他线程会被阻塞，直到这个线程执行完方法中的代码。

代码块上的Synchronized

当一个代码块用Synchronized关键字修饰时，它变成了一个同步代码块，只有一个线程可以访问它。

下面是一个示例：

public void synBlock() {
    synchronized (this) {
        //操作共享资源的代码
    }
}

当一个线程进入synBlock方法时，其他线程也可以进入这个方法，但是只有一个线程可以进入同步代码块中的代码。

示例

下面是一个示例，演示Synchronized关键字的用法。

public class SyncExample {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public void run() throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                increment();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Count: " + count);
    }
}

在这个示例中，我们定义了一个SyncExample类，它有一个increment方法，用来增加count变量的值。

我们定义了两个线程(thread1和thread2)，它们都会调用increment方法增加count的值。

我们运行这个程序后，期望的结果是count的值应该是20000。但是，由于多个线程同时访问了count变量，可能会造成数据竞争问题，导致count的值出现错误。

为了避免这个问题，我们需要在increment方法上使用Synchronized关键字，让多个线程同步访问这个方法。

public synchronized void increment() {
    count++;
}

我们再次运行这个程序，就会发现count的值确实是20000，这说明Synchronized关键字确实解决了多个线程同时访问共享资源的问题。

另外一个示例：

public class SyncExample {
    private int count = 0;

    public void run() throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            synchronized (this) {
                for (int i = 0; i < 10000; i++) {
                    count++;
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (this) {
                for (int i = 0; i < 10000; i++) {
                    count++;
                }
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Count: " + count);
    }
}

在这个示例中，我们定义了两个线程(thread1和thread2)，它们对count变量进行了递增操作。

为了避免数据竞争问题，我们在每个线程的递增操作前使用了Synchronized关键字：synchronized(this)，这样每次只有一个线程可以访问count变量。

我们运行这个程序，发现count的值确实是20000，这也说明Synchronized关键字确实解决了多个线程同时访问共享资源的问题。

通过这两个示例，我们可以看到Synchronized关键字确实可以确保多个线程并发访问共享资源时的线程安全性，并防止数据竞争问题的发生。