设计模式 Concurrency 之 Mutex 互斥锁

最新推荐文章于 2024-03-06 19:19:20 发布

原创最新推荐文章于 2024-03-06 19:19:20 发布 · 849 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #并发 #semaphore #竞争 #线程

设计模式专栏收录该内容

8 篇文章

订阅专栏

本文介绍了Mutex互斥锁的概念，作为一种防止访问冲突的并发控制机制，它确保在同一时间仅有一个线程能访问共享资源。当信号量阈值设为1时，即为互斥锁模式。文中通过Lock、Mutex、Jar、Thief和App等实例来阐述其工作原理和使用方法，并提供了测试结果以验证其正确性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

定义
例子

1. 定义

不同线程通过竞争进入临界区（共享的数据和硬件资源），为了防止访问冲突，在有限的时间内只允许其中之一独占性的使用共享资源。

是Semaphore的特殊情况当信号量的阈值设为1时就是互斥锁模式

2. 例子

这里写图片描述

Lock

package com.hqq.concurrency.mutex;

/**
 * Lock
 * Created by heqianqian on 2017/7/29.
 */
public interface Lock {

    void acquire() throws InterruptedException;

    void release();

}

Mutex

package com.hqq.concurrency.mutex;

/**
 * Mutex
 * 独占锁
 * Created by heqianqian on 2017/7/29.
 */
public class Mutex implements Lock {

    /**
     * 当前锁的拥有者
     */
    private Object owner;

    @Override
    public synchronized void acquire() throws InterruptedException {
        while (owner != null) {
            wait();
        }

        owner = Thread.currentThread();
    }

    @Override
    public synchronized void release() {
        if ( Thread.currentThread() == owner) {
            owner = null;
            notify();
        }
    }

    public Object getOwner() {
        return owner;
    }

    public void setOwner(Object owner) {
        this.owner = owner;
    }
}

Jar

package com.hqq.concurrency.mutex;

/**
 * Jar
 * Mutex锁保证jar只可以被单个Thief线程访问
 * Created by heqianqian on 2017/7/29.
 */
public class Jar {

    private final Lock lock;

    private int beans;

    public Jar(Lock lock, int beans) {
        this.lock = lock;
        this.beans = beans;
    }

    public boolean takeBean() {
        boolean success = false;
        try {
            lock.acquire();
            success = beans > 0;
            if (success) {
                beans -= 1;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.release();
        }
        return success;
    }
}

Thief

package com.hqq.concurrency.mutex;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Thief
 * Created by heqianqian on 2017/7/29.
 */
public class Thief extends Thread {

    private static Logger LOGGER = LoggerFactory.getLogger(Thief.class);

    private String name;

    private Jar jar;

    public Thief(String name, Jar jar) {
        this.name = name;
        this.jar = jar;
    }

    /**
     * 一直获取bean对象直到bean个数为0
     */
    @Override
    public void run() {
        int beans = 0;
        while (jar.takeBean()) {
            beans += 1;
            LOGGER.info("{} take a bean", name);
        }
        LOGGER.info("{} take {} beans ", name, beans);
    }
}

App

package com.hqq.concurrency.mutex;

/**
 * Mutex 可以防止多个线程同时访问一个资源
 * 在这个例子里.我们开启两个线程Thief对象同时从jar对象中获取bean
 * 一次只有一个对象可以获取bean 获得Mutex的锁 而另一个对象则将阻塞
 * Created by heqianqian on 2017/7/29.
 */
public class App {

    /**
     * main方法
     */
    public static void main(String[] args) {
        Lock lock = new Mutex();
        Jar jar = new Jar(lock, 2);
        Thief jack = new Thief("Jack", jar);
        Thief john = new Thief("Join", jar);

        jack.start();
        john.start();
    }

}

测试结果

INFO  [2017-08-09 02:08:41,674] com.hqq.concurrency.mutex.Thief: Join take a bean
INFO  [2017-08-09 02:08:41,674] com.hqq.concurrency.mutex.Thief: Jack take a bean
INFO  [2017-08-09 02:08:41,674] com.hqq.concurrency.mutex.Thief: Jack take 1 beans 
INFO  [2017-08-09 02:08:41,674] com.hqq.concurrency.mutex.Thief: Join take 1 beans