FD_ALL2

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

```
public class FD_ALL2
extends Protocol
```
Failure detection based on simple heartbeat protocol. Every member periodically (interval ms) multicasts a heartbeat. Every member also maintains a table of all members (minus itself). When data or a heartbeat from P is received, we set the flag associated with P to true. Periodically, we check for expired members, and suspect those whose flag is false (no heartbeat or message received within timeout ms).

版本:

3.5

作者:

Bela Ban

嵌套类概要

嵌套类
限定符和类型类和说明

static class FD_ALL2.HeartbeatHeader

嵌套类
限定符和类型	类和说明
`static class`	`FD_ALL2.HeartbeatHeader`

字段概要

字段
限定符和类型	字段和说明
`protected boolean`	`has_suspected_mbrs`
`protected java.util.concurrent.Future<?>`	`heartbeat_sender_future`
`protected long`	`interval`
`protected Address`	`local_addr`
`protected java.util.concurrent.locks.Lock`	`lock`
`protected java.util.List<Address>`	`members`
`protected boolean`	`msg_counts_as_heartbeat`
`protected int`	`num_heartbeats_received`
`protected int`	`num_heartbeats_sent`
`protected int`	`num_suspect_events`
`protected BoundedList<Tuple<Address,java.lang.Long>>`	`suspect_history`
`protected java.util.Set<Address>`	`suspected_mbrs`
`protected long`	`timeout`
`protected long`	`timeout_check_interval`
`protected java.util.concurrent.Future<?>`	`timeout_checker_future`
`protected TimeScheduler`	`timer`
`protected java.util.concurrent.ConcurrentMap<Address,java.util.concurrent.atomic.AtomicBoolean>`	`timestamps`

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

构造器概要

构造器
构造器和说明

FD_ALL2()

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

方法概要

方法
限定符和类型	方法和说明
`protected java.lang.String`	`_printTimestamps()`
`java.lang.Object`	`down(Event evt)` An event is to be sent down the stack.
`int`	`getHeartbeatsReceived()`
`int`	`getHeartbeatsSent()`
`long`	`getInterval()`
`java.lang.String`	`getLocalAddress()`
`java.lang.String`	`getMembers()`
`java.lang.String`	`getSuspectedMembers()`
`int`	`getSuspectEventsSent()`
`long`	`getTimeout()`
`long`	`getTimeoutCheckInterval()`
`protected void`	`handleViewChange(View v)`
`void`	`init()` Called after instance has been created (null constructor) and before protocol is started.
`protected boolean`	`isHeartbeatSenderRunning()`
`boolean`	`isRunning()`
`protected boolean`	`isTimeoutCheckerRunning()`
`java.lang.String`	`printSuspectHistory()`
`java.lang.String`	`printTimestamps()`
`void`	`resetStats()`
`void`	`setInterval(long interval)`
`void`	`setTimeout(long timeout)`
`void`	`setTimeoutCheckInterval(long timeout_check_interval)`
`void`	`startFailureDetection()`
`protected void`	`startHeartbeatSender()`
`protected void`	`startTimeoutChecker()`
`void`	`stop()` This method is called on a `Channel.disconnect()`.
`void`	`stopFailureDetection()`
`protected void`	`stopHeartbeatSender()`
`protected void`	`stopTimeoutChecker()`
`protected void`	`suspect(java.util.List<Address> suspects)`
`protected boolean`	`unsuspect(Address mbr)` Removes mbr from suspected_mbrs and sends a UNSUSPECT event up and down the stack
`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(Address sender)`

从类继承的方法 com.fr.third.jgroups.stack.Protocol
accept, destroy, dumpStats, enableStats, getConfigurableObjects, getDownProtocol, getDownServices, getId, getIdsAbove, getLevel, 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, start, statsEnabled

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

- 字段详细资料
  - interval
```
protected long interval
```
  - timeout
```
protected long timeout
```
  - timeout_check_interval
```
protected long timeout_check_interval
```
  - msg_counts_as_heartbeat
```
protected boolean msg_counts_as_heartbeat
```
  - num_heartbeats_sent
```
protected int num_heartbeats_sent
```
  - num_heartbeats_received
```
protected int num_heartbeats_received
```
  - num_suspect_events
```
protected int num_suspect_events
```
  - timestamps
```
protected final java.util.concurrent.ConcurrentMap<Address,java.util.concurrent.atomic.AtomicBoolean> timestamps
```
  - local_addr
```
protected Address local_addr
```
  - members
```
protected final java.util.List<Address> members
```
  - suspected_mbrs
```
protected final java.util.Set<Address> suspected_mbrs
```
  - has_suspected_mbrs
```
protected volatile boolean has_suspected_mbrs
```
  - timer
```
protected TimeScheduler timer
```
  - heartbeat_sender_future
```
protected java.util.concurrent.Future<?> heartbeat_sender_future
```
  - timeout_checker_future
```
protected java.util.concurrent.Future<?> timeout_checker_future
```
  - lock
```
protected final java.util.concurrent.locks.Lock lock
```
  - suspect_history
```
protected final BoundedList<Tuple<Address,java.lang.Long>> suspect_history
```
- 构造器详细资料
  - FD_ALL2
```
public FD_ALL2()
```
- 方法详细资料
  - getLocalAddress
```
public java.lang.String getLocalAddress()
```
  - getMembers
```
public java.lang.String getMembers()
```
  - getSuspectedMembers
```
public java.lang.String getSuspectedMembers()
```
  - getHeartbeatsSent
```
public int getHeartbeatsSent()
```
  - getHeartbeatsReceived
```
public int getHeartbeatsReceived()
```
  - getSuspectEventsSent
```
public int getSuspectEventsSent()
```
  - getTimeout
```
public long getTimeout()
```
  - setTimeout
```
public void setTimeout(long timeout)
```
  - getTimeoutCheckInterval
```
public long getTimeoutCheckInterval()
```
  - setTimeoutCheckInterval
```
public void setTimeoutCheckInterval(long timeout_check_interval)
```
  - getInterval
```
public long getInterval()
```
  - setInterval
```
public void setInterval(long interval)
```
  - isRunning
```
public boolean isRunning()
```
  - printSuspectHistory
```
public java.lang.String printSuspectHistory()
```
  - printTimestamps
```
public java.lang.String printTimestamps()
```
  - stopFailureDetection
```
public void stopFailureDetection()
```
  - startFailureDetection
```
public void startFailureDetection()
```
  - 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
  - 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
  - up
```
public java.lang.Object up(Event evt)
```
    从类复制的说明: 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().
    
    覆盖:
    
    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
  - down
```
public java.lang.Object down(Event evt)
```
    从类复制的说明: 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().
    
    覆盖:
    
    down 在类中 Protocol
  - startTimeoutChecker
```
protected void startTimeoutChecker()
```
  - stopTimeoutChecker
```
protected void stopTimeoutChecker()
```
  - startHeartbeatSender
```
protected void startHeartbeatSender()
```
  - stopHeartbeatSender
```
protected void stopHeartbeatSender()
```
  - isTimeoutCheckerRunning
```
protected boolean isTimeoutCheckerRunning()
```
  - isHeartbeatSenderRunning
```
protected boolean isHeartbeatSenderRunning()
```
  - update
```
protected void update(Address sender)
```
  - handleViewChange
```
protected void handleViewChange(View v)
```
  - _printTimestamps
```
protected java.lang.String _printTimestamps()
```
  - suspect
```
protected void suspect(java.util.List<Address> suspects)
```
  - unsuspect
```
protected boolean unsuspect(Address mbr)
```
    Removes mbr from suspected_mbrs and sends a UNSUSPECT event up and down the stack
    
    参数:
    mbr -
    
    返回:
    true if the member was removed from suspected_mbrs, otherwise false

类 FD_ALL2

嵌套类概要

字段概要

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

构造器概要

方法概要

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

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

字段详细资料

interval

timeout

timeout_check_interval

msg_counts_as_heartbeat

num_heartbeats_sent

num_heartbeats_received

num_suspect_events

timestamps

local_addr

members

suspected_mbrs

has_suspected_mbrs

timer

heartbeat_sender_future

timeout_checker_future

lock

suspect_history

构造器详细资料

FD_ALL2

方法详细资料

getLocalAddress

getMembers

getSuspectedMembers

getHeartbeatsSent

getHeartbeatsReceived

getSuspectEventsSent

getTimeout

setTimeout

getTimeoutCheckInterval

setTimeoutCheckInterval

getInterval

setInterval

isRunning

printSuspectHistory

printTimestamps

stopFailureDetection

startFailureDetection

resetStats

init

stop

up

up

down

startTimeoutChecker

stopTimeoutChecker

startHeartbeatSender

stopHeartbeatSender

isTimeoutCheckerRunning

isHeartbeatSenderRunning

update

handleViewChange

_printTimestamps

suspect

unsuspect