Uses a single Thread per StunStack to expire StunServerTransactions in order to reduce the total number of utilized Threads.
This commit is contained in:
parent
987512ede1
commit
58f9e29c82
@ -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;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -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();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -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();
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user