TP

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

所有已实现的接口:

DiagnosticsHandler.ProbeHandler

直接已知子类:

BasicTCP, SHARED_LOOPBACK, TUNNEL, UDP
```
public abstract class TP
extends Protocol
implements DiagnosticsHandler.ProbeHandler
```
Generic transport - specific implementations should extend this abstract class. Features which are provided to the subclasses include
- version checking
- marshalling and unmarshalling
- message bundling (handling single messages, and message lists)
- incoming packet handler
A subclass has to override
- sendMulticast(AsciiString, byte[], int, int)
- sendUnicast(PhysicalAddress, byte[], int, int)
- init()
- start(): subclasses must call super.start() after they initialize themselves (e.g., created their sockets).
- stop(): subclasses must call super.stop() after they deinitialized themselves
- destroy()
The create() or start() method has to create a local address.
The receive(Address, byte[], int, int) method must be called by subclasses when a unicast or multicast message has been received.
作者:

Bela Ban

嵌套类概要

嵌套类
限定符和类型	类和说明
`protected class`	`TP.BaseBundler`
`protected class`	`TP.BatchHandler`
`protected static interface`	`TP.Bundler`
`protected class`	`TP.MyHandler`
`static class`	`TP.ProtocolAdapter` Used when the transport is shared (singleton_name !
`protected class`	`TP.SenderSendsBundler`
`protected class`	`TP.SenderSendsWithTimerBundler` The sender's thread adds a message to the hashmap and - if the accumulated size has been exceeded - sends all bundled messages.
`protected class`	`TP.SingleMessageHandler`
`protected class`	`TP.TransferQueueBundler` This bundler adds all (unicast or multicast) messages to a queue until max size has been exceeded, but does send messages immediately when no other messages are available. https://issues.jboss.org/browse/JGRP-1540

字段概要

字段
限定符和类型	字段和说明
`protected Average`	`avg_batch_size`
`protected java.net.InetAddress`	`bind_addr`
`protected java.lang.String`	`bind_interface_str`
`protected int`	`bind_port` The port to which the transport binds. 0 means to bind to any (ephemeral) port
`protected static java.lang.String`	`BUNDLE_MSG`
`protected TP.Bundler`	`bundler`
`protected int`	`bundler_capacity`
`protected java.lang.String`	`bundler_type`
`protected static boolean`	`can_bind_to_mcast_addr`
`protected AsciiString`	`cluster_name` The name of the group to which this member is connected.
`protected int`	`connect_count` Keeps track of connects and disconnects, in order to start and stop threads
`protected java.util.concurrent.locks.ReentrantLock`	`connectLock`
`protected ThreadFactory`	`default_thread_factory` Factory which is used by oob_thread_pool
`protected DiagnosticsHandler`	`diag_handler`
`protected java.net.InetAddress`	`diagnostics_addr`
`protected java.util.List<java.net.NetworkInterface>`	`diagnostics_bind_interfaces`
`protected java.lang.String`	`diagnostics_passcode`
`protected int`	`diagnostics_port`
`protected int`	`diagnostics_ttl`
`protected boolean`	`discard_incompatible_packets` 已过时。
`protected boolean`	`enable_batching`
`protected boolean`	`enable_bundling` 已过时。
`protected boolean`	`enable_diagnostics`
`protected boolean`	`enable_unicast_bundling` 已过时。
`protected java.net.InetAddress`	`external_addr`
`protected int`	`external_port`
`protected static java.text.NumberFormat`	`f`
`protected ThreadFactory`	`global_thread_factory` Used by all threads created by JGroups outside of the thread pools
`protected TpHeader`	`header` The header including the cluster name, sent with each message.
`protected boolean`	`ignore_dont_bundle`
`protected ThreadFactory`	`internal_thread_factory` Factory which is used by internal_thread_pool
`protected java.util.concurrent.Executor`	`internal_thread_pool` The thread pool which handles JGroups internal messages (Flag.INTERNAL)
`protected boolean`	`internal_thread_pool_enabled`
`protected long`	`internal_thread_pool_keep_alive_time`
`protected int`	`internal_thread_pool_max_threads`
`protected int`	`internal_thread_pool_min_threads`
`protected java.util.concurrent.BlockingQueue<java.lang.Runnable>`	`internal_thread_pool_queue` Used if thread_pool is a ThreadPoolExecutor and thread_pool_queue_enabled is true
`protected boolean`	`internal_thread_pool_queue_enabled`
`protected int`	`internal_thread_pool_queue_max_size`
`protected java.lang.String`	`internal_thread_pool_rejection_policy`
`protected long`	`last_discovery_request`
`protected static byte`	`LIST`
`protected Address`	`local_addr` The address (host and port) of this member.
`protected PhysicalAddress`	`local_physical_addr`
`protected boolean`	`log_discard_msgs` Whether or not warnings about messages from different groups are logged - private flag, not for common use
`protected boolean`	`log_discard_msgs_version`
`protected LazyRemovalCache<Address,PhysicalAddress>`	`logical_addr_cache` Cache which maintains mappings between logical and physical addresses.
`protected long`	`logical_addr_cache_expiration`
`protected int`	`logical_addr_cache_max_size`
`protected long`	`logical_addr_cache_reaper_interval`
`protected boolean`	`loopback` 已过时。
`protected boolean`	`loopback_copy`
`protected boolean`	`loopback_separate_thread`
`protected int`	`max_bundle_size` Maximum number of bytes for messages to be queued until they are sent.
`protected long`	`max_bundle_timeout` Max number of milliseconds until queued messages are sent.
`protected java.util.Set<Address>`	`members` The members of this group (updated when a member joins or leaves).
`protected static int`	`MSG_OFFSET`
`protected static int`	`MSG_OVERHEAD`
`protected static byte`	`MULTICAST`
`protected long`	`num_batches_received`
`protected long`	`num_batches_sent`
`protected long`	`num_bytes_received`
`protected long`	`num_bytes_sent`
`protected long`	`num_incoming_msgs_received`
`protected long`	`num_internal_msgs_received`
`protected long`	`num_msgs_received`
`protected long`	`num_msgs_sent`
`protected long`	`num_oob_msgs_received`
`protected int`	`num_rejected_msgs`
`protected long`	`num_single_msgs_received`
`protected long`	`num_single_msgs_sent`
`protected ThreadFactory`	`oob_thread_factory` Factory which is used by oob_thread_pool
`protected java.util.concurrent.Executor`	`oob_thread_pool`
`protected boolean`	`oob_thread_pool_enabled`
`protected long`	`oob_thread_pool_keep_alive_time`
`protected int`	`oob_thread_pool_max_threads`
`protected int`	`oob_thread_pool_min_threads`
`protected java.util.concurrent.BlockingQueue<java.lang.Runnable>`	`oob_thread_pool_queue` Used if oob_thread_pool is a ThreadPoolExecutor and oob_thread_pool_queue_enabled is true
`protected boolean`	`oob_thread_pool_queue_enabled`
`protected int`	`oob_thread_pool_queue_max_size`
`protected java.lang.String`	`oob_thread_pool_rejection_policy`
`protected int`	`physical_addr_max_fetch_attempts`
`protected int`	`port_range`
`protected java.util.List<DiagnosticsHandler.ProbeHandler>`	`preregistered_probe_handlers`
`protected static LazyRemovalCache.Printable<Address,LazyRemovalCache.Entry<PhysicalAddress>>`	`print_function`
`protected java.util.List<java.net.NetworkInterface>`	`receive_interfaces` List of interfaces to receive multicasts on.
`protected boolean`	`receive_on_all_interfaces`
`protected java.lang.String`	`singleton_name`
`protected SocketFactory`	`socket_factory`
`protected SuppressLog<Address>`	`suppress_log_different_cluster` Log to suppress identical warnings for messages from members in different clusters
`protected SuppressLog<Address>`	`suppress_log_different_version` Log to suppress identical warnings for messages from members with different (incompatible) versions
`protected long`	`suppress_time_different_cluster_warnings`
`protected long`	`suppress_time_different_version_warnings`
`protected java.lang.String`	`thread_naming_pattern`
`protected java.util.concurrent.Executor`	`thread_pool` The thread pool which handles unmarshalling, version checks and dispatching of regular messages
`protected boolean`	`thread_pool_enabled`
`protected long`	`thread_pool_keep_alive_time`
`protected int`	`thread_pool_max_threads`
`protected int`	`thread_pool_min_threads`
`protected java.util.concurrent.BlockingQueue<java.lang.Runnable>`	`thread_pool_queue` Used if thread_pool is a ThreadPoolExecutor and thread_pool_queue_enabled is true
`protected boolean`	`thread_pool_queue_enabled`
`protected int`	`thread_pool_queue_max_size`
`protected java.lang.String`	`thread_pool_rejection_policy`
`protected long`	`tick_time`
`protected TimeService`	`time_service`
`protected long`	`time_service_interval`
`protected TimeScheduler`	`timer`
`protected long`	`timer_keep_alive_time`
`protected int`	`timer_max_threads`
`protected int`	`timer_min_threads`
`protected int`	`timer_queue_max_size`
`protected java.lang.String`	`timer_rejection_policy`
`protected ThreadFactory`	`timer_thread_factory`
`protected java.lang.String`	`timer_type`
`protected java.util.concurrent.ConcurrentMap<AsciiString,Protocol>`	`up_prots` If singleton_name is enabled, this map is used to de-multiplex incoming messages according to their cluster names (attached to the message by the transport anyway).
`protected int`	`wheel_size`
`protected ExpiryCache<Address>`	`who_has_cache` Cache keeping track of WHO_HAS requests for physical addresses (given a logical address) and expiring them after who_has_cache_timeout ms
`protected long`	`who_has_cache_timeout`

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

构造器概要

构造器
限定符构造器和说明

protected TP()
Creates the TP protocol, and initializes the state variables, does however not start any sockets or threads.

构造器
限定符	构造器和说明
`protected`	`TP()` Creates the TP protocol, and initializes the state variables, does however not start any sockets or threads.

方法概要

方法
限定符和类型	方法和说明
`protected void`	`_send(Message msg, Address dest)`
`protected boolean`	`addPhysicalAddressToCache(Address logical_addr, PhysicalAddress physical_addr)`
`void`	`clearDifferentClusterCache()`
`void`	`clearDifferentVersionCache()`
`void`	`clearLogicalAddressCache()` Clears the cache.
`protected static java.util.concurrent.ExecutorService`	`createThreadPool(int min_threads, int max_threads, long keep_alive_time, java.lang.String rejection_policy, java.util.concurrent.BlockingQueue<java.lang.Runnable> queue, ThreadFactory factory)`
`void`	`destroy()` This method is called on a `Channel.close()`.
`void`	`disableDiagnostics()`
`protected void`	`doSend(AsciiString cluster_name, byte[] buf, int offset, int length, Address dest)`
`java.lang.Object`	`down(Event evt)` Caller by the layer above this layer.
`java.lang.String`	`dumpTimerTasks()`
`void`	`enableDiagnostics()`
`void`	`evictLogicalAddressCache()`
`void`	`evictLogicalAddressCache(boolean force)`
`protected void`	`fetchLocalAddresses()` Grabs the local address (or addresses in the shared transport case) and registers them with the physical address in the transport's cache
`protected void`	`fetchPhysicalAddrs(java.util.List<Address> missing)`
`protected Responses`	`fetchResponsesFromDiscoveryProtocol(java.util.List<Address> missing)`
`protected java.util.Collection<PhysicalAddress>`	`getAllPhysicalAddressesFromCache()`
`double`	`getAvgBatchSize()`
`java.net.InetAddress`	`getBindAddress()`
`int`	`getBindPort()`
`int`	`getBundlerBufferSize()`
`java.lang.String`	`getClusterName()`
`protected AsciiString`	`getClusterName(Message msg)`
`java.util.concurrent.Executor`	`getDefaultThreadPool()`
`ThreadFactory`	`getDefaultThreadPoolThreadFactory()`
`int`	`getDifferentClusterMessages()`
`int`	`getDifferentVersionMessages()`
`abstract java.lang.String`	`getInfo()`
`int`	`getInternalMaxQueueSize()`
`long`	`getInternalMessages()`
`int`	`getInternalPoolSize()`
`int`	`getInternalPoolSizeActive()`
`int`	`getInternalQueueSize()`
`java.util.concurrent.Executor`	`getInternalThreadPool()`
`ThreadFactory`	`getInternalThreadPoolThreadFactory()`
`java.lang.String`	`getLocalAddress()`
`java.lang.String`	`getLocalPhysicalAddress()`
`boolean`	`getLogDiscardMessages()`
`boolean`	`getLogDiscardMessagesVersion()`
`int`	`getMaxBundleSize()`
`long`	`getMaxBundleTimeout()`
`long`	`getNumBytesReceived()`
`long`	`getNumBytesSent()`
`long`	`getNumMessagesReceived()`
`long`	`getNumMessagesSent()`
`static int`	`getNumThreads()`
`int`	`getNumTimerTasks()`
`int`	`getOOBMaxQueueSize()`
`long`	`getOOBMessages()`
`int`	`getOOBPoolSize()`
`int`	`getOOBPoolSizeActive()`
`int`	`getOOBQueueSize()`
`java.util.concurrent.Executor`	`getOOBThreadPool()`
`long`	`getOOBThreadPoolKeepAliveTime()`
`int`	`getOOBThreadPoolMaxThreads()`
`int`	`getOOBThreadPoolMinThreads()`
`ThreadFactory`	`getOOBThreadPoolThreadFactory()`
`protected abstract PhysicalAddress`	`getPhysicalAddress()`
`protected PhysicalAddress`	`getPhysicalAddressFromCache(Address logical_addr)`
`int`	`getPortRange()`
`java.util.List<java.net.NetworkInterface>`	`getReceiveInterfaces()`
`int`	`getRegularMaxQueueSize()`
`long`	`getRegularMessages()`
`int`	`getRegularPoolSize()`
`int`	`getRegularPoolSizeActive()`
`int`	`getRegularQueueSize()`
`java.lang.String`	`getSingletonName()`
`SocketFactory`	`getSocketFactory()` Returns the SocketFactory associated with this protocol, if overridden in a subclass, or passes the call down
`ThreadFactory`	`getThreadFactory()` Supposed to be overwritten by subclasses.
`java.lang.String`	`getThreadNamingPattern()` Names the current thread.
`long`	`getThreadPoolKeepAliveTime()`
`int`	`getThreadPoolMaxThreads()`
`int`	`getThreadPoolMinThreads()`
`TimeScheduler`	`getTimer()`
`java.lang.String`	`getTimerClass()`
`long`	`getTimerKeepAliveTime()`
`int`	`getTimerMaxThreads()`
`int`	`getTimerMinThreads()`
`int`	`getTimerQueueSize()`
`ThreadFactory`	`getTimerThreadFactory()`
`int`	`getTimerThreads()`
`TimeService`	`getTimeService()`
`java.util.concurrent.ConcurrentMap<AsciiString,Protocol>`	`getUpProtocols()`
`protected void`	`handleConnect()`
`protected void`	`handleDisconnect()`
`protected java.lang.Object`	`handleDownEvent(Event evt)`
`protected void`	`handleMessageBatch(Address sender, byte[] data, int offset, int length)`
`java.util.Map<java.lang.String,java.lang.String>`	`handleProbe(java.lang.String... keys)` Handles a probe.
`protected void`	`handleSingleMessage(Address sender, byte[] data, int offset, int length)`
`void`	`init()` Called after instance has been created (null constructor) and before protocol is started.
`boolean`	`isDefaulThreadPoolEnabled()`
`boolean`	`isDiagnosticsHandlerRunning()`
`static boolean`	`isDiscardIncompatiblePackets()`
`static boolean`	`isEnableBundling()` 已过时。
`static boolean`	`isEnableUnicastBundling()` 已过时。
`boolean`	`isLogicalAddressCacheReaperRunning()`
`boolean`	`isLoopback()` 已过时。
`boolean`	`isMulticastCapable()`
`boolean`	`isOOBThreadPoolEnabled()`
`boolean`	`isReceiveOnAllInterfaces()`
`boolean`	`isSingleton()`
`static java.lang.String`	`loggerType()`
`protected void`	`loopback(Message msg, boolean multicast)`
`protected void`	`passBatchUp(MessageBatch batch, boolean perform_cluster_name_matching, boolean discard_own_mcast)`
`protected void`	`passMessageUp(Message msg, AsciiString cluster_name, boolean perform_cluster_name_matching, boolean multicast, boolean discard_own_mcast)`
`protected void`	`passToAllUpProtocols(Event evt)`
`protected java.util.concurrent.Executor`	`pickThreadPool(boolean oob, boolean internal)`
`java.lang.String`	`printLogicalAddressCache()`
`java.lang.String`	`printWhoHasCache()`
`static Message`	`readMessage(java.io.DataInput instream)`
`static MessageBatch[]`	`readMessageBatch(java.io.DataInput in, boolean multicast)` Reads a list of messages into 4 MessageBatches: regular OOB INTERNAL-OOB (INTERNAL and OOB) INTERNAL (INTERNAL)
`static java.util.List<Message>`	`readMessageList(java.io.DataInput in, short transport_id)`
`void`	`receive(Address sender, byte[] data, int offset, int length)` Subclasses must call this method when a unicast or multicast message has been received.
`protected void`	`registerLocalAddress(Address addr)` Associates the address with the physical address fetched from the cache
`void`	`registerProbeHandler(DiagnosticsHandler.ProbeHandler handler)`
`protected void`	`removeAndDispatchNonBundledMessages(MessageBatch... oob_batches)` Removes messages with flags DONT_BUNDLE and OOB set and executes them in the oob or internal thread pool.
`protected void`	`removeLogicalAddressFromCache(Address logical_addr)`
`void`	`resetStats()`
`protected void`	`send(Message msg, Address dest)` Serializes and sends a message.
`abstract void`	`sendMulticast(AsciiString cluster_name, byte[] data, int offset, int length)` Send to all members in the group.
`protected void`	`sendToMembers(java.util.Collection<Address> mbrs, byte[] buf, int offset, int length)` Fetches the physical addrs for mbrs and sends the msg to each physical address.
`protected void`	`sendToSingleMember(Address dest, byte[] buf, int offset, int length)`
`abstract void`	`sendUnicast(PhysicalAddress dest, byte[] data, int offset, int length)` Send a unicast to 1 member.
`void`	`setBindAddress(java.net.InetAddress bind_addr)`
`void`	`setBindPort(int port)`
`void`	`setBindToAllInterfaces(boolean flag)`
`void`	`setBundler(TP.Bundler bundler)` Installs a bundler.
`void`	`setDefaultThreadPool(java.util.concurrent.Executor thread_pool)`
`void`	`setDefaultThreadPoolThreadFactory(ThreadFactory factory)`
`void`	`setDiagnosticsHandler(DiagnosticsHandler handler)` Sets a `DiagnosticsHandler`.
`static void`	`setDiscardIncompatiblePackets(boolean flag)`
`void`	`setEnableBundling(boolean flag)` 已过时。
`void`	`setEnableUnicastBundling(boolean enable_unicast_bundling)` 已过时。
`protected void`	`setInAllThreadFactories(java.lang.String cluster_name, Address local_address, java.lang.String pattern)`
`void`	`setInternalThreadPool(java.util.concurrent.Executor internal_thread_pool)`
`void`	`setInternalThreadPoolThreadFactory(ThreadFactory factory)`
`void`	`setLogDiscardMessages(boolean flag)`
`void`	`setLogDiscardMessagesVersion(boolean flag)`
`void`	`setLoopback(boolean b)` 已过时。
`void`	`setMaxBundleSize(int size)`
`void`	`setMaxBundleTimeout(long timeout)`
`void`	`setOOBRejectionPolicy(java.lang.String rejection_policy)`
`void`	`setOOBThreadPool(java.util.concurrent.Executor oob_thread_pool)`
`void`	`setOOBThreadPoolKeepAliveTime(long time)`
`void`	`setOOBThreadPoolMaxThreads(int size)`
`void`	`setOOBThreadPoolMinThreads(int size)`
`void`	`setOOBThreadPoolQueueEnabled(boolean flag)`
`void`	`setOOBThreadPoolThreadFactory(ThreadFactory factory)`
`protected void`	`setPingData(PingData data)`
`void`	`setPortRange(int range)`
`void`	`setRegularRejectionPolicy(java.lang.String rejection_policy)`
`void`	`setSocketFactory(SocketFactory factory)` Sets a SocketFactory.
`protected void`	`setSourceAddress(Message msg)` If the sender is null, set our own address.
`void`	`setThreadFactory(ThreadFactory factory)`
`protected void`	`setThreadNames()`
`void`	`setThreadPoolKeepAliveTime(long time)`
`void`	`setThreadPoolMaxThreads(int size)`
`void`	`setThreadPoolMinThreads(int size)`
`void`	`setThreadPoolQueueEnabled(boolean flag)`
`void`	`setTimer(TimeScheduler timer)` Sets a new timer.
`void`	`setTimerKeepAliveTime(long time)`
`void`	`setTimerMaxThreads(int size)`
`void`	`setTimerMinThreads(int size)`
`void`	`setTimerThreadFactory(ThreadFactory factory)`
`void`	`setTimeService(TimeService ts)`
`protected static void`	`shutdownThreadPool(java.util.concurrent.Executor thread_pool)`
`void`	`start()` Creates the unicast and multicast sockets and starts the unicast and multicast receiver threads
`protected void`	`startDiagnostics()`
`void`	`stop()` This method is called on a `Channel.disconnect()`.
`protected void`	`stopDiagnostics()`
`java.lang.String[]`	`supportedKeys()` Returns a list of supported keys
`abstract boolean`	`supportsMulticasting()` Whether or not hardware multicasting is supported
`java.lang.String`	`toString()`
`void`	`unregisterProbeHandler(DiagnosticsHandler.ProbeHandler handler)`
`protected void`	`unsetThreadNames()`
`java.lang.Object`	`up(Event evt)` handle the UP event.
`protected boolean`	`versionMatch(short version, Address sender)`
`protected static void`	`writeMessage(Message msg, java.io.DataOutput dos, boolean multicast)` This method needs to be synchronized on out_stream when it is called
`static void`	`writeMessageList(Address dest, Address src, byte[] cluster_name, java.util.List<Message> msgs, java.io.DataOutput dos, boolean multicast, short transport_id)` Write a list of messages with the same destination and src addresses.

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

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

字段详细资料
- LIST
```
protected static final byte LIST
```
  另请参阅:
  常量字段值
- MULTICAST
```
protected static final byte MULTICAST
```
  另请参阅:
  常量字段值
- MSG_OFFSET
```
protected static final int MSG_OFFSET
```
  另请参阅:
  常量字段值
- MSG_OVERHEAD
```
protected static final int MSG_OVERHEAD
```
  另请参阅:
  常量字段值
- can_bind_to_mcast_addr
```
protected static final boolean can_bind_to_mcast_addr
```
- BUNDLE_MSG
```
protected static final java.lang.String BUNDLE_MSG
```
  另请参阅:
  常量字段值
- f
```
protected static java.text.NumberFormat f
```
- bind_addr
```
protected java.net.InetAddress bind_addr
```
- external_addr
```
protected java.net.InetAddress external_addr
```
- external_port
```
protected int external_port
```
- bind_interface_str
```
protected java.lang.String bind_interface_str
```
- receive_on_all_interfaces
```
protected boolean receive_on_all_interfaces
```
- receive_interfaces
```
protected java.util.List<java.net.NetworkInterface> receive_interfaces
```
  List of interfaces to receive multicasts on. The multicast receive socket will listen on all of these interfaces. This is a comma-separated list of IP addresses or interface names. E.g. "192.168.5.1,eth1,127.0.0.1". Duplicates are discarded; we only bind to an interface once. If this property is set, it overrides receive_on_all_interfaces.
- logical_addr_cache_max_size
```
protected int logical_addr_cache_max_size
```
- logical_addr_cache_expiration
```
protected long logical_addr_cache_expiration
```
- logical_addr_cache_reaper_interval
```
protected long logical_addr_cache_reaper_interval
```
- bind_port
```
protected int bind_port
```
  The port to which the transport binds. 0 means to bind to any (ephemeral) port
- port_range
```
protected int port_range
```
- loopback
```
@Deprecated
protected boolean loopback
```
  已过时。
  
  If true, messages sent to self are treated specially: unicast messages are looped back immediately, multicast messages get a local copy first and - when the real copy arrives - it will be discarded
- loopback_copy
```
protected boolean loopback_copy
```
- loopback_separate_thread
```
protected boolean loopback_separate_thread
```
- discard_incompatible_packets
```
@Deprecated
protected boolean discard_incompatible_packets
```
  已过时。
  
  Discard packets with a different version. Usually minor version differences are okay. Setting this property to true means that we expect the exact same version on all incoming packets
- thread_naming_pattern
```
protected java.lang.String thread_naming_pattern
```
- oob_thread_pool_enabled
```
protected boolean oob_thread_pool_enabled
```
- oob_thread_pool_min_threads
```
protected int oob_thread_pool_min_threads
```
- oob_thread_pool_max_threads
```
protected int oob_thread_pool_max_threads
```
- oob_thread_pool_keep_alive_time
```
protected long oob_thread_pool_keep_alive_time
```
- oob_thread_pool_queue_enabled
```
protected boolean oob_thread_pool_queue_enabled
```
- oob_thread_pool_queue_max_size
```
protected int oob_thread_pool_queue_max_size
```
- oob_thread_pool_rejection_policy
```
protected java.lang.String oob_thread_pool_rejection_policy
```
- thread_pool_min_threads
```
protected int thread_pool_min_threads
```
- thread_pool_max_threads
```
protected int thread_pool_max_threads
```
- thread_pool_keep_alive_time
```
protected long thread_pool_keep_alive_time
```
- thread_pool_enabled
```
protected boolean thread_pool_enabled
```
- thread_pool_queue_enabled
```
protected boolean thread_pool_queue_enabled
```
- thread_pool_queue_max_size
```
protected int thread_pool_queue_max_size
```
- thread_pool_rejection_policy
```
protected java.lang.String thread_pool_rejection_policy
```
- internal_thread_pool_enabled
```
protected boolean internal_thread_pool_enabled
```
- internal_thread_pool_min_threads
```
protected int internal_thread_pool_min_threads
```
- internal_thread_pool_max_threads
```
protected int internal_thread_pool_max_threads
```
- internal_thread_pool_keep_alive_time
```
protected long internal_thread_pool_keep_alive_time
```
- internal_thread_pool_queue_enabled
```
protected boolean internal_thread_pool_queue_enabled
```
- internal_thread_pool_queue_max_size
```
protected int internal_thread_pool_queue_max_size
```
- internal_thread_pool_rejection_policy
```
protected java.lang.String internal_thread_pool_rejection_policy
```
- timer_type
```
protected java.lang.String timer_type
```
- timer_min_threads
```
protected int timer_min_threads
```
- timer_max_threads
```
protected int timer_max_threads
```
- timer_keep_alive_time
```
protected long timer_keep_alive_time
```
- timer_queue_max_size
```
protected int timer_queue_max_size
```
- timer_rejection_policy
```
protected java.lang.String timer_rejection_policy
```
- wheel_size
```
protected int wheel_size
```
- tick_time
```
protected long tick_time
```
- time_service_interval
```
protected long time_service_interval
```
- enable_bundling
```
@Deprecated
protected boolean enable_bundling
```
  已过时。
- enable_unicast_bundling
```
@Deprecated
protected boolean enable_unicast_bundling
```
  已过时。
  
  Enable bundling for unicast messages. Ignored if enable_bundling is off
- enable_batching
```
protected boolean enable_batching
```
- ignore_dont_bundle
```
protected boolean ignore_dont_bundle
```
- enable_diagnostics
```
protected boolean enable_diagnostics
```
- diagnostics_addr
```
protected java.net.InetAddress diagnostics_addr
```
- diagnostics_bind_interfaces
```
protected java.util.List<java.net.NetworkInterface> diagnostics_bind_interfaces
```
- diagnostics_port
```
protected int diagnostics_port
```
- diagnostics_ttl
```
protected int diagnostics_ttl
```
- diagnostics_passcode
```
protected java.lang.String diagnostics_passcode
```
- singleton_name
```
protected java.lang.String singleton_name
```
- log_discard_msgs
```
protected boolean log_discard_msgs
```
  Whether or not warnings about messages from different groups are logged - private flag, not for common use
- log_discard_msgs_version
```
protected boolean log_discard_msgs_version
```
- who_has_cache_timeout
```
protected long who_has_cache_timeout
```
- physical_addr_max_fetch_attempts
```
protected int physical_addr_max_fetch_attempts
```
- suppress_time_different_version_warnings
```
protected long suppress_time_different_version_warnings
```
- suppress_time_different_cluster_warnings
```
protected long suppress_time_different_cluster_warnings
```
- max_bundle_size
```
protected int max_bundle_size
```
  Maximum number of bytes for messages to be queued until they are sent. This value needs to be smaller than the largest datagram packet size in case of UDP
- max_bundle_timeout
```
protected long max_bundle_timeout
```
  Max number of milliseconds until queued messages are sent. Messages are sent when max_bundle_size or max_bundle_timeout has been exceeded (whichever occurs faster)
- bundler_type
```
protected java.lang.String bundler_type
```
- bundler_capacity
```
protected int bundler_capacity
```
- num_msgs_sent
```
protected long num_msgs_sent
```
- num_msgs_received
```
protected long num_msgs_received
```
- num_single_msgs_received
```
protected long num_single_msgs_received
```
- num_single_msgs_sent
```
protected long num_single_msgs_sent
```
- num_batches_received
```
protected long num_batches_received
```
- num_batches_sent
```
protected long num_batches_sent
```
- num_bytes_sent
```
protected long num_bytes_sent
```
- num_bytes_received
```
protected long num_bytes_received
```
- num_rejected_msgs
```
protected int num_rejected_msgs
```
- cluster_name
```
protected AsciiString cluster_name
```
  The name of the group to which this member is connected. With a shared transport, the channel name is in TP.ProtocolAdapter (cluster_name), and this field is not used
- num_oob_msgs_received
```
protected long num_oob_msgs_received
```
- num_incoming_msgs_received
```
protected long num_incoming_msgs_received
```
- num_internal_msgs_received
```
protected long num_internal_msgs_received
```
- local_addr
```
protected Address local_addr
```
  The address (host and port) of this member. Null by default when a shared transport is used
- local_physical_addr
```
protected PhysicalAddress local_physical_addr
```
- members
```
protected final java.util.Set<Address> members
```
  The members of this group (updated when a member joins or leaves). With a shared transport, members contains *all* members from all channels sitting on the shared transport
- connect_count
```
protected int connect_count
```
  Keeps track of connects and disconnects, in order to start and stop threads
- connectLock
```
protected final java.util.concurrent.locks.ReentrantLock connectLock
```
- oob_thread_pool
```
protected java.util.concurrent.Executor oob_thread_pool
```
- oob_thread_factory
```
protected ThreadFactory oob_thread_factory
```
  Factory which is used by oob_thread_pool
- oob_thread_pool_queue
```
protected java.util.concurrent.BlockingQueue<java.lang.Runnable> oob_thread_pool_queue
```
  Used if oob_thread_pool is a ThreadPoolExecutor and oob_thread_pool_queue_enabled is true
- thread_pool
```
protected java.util.concurrent.Executor thread_pool
```
  The thread pool which handles unmarshalling, version checks and dispatching of regular messages
- default_thread_factory
```
protected ThreadFactory default_thread_factory
```
  Factory which is used by oob_thread_pool
- thread_pool_queue
```
protected java.util.concurrent.BlockingQueue<java.lang.Runnable> thread_pool_queue
```
  Used if thread_pool is a ThreadPoolExecutor and thread_pool_queue_enabled is true
- internal_thread_pool
```
protected java.util.concurrent.Executor internal_thread_pool
```
  The thread pool which handles JGroups internal messages (Flag.INTERNAL)
- internal_thread_factory
```
protected ThreadFactory internal_thread_factory
```
  Factory which is used by internal_thread_pool
- internal_thread_pool_queue
```
protected java.util.concurrent.BlockingQueue<java.lang.Runnable> internal_thread_pool_queue
```
  Used if thread_pool is a ThreadPoolExecutor and thread_pool_queue_enabled is true
- timer
```
protected TimeScheduler timer
```
- timer_thread_factory
```
protected ThreadFactory timer_thread_factory
```
- time_service
```
protected TimeService time_service
```
- global_thread_factory
```
protected ThreadFactory global_thread_factory
```
  Used by all threads created by JGroups outside of the thread pools
- socket_factory
```
protected SocketFactory socket_factory
```
- bundler
```
protected TP.Bundler bundler
```
- diag_handler
```
protected DiagnosticsHandler diag_handler
```
- preregistered_probe_handlers
```
protected final java.util.List<DiagnosticsHandler.ProbeHandler> preregistered_probe_handlers
```
- up_prots
```
protected final java.util.concurrent.ConcurrentMap<AsciiString,Protocol> up_prots
```
  If singleton_name is enabled, this map is used to de-multiplex incoming messages according to their cluster names (attached to the message by the transport anyway). The values are the next protocols above the transports.
- header
```
protected TpHeader header
```
  The header including the cluster name, sent with each message. Not used with a shared transport (instead TP.ProtocolAdapter attaches the header to the message
- logical_addr_cache
```
protected LazyRemovalCache<Address,PhysicalAddress> logical_addr_cache
```
  Cache which maintains mappings between logical and physical addresses. When sending a message to a logical address, we look up the physical address from logical_addr_cache and send the message to the physical address
  The keys are logical addresses, the values physical addresses
- last_discovery_request
```
protected long last_discovery_request
```
- avg_batch_size
```
protected final Average avg_batch_size
```
- print_function
```
protected static final LazyRemovalCache.Printable<Address,LazyRemovalCache.Entry<PhysicalAddress>> print_function
```
- who_has_cache
```
protected ExpiryCache<Address> who_has_cache
```
  Cache keeping track of WHO_HAS requests for physical addresses (given a logical address) and expiring them after who_has_cache_timeout ms
- suppress_log_different_version
```
protected SuppressLog<Address> suppress_log_different_version
```
  Log to suppress identical warnings for messages from members with different (incompatible) versions
- suppress_log_different_cluster
```
protected SuppressLog<Address> suppress_log_different_cluster
```
  Log to suppress identical warnings for messages from members in different clusters

构造器详细资料
- TP
```
protected TP()
```
  Creates the TP protocol, and initializes the state variables, does however not start any sockets or threads.

方法详细资料

setMaxBundleSize

public void setMaxBundleSize(int size)

getMaxBundleTimeout
```
public long getMaxBundleTimeout()
```

setMaxBundleTimeout

public void setMaxBundleTimeout(long timeout)

getMaxBundleSize
```
public int getMaxBundleSize()
```

getBundlerBufferSize
```
public int getBundlerBufferSize()
```

isLogicalAddressCacheReaperRunning

public boolean isLogicalAddressCacheReaperRunning()

getAvgBatchSize
```
public double getAvgBatchSize()
```

setOOBThreadPoolKeepAliveTime

public void setOOBThreadPoolKeepAliveTime(long time)

getOOBThreadPoolKeepAliveTime

public long getOOBThreadPoolKeepAliveTime()

setOOBThreadPoolMinThreads

public void setOOBThreadPoolMinThreads(int size)

getOOBThreadPoolMinThreads

public int getOOBThreadPoolMinThreads()

setOOBThreadPoolMaxThreads

public void setOOBThreadPoolMaxThreads(int size)

getOOBThreadPoolMaxThreads

public int getOOBThreadPoolMaxThreads()

setOOBThreadPoolQueueEnabled

public void setOOBThreadPoolQueueEnabled(boolean flag)

setThreadPoolMinThreads

public void setThreadPoolMinThreads(int size)

getThreadPoolMinThreads
```
public int getThreadPoolMinThreads()
```

setThreadPoolMaxThreads

public void setThreadPoolMaxThreads(int size)

getThreadPoolMaxThreads
```
public int getThreadPoolMaxThreads()
```

setThreadPoolKeepAliveTime

public void setThreadPoolKeepAliveTime(long time)

getThreadPoolKeepAliveTime

public long getThreadPoolKeepAliveTime()

setTimerMinThreads

public void setTimerMinThreads(int size)

getTimerMinThreads
```
public int getTimerMinThreads()
```

setTimerMaxThreads

public void setTimerMaxThreads(int size)

getTimerMaxThreads
```
public int getTimerMaxThreads()
```

setTimerKeepAliveTime

public void setTimerKeepAliveTime(long time)

getTimerKeepAliveTime
```
public long getTimerKeepAliveTime()
```

getTimerQueueSize
```
public int getTimerQueueSize()
```

getTimerClass

public java.lang.String getTimerClass()

getClusterName

public java.lang.String getClusterName()

getDifferentClusterMessages

public int getDifferentClusterMessages()

getDifferentVersionMessages

public int getDifferentVersionMessages()

clearDifferentClusterCache

public void clearDifferentClusterCache()

clearDifferentVersionCache

public void clearDifferentVersionCache()

loggerType

public static java.lang.String loggerType()

supportsMulticasting
```
public abstract boolean supportsMulticasting()
```
Whether or not hardware multicasting is supported

isMulticastCapable
```
public boolean isMulticastCapable()
```

toString
```
public java.lang.String toString()
```
覆盖:

toString 在类中 java.lang.Object

getLocalAddress

public java.lang.String getLocalAddress()

getLocalPhysicalAddress

public java.lang.String getLocalPhysicalAddress()

resetStats
```
public void resetStats()
```
覆盖:

resetStats 在类中 Protocol

registerProbeHandler

public void registerProbeHandler(DiagnosticsHandler.ProbeHandler handler)

unregisterProbeHandler

public void unregisterProbeHandler(DiagnosticsHandler.ProbeHandler handler)

setDiagnosticsHandler
```
public void setDiagnosticsHandler(DiagnosticsHandler handler)
```
Sets a DiagnosticsHandler. Should be set before the stack is started

参数:
handler -

setBundler
```
public void setBundler(TP.Bundler bundler)
```
Installs a bundler. Needs to be done before the channel is connected

setThreadPoolQueueEnabled

public void setThreadPoolQueueEnabled(boolean flag)

getDefaultThreadPool

public java.util.concurrent.Executor getDefaultThreadPool()

setDefaultThreadPool

public void setDefaultThreadPool(java.util.concurrent.Executor thread_pool)

getDefaultThreadPoolThreadFactory

public ThreadFactory getDefaultThreadPoolThreadFactory()

setDefaultThreadPoolThreadFactory

public void setDefaultThreadPoolThreadFactory(ThreadFactory factory)

getOOBThreadPool

public java.util.concurrent.Executor getOOBThreadPool()

setOOBThreadPool

public void setOOBThreadPool(java.util.concurrent.Executor oob_thread_pool)

getOOBThreadPoolThreadFactory

public ThreadFactory getOOBThreadPoolThreadFactory()

setOOBThreadPoolThreadFactory

public void setOOBThreadPoolThreadFactory(ThreadFactory factory)

getInternalThreadPool

public java.util.concurrent.Executor getInternalThreadPool()

setInternalThreadPool

public void setInternalThreadPool(java.util.concurrent.Executor internal_thread_pool)

getInternalThreadPoolThreadFactory

public ThreadFactory getInternalThreadPoolThreadFactory()

setInternalThreadPoolThreadFactory

public void setInternalThreadPoolThreadFactory(ThreadFactory factory)

getTimerThreadFactory

public ThreadFactory getTimerThreadFactory()

setTimerThreadFactory

public void setTimerThreadFactory(ThreadFactory factory)

getTimer
```
public TimeScheduler getTimer()
```

setTimer
```
public void setTimer(TimeScheduler timer)
```
Sets a new timer. This should be done before the transport is initialized; be very careful, as replacing a running timer with tasks in it can wreak havoc !

参数:
timer -

getTimeService
```
public TimeService getTimeService()
```

setTimeService

public void setTimeService(TimeService ts)

getThreadFactory
```
public ThreadFactory getThreadFactory()
```
从类复制的说明: Protocol

Supposed to be overwritten by subclasses. Usually the transport returns a valid non-null thread factory, but thread factories can also be created by individual protocols

覆盖:

getThreadFactory 在类中 Protocol

返回:

setThreadFactory

public void setThreadFactory(ThreadFactory factory)

getSocketFactory
```
public SocketFactory getSocketFactory()
```
从类复制的说明: Protocol

Returns the SocketFactory associated with this protocol, if overridden in a subclass, or passes the call down

覆盖:

getSocketFactory 在类中 Protocol

返回:
SocketFactory

setSocketFactory
```
public void setSocketFactory(SocketFactory factory)
```
从类复制的说明: Protocol

Sets a SocketFactory. Socket factories are typically provided by the transport (TP) or TP.ProtocolAdapter

覆盖:

setSocketFactory 在类中 Protocol

getThreadNamingPattern
```
public java.lang.String getThreadNamingPattern()
```
Names the current thread. Valid values are "pcl": p: include the previous (original) name, e.g. "Incoming thread-1", "UDP ucast receiver" c: include the cluster name, e.g. "MyCluster" l: include the local address of the current member, e.g. "192.168.5.1:5678"

getNumMessagesSent
```
public long getNumMessagesSent()
```

getNumMessagesReceived
```
public long getNumMessagesReceived()
```

getNumBytesSent
```
public long getNumBytesSent()
```

getNumBytesReceived
```
public long getNumBytesReceived()
```

getBindAddress

public java.net.InetAddress getBindAddress()

setBindAddress

public void setBindAddress(java.net.InetAddress bind_addr)

getBindPort
```
public int getBindPort()
```

setBindPort
```
public void setBindPort(int port)
```

setBindToAllInterfaces

public void setBindToAllInterfaces(boolean flag)

isReceiveOnAllInterfaces

public boolean isReceiveOnAllInterfaces()

getReceiveInterfaces

public java.util.List<java.net.NetworkInterface> getReceiveInterfaces()

isDiscardIncompatiblePackets

public static boolean isDiscardIncompatiblePackets()

setDiscardIncompatiblePackets

public static void setDiscardIncompatiblePackets(boolean flag)

isEnableBundling

@Deprecated
public static boolean isEnableBundling()

已过时。

setEnableBundling

@Deprecated
public void setEnableBundling(boolean flag)

已过时。

isEnableUnicastBundling

@Deprecated
public static boolean isEnableUnicastBundling()

已过时。

setEnableUnicastBundling

@Deprecated
public void setEnableUnicastBundling(boolean enable_unicast_bundling)

已过时。

setPortRange
```
public void setPortRange(int range)
```

getPortRange
```
public int getPortRange()
```

isOOBThreadPoolEnabled

public boolean isOOBThreadPoolEnabled()

isDefaulThreadPoolEnabled

public boolean isDefaulThreadPoolEnabled()

isLoopback

@Deprecated
public boolean isLoopback()

已过时。

setLoopback

@Deprecated
public void setLoopback(boolean b)

已过时。

getUpProtocols

public java.util.concurrent.ConcurrentMap<AsciiString,Protocol> getUpProtocols()

getOOBPoolSize
```
public int getOOBPoolSize()
```

getOOBPoolSizeActive
```
public int getOOBPoolSizeActive()
```

getOOBMessages
```
public long getOOBMessages()
```

getOOBQueueSize
```
public int getOOBQueueSize()
```

getOOBMaxQueueSize
```
public int getOOBMaxQueueSize()
```

setOOBRejectionPolicy

public void setOOBRejectionPolicy(java.lang.String rejection_policy)

getRegularPoolSize
```
public int getRegularPoolSize()
```

getRegularPoolSizeActive
```
public int getRegularPoolSizeActive()
```

getRegularMessages
```
public long getRegularMessages()
```

getRegularQueueSize
```
public int getRegularQueueSize()
```

getRegularMaxQueueSize
```
public int getRegularMaxQueueSize()
```

getInternalPoolSize
```
public int getInternalPoolSize()
```

getInternalPoolSizeActive

public int getInternalPoolSizeActive()

getInternalMessages
```
public long getInternalMessages()
```

getInternalQueueSize
```
public int getInternalQueueSize()
```

getInternalMaxQueueSize
```
public int getInternalMaxQueueSize()
```

getNumTimerTasks
```
public int getNumTimerTasks()
```

dumpTimerTasks

public java.lang.String dumpTimerTasks()

getTimerThreads
```
public int getTimerThreads()
```

getNumThreads
```
public static int getNumThreads()
```

isDiagnosticsHandlerRunning

public boolean isDiagnosticsHandlerRunning()

setRegularRejectionPolicy

public void setRegularRejectionPolicy(java.lang.String rejection_policy)

setLogDiscardMessages

public void setLogDiscardMessages(boolean flag)

getLogDiscardMessages

public boolean getLogDiscardMessages()

setLogDiscardMessagesVersion

public void setLogDiscardMessagesVersion(boolean flag)

getLogDiscardMessagesVersion

public boolean getLogDiscardMessagesVersion()

printLogicalAddressCache

public java.lang.String printLogicalAddressCache()

printWhoHasCache

public java.lang.String printWhoHasCache()

evictLogicalAddressCache

public void evictLogicalAddressCache()

evictLogicalAddressCache

public void evictLogicalAddressCache(boolean force)

sendMulticast
```
public abstract void sendMulticast(AsciiString cluster_name,
                 byte[] data,
                 int offset,
                 int length)
                            throws java.lang.Exception
```
Send to all members in the group. UDP would use an IP multicast message, whereas TCP would send N messages, one for each member

参数:
cluster_name - The name of the cluster. Null if not a shared transport
data - The data to be sent. This is not a copy, so don't modify it
offset -
length -

抛出:

java.lang.Exception

sendUnicast
```
public abstract void sendUnicast(PhysicalAddress dest,
               byte[] data,
               int offset,
               int length)
                          throws java.lang.Exception
```
Send a unicast to 1 member. Note that the destination address is a *physical*, not a logical address

参数:
dest - Must be a non-null unicast address
data - The data to be sent. This is not a copy, so don't modify it
offset -
length -

抛出:

java.lang.Exception

getInfo

public abstract java.lang.String getInfo()

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

destroy
```
public void destroy()
```
从类复制的说明: Protocol

This method is called on a Channel.close(). Does some cleanup; after the call the VM will terminate

覆盖:

destroy 在类中 Protocol

start
```
public void start()
           throws java.lang.Exception
```
Creates the unicast and multicast sockets and starts the unicast and multicast receiver threads

覆盖:

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

enableDiagnostics
```
public void enableDiagnostics()
```

disableDiagnostics
```
public void disableDiagnostics()
```

startDiagnostics

protected void startDiagnostics()
                         throws java.lang.Exception

抛出:: java.lang.Exception

stopDiagnostics
```
protected void stopDiagnostics()
```

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

handleConnect

protected void handleConnect()
                      throws java.lang.Exception

抛出:: java.lang.Exception

handleDisconnect
```
protected void handleDisconnect()
```

getSingletonName

public java.lang.String getSingletonName()

isSingleton
```
public boolean isSingleton()
```

up
```
public java.lang.Object up(Event evt)
```
handle the UP event.

覆盖:

up 在类中 Protocol

参数:
evt - - the event being send from the stack

down
```
public java.lang.Object down(Event evt)
```
Caller by the layer above this layer. Usually we just put this Message into the send queue and let one or more worker threads handle it. A worker thread then removes the Message from the send queue, performs a conversion and adds the modified Message to the send queue of the layer below it, by calling down()).

覆盖:

down 在类中 Protocol

loopback

protected void loopback(Message msg,
            boolean multicast)

_send

protected void _send(Message msg,
         Address dest)

setSourceAddress
```
protected void setSourceAddress(Message msg)
```
If the sender is null, set our own address. We cannot just go ahead and set the address anyway, as we might be sending a message on behalf of someone else ! E.g. in case of retransmission, when the original sender has crashed, or in a FLUSH protocol when we have to return all unstable messages with the FLUSH_OK response.

passMessageUp

protected void passMessageUp(Message msg,
                 AsciiString cluster_name,
                 boolean perform_cluster_name_matching,
                 boolean multicast,
                 boolean discard_own_mcast)

passBatchUp

protected void passBatchUp(MessageBatch batch,
               boolean perform_cluster_name_matching,
               boolean discard_own_mcast)

receive

public void receive(Address sender,
           byte[] data,
           int offset,
           int length)

Subclasses must call this method when a unicast or multicast message has been received.

handleMessageBatch

protected void handleMessageBatch(Address sender,
                      byte[] data,
                      int offset,
                      int length)

handleSingleMessage

protected void handleSingleMessage(Address sender,
                       byte[] data,
                       int offset,
                       int length)

removeAndDispatchNonBundledMessages
```
protected void removeAndDispatchNonBundledMessages(MessageBatch... oob_batches)
```
Removes messages with flags DONT_BUNDLE and OOB set and executes them in the oob or internal thread pool. JGRP-1737

pickThreadPool

protected java.util.concurrent.Executor pickThreadPool(boolean oob,
                                           boolean internal)

versionMatch

protected boolean versionMatch(short version,
                   Address sender)

send

protected void send(Message msg,
        Address dest)
             throws java.lang.Exception

Serializes and sends a message. This method is not reentrant

抛出:: java.lang.Exception

doSend

protected void doSend(AsciiString cluster_name,
          byte[] buf,
          int offset,
          int length,
          Address dest)
               throws java.lang.Exception

抛出:: java.lang.Exception

sendToSingleMember

protected void sendToSingleMember(Address dest,
                      byte[] buf,
                      int offset,
                      int length)
                           throws java.lang.Exception

抛出:: java.lang.Exception

sendToMembers

protected void sendToMembers(java.util.Collection<Address> mbrs,
                 byte[] buf,
                 int offset,
                 int length)
                      throws java.lang.Exception

Fetches the physical addrs for mbrs and sends the msg to each physical address. Asks discovery for missing members' physical addresses if needed

抛出:: java.lang.Exception

fetchPhysicalAddrs

protected void fetchPhysicalAddrs(java.util.List<Address> missing)

fetchResponsesFromDiscoveryProtocol

protected Responses fetchResponsesFromDiscoveryProtocol(java.util.List<Address> missing)

getClusterName

protected AsciiString getClusterName(Message msg)

setPingData

protected void setPingData(PingData data)

writeMessage

protected static void writeMessage(Message msg,
                java.io.DataOutput dos,
                boolean multicast)
                            throws java.lang.Exception

This method needs to be synchronized on out_stream when it is called

参数:: msg -
抛出:: java.io.IOException; java.lang.Exception

readMessage

public static Message readMessage(java.io.DataInput instream)
                           throws java.lang.Exception

抛出:: java.lang.Exception

writeMessageList

public static void writeMessageList(Address dest,
                    Address src,
                    byte[] cluster_name,
                    java.util.List<Message> msgs,
                    java.io.DataOutput dos,
                    boolean multicast,
                    short transport_id)
                             throws java.lang.Exception

Write a list of messages with the *same* destination and src addresses. The message list is marshalled as follows (see doc/design/MarshallingFormat.txt for details):

 List: * | version | flags | dest | src | cluster-name | [Message*] |

 Message:  | presence | leading | flags | [src] | length | [buffer] | size | [Headers*] |

参数:: dest -; src -; msgs -; dos -; multicast -
抛出:: java.lang.Exception

readMessageList

public static java.util.List<Message> readMessageList(java.io.DataInput in,
                                      short transport_id)
                                               throws java.lang.Exception

抛出:: java.lang.Exception

readMessageBatch
```
public static MessageBatch[] readMessageBatch(java.io.DataInput in,
                              boolean multicast)
                                       throws java.lang.Exception
```
Reads a list of messages into 4 MessageBatches:
1. regular
2. OOB
3. INTERNAL-OOB (INTERNAL and OOB)
4. INTERNAL (INTERNAL)
参数:
in -

返回:
an array of 4 MessageBatches in the order above, the first batch is at index 0

抛出:

java.lang.Exception

handleDownEvent

protected java.lang.Object handleDownEvent(Event evt)

registerLocalAddress
```
protected void registerLocalAddress(Address addr)
```
Associates the address with the physical address fetched from the cache

参数:
addr -

fetchLocalAddresses
```
protected void fetchLocalAddresses()
```
Grabs the local address (or addresses in the shared transport case) and registers them with the physical address in the transport's cache

setThreadNames
```
protected void setThreadNames()
```

unsetThreadNames
```
protected void unsetThreadNames()
```

setInAllThreadFactories

protected void setInAllThreadFactories(java.lang.String cluster_name,
                           Address local_address,
                           java.lang.String pattern)

createThreadPool

protected static java.util.concurrent.ExecutorService createThreadPool(int min_threads,
                                                    int max_threads,
                                                    long keep_alive_time,
                                                    java.lang.String rejection_policy,
                                                    java.util.concurrent.BlockingQueue<java.lang.Runnable> queue,
                                                    ThreadFactory factory)

shutdownThreadPool

protected static void shutdownThreadPool(java.util.concurrent.Executor thread_pool)

passToAllUpProtocols

protected void passToAllUpProtocols(Event evt)

addPhysicalAddressToCache

protected boolean addPhysicalAddressToCache(Address logical_addr,
                                PhysicalAddress physical_addr)

getPhysicalAddressFromCache

protected PhysicalAddress getPhysicalAddressFromCache(Address logical_addr)

getAllPhysicalAddressesFromCache

protected java.util.Collection<PhysicalAddress> getAllPhysicalAddressesFromCache()

removeLogicalAddressFromCache

protected void removeLogicalAddressFromCache(Address logical_addr)

clearLogicalAddressCache
```
public void clearLogicalAddressCache()
```
Clears the cache. Do not use, this is only for unit testing !

getPhysicalAddress

protected abstract PhysicalAddress getPhysicalAddress()

类 TP

嵌套类概要

字段概要

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

构造器概要

方法概要

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

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

字段详细资料

LIST

MULTICAST

MSG_OFFSET

MSG_OVERHEAD

can_bind_to_mcast_addr

BUNDLE_MSG

f

bind_addr

external_addr

external_port

bind_interface_str

receive_on_all_interfaces

receive_interfaces

logical_addr_cache_max_size

logical_addr_cache_expiration

logical_addr_cache_reaper_interval

bind_port

port_range

loopback

loopback_copy

loopback_separate_thread

discard_incompatible_packets

thread_naming_pattern

oob_thread_pool_enabled

oob_thread_pool_min_threads

oob_thread_pool_max_threads

oob_thread_pool_keep_alive_time

oob_thread_pool_queue_enabled

oob_thread_pool_queue_max_size

oob_thread_pool_rejection_policy

thread_pool_min_threads

thread_pool_max_threads

thread_pool_keep_alive_time

thread_pool_enabled

thread_pool_queue_enabled

thread_pool_queue_max_size

thread_pool_rejection_policy

internal_thread_pool_enabled

internal_thread_pool_min_threads

internal_thread_pool_max_threads

internal_thread_pool_keep_alive_time

internal_thread_pool_queue_enabled

internal_thread_pool_queue_max_size

internal_thread_pool_rejection_policy

timer_type

timer_min_threads

timer_max_threads

timer_keep_alive_time

timer_queue_max_size

timer_rejection_policy

wheel_size

tick_time

time_service_interval

enable_bundling

enable_unicast_bundling

enable_batching

ignore_dont_bundle

enable_diagnostics

diagnostics_addr

diagnostics_bind_interfaces

diagnostics_port

diagnostics_ttl

diagnostics_passcode

singleton_name

log_discard_msgs

log_discard_msgs_version

who_has_cache_timeout

physical_addr_max_fetch_attempts

suppress_time_different_version_warnings

suppress_time_different_cluster_warnings

max_bundle_size