java多线程编程之使用Synchronized块同步变量

下面就是关于Java多线程编程中使用Synchronized块同步变量的完整攻略。

一、Synchronized块的作用

在Java多线程编程中，当多个线程同时访问某个对象的某个数据时，就会出现竞争状态，进而导致数据的不稳定性。Synchronized（同步）关键字可以用来给对象和方法上锁，以保证只有一个线程可以访问该对象或方法。

Synchronized只锁定对象，而不锁定代码块，所以当线程访问被Synchronized关键字锁定的对象时，其他线程只能等待。也就是说，当多个线程尝试同时访问同一个对象时，只有一个线程能够访问，其余的线程将被阻塞，直到该对象被释放。

二、使用Synchronized同步变量示例

下面我们通过两个示例来详细讲解如何使用Synchronized关键字同步变量。

示例一：使用Synchronized同步方法

public class Account {
    private int balance = 100;

    public synchronized int getBalance() {
        return balance;
    }

    public synchronized void withdraw(int amount) {
        balance -= amount;
    }
}

public class AccountTest {
    public static void main(String[] args) {
        Account account = new Account();
        // 创建两个线程，分别对账户进行取款操作
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                account.withdraw(10);
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                account.withdraw(10);
            }
        });

        thread1.start(); // 启动线程1
        thread2.start(); // 启动线程2
        try {
            thread1.join(); // 等待线程1执行完毕
            thread2.join(); // 等待线程2执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("余额：" + account.getBalance()); // 最终余额应为50
    }
}

在上述示例中，我们创建了一个银行账户类Account，在该类的getBalance()方法和withdraw(int amount)方法上都使用了Synchronized关键字。在主程序中，我们创建了两个线程，分别对账户进行多次取款操作。

需要注意的一点是，当一个线程访问了一个被Synchronized关键字锁定的对象时，其他访问同一对象的线程将被阻塞，直到该对象被释放。

示例二：使用Synchronized同步代码块

public class Counter {
    private int count = 0;
    private Object lock = new Object();

    public int getCount() {
        return count;
    }

    public void increase() {
        synchronized (lock) {
            count++;
        }
    }
}

public class CounterTest {
    public static void main(String[] args) {
        Counter counter = new Counter();

        // 启动10个线程，每个线程累加1000次
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter.increase();
                }
            }).start();
        }

        try {
            Thread.sleep(3000); // 等待所有线程执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Count: " + counter.getCount()); // 最终count的值应为10000
    }
}

在上述示例中，我们创建了一个计数器类Counter，在该类的increase()方法中，我们使用了Synchronized块，将需要同步的代码放在了Synchronized块中。在主程序中，我们创建了10个线程，分别对计数器进行多次累加操作。

需要注意的一点是，当Synchronized块里的代码执行完后，会自动释放锁，等待其他线程获取锁。

三、总结

本文讲解了Java多线程编程中使用Synchronized块同步变量的完整攻略，包括Synchronized块的作用以及通过两个示例详细讲解了如何使用Synchronized关键字同步变量。在编写多线程程序时，要注意对共享数据的访问，使用Synchronized关键字可以有效避免线程安全问题的发生。