Java中关于线程安全的三种解决方式

Java中线程安全是个比较重要的概念，因为多线程的应用非常常见，如果不保证线程安全就会导致程序运行出现问题。我们可以通过以下三种方式来解决Java中的线程安全问题：

1. 线程同步

线程同步是在多线程环境下为了保证资源的正确访问而采取的一种机制。在Java中可以通过synchronized关键字来实现线程同步。在同一时刻只有一个线程能够执行同步代码块。

举个例子，下面代码实现了一个线程对i进行累加的操作，使用synchronized关键字，保证了多个线程不会同时对i进行操作，也就是保证了线程安全。

class Count {
    private int i;
    public synchronized void increment() {
        i++;
    }
    public int getI() {
        return i;
    }
}

public class Example {
    public static void main(String[] args) throws InterruptedException {
        Count count = new Count();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 100000; j++) {
                    count.increment();
                }
            }).start();
        }
        Thread.sleep(1000);
        System.out.println(count.getI());
    }
}

2. 可重入锁

Java中的可重入锁（ReentrantLock）也可以用来实现线程安全。ReentrantLock提供了与synchronized相同的互斥性和可见性，但是它具有更精细的控制能力。

举个例子，下面代码和上面的例子等效，使用了ReentrantLock实现了锁机制。

class Count {
    private int i;
    private ReentrantLock lock = new ReentrantLock();
    public void increment() {
        lock.lock();
        try {
            i++;
        } finally {
            lock.unlock();
        }
    }
    public int getI() {
        return i;
    }
}

public class Example {
    public static void main(String[] args) throws InterruptedException {
        Count count = new Count();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 100000; j++) {
                    count.increment();
                }
            }).start();
        }
        Thread.sleep(1000);
        System.out.println(count.getI());
    }
}

3. 原子性变量

Java中提供的原子性变量（AtomicXXX）也可以用来实现线程安全。原子性变量提供原子性的读取和写入操作，保证多线程对变量的操作不会引起数据冲突。

举个例子，下面代码也是对i进行累加操作，但是使用了AtomicInteger来代替int，保证了线程安全。

class Count {
    private AtomicInteger i = new AtomicInteger(0);
    public void increment() {
        i.getAndIncrement();
    }
    public int getI() {
        return i.get();
    }
}

public class Example {
    public static void main(String[] args) throws InterruptedException {
        Count count = new Count();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 100000; j++) {
                    count.increment();
                }
            }).start();
        }
        Thread.sleep(1000);
        System.out.println(count.getI());
    }
}

这些都是Java中关于线程安全的三种解决方式，每种方式都有其优缺点，需要结合实际需求来选择。