NAKACK2

java.lang.Object
- com.fr.third.jgroups.stack.Protocol
- - com.fr.third.jgroups.protocols.pbcast.NAKACK2

所有已实现的接口:

DiagnosticsHandler.ProbeHandler
```
public class NAKACK2
extends Protocol
implements DiagnosticsHandler.ProbeHandler
```
Negative AcKnowledgement layer (NAKs). Messages are assigned a monotonically increasing sequence number (seqno). Receivers deliver messages ordered according to seqno and request retransmission of missing messages.
Retransmit requests are usually sent to the original sender of a message, but this can be changed by xmit_from_random_member (send to random member) or use_mcast_xmit_req (send to everyone). Responses can also be sent to everyone instead of the requester by setting use_mcast_xmit to true.

作者:

Bela Ban

嵌套类概要

嵌套类
限定符和类型	类和说明
`protected static class`	`NAKACK2.Counter`
`protected class`	`NAKACK2.RetransmitTask` Retransmitter task which periodically (every xmit_interval ms) looks at all the retransmit tables and sends retransmit request to all members from which we have missing messages

字段概要

字段
限定符和类型	字段和说明
`protected BoundedList<Message>`	`become_server_queue`
`protected int`	`become_server_queue_size`
`protected BoundedList<java.lang.String>`	`digest_history` Keeps a bounded list of the last N digest sets
`protected boolean`	`discard_delivered_msgs` Messages that have been received in order are sent up the stack (= delivered to the application).
`protected static Filter<Message>`	`dont_loopback_filter`
`protected static Message`	`DUMMY_OOB_MSG`
`protected boolean`	`is_server`
`protected boolean`	`leaving`
`protected Address`	`local_addr`
`protected boolean`	`log_discard_msgs` If true, logs messages discarded because received from other members
`protected boolean`	`log_not_found_msgs`
`protected int`	`max_msg_batch_size`
`protected long`	`max_rebroadcast_timeout`
`protected java.util.List<Address>`	`members`
`protected Filter<Message>`	`no_dummy_and_no_oob_delivered_msgs_and_no_dont_loopback_msgs`
`protected int`	`num_messages_received`
`protected int`	`num_messages_sent`
`protected static int`	`NUM_REBROADCAST_MSGS`
`protected boolean`	`print_stability_history_on_failed_xmit` 已过时。
`protected Digest`	`rebroadcast_digest`
`protected java.util.concurrent.locks.Lock`	`rebroadcast_digest_lock`
`protected java.util.concurrent.locks.Condition`	`rebroadcast_done`
`protected java.util.concurrent.locks.Lock`	`rebroadcast_lock`
`protected boolean`	`rebroadcasting`
`protected boolean`	`running`
`protected BoundedList<java.lang.String>`	`stability_msgs` Keeps the last N stability messages
`protected SuppressLog<Address>`	`suppress_log_non_member` Log to suppress identical warnings for messages from non-members
`protected long`	`suppress_time_non_member_warnings`
`protected TimeScheduler`	`timer`
`protected boolean`	`use_mcast_xmit` Retransmit messages using multicast rather than unicast.
`protected boolean`	`use_mcast_xmit_req` Use a multicast to request retransmission of missing messages.
`protected View`	`view`
`protected boolean`	`xmit_from_random_member` Ask a random member for retransmission of a missing message.
`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_received`
`protected java.util.concurrent.atomic.AtomicLong`	`xmit_rsps_sent`
`protected java.util.concurrent.ConcurrentMap<Address,Table<Message>>`	`xmit_table` Map to store sent and received messages (keyed by sender)
`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)

从类继承的字段 com.fr.third.jgroups.stack.Protocol
down_prot, ergonomics, id, log, name, stack, stats, up_prot

构造器概要

构造器
构造器和说明

NAKACK2()

构造器
构造器和说明
`NAKACK2()`

方法概要

方法
限定符和类型	方法和说明
`protected void`	`adjustReceivers(java.util.List<Address> members)` Removes old members from xmit-table and adds new members to xmit-table (at seqnos hd=0, hr=0).
`protected void`	`cancelRebroadcasting()`
`protected void`	`checkForRebroadcasts()`
`void`	`clearNonMemberCache()`
`void`	`compact()`
`protected Table<Message>`	`createTable(long initial_seqno)`
`protected void`	`deliver(Message msg, Address sender, long seqno, java.lang.String error_msg)`
`protected void`	`deliverBatch(MessageBatch batch)`
`java.lang.Object`	`down(Event evt)` Callback.
`java.util.Map<java.lang.String,java.lang.Object>`	`dumpStats()`
`java.lang.String`	`dumpXmitTablesNumCurrentRows()`
`protected void`	`flushBecomeServerQueue()` Flushes the queue.
`int`	`getBecomeServerQueueSizeActual()`
`long`	`getCurrentSeqno()`
`Digest`	`getDigest()` Returns a message digest: for each member P the highest delivered and received seqno is added
`Digest`	`getDigest(Address mbr)`
`boolean`	`getLogDiscardMessages()`
`int`	`getNonMemberMessages()`
`long`	`getSizeOfAllMessages()`
`long`	`getSizeOfAllMessagesInclHeaders()`
`Table<Message>`	`getWindow(Address sender)` Returns the receive window for sender; only used for testing.
`long`	`getXmitRequestsReceived()`
`long`	`getXmitRequestsSent()`
`long`	`getXmitResponsesReceived()`
`long`	`getXmitResponsesSent()`
`long`	`getXmitTableCapacity()`
`int`	`getXmitTableMissingMessages()`
`int`	`getXmitTableNumCompactions()`
`int`	`getXmitTableNumCurrentRows()`
`int`	`getXmitTableNumMoves()`
`int`	`getXmitTableNumPurges()`
`int`	`getXmitTableNumResizes()`
`int`	`getXmitTableUndeliveredMsgs()`
`protected void`	`handleMessage(Message msg, NakAckHeader2 hdr)` Finds the corresponding retransmit buffer and adds the message to it (according to seqno).
`protected void`	`handleMessages(Address dest, Address sender, java.util.List<Tuple<java.lang.Long,Message>> msgs, boolean oob, AsciiString cluster_name)`
`java.util.Map<java.lang.String,java.lang.String>`	`handleProbe(java.lang.String... keys)` Handles a probe.
`protected void`	`handleXmitReq(Address xmit_requester, SeqnoList missing_msgs, Address original_sender)` Retransmits messsages first_seqno to last_seqno from original_sender from xmit_table to xmit_requester, called when XMIT_REQ is received.
`protected void`	`handleXmitRsp(Message msg, NakAckHeader2 hdr)`
`void`	`init()` Called after instance has been created (null constructor) and before protocol is started.
`boolean`	`isDiscardDeliveredMsgs()`
`protected static boolean`	`isGreaterThanOrEqual(Digest first, Digest other)` Returns true if all senders of the current digest have their seqnos >= the ones from other
`boolean`	`isUseMcastXmit()`
`boolean`	`isXmitFromRandomMember()`
`boolean`	`isXmitTaskRunning()`
`protected void`	`mergeDigest(Digest digest)` For all members of the digest, adjust the retransmit buffers in xmit_table.
`protected Message`	`msgFromXmitRsp(Message msg, NakAckHeader2 hdr)`
`protected void`	`overwriteDigest(Digest digest)` Overwrites existing entries, but does NOT remove entries not found in the digest
`java.lang.String`	`printDigestHistory()`
`java.lang.String`	`printMessages()`
`java.lang.String`	`printStabilityHistory()`
`java.lang.String`	`printStabilityMessages()`
`java.lang.String`	`printStats()`
`java.util.List<java.lang.Integer>`	`providedUpServices()` List of events that are provided to layers above (they will be handled when sent down from above)
`protected void`	`queueMessage(Message msg, long seqno)`
`protected void`	`rebroadcastMessages()` Takes the argument highest_seqnos and compares it to the current digest.
`protected void`	`removeAndPassUp(Table<Message> buf, Address sender, boolean loopback, AsciiString cluster_name)` Efficient way of checking whether another thread is already processing messages from sender.
`protected void`	`reset()`
`void`	`resetStats()`
`protected void`	`retransmit(long first_seqno, long last_seqno, Address sender)`
`protected void`	`retransmit(long first_seqno, long last_seqno, Address sender, boolean multicast_xmit_request)`
`protected void`	`retransmit(SeqnoList missing_msgs, Address sender, boolean multicast_xmit_request)`
`protected void`	`send(Event evt, Message msg)` Adds the message to the sent_msgs table and then passes it down the stack.
`protected void`	`sendXmitRsp(Address dest, Message msg)` Sends a message msg to the requester.
`protected void`	`setDigest(Digest digest)` Creates a retransmit buffer for each sender in the digest according to the sender's seqno.
`protected void`	`setDigest(Digest digest, boolean merge)` Sets or merges the digest.
`void`	`setDiscardDeliveredMsgs(boolean discard_delivered_msgs)`
`void`	`setLogDiscardMessages(boolean flag)`
`void`	`setLogNotFoundMessages(boolean flag)`
`void`	`setTimer(TimeScheduler timer)` Only used for unit tests, don't use !
`void`	`setUseMcastXmit(boolean use_mcast_xmit)`
`void`	`setUseMcastXmitReq(boolean flag)`
`void`	`setXmitFromRandomMember(boolean xmit_from_random_member)`
`protected static long`	`sizeOfAllMessages(Table<Message> buf, boolean include_headers)`
`protected void`	`stable(Digest digest)` Garbage collect messages that have been seen by all members.
`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()`
`java.lang.String[]`	`supportedKeys()` Returns a list of supported keys
`void`	`triggerXmit()`
`protected void`	`unknownMember(Address sender, java.lang.Object message)`
`java.lang.Object`	`up(Event evt)` Callback.
`void`	`up(MessageBatch batch)` Sends up a multiple messages in a `MessageBatch`.

从类继承的方法 com.fr.third.jgroups.stack.Protocol
accept, destroy, enableStats, getConfigurableObjects, getDownProtocol, getDownServices, getId, getIdsAbove, getLevel, getName, getProtocolStack, getSocketFactory, getThreadFactory, getTransport, getUpProtocol, getUpServices, getValue, isErgonomics, level, parse, providedDownServices, requiredDownServices, requiredUpServices, resetStatistics, setDownProtocol, setErgonomics, setId, setLevel, setProtocolStack, setSocketFactory, setUpProtocol, setValue, setValues, statsEnabled

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - NUM_REBROADCAST_MSGS
```
protected static final int NUM_REBROADCAST_MSGS
```
    另请参阅:
    常量字段值
  - max_msg_batch_size
```
protected int max_msg_batch_size
```
  - use_mcast_xmit
```
protected boolean use_mcast_xmit
```
    Retransmit messages using multicast rather than unicast. This has the advantage that, if many receivers lost a message, the sender only retransmits once
  - use_mcast_xmit_req
```
protected boolean use_mcast_xmit_req
```
    Use a multicast to request retransmission of missing messages. This may be costly as every member in the cluster will send a response
  - xmit_from_random_member
```
protected boolean xmit_from_random_member
```
    Ask a random member for retransmission of a missing message. If set to true, discard_delivered_msgs will be set to false
  - discard_delivered_msgs
```
protected boolean discard_delivered_msgs
```
    Messages that have been received in order are sent up the stack (= delivered to the application). Delivered messages are removed from the retransmission buffer, so they can get GC'ed by the JVM. When this property is true, everyone (except the sender of a message) removes the message from their retransission buffers as soon as it has been delivered to the application
  - max_rebroadcast_timeout
```
protected long max_rebroadcast_timeout
```
  - print_stability_history_on_failed_xmit
```
@Deprecated
protected boolean print_stability_history_on_failed_xmit
```
    已过时。
    
    When not finding a message on an XMIT request, include the last N stability messages in the error message
  - log_discard_msgs
```
protected boolean log_discard_msgs
```
    If true, logs messages discarded because received from other members
  - log_not_found_msgs
```
protected boolean log_not_found_msgs
```
  - xmit_interval
```
protected long xmit_interval
```
  - 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
```
  - become_server_queue_size
```
protected int become_server_queue_size
```
  - suppress_time_non_member_warnings
```
protected long suppress_time_non_member_warnings
```
  - num_messages_sent
```
protected int num_messages_sent
```
  - num_messages_received
```
protected int num_messages_received
```
  - DUMMY_OOB_MSG
```
protected static final Message DUMMY_OOB_MSG
```
  - no_dummy_and_no_oob_delivered_msgs_and_no_dont_loopback_msgs
```
protected final Filter<Message> no_dummy_and_no_oob_delivered_msgs_and_no_dont_loopback_msgs
```
  - dont_loopback_filter
```
protected static final Filter<Message> dont_loopback_filter
```
  - 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_received
```
protected final java.util.concurrent.atomic.AtomicLong xmit_rsps_received
```
  - xmit_rsps_sent
```
protected final java.util.concurrent.atomic.AtomicLong xmit_rsps_sent
```
  - is_server
```
protected volatile boolean is_server
```
  - local_addr
```
protected Address local_addr
```
  - members
```
protected volatile java.util.List<Address> members
```
  - view
```
protected volatile View view
```
  - xmit_table
```
protected final java.util.concurrent.ConcurrentMap<Address,Table<Message>> xmit_table
```
    Map to store sent and received messages (keyed by sender)
  - xmit_task
```
protected java.util.concurrent.Future<?> xmit_task
```
    RetransmitTask running every xmit_interval ms
  - 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)
  - leaving
```
protected volatile boolean leaving
```
  - running
```
protected volatile boolean running
```
  - timer
```
protected TimeScheduler timer
```
  - rebroadcast_lock
```
protected final java.util.concurrent.locks.Lock rebroadcast_lock
```
  - rebroadcast_done
```
protected final java.util.concurrent.locks.Condition rebroadcast_done
```
  - rebroadcasting
```
protected volatile boolean rebroadcasting
```
  - rebroadcast_digest_lock
```
protected final java.util.concurrent.locks.Lock rebroadcast_digest_lock
```
  - rebroadcast_digest
```
protected Digest rebroadcast_digest
```
  - stability_msgs
```
protected final BoundedList<java.lang.String> stability_msgs
```
    Keeps the last N stability messages
  - digest_history
```
protected final BoundedList<java.lang.String> digest_history
```
    Keeps a bounded list of the last N digest sets
  - become_server_queue
```
protected BoundedList<Message> become_server_queue
```
  - suppress_log_non_member
```
protected SuppressLog<Address> suppress_log_non_member
```
    Log to suppress identical warnings for messages from non-members
- 构造器详细资料
  - NAKACK2
```
public NAKACK2()
```
- 方法详细资料
  - isXmitTaskRunning
```
public boolean isXmitTaskRunning()
```
  - getNonMemberMessages
```
public int getNonMemberMessages()
```
  - clearNonMemberCache
```
public void clearNonMemberCache()
```
  - getXmitRequestsReceived
```
public long getXmitRequestsReceived()
```
  - getXmitRequestsSent
```
public long getXmitRequestsSent()
```
  - getXmitResponsesReceived
```
public long getXmitResponsesReceived()
```
  - getXmitResponsesSent
```
public long getXmitResponsesSent()
```
  - isUseMcastXmit
```
public boolean isUseMcastXmit()
```
  - isXmitFromRandomMember
```
public boolean isXmitFromRandomMember()
```
  - isDiscardDeliveredMsgs
```
public boolean isDiscardDeliveredMsgs()
```
  - getLogDiscardMessages
```
public boolean getLogDiscardMessages()
```
  - setUseMcastXmit
```
public void setUseMcastXmit(boolean use_mcast_xmit)
```
  - setUseMcastXmitReq
```
public void setUseMcastXmitReq(boolean flag)
```
  - setLogDiscardMessages
```
public void setLogDiscardMessages(boolean flag)
```
  - setLogNotFoundMessages
```
public void setLogNotFoundMessages(boolean flag)
```
  - setXmitFromRandomMember
```
public void setXmitFromRandomMember(boolean xmit_from_random_member)
```
  - setDiscardDeliveredMsgs
```
public void setDiscardDeliveredMsgs(boolean discard_delivered_msgs)
```
  - getBecomeServerQueueSizeActual
```
public int getBecomeServerQueueSizeActual()
```
  - getWindow
```
public Table<Message> getWindow(Address sender)
```
    Returns the receive window for sender; only used for testing. Do not use !
  - setTimer
```
public void setTimer(TimeScheduler timer)
```
    Only used for unit tests, don't use !
  - getXmitTableUndeliveredMsgs
```
public int getXmitTableUndeliveredMsgs()
```
  - getXmitTableMissingMessages
```
public int getXmitTableMissingMessages()
```
  - getXmitTableCapacity
```
public long getXmitTableCapacity()
```
  - getXmitTableNumCurrentRows
```
public int getXmitTableNumCurrentRows()
```
  - getSizeOfAllMessages
```
public long getSizeOfAllMessages()
```
  - getSizeOfAllMessagesInclHeaders
```
public long getSizeOfAllMessagesInclHeaders()
```
  - getXmitTableNumCompactions
```
public int getXmitTableNumCompactions()
```
  - getXmitTableNumMoves
```
public int getXmitTableNumMoves()
```
  - getXmitTableNumResizes
```
public int getXmitTableNumResizes()
```
  - getXmitTableNumPurges
```
public int getXmitTableNumPurges()
```
  - printMessages
```
public java.lang.String printMessages()
```
  - getCurrentSeqno
```
public long getCurrentSeqno()
```
  - printStabilityMessages
```
public java.lang.String printStabilityMessages()
```
  - printDigestHistory
```
public java.lang.String printDigestHistory()
```
  - compact
```
public void compact()
```
  - dumpXmitTablesNumCurrentRows
```
public java.lang.String dumpXmitTablesNumCurrentRows()
```
  - resetStats
```
public void resetStats()
```
    覆盖:
    
    resetStats 在类中 Protocol
  - init
```
public void init()
          throws java.lang.Exception
```
    从类复制的说明: 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.
    
    覆盖:
    
    init 在类中 Protocol
    
    抛出:
    
    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
  - dumpStats
```
public java.util.Map<java.lang.String,java.lang.Object> dumpStats()
```
    覆盖:
    
    dumpStats 在类中 Protocol
  - printStats
```
public java.lang.String printStats()
```
    覆盖:
    
    printStats 在类中 Protocol
  - printStabilityHistory
```
public java.lang.String printStabilityHistory()
```
  - providedUpServices
```
public java.util.List<java.lang.Integer> providedUpServices()
```
    从类复制的说明: Protocol
    
    List of events that are provided to layers above (they will be handled when sent down from above)
    
    覆盖:
    
    providedUpServices 在类中 Protocol
  - start
```
public void start()
           throws java.lang.Exception
```
    从类复制的说明: 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.
    
    覆盖:
    
    start 在类中 Protocol
    
    抛出:
    
    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()
```
    从类复制的说明: 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
    
    覆盖:
    
    stop 在类中 Protocol
  - down
```
public java.lang.Object down(Event evt)
```
    Callback. Called by superclass when event may be handled.
    Do not use down_prot.down() in this method as the event is passed down by default by the superclass after this method returns !
    
    覆盖:
    
    down 在类中 Protocol
  - up
```
public java.lang.Object up(Event evt)
```
    Callback. Called by superclass when event may be handled.
    Do not use PassUp in this method as the event is passed up by default by the superclass after this method returns !
    
    覆盖:
    
    up 在类中 Protocol
  - up
```
public void up(MessageBatch batch)
```
    从类复制的说明: 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(Message)), and - if true - calls Protocol.up(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.
    
    覆盖:
    
    up 在类中 Protocol
    
    参数:
    batch - The message batch
  - handleProbe
```
public java.util.Map<java.lang.String,java.lang.String> handleProbe(java.lang.String... keys)
```
    从接口复制的说明: DiagnosticsHandler.ProbeHandler
    
    Handles a probe. For each key that is handled, the key and its result should be in the returned map.
    
    指定者:
    
    handleProbe 在接口中 DiagnosticsHandler.ProbeHandler
    
    返回:
    Map. A map of keys and values. A null return value is permissible.
  - supportedKeys
```
public java.lang.String[] supportedKeys()
```
    从接口复制的说明: DiagnosticsHandler.ProbeHandler
    
    Returns a list of supported keys
    
    指定者:
    
    supportedKeys 在接口中 DiagnosticsHandler.ProbeHandler
  - queueMessage
```
protected void queueMessage(Message msg,
                long seqno)
```
  - unknownMember
```
protected void unknownMember(Address sender,
                 java.lang.Object message)
```
  - send
```
protected void send(Event evt,
        Message msg)
```
    Adds the message to the sent_msgs table and then passes it down the stack. Change Bela Ban May 26 2002: we don't store a copy of the message, but a reference ! This saves us a lot of memory. However, this also means that a message should not be changed after storing it in the sent-table ! See protocols/DESIGN for details. Made seqno increment and adding to sent_msgs atomic, e.g. seqno won't get incremented if adding to sent_msgs fails e.g. due to an OOM (see http://jira.jboss.com/jira/browse/JGRP-179). bela Jan 13 2006
  - handleMessage
```
protected void handleMessage(Message msg,
                 NakAckHeader2 hdr)
```
    Finds the corresponding retransmit buffer and adds the message to it (according to seqno). Then removes as many messages as possible and passes them up the stack. Discards messages from non-members.
  - handleMessages
```
protected void handleMessages(Address dest,
                  Address sender,
                  java.util.List<Tuple<java.lang.Long,Message>> msgs,
                  boolean oob,
                  AsciiString cluster_name)
```
  - removeAndPassUp
```
protected void removeAndPassUp(Table<Message> buf,
                   Address sender,
                   boolean loopback,
                   AsciiString cluster_name)
```
    Efficient way of checking whether another thread is already processing messages from sender. If that's the case, we return immediately and let the existing thread process our message (https://jira.jboss.org/jira/browse/JGRP-829). Benefit: fewer threads blocked on the same lock, these threads an be returned to the thread pool
  - handleXmitReq
```
protected void handleXmitReq(Address xmit_requester,
                 SeqnoList missing_msgs,
                 Address original_sender)
```
    Retransmits messsages first_seqno to last_seqno from original_sender from xmit_table to xmit_requester, called when XMIT_REQ is received.
    
    参数:
    xmit_requester - The sender of the XMIT_REQ, we have to send the requested copy of the message to this address
    missing_msgs - A list of seqnos that have to be retransmitted
    original_sender - The member who originally sent the messsage. Guaranteed to be non-null
  - deliver
```
protected void deliver(Message msg,
           Address sender,
           long seqno,
           java.lang.String error_msg)
```
  - deliverBatch
```
protected void deliverBatch(MessageBatch batch)
```
  - flushBecomeServerQueue
```
protected void flushBecomeServerQueue()
```
    Flushes the queue. Done in a separate thread as we don't want to block the ClientGmsImpl.installView(View, Digest) method (called when a view is installed).
  - cancelRebroadcasting
```
protected void cancelRebroadcasting()
```
  - sendXmitRsp
```
protected void sendXmitRsp(Address dest,
               Message msg)
```
    Sends a message msg to the requester. We have to wrap the original message into a retransmit message, as we need to preserve the original message's properties, such as src, headers etc.
    
    参数:
    dest -
    msg -
  - handleXmitRsp
```
protected void handleXmitRsp(Message msg,
                 NakAckHeader2 hdr)
```
  - msgFromXmitRsp
```
protected Message msgFromXmitRsp(Message msg,
                     NakAckHeader2 hdr)
```
  - rebroadcastMessages
```
protected void rebroadcastMessages()
```
    Takes the argument highest_seqnos and compares it to the current digest. If the current digest has fewer messages, then send retransmit messages for the missing messages. Return when all missing messages have been received. If we're waiting for a missing message from P, and P crashes while waiting, we need to exclude P from the wait set.
  - checkForRebroadcasts
```
protected void checkForRebroadcasts()
```
  - isGreaterThanOrEqual
```
protected static boolean isGreaterThanOrEqual(Digest first,
                           Digest other)
```
    Returns true if all senders of the current digest have their seqnos >= the ones from other
  - adjustReceivers
```
protected void adjustReceivers(java.util.List<Address> members)
```
    Removes old members from xmit-table and adds new members to xmit-table (at seqnos hd=0, hr=0). This method is not called concurrently
  - getDigest
```
public Digest getDigest()
```
    Returns a message digest: for each member P the highest delivered and received seqno is added
  - getDigest
```
public Digest getDigest(Address mbr)
```
  - setDigest
```
protected void setDigest(Digest digest)
```
    Creates a retransmit buffer for each sender in the digest according to the sender's seqno. If a buffer already exists, it resets it.
  - mergeDigest
```
protected void mergeDigest(Digest digest)
```
    For all members of the digest, adjust the retransmit buffers in xmit_table. If no entry exists, create one with the initial seqno set to the seqno of the member in the digest. If the member already exists, and is not the local address, replace it with the new entry (http://jira.jboss.com/jira/browse/JGRP-699) if the digest's seqno is greater than the seqno in the window.
  - overwriteDigest
```
protected void overwriteDigest(Digest digest)
```
    Overwrites existing entries, but does NOT remove entries not found in the digest
    
    参数:
    digest -
  - setDigest
```
protected void setDigest(Digest digest,
             boolean merge)
```
    Sets or merges the digest. If there is no entry for a given member in xmit_table, create a new buffer. Else skip the existing entry, unless it is a merge. In this case, skip the existing entry if its seqno is greater than or equal to the one in the digest, or reset the window and create a new one if not.
    
    参数:
    digest - The digest
    merge - Whether to merge the new digest with our own, or not
  - createTable
```
protected Table<Message> createTable(long initial_seqno)
```
  - stable
```
protected void stable(Digest digest)
```
    Garbage collect messages that have been seen by all members. Update sent_msgs: for the sender P in the digest which is equal to the local address, garbage collect all messages <= seqno at digest[P]. Update xmit_table: for each sender P in the digest and its highest seqno seen SEQ, garbage collect all delivered_msgs in the retransmit buffer corresponding to P which are <= seqno at digest[P].
  - retransmit
```
protected void retransmit(long first_seqno,
              long last_seqno,
              Address sender)
```
  - retransmit
```
protected void retransmit(long first_seqno,
              long last_seqno,
              Address sender,
              boolean multicast_xmit_request)
```
  - retransmit
```
protected void retransmit(SeqnoList missing_msgs,
              Address sender,
              boolean multicast_xmit_request)
```
  - reset
```
protected void reset()
```
  - sizeOfAllMessages
```
protected static long sizeOfAllMessages(Table<Message> buf,
                     boolean include_headers)
```
  - startRetransmitTask
```
protected void startRetransmitTask()
```
  - stopRetransmitTask
```
protected void stopRetransmitTask()
```
  - triggerXmit
```
public void triggerXmit()
```

类 NAKACK2

嵌套类概要

字段概要

从类继承的字段 com.fr.third.jgroups.stack.Protocol

构造器概要

方法概要

从类继承的方法 com.fr.third.jgroups.stack.Protocol

从类继承的方法 java.lang.Object

字段详细资料

NUM_REBROADCAST_MSGS

max_msg_batch_size

use_mcast_xmit

use_mcast_xmit_req

xmit_from_random_member

discard_delivered_msgs

max_rebroadcast_timeout

print_stability_history_on_failed_xmit

log_discard_msgs

log_not_found_msgs

xmit_interval

xmit_table_num_rows

xmit_table_msgs_per_row

xmit_table_resize_factor

xmit_table_max_compaction_time

become_server_queue_size

suppress_time_non_member_warnings

num_messages_sent

num_messages_received

DUMMY_OOB_MSG

no_dummy_and_no_oob_delivered_msgs_and_no_dont_loopback_msgs

dont_loopback_filter

xmit_reqs_received

xmit_reqs_sent

xmit_rsps_received

xmit_rsps_sent

is_server

local_addr

members

view

xmit_table

xmit_task

xmit_task_map

leaving

running

timer

rebroadcast_lock

rebroadcast_done

rebroadcasting

rebroadcast_digest_lock

rebroadcast_digest

stability_msgs

digest_history

become_server_queue

suppress_log_non_member

构造器详细资料

NAKACK2

方法详细资料

isXmitTaskRunning

getNonMemberMessages

clearNonMemberCache

getXmitRequestsReceived

getXmitRequestsSent

getXmitResponsesReceived

getXmitResponsesSent

isUseMcastXmit

isXmitFromRandomMember

isDiscardDeliveredMsgs

getLogDiscardMessages

setUseMcastXmit

setUseMcastXmitReq

setLogDiscardMessages

setLogNotFoundMessages

setXmitFromRandomMember

setDiscardDeliveredMsgs

getBecomeServerQueueSizeActual

getWindow

setTimer

getXmitTableUndeliveredMsgs

getXmitTableMissingMessages

getXmitTableCapacity