在Linux下使用Ja va实现并发控制

在Linux环境下进行Ja va开发，并发控制是绕不开的核心话题。面对多线程带来的数据竞争和状态不一致问题，Ja va提供了一套相当成熟的工具箱。今天，我们就来梳理几种最常用、也最有效的同步机制，看看它们各自的特点和适用场景。

1. 使用synchronized关键字

说到Ja va同步，synchronized关键字绝对是元老级的存在。它作为语言内置的最基本同步机制，用法直观：既可以修饰整个方法，也可以包裹特定的代码块。其核心逻辑很简单——当一个线程进入某个对象的同步方法或代码块时，它就持有了该对象的锁，其他线程要想访问同一对象的同步区域，就只能乖乖排队等候。

public class Counter {
    private int count;
    public synchronized void increment() {
        count++;
    }
}

这种方式优点是上手快，语义清晰。但缺点也明显：锁的获取和释放是隐式的，灵活性相对不足。

2. 使用ReentrantLock类

如果你需要更精细的控制，那么ja va.util.concurrent.locks.ReentrantLock就该登场了。作为synchronized的增强版，它是一个可重入的互斥锁，把锁的操作从语言层面提升到了API层面。

import ja va.util.concurrent.locks.Lock;
import ja va.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count;
    private final Lock lock = new ReentrantLock();

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

最大的好处是什么？灵活性。你可以尝试非阻塞地获取锁（tryLock），可以设置公平性策略，还能配合Condition实现更复杂的线程通信。当然，权力越大责任越大，务必记得在finally块中释放锁，这是铁律。

3. 使用Semaphore类

有些场景下，限制同时访问资源的线程数量比互斥访问更重要。比如数据库连接池。这时，ja va.util.concurrent.Semaphore（信号量）就是专为此而生的工具。它维护了一组“许可”，线程通过acquire()获取许可，用完后通过release()归还。

import ja va.util.concurrent.Semaphore;

public class Counter {
    private int count;
    private final Semaphore semaphore;

    public Counter(int permits) {
        semaphore = new Semaphore(permits);
    }

    public void increment() throws InterruptedException {
        semaphore.acquire();
        try {
            count++;
        } finally {
            semaphore.release();
        }
    }
}

通过初始化时指定许可数量，你可以轻松控制并发度。它实现的是一种“配额管理”式的同步。

4. 使用CountDownLatch类

有没有遇到过需要等待多个线程全部完成，主线程才能继续的场景？比如并行计算任务汇总。CountDownLatch就是一个完美的“发令枪”和“终点线”。它初始化一个计数器，线程完成任务时调用countDown()，而等待的线程则调用await()，直到计数器归零。

import ja va.util.concurrent.CountDownLatch;

public class Worker implements Runnable {
    private final CountDownLatch latch;
    public Worker(CountDownLatch latch) {
        this.latch = latch;
    }
    @Override
    public void run() {
        try {
            // 执行任务
        } finally {
            latch.countDown(); // 任务完成，计数减一
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        int numWorkers = 5;
        CountDownLatch latch = new CountDownLatch(numWorkers);
        for (int i = 0; i < numWorkers; i++) {
            new Thread(new Worker(latch)).start();
        }
        latch.await(); // 主线程在此等待，直到所有工作线程完成
    }
}

它的特点是“一次性”，计数器归零后就无法再使用，适合一锤子买卖的同步。

5. 使用CyclicBarrier类

与CountDownLatch“主等从”的模式不同，CyclicBarrier（循环屏障）更像是“线程们互相等”。它让一组线程彼此等待，直到所有线程都到达某个屏障点，然后大家再一起继续执行，甚至可以循环使用。

import ja va.util.concurrent.CyclicBarrier;

public class Worker implements Runnable {
    private final CyclicBarrier barrier;
    public Worker(CyclicBarrier barrier) {
        this.barrier = barrier;
    }
    @Override
    public void run() {
        try {
            // 执行任务
            barrier.await(); // 到达屏障，等待其他线程
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int numWorkers = 5;
        CyclicBarrier barrier = new CyclicBarrier(numWorkers,
                () -> System.out.println("所有工作线程已完成")); // 所有线程到达后执行的动作
        for (int i = 0; i < numWorkers; i++) {
            new Thread(new Worker(barrier)).start();
        }
    }
}

这在多阶段计算或迭代算法中非常有用，而且“循环”的特性意味着它可以重复使用。

说到底，在Linux下用Ja va做并发控制，关键不在于记住所有工具，而在于理解它们背后的模型——互斥、信号量、条件等待、集合点同步。根据你的具体需求，无论是简单的资源保护，还是复杂的多线程协调，上面这几种机制总有一款适合你。选择合适的工具，才能写出既高效又健壮的并发程序。