Uses a single Thread per StunStack to expire StunServerTransactions in order to reduce the total number of utilized Threads.

This commit is contained in:
lubomir.marinov 2014-02-11 07:54:43 +00:00
parent 987512ede1
commit 58f9e29c82
3 changed files with 290 additions and 133 deletions

View File

@ -33,12 +33,11 @@ import org.ice4j.message.*;
* @author Emil Ivov
*/
class StunServerTransaction
implements Runnable
{
/**
* The time that we keep server transactions active.
*/
private static final long LIFETIME = 16000;
static final long LIFETIME = 16000;
/**
* The <tt>StunStack</tt> that created us.
@ -76,14 +75,9 @@ class StunServerTransaction
private final TransactionID transactionID;
/**
* The date (in milliseconds) when the next retransmission should follow.
* The time in milliseconds when the next retransmission should follow.
*/
private long expirationDate = -1;
/**
* The thread that this transaction runs in.
*/
private Thread runningThread = null;
private long expirationTime = -1;
/**
* Determines whether or not the transaction has expired.
@ -116,35 +110,25 @@ class StunServerTransaction
this.transactionID = tranID;
this.localListeningAddress = localListeningAddress;
this.requestSource = requestSource;
runningThread = new Thread(this, "StunServerTransaction@"+hashCode());
runningThread.setDaemon(true);
}
/**
* Start the transaction. This launches the countdown to the moment the
* transaction would expire.
*/
public void start()
public synchronized void start()
{
expired = false;
runningThread.start();
}
/**
* Actually this method is simply a timer waiting for the server transaction
* lifetime to come to an end.
*/
public void run()
{
runningThread.setName("ServTran");
schedule(LIFETIME);
waitNextScheduledDate();
//let's get lost
expire();
stackCallback.removeServerTransaction(this);
if (expirationTime == -1)
{
expired = false;
expirationTime = LIFETIME + System.currentTimeMillis();
}
else
{
throw new IllegalStateException(
"StunServerTransaction " + getTransactionID()
+ " has already been started!");
}
}
/**
@ -200,7 +184,7 @@ class StunServerTransaction
{
//don't retransmit if we are expired or if the user application
//hasn't yet transmitted a first response
if(expired || !isRetransmitting)
if(isExpired() || !isRetransmitting)
return;
stackCallback.getNetAccessManager().sendMessage(
@ -209,45 +193,47 @@ class StunServerTransaction
responseDestination);
}
/**
* Waits until next retransmission is due or until the transaction is
* cancelled (whichever comes first).
*/
private synchronized void waitNextScheduledDate()
{
long timeout;
while (!expired
&& (timeout = expirationDate - System.currentTimeMillis()) > 0)
{
try
{
wait(timeout);
}
catch (InterruptedException ex)
{
}
}
}
/**
* Sets the expiration date for this server transaction.
*
* @param timeout the number of milliseconds to wait before expiration.
*/
private void schedule(long timeout)
{
this.expirationDate = System.currentTimeMillis() + timeout;
}
/**
* Cancels the transaction. Once this method is called the transaction is
* considered terminated and will stop retransmissions.
*/
public synchronized void expire()
{
this.expired = true;
notifyAll();
expired = true;
/*
* StunStack has a background Thread running with the purpose of
* removing expired StunServerTransactions.
*/
}
/**
* Determines whether this <tt>StunServerTransaction</tt> is expired now.
*
* @return <tt>true</tt> if this <tt>StunServerTransaction</tT> is expired
* now; otherwise, <tt>false</tt>
*/
public boolean isExpired()
{
return isExpired(System.currentTimeMillis());
}
/**
* Determines whether this <tt>StunServerTransaction</tt> will be expired at
* a specific point in time.
*
* @param now the time in milliseconds at which the <tt>expired</tt> state
* of this <tt>StunServerTransaction</tt> is to be returned
* @return <tt>true</tt> if this <tt>StunServerTransaction</tt> will be
* expired at the specified point in time; otherwise, <tt>false</tt>
*/
public synchronized boolean isExpired(long now)
{
if (expirationTime == -1)
return false;
else if (expirationTime < now)
return true;
else
return expired;
}
/**
@ -257,7 +243,7 @@ class StunServerTransaction
*/
public TransactionID getTransactionID()
{
return this.transactionID;
return transactionID;
}
/**

View File

@ -72,6 +72,13 @@ public class StunStack
clientTransactions
= new Hashtable<TransactionID, StunClientTransaction>();
/**
* The <tt>Thread</tt> which expires the <tt>StunServerTransaction</tt>s of
* this <tt>StunStack</tt> and removes them from
* {@link #serverTransactions}.
*/
private Thread serverTransactionExpireThread;
/**
* Currently open server transactions. The vector contains transaction ids
* for transactions corresponding to all non-answered received requests.
@ -167,18 +174,50 @@ public class StunStack
{
synchronized (serverTransactions)
{
Collection<StunServerTransaction> sTrans
= serverTransactions.values();
long now = System.currentTimeMillis();
for (StunServerTransaction tran : sTrans)
for (Iterator<StunServerTransaction> i
= serverTransactions.values().iterator();
i.hasNext();)
{
if (tran.getTransactionID().equals(transactionID))
return tran;
StunServerTransaction serverTransaction = i.next();
if (serverTransaction.isExpired(now))
i.remove();
else if (serverTransaction.getTransactionID().equals(
transactionID))
return serverTransaction;
}
}
return null;
}
/**
* Returns the transaction with the specified <tt>transactionID</tt> or
* <tt>null</tt> if no such transaction exists.
*
* @param transactionID the ID of the transaction we are looking for.
*
* @return the {@link StunClientTransaction} we are looking for.
*/
protected StunServerTransaction getServerTransaction(
TransactionID transactionID)
{
StunServerTransaction serverTransaction;
synchronized (serverTransactions)
{
serverTransaction = serverTransactions.get(transactionID);
}
/*
* If a StunServerTransaction is expired, do not return it. It will be
* removed from serverTransactions soon.
*/
if ((serverTransaction != null) && serverTransaction.isExpired())
serverTransaction = null;
return serverTransaction;
}
/**
* Cancels the {@link StunClientTransaction} with the specified
* <tt>transactionID</tt>. Cancellation means that the stack will not
@ -208,48 +247,41 @@ public class StunStack
*/
private void cancelTransactionsForAddress(TransportAddress localAddr)
{
synchronized(clientTransactions)
synchronized (clientTransactions)
{
Iterator<Map.Entry<TransactionID, StunClientTransaction>>
clientTransactionsIter = clientTransactions.entrySet()
.iterator();
Iterator<StunClientTransaction> clientTransactionsIter
= clientTransactions.values().iterator();
while (clientTransactionsIter.hasNext())
{
Map.Entry<TransactionID, StunClientTransaction> entry
= clientTransactionsIter.next();
StunClientTransaction tran = clientTransactionsIter.next();
StunClientTransaction tran = entry.getValue();
if (tran.getLocalAddress().equals(localAddr))
{
clientTransactionsIter.remove();
tran.cancel();
tran.cancel();
}
}
}
synchronized(serverTransactions)
synchronized (serverTransactions)
{
Iterator<Map.Entry<TransactionID, StunServerTransaction>>
serverTransactionsIter = serverTransactions.entrySet()
.iterator();
Iterator<StunServerTransaction> serverTransactionsIter
= serverTransactions.values().iterator();
while (serverTransactionsIter.hasNext())
{
Map.Entry<TransactionID, StunServerTransaction> entry
= serverTransactionsIter.next();
StunServerTransaction tran = entry.getValue();
StunServerTransaction tran = serverTransactionsIter.next();
TransportAddress listenAddr = tran.getLocalListeningAddress();
TransportAddress sendingAddr = tran.getSendingAddress();
if ( listenAddr.equals(localAddr)
|| (sendingAddr != null && sendingAddr.equals(localAddr)) )
if (listenAddr.equals(localAddr)
|| (sendingAddr != null
&& sendingAddr.equals(localAddr)))
{
serverTransactionsIter.remove();
tran.expire();
}
tran.expire();
}
}
}
@ -534,7 +566,7 @@ public class StunStack
{
TransactionID tid
= TransactionID.createTransactionID(this, transactionID);
StunServerTransaction sTran = serverTransactions.get(tid);
StunServerTransaction sTran = getServerTransaction(tid);
if(sTran == null)
{
@ -652,9 +684,12 @@ public class StunStack
* Method is used by StunClientTransaction-s themselves when a timeout occurs.
* @param tran the transaction to remove.
*/
synchronized void removeClientTransaction(StunClientTransaction tran)
void removeClientTransaction(StunClientTransaction tran)
{
clientTransactions.remove(tran.getTransactionID());
synchronized (clientTransactions)
{
clientTransactions.remove(tran.getTransactionID());
}
}
/**
@ -663,9 +698,12 @@ public class StunStack
* Method is used by StunServerTransaction-s themselves when they expire.
* @param tran the transaction to remove.
*/
synchronized void removeServerTransaction(StunServerTransaction tran)
void removeServerTransaction(StunServerTransaction tran)
{
serverTransactions.remove(tran.getTransactionID());
synchronized (serverTransactions)
{
serverTransactions.remove(tran.getTransactionID());
}
}
/**
@ -690,7 +728,7 @@ public class StunStack
logger.finest("parsing request");
TransactionID serverTid = ev.getTransactionID();
StunServerTransaction sTran = serverTransactions.get(serverTid);
StunServerTransaction sTran = getServerTransaction(serverTid);
if( sTran != null)
{
@ -740,7 +778,11 @@ public class StunStack
logger.info("STUN transaction thread start failed:" + t);
return;
}
serverTransactions.put(serverTid, sTran);
synchronized (serverTransactions)
{
serverTransactions.put(serverTid, sTran);
maybeStartServerTransactionExpireThread();
}
}
//validate attributes that need validation.
@ -856,26 +898,32 @@ public class StunStack
{
eventDispatcher.removeAllListeners();
for (Iterator<StunClientTransaction> i
= clientTransactions.values().iterator();
i.hasNext();)
synchronized (clientTransactions)
{
StunClientTransaction tran = i.next();
for (Iterator<StunClientTransaction> i
= clientTransactions.values().iterator();
i.hasNext();)
{
StunClientTransaction tran = i.next();
i.remove();
if(tran != null)
tran.cancel();
i.remove();
if (tran != null)
tran.cancel();
}
}
for (Iterator<StunServerTransaction> i
= serverTransactions.values().iterator();
i.hasNext();)
synchronized (serverTransactions)
{
StunServerTransaction tran = i.next();
for (Iterator<StunServerTransaction> i
= serverTransactions.values().iterator();
i.hasNext();)
{
StunServerTransaction tran = i.next();
i.remove();
if(tran != null)
tran.expire();
i.remove();
if (tran != null)
tran.expire();
}
}
netAccessManager.stop();
@ -1214,4 +1262,133 @@ public class StunStack
{
return mode;
}
/**
* Initializes and starts {@link #serverTransactionExpireThread} if
* necessary.
*/
private void maybeStartServerTransactionExpireThread()
{
synchronized (serverTransactions)
{
if (!serverTransactions.isEmpty()
&& (serverTransactionExpireThread == null))
{
Thread t
= new Thread()
{
@Override
public void run()
{
runInServerTransactionExpireThread();
}
};
t.setDaemon(true);
t.setName(
getClass().getName()
+ ".serverTransactionExpireThread");
boolean started = false;
serverTransactionExpireThread = t;
try
{
t.start();
started = true;
}
finally
{
if (!started && (serverTransactionExpireThread == t))
serverTransactionExpireThread = null;
}
}
}
}
/**
* Runs in {@link #serverTransactionExpireThread} and expires the
* <tt>StunServerTransaction</tt>s of this <tt>StunStack</tt> and removes
* them from {@link #serverTransactions}.
*/
private void runInServerTransactionExpireThread()
{
try
{
long idleStartTime = -1;
do
{
synchronized (serverTransactions)
{
try
{
serverTransactions.wait(StunServerTransaction.LIFETIME);
}
catch (InterruptedException ie)
{
}
/*
* Is the current Thread still designated to expire the
* StunServerTransactions of this StunStack?
*/
if (Thread.currentThread() != serverTransactionExpireThread)
break;
long now = System.currentTimeMillis();
/*
* Has the current Thread been idle long enough to merit
* disposing of it?
*/
if (serverTransactions.isEmpty())
{
if (idleStartTime == -1)
idleStartTime = now;
else if (now - idleStartTime > 60 * 1000)
break;
}
else
{
// Expire the StunServerTransactions of this StunStack.
idleStartTime = -1;
for (Iterator<StunServerTransaction> i
= serverTransactions.values().iterator();
i.hasNext();)
{
StunServerTransaction serverTransaction = i.next();
if (serverTransaction == null)
{
i.remove();
}
else if (serverTransaction.isExpired(now))
{
i.remove();
serverTransaction.expire();
}
}
}
}
}
while (true);
}
finally
{
synchronized (serverTransactions)
{
if (serverTransactionExpireThread == Thread.currentThread())
serverTransactionExpireThread = null;
/*
* If serverTransactionExpireThread dies unexpectedly and yet it
* is still necessary, resurrect it.
*/
if (serverTransactionExpireThread == null)
maybeStartServerTransactionExpireThread();
}
}
}
}

View File

@ -30,7 +30,7 @@ public class TransactionID
/**
* The id itself
*/
private final byte transactionID[];
private final byte[] transactionID;
/**
* Any object that the application would like to correlate to a transaction.
@ -53,7 +53,7 @@ public class TransactionID
*/
private TransactionID()
{
transactionID = new byte[RFC5389_TRANSACTION_ID_LENGTH];
this(false);
}
/**
@ -63,14 +63,11 @@ public class TransactionID
*/
private TransactionID(boolean rfc3489Compatibility)
{
if(rfc3489Compatibility)
{
transactionID = new byte[RFC3489_TRANSACTION_ID_LENGTH];
}
else
{
transactionID = new byte[RFC5389_TRANSACTION_ID_LENGTH];
}
transactionID
= new byte[
rfc3489Compatibility
? RFC3489_TRANSACTION_ID_LENGTH
: RFC5389_TRANSACTION_ID_LENGTH];
}
/**
@ -211,11 +208,10 @@ public class TransactionID
*/
public boolean equals(Object obj)
{
if(!(obj instanceof TransactionID))
return false;
if(this == obj)
return true;
if(!(obj instanceof TransactionID))
return false;
byte targetBytes[] = ((TransactionID)obj).transactionID;
@ -234,7 +230,7 @@ public class TransactionID
/**
* Returns the first four bytes of the transactionID to ensure proper
* retrieval from hashtables;
* retrieval from hashtables.
* @return the hashcode of this object - as advised by the Java Platform
* Specification
*/
@ -262,19 +258,17 @@ public class TransactionID
*/
public static String toString(byte[] transactionID)
{
StringBuffer idStr = new StringBuffer();
StringBuilder idStr = new StringBuilder();
idStr.append("0x");
for(int i = 0; i < transactionID.length; i++)
{
if((transactionID[i] & 0xFF) <= 15)
{
idStr.append("0");
}
idStr.append(Integer.toHexString(transactionID[i] & 0xff)
.toUpperCase());
idStr.append(
Integer.toHexString(transactionID[i] & 0xFF).toUpperCase());
}
return idStr.toString();