在java中多线程加锁的四种方式

在Java中，多线程加锁的方式主要有以下几种：

1. 使用synchronized关键字

synchronized可以用于方法或代码块，确保只有一个线程能访问被锁定的代码。

方法锁

class SynchronizedMethod {
    public synchronized void synchronizedMethod() {
        System.out.println("Synchronized method executed by " + Thread.currentThread().getName());
    }
}

代码块锁

class SynchronizedBlock {
    private final Object lock = new Object();

    public void synchronizedBlock() {
        synchronized (lock) {
            System.out.println("Synchronized block executed by " + Thread.currentThread().getName());
        }
    }
}

2. 使用ReentrantLock类

ReentrantLock是java.util.concurrent.locks包中的一种锁，具有比synchronized更灵活的锁定机制。

import java.util.concurrent.locks.ReentrantLock;

class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();

    public void lockMethod() {
        lock.lock();
        try {
            System.out.println("ReentrantLock method executed by " + Thread.currentThread().getName());
        } finally {
            lock.unlock();
        }
    }
}

3. 使用读写锁（ReadWriteLock）

ReadWriteLock允许多个读线程同时访问共享资源，但在写线程访问时，阻止其他线程的读和写访问。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

class ReadWriteLockExample {
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void readMethod() {
        readWriteLock.readLock().lock();
        try {
            System.out.println("Read lock method executed by " + Thread.currentThread().getName());
        } finally {
            readWriteLock.readLock().unlock();
        }
    }

    public void writeMethod() {
        readWriteLock.writeLock().lock();
        try {
            System.out.println("Write lock method executed by " + Thread.currentThread().getName());
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }
}

4. 使用信号量（Semaphore）

Semaphore是一种计数信号量，可以限制同时访问某个资源的线程数量。

import java.util.concurrent.Semaphore;

class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(2); // 允许最多两个线程访问

    public void accessResource() {
        try {
            semaphore.acquire();
            System.out.println("Accessing resource by " + Thread.currentThread().getName());
            Thread.sleep(1000); // 模拟工作
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

总结

synchronized是 Java 内置的关键字，易于使用，但灵活性不足。
ReentrantLock提供了更强大的锁控制能力，如可重入锁、超时锁。
ReadWriteLock允许更高效地处理读写操作，适用于读多写少的场景。
Semaphore可以控制访问资源的线程数量，适合有限资源的场景。

这些加锁机制可以帮助你在多线程环境中实现线程安全的访问

秒客网