UNICAST3

java.lang.Object
- org.jgroups.stack.Protocol
- - org.jgroups.protocols.UNICAST3

All Implemented Interfaces:

AgeOutCache.Handler<Address>
```
public class UNICAST3
extends Protocol
implements AgeOutCache.Handler<Address>
```
Reliable unicast protocol using a combination of positive and negative acks. See docs/design/UNICAST3.txt for details.

Since:

3.3

Author:

Bela Ban

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`UNICAST3.Entry`
`static class`	`UNICAST3.Header` The following types and fields are serialized:
`protected class`	`UNICAST3.ReceiverEntry`
`protected class`	`UNICAST3.RetransmitTask` Retransmitter task which periodically (every xmit_interval ms): If any of the receiver windows have the ack flag set, clears the flag and sends an ack for the highest delivered seqno to the sender Checks all receiver windows for missing messages and asks senders for retransmission For all sender windows, checks if highest acked (HA) < highest sent (HS).
`protected class`	`UNICAST3.SenderEntry`
`protected static class`	`UNICAST3.State`

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`ack_batches_immediately` Deprecated.
`protected int`	`ack_threshold`
`protected AgeOutCache<Address>`	`cache`
`protected long`	`conn_close_timeout`
`protected long`	`conn_expiry_timeout`
`protected static long`	`DEFAULT_FIRST_SEQNO`
`protected static Filter<Message>`	`dont_loopback_filter`
`protected Filter<Message>`	`drop_oob_and_dont_loopback_msgs_filter`
`protected static Message`	`DUMMY_OOB_MSG`
`protected short`	`last_conn_id`
`protected ExpiryCache<Address>`	`last_sync_sent` Keep track of when a SEND_FIRST_SEQNO message was sent to a given sender
`protected Address`	`local_addr`
`protected boolean`	`log_not_found_msgs`
`protected int`	`max_msg_batch_size`
`protected long`	`max_retransmit_time`
`protected int`	`max_xmit_req_size`
`protected java.util.List<Address>`	`members`
`protected long`	`num_acks_received`
`protected long`	`num_acks_sent`
`protected long`	`num_msgs_received`
`protected long`	`num_msgs_sent`
`protected long`	`num_xmits`
`protected java.util.concurrent.ConcurrentMap<Address,UNICAST3.ReceiverEntry>`	`recv_table`
`protected java.util.concurrent.locks.ReentrantLock`	`recv_table_lock`
`protected boolean`	`running`
`protected java.util.concurrent.ConcurrentMap<Address,UNICAST3.SenderEntry>`	`send_table`
`protected long`	`sync_min_interval`
`protected TimeService`	`time_service`
`protected TimeScheduler`	`timer`
`protected java.util.concurrent.atomic.AtomicLong`	`timestamper`
`protected long`	`xmit_interval`
`protected java.util.concurrent.atomic.AtomicLong`	`xmit_reqs_received`
`protected java.util.concurrent.atomic.AtomicLong`	`xmit_reqs_sent`
`protected java.util.concurrent.atomic.AtomicLong`	`xmit_rsps_sent`
`protected long`	`xmit_table_max_compaction_time`
`protected int`	`xmit_table_msgs_per_row`
`protected int`	`xmit_table_num_rows`
`protected double`	`xmit_table_resize_factor`
`protected java.util.concurrent.Future<?>`	`xmit_task` RetransmitTask running every xmit_interval ms
`protected java.util.Map<Address,java.lang.Long>`	`xmit_task_map` Used by the retransmit task to keep the last retransmitted seqno per sender (https://issues.jboss.org/browse/JGRP-1539)

Fields inherited from class org.jgroups.stack.Protocol
after_creation_hook, down_prot, ergonomics, id, log, name, stack, stats, up_prot

Constructor Summary

Constructors
Constructor and Description

UNICAST3()

Constructors
Constructor and Description
`UNICAST3()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`closeConnection(Address mbr)` Removes and resets from connection table (which is already locked).
`void`	`closeIdleConnections()`
`void`	`closeReceiveConnection(Address mbr)`
`void`	`closeSendConnection(Address mbr)`
`protected static int`	`compare(long ts1, long ts2)` Compares 2 timestamps, handles numeric overflow
`protected UNICAST3.ReceiverEntry`	`createReceiverEntry(Address sender, long seqno, short conn_id)`
`protected void`	`deliverBatch(MessageBatch batch)`
`protected void`	`deliverMessage(Event evt, Address sender, long seqno)`
`java.lang.Object`	`down(Event evt)` An event is to be sent down the stack.
`java.util.Map<java.lang.String,java.lang.Object>`	`dumpStats()`
`void`	`expired(Address key)` Called by AgeOutCache, to removed expired connections
`AgeOutCache<Address>`	`getAgeOutCache()`
`int`	`getAgeOutCacheSize()`
`java.lang.String`	`getLocalAddress()`
`long`	`getMaxRetransmitTime()`
`java.lang.String`	`getMembers()`
`protected short`	`getNewConnectionId()`
`long`	`getNumAcksReceived()`
`long`	`getNumAcksSent()`
`int`	`getNumConnections()`
`long`	`getNumMessagesReceived()`
`long`	`getNumMessagesSent()`
`int`	`getNumReceiveConnections()`
`int`	`getNumSendConnections()`
`int`	`getNumUnackedMessages()` The number of messages in all Entry.sent_msgs tables (haven't received an ACK yet)
`long`	`getNumXmits()`
`protected UNICAST3.ReceiverEntry`	`getReceiverEntry(Address sender, long seqno, boolean first, short conn_id)`
`protected UNICAST3.SenderEntry`	`getSenderEntry(Address dst)`
`protected long`	`getTimestamp()`
`long`	`getTimestamper()`
`long`	`getXmitTableMissingMessages()`
`int`	`getXmitTableNumCompactions()`
`int`	`getXmitTableNumMoves()`
`int`	`getXmitTableNumPurges()`
`int`	`getXmitTableNumResizes()`
`long`	`getXmitTableUndeliveredMessages()`
`protected void`	`handleAckReceived(Address sender, long seqno, short conn_id, long timestamp)` Add the ACK to hashtable.sender.sent_msgs
`protected void`	`handleBatchFromSelf(MessageBatch batch, UNICAST3.Entry entry)`
`protected void`	`handleBatchReceived(UNICAST3.ReceiverEntry entry, Address sender, java.util.List<Tuple<java.lang.Long,Message>> msgs, boolean oob)`
`protected void`	`handleDataReceived(Address sender, long seqno, short conn_id, boolean first, Message msg, Event evt)` Check whether the hashtable contains an entry e for `sender` (create if not).
`protected void`	`handleDataReceivedFromSelf(Address sender, long seqno, Message msg)` Called when the sender of a message is the local member.
`protected void`	`handleResendingOfFirstMessage(Address sender, long timestamp)` We need to resend the first message with our conn_id
`protected void`	`handleUpEvent(Address sender, Message msg, UNICAST3.Header hdr)`
`protected void`	`handleXmitRequest(Address sender, SeqnoList missing)`
`boolean`	`hasSendConnectionTo(Address dest)` Used for testing only
`void`	`init()` Called after instance has been created (null constructor) and before protocol is started.
`boolean`	`isXmitTaskRunning()`
`java.lang.String`	`printAgeOutCache()`
`java.lang.String`	`printConnections()`
`protected java.lang.String`	`printMessageList(java.util.List<Tuple<java.lang.Long,Message>> list)`
`java.lang.String`	`printReceiveWindowMessages()`
`java.lang.String`	`printSendWindowMessages()`
`protected void`	`processInternalMessage(Table<Message> win, Address sender)`
`void`	`removeAllConnections()` This method is public only so it can be invoked by unit testing, but should not otherwise be used !
`protected void`	`removeAndDeliver(java.util.concurrent.atomic.AtomicBoolean processing, Table<Message> win, Address sender)` Try to remove as many messages as possible from the table as pass them up.
`int`	`removeExpiredConnections()`
`protected void`	`removeReceiveConnection(Address mbr)`
`protected void`	`removeSendConnection(Address mbr)`
`void`	`resetStats()`
`protected void`	`retransmit(Message msg)` Called by the sender to resend messages for which no ACK has been received yet
`protected void`	`retransmit(SeqnoList missing, Address sender)` Sends a retransmit request to the given sender
`protected void`	`sendAck(Address dst, long seqno, short conn_id)`
`void`	`sendClose(Address dest, short conn_id)`
`void`	`sendPendingAcks()`
`protected void`	`sendRequestForFirstSeqno(Address dest)`
`void`	`setMaxMessageBatchSize(int size)`
`void`	`setMaxRetransmitTime(long max_retransmit_time)`
`void`	`start()` This method is called on a `Channel.connect(String)`.
`protected void`	`startRetransmitTask()`
`void`	`stop()` This method is called on a `Channel.disconnect()`.
`protected void`	`stopRetransmitTask()`
`void`	`triggerXmit()`
`java.lang.Object`	`up(Event evt)` An event was received from the layer below.
`void`	`up(MessageBatch batch)` Sends up a multiple messages in a `MessageBatch`.
`protected void`	`update(UNICAST3.Entry entry, int num_received)`

Methods inherited from class org.jgroups.stack.Protocol
accept, afterCreationHook, destroy, enableStats, getConfigurableObjects, getDownProtocol, getDownServices, getId, getIdsAbove, getLevel, getLog, getName, getProtocolStack, getSocketFactory, getThreadFactory, getTransport, getUpProtocol, getUpServices, getValue, isErgonomics, level, parse, printStats, providedDownServices, providedUpServices, requiredDownServices, requiredUpServices, resetStatistics, setDownProtocol, setErgonomics, setId, setLevel, setProtocolStack, setSocketFactory, setUpProtocol, setValue, setValues, statsEnabled

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DEFAULT_FIRST_SEQNO
```
protected static final long DEFAULT_FIRST_SEQNO
```
    See Also:
    
    Constant Field Values
  - max_msg_batch_size
```
protected int max_msg_batch_size
```
  - conn_expiry_timeout
```
protected long conn_expiry_timeout
```
  - conn_close_timeout
```
protected long conn_close_timeout
```
  - xmit_table_num_rows
```
protected int xmit_table_num_rows
```
  - xmit_table_msgs_per_row
```
protected int xmit_table_msgs_per_row
```
  - xmit_table_resize_factor
```
protected double xmit_table_resize_factor
```
  - xmit_table_max_compaction_time
```
protected long xmit_table_max_compaction_time
```
  - max_retransmit_time
```
protected long max_retransmit_time
```
  - xmit_interval
```
protected long xmit_interval
```
  - log_not_found_msgs
```
protected boolean log_not_found_msgs
```
  - ack_batches_immediately
```
@Deprecated
protected boolean ack_batches_immediately
```
    Deprecated.
  - ack_threshold
```
protected int ack_threshold
```
  - sync_min_interval
```
protected long sync_min_interval
```
  - max_xmit_req_size
```
protected int max_xmit_req_size
```
  - num_msgs_sent
```
protected long num_msgs_sent
```
  - num_msgs_received
```
protected long num_msgs_received
```
  - num_acks_sent
```
protected long num_acks_sent
```
  - num_acks_received
```
protected long num_acks_received
```
  - num_xmits
```
protected long num_xmits
```
  - xmit_reqs_received
```
protected final java.util.concurrent.atomic.AtomicLong xmit_reqs_received
```
  - xmit_reqs_sent
```
protected final java.util.concurrent.atomic.AtomicLong xmit_reqs_sent
```
  - xmit_rsps_sent
```
protected final java.util.concurrent.atomic.AtomicLong xmit_rsps_sent
```
  - send_table
```
protected final java.util.concurrent.ConcurrentMap<Address,UNICAST3.SenderEntry> send_table
```
  - recv_table
```
protected final java.util.concurrent.ConcurrentMap<Address,UNICAST3.ReceiverEntry> recv_table
```
  - recv_table_lock
```
protected final java.util.concurrent.locks.ReentrantLock recv_table_lock
```
  - xmit_task_map
```
protected final java.util.Map<Address,java.lang.Long> xmit_task_map
```
    Used by the retransmit task to keep the last retransmitted seqno per sender (https://issues.jboss.org/browse/JGRP-1539)
  - xmit_task
```
protected java.util.concurrent.Future<?> xmit_task
```
    RetransmitTask running every xmit_interval ms
  - members
```
protected volatile java.util.List<Address> members
```
  - local_addr
```
protected Address local_addr
```
  - timer
```
protected TimeScheduler timer
```
  - running
```
protected volatile boolean running
```
  - last_conn_id
```
protected short last_conn_id
```
  - cache
```
protected AgeOutCache<Address> cache
```
  - time_service
```
protected TimeService time_service
```
  - timestamper
```
protected final java.util.concurrent.atomic.AtomicLong timestamper
```
  - last_sync_sent
```
protected ExpiryCache<Address> last_sync_sent
```
    Keep track of when a SEND_FIRST_SEQNO message was sent to a given sender
  - DUMMY_OOB_MSG
```
protected static final Message DUMMY_OOB_MSG
```
  - drop_oob_and_dont_loopback_msgs_filter
```
protected final Filter<Message> drop_oob_and_dont_loopback_msgs_filter
```
  - dont_loopback_filter
```
protected static final Filter<Message> dont_loopback_filter
```
- Constructor Detail
  - UNICAST3
```
public UNICAST3()
```
- Method Detail
  - setMaxMessageBatchSize
```
public void setMaxMessageBatchSize(int size)
```
  - getLocalAddress
```
public java.lang.String getLocalAddress()
```
  - getMembers
```
public java.lang.String getMembers()
```
  - getNumSendConnections
```
public int getNumSendConnections()
```
  - getNumReceiveConnections
```
public int getNumReceiveConnections()
```
  - getNumConnections
```
public int getNumConnections()
```
  - getTimestamper
```
public long getTimestamper()
```
  - printConnections
```
public java.lang.String printConnections()
```
  - getNumMessagesSent
```
public long getNumMessagesSent()
```
  - getNumMessagesReceived
```
public long getNumMessagesReceived()
```
  - getNumAcksSent
```
public long getNumAcksSent()
```
  - getNumAcksReceived
```
public long getNumAcksReceived()
```
  - getNumXmits
```
public long getNumXmits()
```
  - getMaxRetransmitTime
```
public long getMaxRetransmitTime()
```
  - setMaxRetransmitTime
```
public void setMaxRetransmitTime(long max_retransmit_time)
```
  - isXmitTaskRunning
```
public boolean isXmitTaskRunning()
```
  - getAgeOutCacheSize
```
public int getAgeOutCacheSize()
```
  - printAgeOutCache
```
public java.lang.String printAgeOutCache()
```
  - getAgeOutCache
```
public AgeOutCache<Address> getAgeOutCache()
```
  - hasSendConnectionTo
```
public boolean hasSendConnectionTo(Address dest)
```
    Used for testing only
  - getNumUnackedMessages
```
public int getNumUnackedMessages()
```
    The number of messages in all Entry.sent_msgs tables (haven't received an ACK yet)
  - getXmitTableUndeliveredMessages
```
public long getXmitTableUndeliveredMessages()
```
  - getXmitTableMissingMessages
```
public long getXmitTableMissingMessages()
```
  - getXmitTableNumCompactions
```
public int getXmitTableNumCompactions()
```
  - getXmitTableNumMoves
```
public int getXmitTableNumMoves()
```
  - getXmitTableNumResizes
```
public int getXmitTableNumResizes()
```
  - getXmitTableNumPurges
```
public int getXmitTableNumPurges()
```
  - printReceiveWindowMessages
```
public java.lang.String printReceiveWindowMessages()
```
  - printSendWindowMessages
```
public java.lang.String printSendWindowMessages()
```
  - resetStats
```
public void resetStats()
```
    Overrides:
    
    resetStats in class Protocol
  - dumpStats
```
public java.util.Map<java.lang.String,java.lang.Object> dumpStats()
```
    Overrides:
    
    dumpStats in class Protocol
  - init
```
public void init()
          throws java.lang.Exception
```
    Description copied from class: Protocol
    
    Called after instance has been created (null constructor) and before protocol is started. Properties are already set. Other protocols are not yet connected and events cannot yet be sent.
    
    Overrides:
    
    init in class Protocol
    
    Throws:
    
    java.lang.Exception - Thrown if protocol cannot be initialized successfully. This will cause the ProtocolStack to fail, so the channel constructor will throw an exception
  - start
```
public void start()
           throws java.lang.Exception
```
    Description copied from class: Protocol
    
    This method is called on a Channel.connect(String). Starts work. Protocols are connected and queues are ready to receive events. Will be called from bottom to top. This call will replace the START and START_OK events.
    
    Overrides:
    
    start in class Protocol
    
    Throws:
    
    java.lang.Exception - Thrown if protocol cannot be started successfully. This will cause the ProtocolStack to fail, so Channel.connect(String) will throw an exception
  - stop
```
public void stop()
```
    Description copied from class: Protocol
    
    This method is called on a Channel.disconnect(). Stops work (e.g. by closing multicast socket). Will be called from top to bottom. This means that at the time of the method invocation the neighbor protocol below is still working. This method will replace the STOP, STOP_OK, CLEANUP and CLEANUP_OK events. The ProtocolStack guarantees that when this method is called all messages in the down queue will have been flushed
    
    Overrides:
    
    stop in class Protocol
  - up
```
public java.lang.Object up(Event evt)
```
    Description copied from class: Protocol
    
    An event was received from the layer below. Usually the current layer will want to examine the event type and - depending on its type - perform some computation (e.g. removing headers from a MSG event type, or updating the internal membership list when receiving a VIEW_CHANGE event). Finally the event is either a) discarded, or b) an event is sent down the stack using down_prot.down() or c) the event (or another event) is sent up the stack using up_prot.up().
    
    Overrides:
    
    up in class Protocol
  - handleUpEvent
```
protected void handleUpEvent(Address sender,
                             Message msg,
                             UNICAST3.Header hdr)
```
  - up
```
public void up(MessageBatch batch)
```
    Description copied from class: Protocol
    
    Sends up a multiple messages in a MessageBatch. The sender of the batch is always the same, and so is the destination (null == multicast messages). Messages in a batch can be OOB messages, regular messages, or mixed messages, although the transport itself will create initial MessageBatches that contain only either OOB or regular messages.
    The default processing below sends messages up the stack individually, based on a matching criteria (calling Protocol.accept(org.jgroups.Message)), and - if true - calls Protocol.up(org.jgroups.Event) for that message and removes the message. If the batch is not empty, it is passed up, or else it is dropped.
    Subclasses should check if there are any messages destined for them (e.g. using MessageBatch.getMatchingMessages(short,boolean)), then possibly remove and process them and finally pass the batch up to the next protocol. Protocols can also modify messages in place, e.g. ENCRYPT could decrypt all encrypted messages in the batch, not remove them, and pass the batch up when done.
    
    Overrides:
    
    up in class Protocol
    
    Parameters:
    
    batch - The message batch
  - handleBatchFromSelf
```
protected void handleBatchFromSelf(MessageBatch batch,
                                   UNICAST3.Entry entry)
```
  - down
```
public java.lang.Object down(Event evt)
```
    Description copied from class: Protocol
    
    An event is to be sent down the stack. The layer may want to examine its type and perform some action on it, depending on the event's type. If the event is a message MSG, then the layer may need to add a header to it (or do nothing at all) before sending it down the stack using down_prot.down(). In case of a GET_ADDRESS event (which tries to retrieve the stack's address from one of the bottom layers), the layer may need to send a new response event back up the stack using up_prot.up().
    
    Overrides:
    
    down in class Protocol
  - closeConnection
```
public void closeConnection(Address mbr)
```
    Removes and resets from connection table (which is already locked). Returns true if member was found, otherwise false. This method is public only so it can be invoked by unit testing, but should not be used !
  - closeSendConnection
```
public void closeSendConnection(Address mbr)
```
  - closeReceiveConnection
```
public void closeReceiveConnection(Address mbr)
```
  - removeSendConnection
```
protected void removeSendConnection(Address mbr)
```
  - removeReceiveConnection
```
protected void removeReceiveConnection(Address mbr)
```
  - removeAllConnections
```
public void removeAllConnections()
```
    This method is public only so it can be invoked by unit testing, but should not otherwise be used !
  - retransmit
```
protected void retransmit(SeqnoList missing,
                          Address sender)
```
    Sends a retransmit request to the given sender
  - retransmit
```
protected void retransmit(Message msg)
```
    Called by the sender to resend messages for which no ACK has been received yet
  - expired
```
public void expired(Address key)
```
    Called by AgeOutCache, to removed expired connections
    
    Specified by:
    
    expired in interface AgeOutCache.Handler<Address>
    
    Parameters:
    
    key -
  - handleDataReceived
```
protected void handleDataReceived(Address sender,
                                  long seqno,
                                  short conn_id,
                                  boolean first,
                                  Message msg,
                                  Event evt)
```
    Check whether the hashtable contains an entry e for sender (create if not). If e.received_msgs is null and first is true: create a new AckReceiverWindow(seqno) and add message. Set e.received_msgs to the new window. Else just add the message.
  - handleDataReceivedFromSelf
```
protected void handleDataReceivedFromSelf(Address sender,
                                          long seqno,
                                          Message msg)
```
    Called when the sender of a message is the local member. In this case, we don't need to add the message to the table as the sender already did that
  - processInternalMessage
```
protected void processInternalMessage(Table<Message> win,
                                      Address sender)
```
  - handleBatchReceived
```
protected void handleBatchReceived(UNICAST3.ReceiverEntry entry,
                                   Address sender,
                                   java.util.List<Tuple<java.lang.Long,Message>> msgs,
                                   boolean oob)
```
  - removeAndDeliver
```
protected void removeAndDeliver(java.util.concurrent.atomic.AtomicBoolean processing,
                                Table<Message> win,
                                Address sender)
```
    Try to remove as many messages as possible from the table as pass them up. Prevents concurrent passing up of messages by different threads (http://jira.jboss.com/jira/browse/JGRP-198); lots of threads can come up to this point concurrently, but only 1 is allowed to pass at a time. We *can* deliver messages from *different* senders concurrently, e.g. reception of P1, Q1, P2, Q2 can result in delivery of P1, Q1, Q2, P2: FIFO (implemented by UNICAST) says messages need to be delivered in the order in which they were sent
  - printMessageList
```
protected java.lang.String printMessageList(java.util.List<Tuple<java.lang.Long,Message>> list)
```
  - getReceiverEntry
```
protected UNICAST3.ReceiverEntry getReceiverEntry(Address sender,
                                                  long seqno,
                                                  boolean first,
                                                  short conn_id)
```
  - getSenderEntry
```
protected UNICAST3.SenderEntry getSenderEntry(Address dst)
```
  - createReceiverEntry
```
protected UNICAST3.ReceiverEntry createReceiverEntry(Address sender,
                                                     long seqno,
                                                     short conn_id)
```
  - handleAckReceived
```
protected void handleAckReceived(Address sender,
                                 long seqno,
                                 short conn_id,
                                 long timestamp)
```
    Add the ACK to hashtable.sender.sent_msgs
  - handleResendingOfFirstMessage
```
protected void handleResendingOfFirstMessage(Address sender,
                                             long timestamp)
```
    We need to resend the first message with our conn_id
    
    Parameters:
    
    sender -
  - handleXmitRequest
```
protected void handleXmitRequest(Address sender,
                                 SeqnoList missing)
```
  - deliverMessage
```
protected void deliverMessage(Event evt,
                              Address sender,
                              long seqno)
```
  - deliverBatch
```
protected void deliverBatch(MessageBatch batch)
```
  - getTimestamp
```
protected long getTimestamp()
```
  - startRetransmitTask
```
protected void startRetransmitTask()
```
  - stopRetransmitTask
```
protected void stopRetransmitTask()
```
  - sendAck
```
protected void sendAck(Address dst,
                       long seqno,
                       short conn_id)
```
  - getNewConnectionId
```
protected short getNewConnectionId()
```
  - sendRequestForFirstSeqno
```
protected void sendRequestForFirstSeqno(Address dest)
```
  - sendClose
```
public void sendClose(Address dest,
                      short conn_id)
```
  - closeIdleConnections
```
public void closeIdleConnections()
```
  - removeExpiredConnections
```
public int removeExpiredConnections()
```
  - update
```
protected void update(UNICAST3.Entry entry,
                      int num_received)
```
  - compare
```
protected static int compare(long ts1,
                             long ts2)
```
    Compares 2 timestamps, handles numeric overflow
  - triggerXmit
```
public void triggerXmit()
```
  - sendPendingAcks
```
public void sendPendingAcks()
```

Class UNICAST3

Nested Class Summary

Field Summary

Fields inherited from class org.jgroups.stack.Protocol

Constructor Summary

Method Summary

Methods inherited from class org.jgroups.stack.Protocol

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_FIRST_SEQNO

max_msg_batch_size

conn_expiry_timeout

conn_close_timeout

xmit_table_num_rows

xmit_table_msgs_per_row

xmit_table_resize_factor

xmit_table_max_compaction_time

max_retransmit_time

xmit_interval

log_not_found_msgs

ack_batches_immediately

ack_threshold

sync_min_interval

max_xmit_req_size

num_msgs_sent

num_msgs_received

num_acks_sent

num_acks_received

num_xmits

xmit_reqs_received

xmit_reqs_sent

xmit_rsps_sent

send_table

recv_table

recv_table_lock

xmit_task_map

xmit_task

members

local_addr

timer

running

last_conn_id

cache

time_service

timestamper

last_sync_sent

DUMMY_OOB_MSG

drop_oob_and_dont_loopback_msgs_filter

dont_loopback_filter

Constructor Detail

UNICAST3

Method Detail

setMaxMessageBatchSize

getLocalAddress

getMembers

getNumSendConnections

getNumReceiveConnections

getNumConnections

getTimestamper

printConnections

getNumMessagesSent

getNumMessagesReceived

getNumAcksSent

getNumAcksReceived

getNumXmits

getMaxRetransmitTime

setMaxRetransmitTime

isXmitTaskRunning

getAgeOutCacheSize

printAgeOutCache

getAgeOutCache

hasSendConnectionTo

getNumUnackedMessages

getXmitTableUndeliveredMessages

getXmitTableMissingMessages

getXmitTableNumCompactions

getXmitTableNumMoves

getXmitTableNumResizes

getXmitTableNumPurges

printReceiveWindowMessages