java 如何处理线程并发

Java处理线程并发的方法有：synchronized关键字、Lock接口、volatile关键字、原子类、线程池。 其中，synchronized关键字 是最常用和最基本的方式之一。它通过在方法或代码块上加锁，确保同一时间只有一个线程可以执行被同步的方法或代码块，从而避免线程间的数据竞争问题。

synchronized关键字的使用非常简单，但也有其局限性。它只适用于单个方法或代码块的同步，对于更复杂的同步需求，可能需要使用Lock接口或其他并发工具。此外，synchronized关键字会阻塞其他线程的执行，可能导致性能问题，因此在高并发场景下需要谨慎使用。

一、synchronized关键字

1. synchronized方法

synchronized关键字可以用来修饰方法，使其成为同步方法。同步方法在执行时，会自动加锁，确保同一时间只有一个线程可以访问该方法。这种方式适合于简单的同步需求。

public class SynchronizedExample {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public synchronized int getCount() {
        return count;
    }
}

在上述代码中，increment和getCount方法是同步方法，确保同一时间只有一个线程可以访问它们。这种方式虽然简单，但在高并发场景下，可能会导致性能瓶颈。

2. synchronized代码块

synchronized关键字还可以用来修饰代码块，这样可以更细粒度地控制同步范围，减少锁的持有时间，提高性能。

public class SynchronizedBlockExample {
    private int count = 0;
    private final Object lock = new Object();
    public void increment() {
        synchronized (lock) {
            count++;
        }
    }
    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }
}

在上述代码中，increment和getCount方法使用了同步代码块，通过显式的锁对象lock来控制同步。这样可以更灵活地控制同步范围，提高性能。

二、Lock接口

1. ReentrantLock

ReentrantLock是Java并发包中的一个锁实现，提供了比synchronized关键字更灵活的锁机制。它支持公平锁、非公平锁、可重入锁等特性。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockExample {
    private int count = 0;
    private final Lock lock = new ReentrantLock();
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

在上述代码中，increment和getCount方法使用了ReentrantLock进行同步，通过显式的lock和unlock方法来控制锁的获取和释放。这种方式更加灵活，但也更容易出错，需要确保在finally块中释放锁。

2. ReadWriteLock

ReadWriteLock是一个读写锁实现，允许多个读线程并发访问，但只允许一个写线程访问，适用于读多写少的场景。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockExample {
    private int count = 0;
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    public void increment() {
        lock.writeLock().lock();
        try {
            count++;
        } finally {
            lock.writeLock().unlock();
        }
    }
    public int getCount() {
        lock.readLock().lock();
        try {
            return count;
        } finally {
            lock.readLock().unlock();
        }
    }
}

在上述代码中，increment方法使用了写锁，而getCount方法使用了读锁，确保同一时间只有一个写线程可以访问，但允许多个读线程并发访问。

三、volatile关键字

volatile关键字用于修饰共享变量，确保变量的可见性。它保证了变量的更新操作对所有线程是可见的，但不保证原子性。

public class VolatileExample {
    private volatile boolean flag = true;
    public void stop() {
        flag = false;
    }
    public void run() {
        while (flag) {
            // do something
        }
    }
}

在上述代码中，flag变量被volatile关键字修饰，确保对其更新操作对所有线程可见。当一个线程调用stop方法将flag设置为false时，另一个线程在run方法中会立即看到这个变化。

四、原子类

1. AtomicInteger

AtomicInteger是Java并发包中的一个原子类，提供了线程安全的整数操作，适用于计数器等场景。

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerExample {
    private final AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet();
    }
    public int getCount() {
        return count.get();
    }
}

在上述代码中，count变量是一个AtomicInteger，通过incrementAndGet方法进行原子递增操作，确保线程安全。

2. AtomicReference

AtomicReference是一个原子引用类型，提供了线程安全的引用操作，适用于复杂对象的原子操作。

import java.util.concurrent.atomic.AtomicReference;
public class AtomicReferenceExample {
    private final AtomicReference<String> value = new AtomicReference<>("initial");
    public void update(String newValue) {
        value.set(newValue);
    }
    public String getValue() {
        return value.get();
    }
}

在上述代码中，value变量是一个AtomicReference，通过set方法进行原子更新操作，确保线程安全。

五、线程池

线程池是Java并发包中的一个重要组件，提供了线程的复用机制，避免频繁创建和销毁线程，提高性能。

1. 创建线程池

Java提供了多种线程池实现，可以通过Executors类来创建常见的线程池。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
    private final ExecutorService executor = Executors.newFixedThreadPool(10);
    public void executeTask(Runnable task) {
        executor.execute(task);
    }
    public void shutdown() {
        executor.shutdown();
    }
}

在上述代码中，通过Executors.newFixedThreadPool方法创建了一个固定大小的线程池，并通过execute方法提交任务进行执行。

2. 自定义线程池

可以通过ThreadPoolExecutor类来自定义线程池，设置线程池的核心线程数、最大线程数、任务队列等参数。

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class CustomThreadPoolExample {
    private final ThreadPoolExecutor executor = new ThreadPoolExecutor(
            10, 20, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
    public void executeTask(Runnable task) {
        executor.execute(task);
    }
    public void shutdown() {
        executor.shutdown();
    }
}

在上述代码中，通过ThreadPoolExecutor类创建了一个自定义线程池，可以根据需求设置线程池的各项参数，提高性能和灵活性。

通过以上几种方法，Java提供了丰富的线程并发处理机制，可以根据具体场景选择合适的方式，确保程序的线程安全和高效运行。在实际应用中，通常需要综合使用这些方法，结合具体业务逻辑，设计合理的并发处理方案。