我之见--java多线程信号量Semaphore

最新推荐文章于 2014-09-22 09:50:17 发布

怪人伽利略

最新推荐文章于 2014-09-22 09:50:17 发布

阅读量1k

点赞数

分类专栏： java技术文章标签：多线程 thread semaphore 线程并发

本文链接：https://blog.csdn.net/chenqinglin163/article/details/38640759

版权

java技术专栏收录该内容

26 篇文章 0 订阅

订阅专栏

jdk提供很原语来让我们控制进程的并发，信号量是重要的一个。信号量一个重要的特质就是计数，

Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。比如在Windows下可以设置共享文件的最大客户端访问个数。

Semaphore实现的功能就类似厕所有5个坑，假如有10个人要上厕所，那么同时只能有多少个人去上厕所呢？同时只能有5个人能够占用，当5个人中的任何一个人让开后，其中等待的另外5个人中又有一个人可以占用了。另外等待的5个人中可以是随机获得优先机会，也可以是按照先来后到的顺序获得机会，这取决于构造Semaphore对象时传入的参数选项。单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”，这可应用于死锁恢复的一些场合。

Semaphore维护了当前访问的个数，提供同步机制，控制同时访问的个数。在数据结构中链表可以保存“无限”的节点，用Semaphore可以实现有限大小的链表。另外重入锁 ReentrantLock 也可以实现该功能，但实现上要复杂些。

当访问个数设置为1时，其功能等于Lock。

下面我们看一下基本用法：

package javaThread;

import java.util.concurrent.Semaphore;

public class SemaphoreThread {

    public static void main(String[] args) {
        Semaphore sp = new Semaphore(3);
        final SemaphoreData spData = new SemaphoreData(sp);
        for (int i = 0; i < 6; i++) {
            new Thread(" name " + i) {
                public void run() {
                    spData.opSemaphoreData();
                };
            }.start();
            ;
        }

    }

    static class SemaphoreData {
        private Semaphore mSp;

        public SemaphoreData(Semaphore sp) {
            mSp = sp;
        }

        public void opSemaphoreData() {
            try {
                mSp.acquire();
                System.out.println(" Thread name " + Thread.currentThread().getName());
                Thread.sleep(1000);
                System.out.println(" Thread name sleep " + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                mSp.release();
            }
        }
    }
}

acquire相当于申请锁，如果进程数没有达到设置的大小，就可以马上申请到锁，如果满了，就等待，

release相当释放锁。

Semaphore 更多的是与进程池使用，控制同时访问的大小，

package javaThread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreThreadTest {

    public static void main(String[] args) {

        ExecutorService exec = Executors.newCachedThreadPool();  
        final Semaphore semp = new Semaphore(3);  
        for (int index = 0; index < 20; index++) {
            final int NO = index;  
            Runnable run = new Runnable() {  
                public void run() {  
                    try {  
                        semp.acquire();  
                        System.out.println("note : " + NO);  
                        Thread.sleep((long) (Math.random() * 10000));  
                        semp.release();  
                        System.out.println("note : release " +NO );
                    } catch (InterruptedException e) {  
                    }  
                }  
            };  
            exec.execute(run);  
        }  
        exec.shutdown();  
    }

也可以多个Semaphore一起使用实现复杂的功能；下面我们就用 Semaphore来实现简单的生产者我消费者模式。

public class SemaphoreProducer {

    public static void main(String[] args) {

        ExecutorService  service = Executors.newCachedThreadPool();
        Data mData =new Data(4);
        
        for(int i = 0 ;i< 8;i++) {
            service.execute(new Producer(mData, " name " +i));         
        }
        
        service.execute(new Customer(mData, " name 1111111" ));
        
    }
   

    //生产 者和消费者使用队列
    
    static class Data {

        private final int DEFAULT_Size = 10;

        private int mCapacity = DEFAULT_Size;

        private Semaphore mMutex = new Semaphore(1);
        
        private Semaphore mProduceVisable ,mCustomVisable;
        
        private int mProducesPtr;
        
        private int mCoustomPrt;
        
        private Object [] mData;
        
        public Data() {

        }

        public Data(int cap) {
            mCapacity = cap;
            mProduceVisable = new Semaphore(mCapacity);
            mCustomVisable = new Semaphore(mCapacity);<pre name="code" class="java"><span style="white-space:pre">	</span>    try {
                mCustomVisable.acquire(mCapacity);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

mData = new Object[mCapacity]; mProducesPtr = 0; mCoustomPrt = 0; } public void put(Object object) { mProduceVisable.acquireUninterruptibly();// 是否 mMutex.acquireUninterruptibly(); mData[mProducesPtr] = object; if(++mProducesPtr == mCapacity) { mProducesPtr = 0; } mMutex.release(); mCustomVisable.release(); } public Object get() { mCustomVisable.acquireUninterruptibly(); mMutex.acquireUninterruptibly(); Object object = mData[mCoustomPrt]; if(++mCoustomPrt == mCapacity) { mCoustomPrt = 0; } mMutex.release(); mProduceVisable.release(); return object; } } static class Producer extends Thread { private Data mData; private String mName; public Producer(Data data,String name) { mData = data; mName = name; } @Override public void run() { super.run(); while (true) { Object object = new String("chenqinglin 1"); mData.put(object); System.out.println(" Producer " + mName); try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } static class Customer extends Thread { private Data mData; private String mName; public Customer(Data data,String name) { mData = data; mName = name; } @Override public void run() { super.run(); while (true) { Object object = mData.get(); System.out.println(" Customer " + mName + " object " + object.toString()); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }}

其实看似简单的Semaphore 也可以完成复杂的功能 .