diff --git a/src/main/java/org/ice4j/ice/Agent.java b/src/main/java/org/ice4j/ice/Agent.java
index d6d33d8..49a4a61 100644
--- a/src/main/java/org/ice4j/ice/Agent.java
+++ b/src/main/java/org/ice4j/ice/Agent.java
@@ -383,7 +383,7 @@ public class Agent
SecureRandom random = new SecureRandom();
connCheckServer = new ConnectivityCheckServer(this);
- connCheckClient = new ConnectivityCheckClient(this);
+ connCheckClient = new ConnectivityCheckClient(this, agentTasksScheduler);
//add the FINGERPRINT attribute to all messages.
System.setProperty(StackProperties.ALWAYS_SIGN, "true");
diff --git a/src/main/java/org/ice4j/ice/ConnectivityCheckClient.java b/src/main/java/org/ice4j/ice/ConnectivityCheckClient.java
index 2b2d750..b9f3ab3 100644
--- a/src/main/java/org/ice4j/ice/ConnectivityCheckClient.java
+++ b/src/main/java/org/ice4j/ice/ConnectivityCheckClient.java
@@ -19,6 +19,8 @@ package org.ice4j.ice;
import java.net.*;
import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
import java.util.logging.*;
import org.ice4j.*;
@@ -54,6 +56,11 @@ class ConnectivityCheckClient
*/
private final Agent parentAgent;
+ /**
+ * A scheduled executor service to perform scheduled task of the client
+ */
+ private final ScheduledExecutorService scheduledExecutorService;
+
/**
* The StunStack that we will use for connectivity checks.
*/
@@ -62,13 +69,15 @@ class ConnectivityCheckClient
/**
* The {@link PaceMaker}s that are currently running checks in this client.
*/
- private final List paceMakers = new LinkedList<>();
+ private final Queue paceMakers
+ = new ConcurrentLinkedQueue<>();
/**
* Timer that is used to let some seconds before a CheckList is considered
* as FAILED.
*/
- private Map timers = new HashMap<>();
+ private ConcurrentMap>
+ checkListCompletionCheckers = new ConcurrentHashMap<>();
/**
* A flag that determines whether we have received a STUN response or not.
@@ -86,10 +95,15 @@ class ConnectivityCheckClient
* information such as user fragments for example.
*
* @param parentAgent the Agent that is creating this instance.
+ * @param scheduledExecutorService the ScheduledExecutorService
+ * to execute clients tasks
*/
- public ConnectivityCheckClient(Agent parentAgent)
+ public ConnectivityCheckClient(
+ Agent parentAgent,
+ ScheduledExecutorService scheduledExecutorService)
{
this.parentAgent = parentAgent;
+ this.scheduledExecutorService = scheduledExecutorService;
logger = new Logger(classLogger, parentAgent.getLogger());
stunStack = this.parentAgent.getStunStack();
@@ -149,12 +163,8 @@ class ConnectivityCheckClient
public void startChecks(CheckList checkList)
{
PaceMaker paceMaker = new PaceMaker(checkList);
-
- synchronized (paceMakers)
- {
- paceMakers.add(paceMaker);
- }
- paceMaker.start();
+ paceMakers.add(paceMaker);
+ paceMaker.schedule();
}
/**
@@ -431,14 +441,12 @@ class ConnectivityCheckClient
if ( !stream.validListContainsAllComponents())
{
final String streamName = stream.getName();
- Timer timer = timers.get(streamName);
-
- if (timer == null)
+ if (!checkListCompletionCheckers.containsKey(streamName))
{
- logger.info("CheckList will failed in a few seconds if no" +
- "succeeded checks come");
+ logger.info("CheckList will failed in a few seconds" +
+ " if no succeeded checks come");
- TimerTask task = new TimerTask()
+ Runnable checkLickCompletedChecker = new Runnable()
{
@Override
public void run()
@@ -453,9 +461,20 @@ class ConnectivityCheckClient
}
}
};
- timer = new Timer();
- timers.put(streamName, timer);
- timer.schedule(task, 5000);
+
+ final ScheduledFuture> scheduledCheckerFuture
+ = scheduledExecutorService.schedule(
+ checkLickCompletedChecker,
+ 5000,
+ TimeUnit.MILLISECONDS);
+
+ final ScheduledFuture> existingCheckerFuture
+ = checkListCompletionCheckers
+ .putIfAbsent(streamName, scheduledCheckerFuture);
+ if (existingCheckerFuture != null)
+ {
+ scheduledCheckerFuture.cancel(false);
+ }
}
}
@@ -847,16 +866,83 @@ class ConnectivityCheckClient
}
/**
- * The thread that actually sends the checks for a particular check list
- * in the pace defined in RFC 5245.
+ * A class to control periodically scheduled runnable that actually sends
+ * the checks for a particular check list in the pace defined in RFC 5245.
*/
- private class PaceMaker
- extends Thread
+ private final class PaceMaker
{
/**
- * Indicates whether this Thread should still be running.
+ * Indicates whether this Runnable should continue running.
*/
- boolean running = true;
+ private final AtomicBoolean cancelled = new AtomicBoolean();
+
+ /**
+ * Sends connectivity checks at the pace determined by the {@link
+ * Agent#calculateTa()} method and using either the trigger check queue
+ * or the regular check lists.
+ */
+ private final Runnable connectivityChecker = new Runnable()
+ {
+ @Override
+ public void run()
+ {
+ if (cancelled.get())
+ {
+ return;
+ }
+
+ CandidatePair pairToCheck = checkList.popTriggeredCheck();
+
+ //if there are no triggered checks, go for an ordinary one.
+ if (pairToCheck == null)
+ {
+ pairToCheck = checkList.getNextOrdinaryPairToCheck();
+ }
+
+ if (pairToCheck != null)
+ {
+ /*
+ * Since we suspect that it is possible to
+ * startCheckForPair, processSuccessResponse and only
+ * then setStateInProgress, we'll synchronize. The
+ * synchronization root is the one of the
+ * CandidatePair#setState method.
+ */
+ synchronized (pairToCheck)
+ {
+ TransactionID transactionID
+ = startCheckForPair(pairToCheck);
+
+ if (transactionID == null)
+ {
+ logger.info(
+ "Pair failed: "
+ + pairToCheck.toShortString());
+ pairToCheck.setStateFailed();
+ }
+ else
+ {
+ pairToCheck.setStateInProgress(transactionID);
+ }
+ }
+ }
+ else
+ {
+ /*
+ * We are done sending checks for this list. We'll set
+ * its final state in either the processResponse(),
+ * processTimeout() or processFailure() method.
+ */
+ logger.finest("will skip a check beat.");
+ checkList.fireEndOfOrdinaryChecks();
+ }
+
+ if (!cancelled.get())
+ {
+ schedule();
+ }
+ }
+ };
/**
* The {@link CheckList} that this PaceMaker will be running
@@ -864,6 +950,11 @@ class ConnectivityCheckClient
*/
private final CheckList checkList;
+ /**
+ * Scheduled instance of {@link #connectivityChecker} runnable
+ */
+ private ScheduledFuture> scheduledCheck;
+
/**
* Creates a new {@link PaceMaker} for this
* ConnectivityCheckClient.
@@ -873,18 +964,37 @@ class ConnectivityCheckClient
*/
public PaceMaker(CheckList checkList)
{
- super("ICE PaceMaker: " + parentAgent.getLocalUfrag());
-
this.checkList = checkList;
+ }
- /*
- * Because PaceMaker does not seem to be a daemon at least on Ubuntu
- * in the run-sample target and it looks like it should be from the
- * standpoint of the application, explicitly tell it to be a daemon.
- * Otherwise, it could prevent the application from exiting because
- * of a problem in the ICE implementation.
- */
- setDaemon(true);
+ /**
+ * Cancel execution of current and further connectivity checks
+ */
+ void cancel()
+ {
+ cancelled.set(true);
+
+ final ScheduledFuture> scheduledCheck = this.scheduledCheck;
+ if (scheduledCheck != null)
+ {
+ scheduledCheck.cancel(true);
+ }
+ }
+
+ /**
+ * Schedules execution of checks for check list
+ */
+ void schedule()
+ {
+ if (cancelled.get())
+ {
+ return;
+ }
+ scheduledCheck
+ = scheduledExecutorService.schedule(
+ connectivityChecker,
+ getNextWaitInterval(),
+ TimeUnit.MILLISECONDS);
}
/**
@@ -907,95 +1017,6 @@ class ConnectivityCheckClient
return parentAgent.calculateTa() * activeCheckLists;
}
-
- /**
- * Sends connectivity checks at the pace determined by the {@link
- * Agent#calculateTa()} method and using either the trigger check queue
- * or the regular check lists.
- */
- @Override
- public synchronized void run()
- {
- try
- {
- while(running)
- {
- long waitFor = getNextWaitInterval();
-
- if (waitFor > 0)
- {
- /*
- * waitFor will be 0 for the first check since we won't
- * have any active check lists at that point yet.
- */
- try
- {
- wait(waitFor);
- }
- catch (InterruptedException e)
- {
- logger.log(Level.FINER, "PaceMaker got interrupted",
- e);
- }
-
- if (!running)
- break;
- }
-
- CandidatePair pairToCheck = checkList.popTriggeredCheck();
-
- //if there are no triggered checks, go for an ordinary one.
- if (pairToCheck == null)
- pairToCheck = checkList.getNextOrdinaryPairToCheck();
-
- if (pairToCheck != null)
- {
- /*
- * Since we suspect that it is possible to
- * startCheckForPair, processSuccessResponse and only
- * then setStateInProgress, we'll synchronize. The
- * synchronization root is the one of the
- * CandidatePair#setState method.
- */
- synchronized (pairToCheck)
- {
- TransactionID transactionID
- = startCheckForPair(pairToCheck);
-
- if (transactionID == null)
- {
- logger.info(
- "Pair failed: "
- + pairToCheck.toShortString());
- pairToCheck.setStateFailed();
- }
- else
- pairToCheck.setStateInProgress(transactionID);
- }
- }
- else
- {
- /*
- * We are done sending checks for this list. We'll set
- * its final state in either the processResponse(),
- * processTimeout() or processFailure() method.
- */
- logger.finest("will skip a check beat.");
- checkList.fireEndOfOrdinaryChecks();
- }
- }
- }
- finally
- {
- synchronized (paceMakers)
- {
- synchronized (this)
- {
- paceMakers.remove(this);
- }
- }
- }
- }
}
/**
@@ -1003,22 +1024,14 @@ class ConnectivityCheckClient
*/
public void stop()
{
- synchronized (paceMakers)
+ while (true)
{
- Iterator paceMakersIter = paceMakers.iterator();
-
- while(paceMakersIter.hasNext())
+ final PaceMaker paceMaker = paceMakers.poll();
+ if (paceMaker == null)
{
- PaceMaker paceMaker = paceMakersIter.next();
-
- synchronized (paceMaker)
- {
- paceMaker.running = false;
- paceMaker.notify();
- }
-
- paceMakersIter.remove();
+ break;
}
+ paceMaker.cancel();
}
}
}