併發工具類（三）控制併發執行緒的數量 Semphore

前言

  JDK中為了處理執行緒之間的同步問題，除了提供鎖機制之外，還提供了幾個非常有用的併發工具類：CountDownLatch、CyclicBarrier、Semphore、Exchanger、Phaser；
  CountDownLatch、CyclicBarrier、Semphore、Phaser 這四個工具類提供一種併發流程的控制手段；而Exchanger工具類則提供了線上程之間交換資料的一種手段。

簡介

應用場景

  Semaphore可以用於做

public class SemaphoreTest {

    private static final int THREAD_COUNT = 30;

    private static ExecutorService threadPool = Executors
            .newFixedThreadPool(THREAD_COUNT);

    private static Semaphore s = new Semaphore(10);

    public static void main(String[] args) {
        for (int i = 0; i < THREAD_COUNT; i++) {
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        s.acquire();
                        System.out.println("save data");
                        s.release();
                    } catch (InterruptedException e) {
                    }
                }
            });
        }

        threadPool.shutdown();
    }
}
複製程式碼

try {
    Semaphore semaphore = new Semaphore(5);
    //獲取一個許可
    semaphore.acquire();
    //一次性獲取4個許可
    semaphore.acquire(4);
    System.out.println("Semaphore 剩下的許可數量："+semaphore.availablePermits());
    //一次性釋放5個許可
    semaphore.release(5);
    System.out.println("Semaphore 剩下的許可數量："+semaphore.availablePermits());
    //再釋放5個許可
    semaphore.release();
    semaphore.release();
    semaphore.release(3);
    System.out.println("Semaphore 剩下的許可數量："+semaphore.availablePermits());
   
    } catch (InterruptedException e) {
    e.printStackTrace();
複製程式碼

執行結果：

Semaphore 剩下的許可數量：0
Semaphore 剩下的許可數量：5
Semaphore 剩下的許可數量：10
複製程式碼

 從上面的執行結果可以看出，

本人測試用例

package com.wxx.demo;

import com.wxx.demo.util.IdUtiles;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Semaphore;

@RunWith(SpringRunner.class)
//@SpringBootTest(classes = LeisureWebApplication.class)
public class TaskTest {

    @Test
    public void taskTest(){

        Runnable task = new Runnable() {

            int count = 0;

            @Override
            public void run() {

                count ++;
                try{
                    String id = IdUtiles.creatId();
                    System.out.println(id);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(count);
                System.out.println("Thread : " + Thread.currentThread().getId());

                try {
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }

            }
        };

        double executeTime = this.executeTime(100, task);
        System.out.println("執行時間： " + executeTime);
    }

    private double executeTime(int taskCount,Runnable task){

        CountDownLatch start = new CountDownLatch(1);
        CountDownLatch end = new CountDownLatch(taskCount);

        for (int i = 0; i < taskCount ; i++) {
            Thread thread = new Thread() {

                public void run(){
                    try {
                        start.await();

                        try {
                            task.run();
                        }finally {
                            end.countDown();
                        }

                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            };

            thread.start();
        }

        long startTime = System.nanoTime();

        //開啟開關
        start.countDown();

        long endTime = System.nanoTime();

        return endTime - startTime;
    }
}
複製程式碼

package com.wxx.demo.util;

import java.text.SimpleDateFormat;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * @Author : leisure
 * @Date : 2019/1/17
 */
public class IdUtiles {

    private static String lead = "leisure";
    private static int Guid = 100;
    private static Semaphore semaphore = new Semaphore(5,false);
    /**
     * 建立以字串打頭結尾自增的唯一id
     * @return
     */
    public static synchronized String creatId() throws InterruptedException{
        //測試控制方法內的併發執行緒數 測試放開synchronized
        //semaphore.acquire();
        semaphore.tryAcquire(1,1000, TimeUnit.MILLISECONDS);
        int i = semaphore.availablePermits();
        System.out.println("當前可用許可" + i);


        int i1 = semaphore.drainPermits();
        System.out.println("當前立即可用的許可" + i1);

        boolean b = semaphore.hasQueuedThreads();
        System.out.println("當前是否有執行緒等待" + b);

        boolean fair = semaphore.isFair();
        System.out.println("當前訊號是否公平" + fair);
        long l = System.currentTimeMillis();

        int queueLength = semaphore.getQueueLength();
        System.out.println("等待執行緒數" + queueLength);
        Thread.sleep(100);
        Guid += 1;

        String format = new SimpleDateFormat("yyyy").format(l);

        if (Guid > 999){
            Guid = 100;
        }

        String id = lead + format + l + Guid;

        semaphore.release();
        return id;
    }
}
複製程式碼

注：文章源地址：https://www.cnblogs.com/jinggod/p/8494246.html