java中for循环如何加锁

在Java中，for循环加锁可以通过synchronized关键字、ReentrantLock类、ReadWriteLock等方式实现。synchronized关键字简便、ReentrantLock更灵活、ReadWriteLock适用于读写分离。其中，synchronized是最常用的方式，它可以确保在同一时刻，只有一个线程能够执行被锁定的代码块。以下是详细描述：

synchronized关键字简便：synchronized关键字可以直接作用于方法或者代码块，确保同一时间只有一个线程能够访问该代码块。其使用简单，适合大多数需要加锁的情况。下面是一个使用synchronized关键字的例子：

public class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public int getCount() {
        return count;
    }
}
public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();
        for (int i = 0; i < 1000; i++) {
            new Thread(() -> {
                counter.increment();
            }).start();
        }
        // wait a bit for all threads to finish
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(counter.getCount());
    }
}

在这个例子中，increment方法使用了synchronized关键字，确保count变量的自增操作是线程安全的。

一、SYNCHRONIZED关键字

1.1 作用于方法

将synchronized关键字直接作用于方法上，可以确保同一时间只有一个线程能够执行该方法。这种方式简单明了，适合绝大多数场景。

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

上述代码确保了在任何时候都只有一个线程能够执行increment方法，从而保证了线程安全。

1.2 作用于代码块

有时我们不需要对整个方法进行加锁，只需要对某些关键代码进行加锁。这时可以将synchronized关键字作用于代码块。

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

这样做的好处是可以减少锁的粒度，提高并发性能。

二、REENTRANTLOCK类

2.1 基本使用

ReentrantLock是Java提供的一个更为灵活的锁实现，可以代替synchronized关键字。它提供了更细粒度的控制以及更多的锁操作，比如尝试获取锁、超时获取锁和中断获取锁等。

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

在这个例子中，increment方法使用了ReentrantLock来进行加锁操作，确保了线程安全。

2.2 尝试获取锁

有时我们不希望阻塞线程，而是希望尝试获取锁，如果获取不到就直接返回。ReentrantLock提供了tryLock方法来实现这一需求。

public void increment() {
    if (lock.tryLock()) {
        try {
            count++;
        } finally {
            lock.unlock();
        }
    } else {
        // 没有获取到锁，执行其他操作
    }
}

这种方式可以避免线程长时间等待锁，提高系统响应速度。

三、READWRITELOCK

3.1 基本使用

ReadWriteLock是Java提供的一种读写锁实现，适用于读多写少的场景。它允许多个读线程同时访问，但写线程访问时会阻塞所有读线程和其他写线程。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Counter {
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private int count = 0;
    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方法使用了读锁，从而实现了读写分离。

3.2 读写锁的优势

读写锁的优势在于它可以显著提高读多写少场景下的并发性能。多个读线程可以同时进行读取操作，而不需要等待其他读线程完成。但写操作还是需要独占锁，从而保证数据的一致性。

四、STAMPEDLOCK

4.1 基本使用

StampedLock是Java 8引入的一种读写锁，它在ReadWriteLock的基础上增加了乐观读锁，可以进一步提高读多写少场景下的并发性能。

import java.util.concurrent.locks.StampedLock;
public class Counter {
    private final StampedLock lock = new StampedLock();
    private int count = 0;
    public void increment() {
        long stamp = lock.writeLock();
        try {
            count++;
        } finally {
            lock.unlockWrite(stamp);
        }
    }
    public int getCount() {
        long stamp = lock.tryOptimisticRead();
        int currentCount = count;
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try {
                currentCount = count;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return currentCount;
    }
}

在这个例子中，increment方法使用了写锁，而getCount方法使用了乐观读锁。如果在读操作期间有写操作发生，乐观读锁会失效，此时会退化为悲观读锁，从而保证数据的一致性。

4.2 乐观读锁的优势

乐观读锁的优势在于它在读操作期间不需要阻塞其他写操作，从而进一步提高了并发性能。只有在读操作期间有写操作发生时，才会退化为悲观读锁。

五、总结

在Java中为for循环加锁有多种方式，synchronized关键字、ReentrantLock类、ReadWriteLock和StampedLock都可以实现。synchronized关键字简便、ReentrantLock更灵活、ReadWriteLock适用于读写分离、StampedLock进一步提高了并发性能。根据具体需求选择合适的锁机制，可以有效提高程序的并发性能和数据一致性。