Spring Boot结合synchronized实现线程安全的案例

在这个案例中，我们将创建一个简单的Spring Boot应用程序，该应用程序使用synchronized关键字来确保线程安全。我们将创建一个计数器类，该类可以在多个线程之间共享，并使用synchronized方法来确保在同一时间只有一个线程可以修改计数器的值。

1. 首先，创建一个新的Spring Boot项目。你可以使用Spring Initializr（https://start.spring.io/）生成一个基本的项目结构。

2. 在项目中创建一个名为Counter的类，用于存储计数器的值，并提供线程安全的方法来修改和获取该值。

public class Counter {
    private int count;

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

    public synchronized void decrement() {
        count--;
    }

    public synchronized int getCount() {
        return count;
    }
}

3. 在项目中创建一个名为CounterService的类，用于处理与计数器相关的业务逻辑。

import org.springframework.stereotype.Service;

@Service
public class CounterService {
    private final Counter counter;

    public CounterService(Counter counter) {
        this.counter = counter;
    }

    public void increment() {
        counter.increment();
    }

    public void decrement() {
        counter.decrement();
    }

    public int getCount() {
        return counter.getCount();
    }
}

4. 在项目中创建一个名为CounterController的类，用于处理HTTP请求。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/counter")
public class CounterController {
    private final CounterService counterService;

    public CounterController(CounterService counterService) {
        this.counterService = counterService;
    }

    @GetMapping
    public int getCount() {
        return counterService.getCount();
    }

    @PostMapping("/increment")
    public void increment() {
        counterService.increment();
    }

    @PostMapping("/decrement")
    public void decrement() {
        counterService.decrement();
    }
}

5. 运行Spring Boot应用程序，并使用Postman或其他HTTP客户端测试API。你将看到，即使在多个线程之间共享计数器，synchronized关键字也确保了线程安全。

这个案例展示了如何在Spring Boot应用程序中使用synchronized关键字来实现线程安全。然而，需要注意的是，synchronized关键字可能会导致性能问题，因为它会阻塞其他线程直到当前线程完成操作。在高并发场景下，可以考虑使用更高效的并发工具，如java.util.concurrent包中的原子类和锁。