Semaphore使用

╰半橙微兮° 2022-05-31 08:43 216阅读 0赞

> 单词Semaphore的中文含义是信号、信号系统。此类的主要作用就是限制线程并发的数量，如果不限制线程并发的数量，则cup的资源很快就被耗尽，每个线程执行的任务是相当缓慢，因为cup要把时间片分配给不同的线程对象，而且上下文切换也要耗时，最终造成系统运行效率大幅降低，所以限制并发线程的数量很有必要

## 1. 简单使用 ##

1.  举个栗子

public class Service { 
        private Semaphore semaphore = new Semaphore(2);
    
        public void testMethod() {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " begin timer=" + System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println(Thread.currentThread().getName() + " end timer=" + System.currentTimeMillis());
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public class ThreadA extends Thread { 
        private Service service;
    
        public ThreadA(Service service) {
            super();
            this.service = service;
        }
    
        @Override
        public void run() {
            service.testMethod();
        }
    }
    
    
    public class Run { 
        public static void main(String[] args) {
            Service service=new Service();
            ThreadA a=new ThreadA(service);
            a.setName("A");
            ThreadA b=new ThreadA(service);
            b.setName("B");
            ThreadA c=new ThreadA(service);
            c.setName("C");
            a.start();
            b.start();
            c.start();
        }
    }

运行效果：

B begin timer=1518577498811
    A begin timer=1518577498812
    B end timer=1518577503812
    C begin timer=1518577503812
    A end timer=1518577503812
    C end timer=1518577508812

可以发现，虽然同时打开了三个线程，但是只有两个线程可以并发执行。

## 2. 使用Semaphore创建字符串池 ##

> 类Semaphore可以有效地对并发执行任务的线程数量进行限制，这种功能可以应用在pool池技术中，可以设置同时访问pool池中数据的线程数量。  
> 本实验的功能是同时有若干线程可以访问池中的数据，但同时只有一个线程可以取得数据，使用完毕后再放回池中。

public class ListPool {
        private int poolMaxSize=3;
        private int semaphorePermits=5;
        private List<String> list=new ArrayList<>();
        private Semaphore concurrencySemaphore=new Semaphore(semaphorePermits);
        private ReentrantLock lock=new ReentrantLock();
        private Condition condition=lock.newCondition();
        public ListPool(){
            super();
            for(int i=0;i<poolMaxSize;i++){
                list.add("test"+(i+1));
            }
        }
        public String get(){
            String getString=null;
            try{
                concurrencySemaphore.acquire();
                lock.lock();
                while (list.size()==0){
                    condition.await();
                }
                getString=list.remove(0);
                lock.unlock();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            return getString;
        }
    
        public void put(String stringValue){
            lock.lock();
            list.add(stringValue);
            condition.signalAll();
            lock.unlock();
            concurrencySemaphore.release();
        }
    
    }
    
    
    public class MyThread extends Thread {
        private ListPool listPool;
    
        public MyThread(ListPool listPool) {
            super();
            this.listPool = listPool;
        }
    
        @Override
        public void run() {
            for (int i = 0; i < Integer.MAX_VALUE; i++) {
                String getString = listPool.get();
                System.out.println(Thread.currentThread().getName() + " 取得值 " + getString);
                listPool.put(getString);
            }
        }
    }
    
    public class Run {
        public static void main(String[] args) {
            ListPool pool = new ListPool();
            MyThread[] threadArray = new MyThread[12];
            for (int i = 0; i < threadArray.length; i++) {
                threadArray[i] = new MyThread(pool);
            }
            for (int i = 0; i < threadArray.length; i++) {
                threadArray[i].start();
            }
        }
    }

*  运行结果

Thread-2 取得值 test1
    Thread-3 取得值 test2
    Thread-2 取得值 test1
    Thread-5 取得值 test1
    Thread-1 取得值 test1
    Thread-1 取得值 test1
    Thread-0 取得值 test3
    Thread-1 取得值 test1
    Thread-10 取得值 test3
    ...............