java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Semaphore信号量使用及原理

Java的Semaphore信号量使用及原理解读

作者:一个风轻云淡

这篇文章主要介绍了Java的Semaphore信号量使用及原理解读,Semaphore(信号量)是Java中一个并发控制工具,用于控制对共享资源的访问,它基于计数器的原理,可以限制同时访问某个资源的线程数量,需要的朋友可以参考下

概述

Semaphore(信号量)是Java中一个并发控制工具,用于控制对共享资源的访问。它基于计数器的原理,可以限制同时访问某个资源的线程数量。

在Java中使用Semaphore,你需要按照以下步骤进行操作:

导包: 

import java.util.concurrent.Semaphore;

 创建Semaphore对象:

Semaphore semaphore = new Semaphore(n);

其中,n是允许同时访问共享资源的线程数量。

在需要访问共享资源的代码段前后,使用acquire()和release()方法来获取和释放信号量:

try {
    semaphore.acquire(); // 获取信号量,如果没有可用的许可证,线程将被阻塞
    // 访问共享资源的代码
} catch (InterruptedException e) {
    // 处理中断异常
} finally {
    semaphore.release(); // 释放信号量,增加一个许可证
}

acquire()方法尝试获取一个许可证,如果当前没有可用的许可证,则该线程将被阻塞,直到有可用的许可证为止。release()方法释放一个许可证,使其可供其他线程使用。

通过适当地使用acquire()和release()方法,在超过信号量允许的线程数量时,可以限制并发访问共享资源的线程数量,实现线程间的同步和互斥。

需要注意的是,Semaphore还提供了一些其他方法,如availablePermits()用于获取当前可用的许可证数量,以及tryAcquire()方法在不阻塞线程的情况下尝试获取许可证等。

具体例子 

    public static void main(String[] args) {
        // 1. 创建 semaphore 对象
        Semaphore semaphore = new Semaphore(3);
        // 2. 10个线程同时运行
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                // 3. 获取许可
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    log.debug("running...");
                    sleep(1);
                    log.debug("end...");
                } finally {
                    // 4. 释放许可
                    semaphore.release();
                }
            }).start();
        }
    }

07:35:15.485 c.TestSemaphore [Thread-2] - running...

07:35:15.485 c.TestSemaphore [Thread-1] - running...

07:35:15.485 c.TestSemaphore [Thread-0] - running...

07:35:16.490 c.TestSemaphore [Thread-2] - end...

07:35:16.490 c.TestSemaphore [Thread-0] - end...

07:35:16.490 c.TestSemaphore [Thread-1] - end...

07:35:16.490 c.TestSemaphore [Thread-3] - running...

07:35:16.490 c.TestSemaphore [Thread-5] - running...

07:35:16.490 c.TestSemaphore [Thread-4] - running...

07:35:17.490 c.TestSemaphore [Thread-5] - end...

07:35:17.490 c.TestSemaphore [Thread-4] - end...

07:35:17.490 c.TestSemaphore [Thread-3] - end...

07:35:17.490 c.TestSemaphore [Thread-6] - running...

07:35:17.490 c.TestSemaphore [Thread-7] - running...

07:35:17.490 c.TestSemaphore [Thread-9] - running...

07:35:18.491 c.TestSemaphore [Thread-6] - end...

07:35:18.491 c.TestSemaphore [Thread-7] - end...

07:35:18.491 c.TestSemaphore [Thread-9] - end...

07:35:18.491 c.TestSemaphore [Thread-8] - running...

07:35:19.492 c.TestSemaphore [Thread-8] - end...  

源码原理解析

加锁解锁流程原理

Semaphore 有点像一个停车场,permits 就好像停车位数量,当线程获得了 permits 就像是获得了停车位,然后 停车场显示空余车位减一 刚开始,permits(state)为 3,这时 5 个线程来获取资源

假设其中 Thread-1,Thread-2,Thread-4 cas 竞争成功,而 Thread-0 和 Thread-3 竞争失败,进入 AQS 队列park 阻塞

接下来 Thread-0 竞争成功,permits 再次设置为 0,设置自己为 head 节点,断开原来的 head 节点,unpark 接 下来的 Thread-3 节点,但由于 permits 是 0,因此 Thread-3 在尝试不成功后再次进入 park 状态

源码 

 构造方法有俩个: 

  public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }

创建 Semaphore 具有给定数量的许可和不公平公平设置。 参数: 许可证 – 可用的许可证的初始数量。此值可能为负数,在这种情况下,必须先进行释放,然后才能授予任何收购。 

    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

创建具有给定数量的许可和给定公平性设置的 。

Semaphore 参数:

许可证 – 可用的许可证的初始数量。此值可能为负数,在这种情况下,必须先进行释放,然后才能授予任何收购。

公平 – true 如果此信号量将保证在争用中授予先进先出的许可证,否则 false 

    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -2694183684443567898L;
 
        NonfairSync(int permits) {
            // permits 即 state
 
            super(permits);
        }
 
        // Semaphore 方法, 方便阅读, 放在此处
 
        public void acquire() throws InterruptedException {
            sync.acquireSharedInterruptibly(1);
        }
 
        // AQS 继承过来的方法, 方便阅读, 放在此处
 
        public final void acquireSharedInterruptibly(int arg)
                throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            if (tryAcquireShared(arg) < 0)
                doAcquireSharedInterruptibly(arg);
        }
 
        // 尝试获得共享锁
 
        protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
 
        // Sync 继承过来的方法, 方便阅读, 放在此处
 
        final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (
                    // 如果许可已经用完, 返回负数, 表示获取失败, 进入 doAcquireSharedInterruptibly
 
                        remaining < 0 ||
 
                                // 如果 cas 重试成功, 返回正数, 表示获取成功
 
                                compareAndSetState(available, remaining)
                ) {
                    return remaining;
                }
            }
        }
 
        // AQS 继承过来的方法, 方便阅读, 放在此处
 
        private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
            final Node node = addWaiter(Node.SHARED);
            boolean failed = true;
            try {
                for (;;) {
                    final Node p = node.predecessor();
                    if (p == head) {
                        // 再次尝试获取许可
 
                        int r = tryAcquireShared(arg);
                        if (r >= 0) {
                            // 成功后本线程出队(AQS), 所在 Node设置为 head
 
                            // 如果 head.waitStatus == Node.SIGNAL ==> 0 成功, 下一个节点 unpark
 
                            // 如果 head.waitStatus == 0 ==> Node.PROPAGATE
 
                            // r 表示可用资源数, 为 0 则不会继续传播
 
                            setHeadAndPropagate(node, r);
                            p.next = null; // help GC
 
                            failed = false;
                            return;
                        }
                    }
                    // 不成功, 设置上一个节点 waitStatus = Node.SIGNAL, 下轮进入 park 阻塞
 
                    if (shouldParkAfterFailedAcquire(p, node) &&
 
                            parkAndCheckInterrupt())
                        throw new InterruptedException();
                }
            } finally {
                if (failed)
                    cancelAcquire(node);
            }
        }
 
        // Semaphore 方法, 方便阅读, 放在此处
 
        public void release() {
            sync.releaseShared(1);
        }
 
        // AQS 继承过来的方法, 方便阅读, 放在此处
 
        public final boolean releaseShared(int arg) {
            if (tryReleaseShared(arg)) {
                doReleaseShared();
                return true;
            }
            return false;
        }
 
        // Sync 继承过来的方法, 方便阅读, 放在此处
        protected final boolean tryReleaseShared(int releases) {
            for (;;) {
                int current = getState();
                int next = current + releases;
                if (next < current) // overflow
                    throw new Error("Maximum permit count exceeded");
                if (compareAndSetState(current, next))
                    return true;
            }
        }
    }

到此这篇关于Java的Semaphore信号量使用及原理解读的文章就介绍到这了,更多相关Semaphore信号量使用及原理内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
阅读全文