From 81fb1ed93ceb3a2dad475099015ea749802457fe Mon Sep 17 00:00:00 2001 From: Florian Schmaus Date: Fri, 20 Nov 2015 15:21:47 +0100 Subject: [PATCH] Make executorService blocking in AbstractXMPPConnection Otherwise AbstractXMPPConnection.processPacket() will throw a RejectedExecutionException if the underlying queue is full. Fixes SMACK-702. --- .../smack/AbstractXMPPConnection.java | 12 ++-- .../smack/util/BoundedThreadPoolExecutor.java | 63 +++++++++++++++++++ 2 files changed, 69 insertions(+), 6 deletions(-) create mode 100644 smack-core/src/main/java/org/jivesoftware/smack/util/BoundedThreadPoolExecutor.java diff --git a/smack-core/src/main/java/org/jivesoftware/smack/AbstractXMPPConnection.java b/smack-core/src/main/java/org/jivesoftware/smack/AbstractXMPPConnection.java index 7653da444..7b680b1a3 100644 --- a/smack-core/src/main/java/org/jivesoftware/smack/AbstractXMPPConnection.java +++ b/smack-core/src/main/java/org/jivesoftware/smack/AbstractXMPPConnection.java @@ -27,14 +27,12 @@ import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; -import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent.CopyOnWriteArraySet; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledFuture; -import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.Lock; @@ -73,6 +71,7 @@ import org.jivesoftware.smack.parsing.ParsingExceptionCallback; import org.jivesoftware.smack.parsing.UnparsablePacket; import org.jivesoftware.smack.provider.ExtensionElementProvider; import org.jivesoftware.smack.provider.ProviderManager; +import org.jivesoftware.smack.util.BoundedThreadPoolExecutor; import org.jivesoftware.smack.util.DNSUtil; import org.jivesoftware.smack.util.Objects; import org.jivesoftware.smack.util.PacketParserUtils; @@ -237,8 +236,8 @@ public abstract class AbstractXMPPConnection implements XMPPConnection { * important that we use a single threaded ExecutorService in order to guarantee that the * PacketListeners are invoked in the same order the stanzas arrived. */ - private final ThreadPoolExecutor executorService = new ThreadPoolExecutor(1, 1, 0, TimeUnit.SECONDS, - new ArrayBlockingQueue(100), new SmackExecutorThreadFactory(connectionCounterValue, "Incoming Processor")); + private final BoundedThreadPoolExecutor executorService = new BoundedThreadPoolExecutor(1, 1, 0, TimeUnit.SECONDS, + 100, new SmackExecutorThreadFactory(connectionCounterValue, "Incoming Processor")); /** * This scheduled thread pool executor is used to remove pending callbacks. @@ -976,12 +975,13 @@ public abstract class AbstractXMPPConnection implements XMPPConnection { * they are a match with the filter. * * @param packet the stanza(/packet) to process. + * @throws InterruptedException */ - protected void processPacket(Stanza packet) { + protected void processPacket(Stanza packet) throws InterruptedException { assert(packet != null); lastStanzaReceived = System.currentTimeMillis(); // Deliver the incoming packet to listeners. - executorService.submit(new ListenerNotification(packet)); + executorService.executeBlocking(new ListenerNotification(packet)); } /** diff --git a/smack-core/src/main/java/org/jivesoftware/smack/util/BoundedThreadPoolExecutor.java b/smack-core/src/main/java/org/jivesoftware/smack/util/BoundedThreadPoolExecutor.java new file mode 100644 index 000000000..c09ddd5d5 --- /dev/null +++ b/smack-core/src/main/java/org/jivesoftware/smack/util/BoundedThreadPoolExecutor.java @@ -0,0 +1,63 @@ +/** + * + * Copyright 2015 Florian Schmaus + * + * 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.jivesoftware.smack.util; + +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.RejectedExecutionException; +import java.util.concurrent.Semaphore; +import java.util.concurrent.ThreadFactory; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +public class BoundedThreadPoolExecutor extends ThreadPoolExecutor { + + private final Semaphore semaphore; + + public BoundedThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, + TimeUnit unit, int bound, ThreadFactory threadFactory) { + // One could think that the array blocking queue bound should be "bound - 1" because the bound protected by the + // Semaphore also includes the "slot" in the worker thread executing the Runnable. But using that as bound could + // actually cause a RejectedExecutionException as the queue could fill up while the worker thread remains + // unscheduled and is thus not removing any entries. + super(corePoolSize, maximumPoolSize, keepAliveTime, + unit, new ArrayBlockingQueue(bound), threadFactory); + semaphore = new Semaphore(bound); + } + + public void executeBlocking(final Runnable command) throws InterruptedException { + semaphore.acquire(); + try { + execute(new Runnable() { + @Override + public void run() { + try { + command.run(); + } finally { + semaphore.release(); + } + } + }); + } catch (Exception e) { + semaphore.release(); + if (e instanceof RejectedExecutionException) { + throw (RejectedExecutionException) e; + } else { + throw new RuntimeException(e); + } + } + } +}