org.jboss.threads.ThreadFactoryExecutor Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including
all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and
JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
/*
* JBoss, Home of Professional Open Source.
* Copyright 2017 Red Hat, Inc., and individual contributors
* as indicated by the @author tags.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jboss.threads;
import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.jboss.threads.management.BoundedThreadPoolExecutorMBean;
import org.wildfly.common.Assert;
@Deprecated
class ThreadFactoryExecutor implements BlockingExecutor, BoundedThreadPoolExecutorMBean {
private final ThreadFactory factory;
private final Semaphore limitSemaphore;
private final DirectExecutor taskExecutor;
private final Object lock = new Object();
private int maxThreads;
private int largestThreadCount;
private int currentThreadCount;
private final AtomicInteger rejected = new AtomicInteger();
private volatile boolean blocking;
ThreadFactoryExecutor(final ThreadFactory factory, int maxThreads, boolean blocking, final DirectExecutor taskExecutor) {
this.factory = factory;
this.maxThreads = maxThreads;
this.blocking = blocking;
this.taskExecutor = taskExecutor;
limitSemaphore = new Semaphore(maxThreads);
}
public int getMaxThreads() {
synchronized (lock) {
return maxThreads;
}
}
public void setMaxThreads(final int maxThreads) {
Assert.checkMinimumParameter("maxThreads", 0, maxThreads);
synchronized (lock) {
final int old = this.maxThreads;
final int diff = old - maxThreads;
if (diff < 0) {
limitSemaphore.release(-diff);
} else if (diff > 0) {
if (! limitSemaphore.tryAcquire(diff)) {
throw Messages.msg.cannotReduceMaxBelowCurrent();
}
}
this.maxThreads = maxThreads;
}
}
public void execute(final Runnable task) {
Assert.checkNotNullParam("task", task);
try {
final Semaphore semaphore = limitSemaphore;
if (blocking) {
try {
semaphore.acquire();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw Messages.msg.executionInterrupted();
}
} else {
if (! semaphore.tryAcquire()) {
throw Messages.msg.taskLimitReached();
}
}
boolean ok = false;
try {
final Thread thread = factory.newThread(new Runnable() {
public void run() {
try {
synchronized (lock) {
int t = ++currentThreadCount;
if (t > largestThreadCount) {
largestThreadCount = t;
}
}
taskExecutor.execute(task);
synchronized (lock) {
currentThreadCount--;
}
} finally {
limitSemaphore.release();
}
}
});
if (thread == null) {
throw Messages.msg.noThreadCreated();
}
thread.start();
ok = true;
} finally {
if (! ok) semaphore.release();
}
} catch (RejectedExecutionException e) {
rejected.getAndIncrement();
throw e;
}
}
public void executeBlocking(final Runnable task) throws RejectedExecutionException, InterruptedException {
Assert.checkNotNullParam("task", task);
try {
final Semaphore semaphore = limitSemaphore;
semaphore.acquire();
boolean ok = false;
try {
final Thread thread = factory.newThread(new Runnable() {
public void run() {
try {
synchronized (lock) {
int t = ++currentThreadCount;
if (t > largestThreadCount) {
largestThreadCount = t;
}
}
taskExecutor.execute(task);
synchronized (lock) {
currentThreadCount--;
}
} finally {
limitSemaphore.release();
}
}
});
if (thread == null) {
throw Messages.msg.noThreadCreated();
}
thread.start();
ok = true;
} finally {
if (! ok) semaphore.release();
}
} catch (RejectedExecutionException e) {
rejected.getAndIncrement();
throw e;
}
}
public void executeBlocking(final Runnable task, final long timeout, final TimeUnit unit) throws RejectedExecutionException, InterruptedException {
Assert.checkNotNullParam("task", task);
try {
final Semaphore semaphore = limitSemaphore;
if (! semaphore.tryAcquire(timeout, unit)) {
throw Messages.msg.executionTimedOut();
}
boolean ok = false;
try {
final Thread thread = factory.newThread(new Runnable() {
public void run() {
try {
synchronized (lock) {
int t = ++currentThreadCount;
if (t > largestThreadCount) {
largestThreadCount = t;
}
}
taskExecutor.execute(task);
synchronized (lock) {
currentThreadCount--;
}
} finally {
limitSemaphore.release();
}
}
});
if (thread == null) {
throw Messages.msg.noThreadCreated();
}
thread.start();
ok = true;
} finally {
if (! ok) semaphore.release();
}
} catch (RejectedExecutionException e) {
rejected.getAndIncrement();
throw e;
}
}
public void executeNonBlocking(final Runnable task) throws RejectedExecutionException {
Assert.checkNotNullParam("task", task);
try {
final Semaphore semaphore = limitSemaphore;
if (! semaphore.tryAcquire()) {
throw Messages.msg.taskLimitReached();
}
boolean ok = false;
try {
final Thread thread = factory.newThread(new Runnable() {
public void run() {
try {
synchronized (lock) {
int t = ++currentThreadCount;
if (t > largestThreadCount) {
largestThreadCount = t;
}
}
taskExecutor.execute(task);
synchronized (lock) {
currentThreadCount--;
}
} finally {
limitSemaphore.release();
}
}
});
if (thread == null) {
throw Messages.msg.noThreadCreated();
}
thread.start();
ok = true;
} finally {
if (! ok) semaphore.release();
}
} catch (RejectedExecutionException e) {
rejected.getAndIncrement();
throw e;
}
}
public boolean isBlocking() {
return blocking;
}
public void setBlocking(final boolean blocking) {
this.blocking = blocking;
}
public int getLargestThreadCount() {
synchronized (lock) {
return largestThreadCount;
}
}
public int getCurrentThreadCount() {
synchronized (lock) {
return currentThreadCount;
}
}
/** {@inheritDoc} */
public int getQueueSize() {
return 0;
}
public int getRejectedCount() {
return rejected.get();
}
public long getKeepAliveTime() {
return 0L;
}
public void setKeepAliveTime(final long milliseconds) {
if (milliseconds != 0L) {
throw Messages.msg.keepAliveNotZero();
}
}
public String toString() {
return String.format("%s (%s)", super.toString(), factory);
}
}