什么是线程安全？

线程安全（Thread Safety）是指在多线程环境下，多个线程可以同时访问一个对象而不造成数据不一致的现象，也就是说，当多个线程同时访问一个对象时，程序的行为依然是正确的。线程安全可以通过多种方式来实现，例如同步（synchronization）、使用线程安全的类（如java.util.concurrent包中的类）等。

以下是Java中实现线程安全的一些常见方法及示例：

1. 使用同步块（Synchronized Block）

同步块是Java中最常见的实现线程安全的方法，通过使用synchronized关键字，可以确保某个代码块在同一时间只能被一个线程执行，从而避免了数据的不一致性。

public class SynchronizedCounter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedCounter counter = new SynchronizedCounter();
        
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount());
    }
}

2. 使用ReentrantLock

ReentrantLock是一个更灵活的同步机制，相比synchronized关键字，它提供了更多的功能，如尝试锁定、可中断锁定、超时锁定等。

import java.util.concurrent.locks.ReentrantLock;

public class LockCounter {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        LockCounter counter = new LockCounter();
        
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount());
    }
}

3. 使用线程安全的类

Java标准库中提供了一些线程安全的类，如java.util.concurrent包中的类，这些类本身是线程安全的，可以直接使用。

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicCounter counter = new AtomicCounter();
        
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount());
    }
}

这些方法可以确保在多线程环境下数据的一致性和正确性，从而实现线程安全。