在Java中，除了synchronized关键字，还有哪些方法可以保证线程安全？

在Java中，除了使用synchronized关键字之外，还有多种方法可以保证线程安全，以下是一些常见的策略：

1. 使用ReentrantLock：ReentrantLock是java.util.concurrent.locks包中的一个类，提供了与synchronized关键字类似的同步功能，但它提供了更灵活的锁定机制，包括尝试非阻塞地获取锁、可中断地获取锁以及超时获取锁等。

   Lock lock = new ReentrantLock();
   public void myMethod() {
       lock.lock();
       try {
           // 执行线程安全的代码
       } finally {
           lock.unlock();
       }
   }

2. 利用volatile关键字：volatile关键字可以确保变量的可见性，即当一个线程修改了volatile变量时，新值对其他线程来说是立即可见的。它适用于保护对共享变量的单个读/写操作，但不适用于复合操作。

   private volatile int count = 0;
   public void increment() {
       count++;
   }

3. 使用原子类：java.util.concurrent.atomic包提供了一系列的原子类，如AtomicInteger、AtomicLong、AtomicReference等，它们利用底层硬件的原子指令来保证操作的原子性。

   private AtomicInteger count = new AtomicInteger();
   public void increment() {
       count.incrementAndGet();
   }

4. 使用并发集合：java.util.concurrent包提供了线程安全的并发集合，如ConcurrentHashMap、ConcurrentLinkedQueue等，它们内部实现了线程安全的机制，适用于多线程环境下的数据共享。

   Map<K, V> map = new ConcurrentHashMap<>();
   Queue<E> queue = new ConcurrentLinkedQueue<>();

5. 利用ThreadLocal：ThreadLocal提供了线程局部变量，每个使用该变量的线程都有独立的变量副本，因此不存在线程安全问题。

   private static ThreadLocal<Integer> threadLocalValue = ThreadLocal.withInitial(() -> 0);
   public void increment() {
       int value = threadLocalValue.get();
       threadLocalValue.set(value + 1);
   }

6. 使用StampedLock：StampedLock是Java 8中引入的一种新的锁机制，它支持乐观读和悲观写，适用于读多写少的场景。

   StampedLock lock = new StampedLock();
   public void read() {
       long stamp = lock.tryOptimisticRead();
       try {
           // 执行读取操作
       } finally {
           lock.validate(stamp);
       }
   }

7. 使用CountDownLatch、CyclicBarrier、Semaphore：这些是同步辅助类，用于在并发编程中协调多个线程的执行。

8. 利用不可变对象：不可变对象一旦创建，其状态就不能改变，因此自然是线程安全的。可以通过final关键字、Collections.unmodifiableXXX方法或Guava库中的ImmutableXXX来创建不可变对象。

9. 减少锁的粒度：通过细分锁的作用范围，减少锁的竞争，提高并发性能。

10. 使用CompletableFuture：在处理异步任务时，CompletableFuture提供了一种线程安全的方式来组合多个异步操作。

这些方法可以根据不同的应用场景和性能要求灵活选择，以达到线程安全的目的。