深入理解Java并发编程中的锁问题实例

原创约定不等于承诺〃 2024-11-24 23:30 19阅读 0赞

在Java的并发编程中，锁问题是一种常见的同步机制。当多个线程试图访问或修改共享资源时，如果没有适当的锁进行保护，就会出现数据不一致或死锁等问题。

以下是一个简单的锁问题实例：

```java
// 假设我们有一个类Person，它有一个私有属性name
public class Person {
    private String name;

// 设置名字的getter方法
    public String getName() {
        return name;
    }

// 设置名字的setter方法（添加锁）
    public void setName(String name) {
        synchronized (this) {  // 对Person对象加锁
            if (name != null && !name.isEmpty()) {
                this.name = name;
            } else {
                System.out.println("Invalid name provided.");
            }
        }
    }
}

// 测试类，创建多个线程修改同一个Person实例
public class TestLock {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person();

// 创建两个线程，尝试同时修改person1的名字
        Thread thread1 = new Thread(() -> {
            try {
                person1.setName("New Name 1");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }));

Thread thread2 = new Thread(() -> {
            try {
                person1.setName("New Name 2");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }));

// 启动两个线程
        thread1.start();
        thread2.start();

// 等待所有线程执行完毕
        thread1.join();
        thread2.join();

System.out.println(person1.getName());  // 检查最终结果
    }
}
```

在这个例子中，`Person`类有两个属性：`name`和`setName`。我们创建了两个线程分别试图修改同一个`person1`对象的名字。

由于没有对`setName`方法加锁（即不使用同步控制），当两个线程同时尝试修改`person1`对象的名字时，就会出现数据不一致的问题。