java锁

1. Synchronized锁（内置锁）

   • 适用于对单个方法或代码块进行同步，实现简单的线程互斥。
   • 对于小规模的同步需求和简单的线程安全问题，使用synchronized是一种便捷和有效的选择。

2. ReentrantLock锁

   • 适用于需要更高级的线程同步需求，相对于synchronized提供了更多的功能和灵活性。
   • 可以使用ReentrantLock的lock()和unlock()方法来手动控制锁的获取和释放。
   • 可以使用ReentrantLock的tryLock()方法来尝试获取锁，可以设置超时时间。

3. 读写锁（ReentrantReadWriteLock）

   • 适用于读多写少的场景，提高并发性能。
   • 当多个线程只读取共享资源时，它们可以并发执行，不需要互斥。
   • 当有线程要修改共享资源时，需要独占锁。

4. Semaphore（信号量）

   • 适用于控制并发访问线程数量的场景。
   • 可以使用Semaphore来限制多个线程同时访问某个资源或代码段。
   • 可以使用acquire()方法来获取许可证，使用release()方法释放许可证。

5. Condition锁和Condition变量

   • 适用于复杂的线程间协作和通信的场景。
   • Condition可以和Lock（如ReentrantLock）配合使用，通过await()和signal()来实现等待和唤醒的机制。
   • 可以使用await()方法让线程等待条件满足，使用signal()或signalAll()方法唤醒等待的线程。

    6.代码示例

public class SynchronizedExample {
    private int count = 0;

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


import java.util.concurrent.locks.ReentrantLock;

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

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


import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private int count = 0;
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

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


import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private Semaphore semaphore = new Semaphore(2);
    
    public void performTask() {
        try {
            semaphore.acquire();
            // 执行任务
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}


import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionExample {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void performTask() {
        lock.lock();
        try {
            while (condition不满足条件) {
                condition.await();
            }
            // 执行任务
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void signalCondition() {
        lock.lock();
        try {
            // 修改condition条件
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}