Linux下Java如何实现并发控制

在Linux下使用Java实现并发控制，可以通过以下几种方式：

使用synchronized关键字：synchronized关键字是Java中最基本的同步机制。它可以用来修饰方法或者以代码块的形式出现。当一个线程访问一个对象的synchronized方法或代码块时，其他线程将无法访问该对象的同步方法或代码块，直到当前线程释放锁。

public class Counter {
    private int count;

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

使用ReentrantLock类：ReentrantLock是Java提供的一个可重入的互斥锁，它提供了比synchronized更灵活的锁定机制。使用ReentrantLock，可以更好地控制锁的获取和释放，以及实现公平锁等。

import java.util.concurrent.locks.Lock;
import java.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();
        }
    }
}

使用Semaphore类：Semaphore是一个计数信号量，可以用来控制同时访问特定资源的线程数量。通过信号量的acquire()和release()方法，可以实现线程之间的同步。

import java.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();
        }
    }
}

使用CountDownLatch类：CountDownLatch是一个同步辅助类，它允许一个或多个线程等待其他线程完成操作。通过await()和countDown()方法，可以实现线程之间的协调。

import java.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(); // 等待所有工作线程完成
    }
}

使用CyclicBarrier类：CyclicBarrier是一个同步辅助类，它允许一组线程互相等待，直到所有线程都准备好继续执行。通过await()方法，可以实现线程之间的同步。

import java.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下使用Java实现并发控制。你可以根据具体需求选择合适的同步机制。

最新问答

相关标签