java Concurrent包学习笔记（五）：Semaphore

一、Semaphore 是什么

信号量Semaphore是一个并发工具类，用来控制可同时并发的线程数，其内部维护了一组虚拟许可，构造函数初始化的时候可以指定许可的总数量

每次线程执行操作时先通过acquire方法获得许可，线程获得许可后Semaphore 的许可数量会减1，执行完毕再通过release方法释放许可，emaphore 的许可数量会加1。如果无可用许可，那么acquire方法将一直阻塞，直到其它线程释放许可。
主要方法：

Semaphore(int permits): 构造方法，创建具有给定许可数的计数信号量并设置为非公平信号量。
Semaphore(int permits,boolean fair): 构造方法，当fair等于true时，创建具有给定许可数的计数信号量并设置为公平信号量。
void acquire(): 从此信号量获取一个许可，如果没有获取到许可线程将一直阻塞。
void acquire(int n): 从此信号量获取给定数目许可，在提供这些许可前一直将线程阻塞。
void release(): 释放一个许可，将其返回给信号量。就如同车开走返回一个车位。
void release(int n): 释放n个许可。
int availablePermits()：当前可用的许可数

二、Semaphore 和线程池的区别

线程池：用来控制实际工作的线程数量，通过线程复用的方式来减小内存开销。线程池可同时工作的线程数量是一定的，超过该数量的线程需进入线程队列等待，直到有可用的工作线程来执行任务。
Semaphore: 你创建了多少线程，实际就会有多少线程进行执行，只是可同时执行的线程数量会受到限制。但使用线程池，不管你创建多少线程，实际可执行的线程数是一定的。

示例程序：

package semaphore.demo;

import java.util.UUID;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Semaphore;

/**

 * @author boshen

 * @date 2018/12/20

 */

public class SemaphoreTest1 {

    /**

     * 用线程池来控制工作线程

     */

    private static void testThreadPoll(){

        ExecutorService executorService = Executors.newFixedThreadPool();

        for(int i = ;i< ;i++)

            executorService.submit(new Runnable() {

                public void run() {

                    try {

                        String name = UUID.randomUUID().toString().substring(,);

                        System.out.println("学生:"+name +" 开始工作，线程号为："+Thread.currentThread().getName());

                        Thread.sleep();

                        System.out.println("学生:"+name +" 完成工作，线程号为："+Thread.currentThread().getName());

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            });

        executorService.shutdown();

    }

    /**

     * 用Semaphore来控制工作线程

     */

    private static void testSemaphore(){

        final Semaphore semaphore = new Semaphore();

        for(int i=;i<;i++){

            Thread thread = new Thread(new Runnable() {

                public void run() {

                    try {

                        semaphore.acquire();

                        String name = UUID.randomUUID().toString().substring(,);

                        System.out.println("学生:"+name +" 开始工作，线程号为："+Thread.currentThread().getName());

                        Thread.sleep();

                        System.out.println("学生:"+name +" 完成工作，线程号为："+Thread.currentThread().getName());

                        semaphore.release();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            });

            thread.start();

        }

    }

    public static void main(String[] args){

        System.out.println("以下是testThreadPoll输出的结果============================================");

        testThreadPoll();

        try {

            Thread.sleep();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println("以下是testSemaphore输出的结果============================================");

        testSemaphore();

    }

}

以下是testThreadPoll输出的结果============================================

学生:14fd- 开始工作，线程号为：pool--thread-

学生:6bc6- 开始工作，线程号为：pool--thread-

学生:6bc6- 完成工作，线程号为：pool--thread-

学生:6a3b- 开始工作，线程号为：pool--thread-

学生:14fd- 完成工作，线程号为：pool--thread-

学生:9e7b- 开始工作，线程号为：pool--thread-

学生:6a3b- 完成工作，线程号为：pool--thread-

学生:2ed3- 开始工作，线程号为：pool--thread-

学生:9e7b- 完成工作，线程号为：pool--thread-

学生:2ed3- 完成工作，线程号为：pool--thread-

以下是testSemaphore输出的结果============================================

学生:- 开始工作，线程号为：Thread-

学生:99e9- 开始工作，线程号为：Thread-

学生:99e9- 完成工作，线程号为：Thread-

学生:- 完成工作，线程号为：Thread-

学生:b9a5- 开始工作，线程号为：Thread-

学生:058d- 开始工作，线程号为：Thread-

学生:b9a5- 完成工作，线程号为：Thread-

学生:7f6a-c 开始工作，线程号为：Thread-

学生:058d- 完成工作，线程号为：Thread-

学生:7f6a-c 完成工作，线程号为：Thread-

由以上结果可知当使用前线池的时候，同时只有2个线程执行工作，线程号只会有1和2，线程会进行复用；Semaphore虽然也只有2个线程能同时工作，但是线程号是0、1、2、3、4，也就是5个线程都执行了，只不过同一时刻有三个线程阻塞了而已。

三、Semaphore 公平信号量和非公平信号量

示例：

package semaphore.demo;

import java.util.UUID;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Semaphore;

/**

 * @author boshen

 * @date 2018/12/20

 */

public class SemaphoreTest2 {

    /**

     * 公平信号量

     */

    private static void testFairSemaphore(){

        final Semaphore semaphore1 = new Semaphore(,true);

        for(int i=;i<;i++){

            Thread thread = new Thread(new Runnable() {

                public void run() {

                    try {

                        String name = UUID.randomUUID().toString().substring(,);

                        System.out.println("学生:"+name +" 开始工作，线程号为："+Thread.currentThread().getName());

                        semaphore1.acquire();

                        Thread.sleep();

                        System.out.println("学生:"+name +" 完成工作，线程号为："+Thread.currentThread().getName());

                        semaphore1.release();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            });

            thread.start();

        }

    }

    /**

     * 非公平信号量

     */

    private static void testUnFairSemaphore(){

        final Semaphore semaphore2 = new Semaphore();

        for(int i=;i<;i++){

            final Thread thread = new Thread(new Runnable() {

                public void run() {

                    try {

                        String name = UUID.randomUUID().toString().substring(,);

                        System.out.println("学生:"+name +" 开始工作，线程号为："+Thread.currentThread().getName());

                        semaphore2.acquire();

                        Thread.sleep();

                        System.out.println("学生:"+name +" 完成工作，线程号为："+Thread.currentThread().getName());

                        semaphore2.release();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }

            });

            thread.start();

        }

    }

    public static void main(String[] args){

        System.out.println("以下是testFairSemaphore输出的结果============================================");

        testFairSemaphore();

        try {

            Thread.sleep();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println("以下是testUnFairSemaphore输出的结果============================================");

        testUnFairSemaphore();

    }

}

以下是testFairSemaphore输出的结果============================================

学生:81f2- 开始工作，线程号为：Thread-

学生:-d 开始工作，线程号为：Thread-

学生:e212-a 开始工作，线程号为：Thread-

学生:f059-d 开始工作，线程号为：Thread-

学生:9ece- 开始工作，线程号为：Thread-

学生:81f2- 完成工作，线程号为：Thread-

学生:e212-a 完成工作，线程号为：Thread-

学生:-d 完成工作，线程号为：Thread-

学生:f059-d 完成工作，线程号为：Thread-

学生:9ece- 完成工作，线程号为：Thread-

以下是testUnFairSemaphore输出的结果============================================

学生:- 开始工作，线程号为：Thread-

学生:- 开始工作，线程号为：Thread-

学生:e920- 开始工作，线程号为：Thread-

学生:be7a-f 开始工作，线程号为：Thread-

学生:e4fc-b 开始工作，线程号为：Thread-

学生:- 完成工作，线程号为：Thread-

学生:e920- 完成工作，线程号为：Thread-

学生:- 完成工作，线程号为：Thread-

学生:e4fc-b 完成工作，线程号为：Thread-

学生:be7a-f 完成工作，线程号为：Thread-

公平信号量的效果：哪信线程首先调用Semaphore.acquire（），哪个线程优先获得许可，首先启动的线程优先获取许可（不是100%，只是增加了概率）

非公平信号量的效果：是与线程的启动顺序与调用Semaphore.acquire（）顺序无关，也就是说先启动的线程并不一定先获得许可。

巴特西

java Concurrent包学习笔记（五）：Semaphore

最新文章

热门文章