com.bt.aloha.batchtest.v2.StackManagerSyncronizationSemaphoreImpl.java Source code

Introduction

Here is the source code for com.bt.aloha.batchtest.v2.StackManagerSyncronizationSemaphoreImpl.java

Source

/*
 * Aloha Open Source SIP Application Server- https://trac.osmosoft.com/Aloha
 *
 * Copyright (c) 2008, British Telecommunications plc. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation; either version 3.0 of the License, or (at your option) any later
 * version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along
 * with this library; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

package com.bt.aloha.batchtest.v2;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class StackManagerSyncronizationSemaphoreImpl implements StackManagerSyncronizationSemaphore {
    private static Log log = LogFactory.getLog(StackManagerSyncronizationSemaphoreImpl.class);
    private Semaphore semaphore;
    private int max;

    public void initialize(int count, int max) {
        this.max = max;
        this.semaphore = new Semaphore(count);
        log.info("Initializing Syncronization semaphore to " + count);
    }

    public void release(int count) {
        checkIfInitialized();
        semaphore.release(count);
    }

    public void releaseAll() {
        release(this.max);
    }

    public void tryAcquire() {
        tryAcquire(5000);
    }

    public void waitForAll() {
        checkIfInitialized();
        final int c0 = 5;
        int c = c0;
        while (semaphore.availablePermits() > 0 || c > 0) {
            log.debug(String.format("Waiting %ss for all threads to consume the permits. Permits left: %s",
                    (c0 - c), semaphore.availablePermits()));
            sleep(1000);
            c--;
        }
    }

    private void sleep(long ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            log.warn("Interrupted whilst sleeping");
        }
    }

    public void tryAcquire(int msTimeout) {
        checkIfInitialized();
        try {
            semaphore.tryAcquire(msTimeout, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            throw new IllegalStateException("Interrupted whilst trying to aquire", e);
        }
    }

    public boolean isInitialized() {
        return semaphore != null;
    }

    private void checkIfInitialized() {
        if (!isInitialized())
            throw new IllegalStateException("Semaphore not initialized");
    }
}