常见锁例子

互斥锁（Mutex Lock）
是一种用于多线程编程中的同步机制，用于保护共享资源，防止多个线程同时访问造成数据不一致或竞态条件的情况发生。
读写锁（Read-Write Lock）：
读写锁允许多个线程同时读取共享资源，但只允许一个线程进行写操作。读写锁可以提高并发读取的效率，适用于读多写少的场景。
自旋锁（Spin Lock）：
自旋锁是一种忙等待的锁机制，线程在获取锁时会循环检查锁是否可用，而不是被阻塞。自旋锁适用于锁的持有时间很短，且线程冲突的概率较低的情况。
信号量（Semaphore）：
信号量是一种计数器，用于控制访问某个资源的线程数。通过对信号量的操作，线程可以申请或释放资源的访问权限。常见的信号量包括二进制信号量（只有0和1两种状态）和计数信号量（可以有多个状态）。
条件变量（Condition Variable）：
条件变量用于线程之间的通信和同步，允许线程在某个条件满足时等待或被唤醒。通常与互斥锁一起使用，通过条件变量可以实现线程的等待和唤醒操作。
屏障（Barrier）：
屏障用于控制多个线程在某个点上同步，要求所有线程都到达屏障点后才能继续执行。屏障可以用于分阶段的并行计算，确保每个阶段的线程都完成后再进行下一阶段。

互斥锁（Mutex Lock）：

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

public class MutexLockExample {
    private Lock lock = new ReentrantLock();

    public void doSomething() {
        lock.lock();
        try {
            // 进行互斥锁保护的操作
        } finally {
            lock.unlock();
        }
    }
}

读写锁（Read-Write Lock）：

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

public class ReadWriteLockExample {
    private ReadWriteLock lock = new ReentrantReadWriteLock();

    public void readData() {
        lock.readLock().lock();
        try {
            // 进行读操作
        } finally {
            lock.readLock().unlock();
        }
    }

    public void writeData() {
        lock.writeLock().lock();
        try {
            // 进行写操作
        } finally {
            lock.writeLock().unlock();
        }
    }
}

自旋锁（Spin Lock）：

import java.util.concurrent.atomic.AtomicBoolean;

public class SpinLockExample {
    private AtomicBoolean lock = new AtomicBoolean(false);

    public void doSomething() {
        while (!lock.compareAndSet(false, true)) {
            // 自旋等待锁释放
        }
        try {
            // 进行自旋锁保护的操作
        } finally {
            lock.set(false);
        }
    }
}

信号量（Semaphore）：

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private Semaphore semaphore = new Semaphore(1);

    public void doSomething() throws InterruptedException {
        semaphore.acquire();
        try {
            // 进行信号量保护的操作
        } finally {
            semaphore.release();
        }
    }
}

条件变量（Condition Variable）：

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

public class ConditionVariableExample {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private boolean conditionMet = false;

    public void doSomething() throws InterruptedException {
        lock.lock();
        try {
            while (!conditionMet) {
                condition.await();
            }
            // 进行条件变量保护的操作
        } finally {
            lock.unlock();
        }
    }

    public void notifyCondition() {
        lock.lock();
        try {
            conditionMet = true;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }
}

屏障（Barrier）：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class BarrierExample {
    private CyclicBarrier barrier = new CyclicBarrier(2);

    public void doSomething() {
        try {
            // 进行操作
            barrier.await();
            // 进行操作
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

注意：
1、信号量：即设置一个值比如10，多个线程设置每次执行消耗的信号量比如1，则最多只能同时执行10个线程
2、读写锁：读读不互斥、读写互斥、写写互斥

猜你喜欢