当前位置：首页 > Java

java 如何互斥

2026-03-20 01:40:50Java

互斥的实现方式

在Java中，互斥（Mutual Exclusion）可以通过多种机制实现，确保多个线程或进程在访问共享资源时不会发生冲突。以下是常见的几种方法：

synchronized 关键字

使用synchronized关键字可以修饰方法或代码块，确保同一时间只有一个线程可以执行该代码。

public class Counter {
    private int count = 0;

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

ReentrantLock 类

ReentrantLock是java.util.concurrent.locks包中的一个类，提供了比synchronized更灵活的锁机制。

import java.util.concurrent.locks.ReentrantLock;

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

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

Semaphore 类

Semaphore可以控制同时访问某个资源的线程数量，通过设置许可数实现互斥。

import java.util.concurrent.Semaphore;

public class Counter {
    private int count = 0;
    private Semaphore semaphore = new Semaphore(1);

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

volatile 关键字

volatile关键字确保变量的可见性，但不提供原子性。适用于简单的标志位场景。

public class Flag {
    private volatile boolean flag = false;

    public void setFlag(boolean value) {
        flag = value;
    }

    public boolean getFlag() {
        return flag;
    }
}

Atomic 类

java.util.concurrent.atomic包中的原子类（如AtomicInteger）提供线程安全的操作。

java 如何互斥

import java.util.concurrent.atomic.AtomicInteger;

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

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