首页 > 编程语言> 文章详细

JDK源码系列(3):CyclicBarrier

2020-03-31 18:03:41 阅读：293 来源： 互联网

标签：许可 JDK permits 获取源码线程 Semaphore CyclicBarrier public

Semaphore

1、介绍

Semaphore是一个计数信号量，可以控同时访问的线程个数，它的本质是一个"共享锁"。

信号量维护了一个信号量许可集。线程可以通过调用acquire()来获取信号量的许可；当信号量中有可用的许可时，线程能获取该许可；否则线程必须等待，直到有可用的许可为止。线程可以通过release()来释放它所持有的信号量许可。

结构示意图

semaphore

1.1、核心接口/方法定义

public void acquire() throws InterruptedException {  }     //获取一个许可
public void acquire(int permits) throws InterruptedException { }    //获取permits个许可
public void release() { }          //释放一个许可
public void release(int permits) { }    //释放permits个许可

acquire()用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。

release()用来释放许可。注意，在释放许可之前，必须先获获得许可。

1.2、构造方法

/**
     * Creates a {@code Semaphore} with the given number of
     * permits and nonfair fairness setting.
     *
     * @param permits the initial number of permits available.
     *        This value may be negative, in which case releases
     *        must occur before any acquires will be granted.
     */
    public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }

    /**
     * permits:表示许可数目，即同时可以允许多少线程进行访问
     * fair:表示是否是公平的，即等待时间越久的越先获取许可
     */
    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

1.3、demo示例

假如一个游乐场有3台滑梯，但是有5个小朋友，一台滑梯同时只能被一个小朋友使用，只有使用完了，其他小朋友才能继续使用。那么我们就可以通过Semaphore来实现：

package com.github.mf.common;

import java.util.concurrent.Semaphore;

public class SemaphoreTest {
    public static void main(String[] args) {
        //小朋友的数量
        int kidsNum = 5;
        //共有三台滑梯
        Semaphore semaphore = new Semaphore(3);
        for(int i=0;i<kidsNum;i++)
            new SemaphoreTest.Worker(i,semaphore).start();
    }

    static class Worker extends Thread{
        private int num;
        private Semaphore semaphore;
        public Worker(int num,Semaphore semaphore){
            this.num = num;
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println(this.num+"号小朋友，占用这台滑梯");
                Thread.sleep(2000);
                System.out.println(this.num+"号小朋友，离开这台滑梯");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

输出：
0号小朋友，占用这台滑梯
1号小朋友，占用这台滑梯
2号小朋友，占用这台滑梯
0号小朋友，离开这台滑梯
2号小朋友，离开这台滑梯
1号小朋友，离开这台滑梯
4号小朋友，占用这台滑梯
3号小朋友，占用这台滑梯
4号小朋友，离开这台滑梯
3号小朋友，离开这台滑梯

2、原理

2.1、tryAcquire方法

以上4个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法：

//尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire() { };    
//尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };  
//尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits) { }; 
//尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { };

另外还可以通过availablePermits()方法得到可用的许可数目。

3、总结

对三个辅助类做一下总结：

　　1）CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

　　　　CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行；

　　　　而CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；

　　　　另外，CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的。

　　2）Semaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限。

标签：许可,JDK,permits,获取,源码,线程,Semaphore,CyclicBarrier,public
来源： https://www.cnblogs.com/muyutingfeng/p/12606943.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9