GroupProperty (Hazelcast Root 3.12.6 API)

java.lang.Object
- com.hazelcast.spi.properties.GroupProperty

```
public final class GroupProperty
extends Object
```
Defines the name and default value for Hazelcast properties.

Field Summary

Fields
Modifier and Type	Field and Description
`static HazelcastProperty`	`AGGREGATION_ACCUMULATION_PARALLEL_EVALUATION` Run aggregation accumulation for multiple entries in parallel.
`static HazelcastProperty`	`APPLICATION_VALIDATION_TOKEN` Use this property to verify that Hazelcast nodes only join the cluster when their 'application' level configuration is the same.
`static HazelcastProperty`	`BACKPRESSURE_BACKOFF_TIMEOUT_MILLIS` Control the maximum timeout in millis to wait for an invocation space to be available.
`static HazelcastProperty`	`BACKPRESSURE_ENABLED` Using back pressure, you can prevent an overload of pending asynchronous backups.
`static HazelcastProperty`	`BACKPRESSURE_MAX_CONCURRENT_INVOCATIONS_PER_PARTITION` The maximum number of concurrent invocations per partition.
`static HazelcastProperty`	`BACKPRESSURE_SYNCWINDOW` Controls the frequency of a BackupAwareOperation getting its async backups converted to a sync backups.
`static HazelcastProperty`	`BIND_SPOOFING_CHECKS` Controls whether we apply more strict checks upon BIND requests towards a cluster member.
`static HazelcastProperty`	`CACHE_INVALIDATION_MESSAGE_BATCH_ENABLED` Defines cache invalidation event batch sending is enabled or not.
`static HazelcastProperty`	`CACHE_INVALIDATION_MESSAGE_BATCH_FREQUENCY_SECONDS` Defines the cache invalidation event batch sending frequency in seconds.
`static HazelcastProperty`	`CACHE_INVALIDATION_MESSAGE_BATCH_SIZE` Defines the maximum number of cache invalidation events to be drained and sent to the event listeners in a batch.
`static HazelcastProperty`	`CLIENT_ENDPOINT_REMOVE_DELAY_SECONDS` Time after which client connection is removed or owner node of a client is removed from the cluster.
`static HazelcastProperty`	`CLIENT_ENGINE_BLOCKING_THREAD_COUNT` The number of threads that the client engine has available for processing requests that are blocking (example: related to transactions) When not set it is set as core-size * 20.
`static HazelcastProperty`	`CLIENT_ENGINE_QUERY_THREAD_COUNT` The number of threads that the client engine has available for processing requests that are related to transactions When not set it is set as core-size.
`static HazelcastProperty`	`CLIENT_ENGINE_THREAD_COUNT` The number of threads that the client engine has available for processing requests that are not partition specific.
`static HazelcastProperty`	`CLIENT_HEARTBEAT_TIMEOUT_SECONDS`
`static HazelcastProperty`	`CLUSTER_SHUTDOWN_TIMEOUT_SECONDS`
`static HazelcastProperty`	`COMPATIBILITY_3_6_CLIENT_ENABLED` When this property is true, if the server can not determine the connected client version, it shall assume that it is of 3.6.x version client.
`static HazelcastProperty`	`CONNECT_ALL_WAIT_SECONDS`
`static HazelcastProperty`	`CONNECTION_MONITOR_INTERVAL`
`static HazelcastProperty`	`CONNECTION_MONITOR_MAX_FAULTS`
`static HazelcastProperty`	`DISABLE_STALE_READ_ON_PARTITION_MIGRATION`
`static HazelcastProperty`	`DISCOVERY_SPI_ENABLED` Enables the Discovery SPI lookup over the old native implementations.
`static HazelcastProperty`	`DISCOVERY_SPI_PUBLIC_IP_ENABLED` Enables the Discovery Joiner to use public ips from DiscoveredNode.
`static HazelcastProperty`	`ENABLE_JMX`
`static HazelcastProperty`	`ENTERPRISE_LICENSE_KEY`
`static HazelcastProperty`	`EVENT_QUEUE_CAPACITY` The capacity of the `EventServiceImpl` executor.
`static HazelcastProperty`	`EVENT_QUEUE_TIMEOUT_MILLIS` The timeout for offering an event to the event executor for processing.
`static HazelcastProperty`	`EVENT_SYNC_TIMEOUT_MILLIS` To prevent overloading of the outbound connections, once in a while an event is made synchronous by wrapping it in a fake operation and waiting for a fake response.
`static HazelcastProperty`	`EVENT_THREAD_COUNT` Number of threads for the `EventServiceImpl` executor.
`static HazelcastProperty`	`FAIL_ON_INDETERMINATE_OPERATION_STATE` When this configuration is enabled, if an operation has sync backups and acks are not received from backup replicas in time, or the member which owns primary replica of the target partition leaves the cluster, then the invocation fails with `IndeterminateOperationStateException`.
`static HazelcastProperty`	`GENERIC_OPERATION_THREAD_COUNT` The number of generic operation handler threads per member.
`static HazelcastProperty`	`GRACEFUL_SHUTDOWN_MAX_WAIT`
`static HazelcastProperty`	`HEALTH_MONITORING_DELAY_SECONDS`
`static HazelcastProperty`	`HEALTH_MONITORING_LEVEL`
`static HazelcastProperty`	`HEALTH_MONITORING_THRESHOLD_CPU_PERCENTAGE`
`static HazelcastProperty`	`HEALTH_MONITORING_THRESHOLD_MEMORY_PERCENTAGE`
`static HazelcastProperty`	`HEARTBEAT_FAILURE_DETECTOR_TYPE` Heartbeat failure detector type.
`static HazelcastProperty`	`HEARTBEAT_INTERVAL_SECONDS` The interval at which member heartbeat messages are sent
`static HazelcastProperty`	`HTTP_HEALTHCHECK_ENABLED` Deprecated. Enable or disable the `RestEndpointGroup.HEALTH_CHECK` group in `RestApiConfig` instead.
`static HazelcastProperty`	`ICMP_ECHO_FAIL_FAST` Deprecated. as of 3.10 this can be configured through `IcmpFailureDetectorConfig` This will be removed in future versions. Until this is done, if the `IcmpFailureDetectorConfig` is null we will still fall back to this
`static HazelcastProperty`	`ICMP_ENABLED` Deprecated. as of 3.10 this can be configured through `IcmpFailureDetectorConfig` This will be removed in future versions. Until this is done, if the `IcmpFailureDetectorConfig` is null we will still fall back to this
`static HazelcastProperty`	`ICMP_INTERVAL` Deprecated. as of 3.10 this can be configured through `IcmpFailureDetectorConfig` This will be removed in future versions. Until this is done, if the `IcmpFailureDetectorConfig` is null we will still fall back to this
`static HazelcastProperty`	`ICMP_MAX_ATTEMPTS` Deprecated. as of 3.10 this can be configured through `IcmpFailureDetectorConfig` This will be removed in future versions. Until this is done, if the `IcmpFailureDetectorConfig` is null we will still fall back to this
`static HazelcastProperty`	`ICMP_PARALLEL_MODE` Deprecated. as of 3.10 this can be configured through `IcmpFailureDetectorConfig` This will be removed in future versions. Until this is done, if the `IcmpFailureDetectorConfig` is null we will still fall back to this
`static HazelcastProperty`	`ICMP_TIMEOUT` Deprecated. as of 3.10 this can be configured through `IcmpFailureDetectorConfig` This will be removed in future versions. Until this is done, if the `IcmpFailureDetectorConfig` is null we will still fall back to this
`static HazelcastProperty`	`ICMP_TTL` Deprecated. as of 3.10 this can be configured through `IcmpFailureDetectorConfig` This will be removed in future versions. Until this is done, if the `IcmpFailureDetectorConfig` is null we will still fall back to this
`static HazelcastProperty`	`INDEX_COPY_BEHAVIOR` Type of Query Index result copying behavior.
`static HazelcastProperty`	`INIT_CLUSTER_VERSION` Override cluster version to use while node is not yet member of a cluster.
`static HazelcastProperty`	`INITIAL_MIN_CLUSTER_SIZE`
`static HazelcastProperty`	`INITIAL_WAIT_SECONDS`
`static HazelcastProperty`	`INVOCATION_MAX_RETRY_COUNT` Maximum number of retries for an invocation.
`static HazelcastProperty`	`INVOCATION_RETRY_PAUSE` Pause time between each retry cycle of an invocation in milliseconds.
`static HazelcastProperty`	`IO_BALANCER_INTERVAL_SECONDS` The interval in seconds between `IOBalancer` executions.
`static HazelcastProperty`	`IO_INPUT_THREAD_COUNT` Controls the number of socket input threads.
`static HazelcastProperty`	`IO_OUTPUT_THREAD_COUNT` Controls the number of socket output threads.
`static HazelcastProperty`	`IO_THREAD_COUNT` The number of threads doing socket input and the number of threads doing socket output.
`static HazelcastProperty`	`JCACHE_PROVIDER_TYPE` Forces the JCache provider, which can have values client or server, to force the provider type.
`static HazelcastProperty`	`JMX_UPDATE_INTERVAL_SECONDS`
`static HazelcastProperty`	`LOCK_MAX_LEASE_TIME_SECONDS`
`static HazelcastProperty`	`LOGGING_TYPE`
`static HazelcastProperty`	`MAP_EVICTION_BATCH_SIZE` Maximum number of IMap entries Hazelcast will evict during a single eviction cycle.
`static HazelcastProperty`	`MAP_EXPIRY_DELAY_SECONDS` You can use MAP_EXPIRY_DELAY_SECONDS to deal with some possible edge cases, such as using EntryProcessor.
`static HazelcastProperty`	`MAP_INVALIDATION_MESSAGE_BATCH_ENABLED` Defines Near Cache invalidation event batch sending is enabled or not.
`static HazelcastProperty`	`MAP_INVALIDATION_MESSAGE_BATCH_FREQUENCY_SECONDS` Defines the Near Cache invalidation event batch sending frequency in seconds.
`static HazelcastProperty`	`MAP_INVALIDATION_MESSAGE_BATCH_SIZE` Defines the maximum number of Near Cache invalidation events to be drained and sent to the event Near Cache in a batch.
`static HazelcastProperty`	`MAP_LOAD_ALL_PUBLISHES_ADDED_EVENT` This property is a switch between old and new event publishing behavior of map#loadAll.
`static HazelcastProperty`	`MAP_LOAD_CHUNK_SIZE` The maximum size of the key batch sent to the partition owners for value loading and the maximum size of a key batch for which values are loaded in a single partition.
`static HazelcastProperty`	`MAP_REPLICA_SCHEDULED_TASK_DELAY_SECONDS`
`static HazelcastProperty`	`MAP_WRITE_BEHIND_QUEUE_CAPACITY` Setting this capacity is valid if you set `MapStoreConfig.writeCoalescing` to `false`.
`static HazelcastProperty`	`MASTER_CONFIRMATION_INTERVAL_SECONDS` Deprecated. since 3.10
`static HazelcastProperty`	`MASTERSHIP_CLAIM_TIMEOUT_SECONDS` The timeout which defines when master candidate gives up waiting for response to its mastership claim.
`static HazelcastProperty`	`MAX_JOIN_MERGE_TARGET_SECONDS`
`static HazelcastProperty`	`MAX_JOIN_SECONDS`
`static HazelcastProperty`	`MAX_NO_HEARTBEAT_SECONDS` The timeout which defines when a cluster member is removed because it has not sent any heartbeats.
`static HazelcastProperty`	`MAX_NO_MASTER_CONFIRMATION_SECONDS` Deprecated. since 3.10
`static HazelcastProperty`	`MAX_WAIT_SECONDS_BEFORE_JOIN`
`static HazelcastProperty`	`MC_MAX_VISIBLE_SLOW_OPERATION_COUNT`
`static HazelcastProperty`	`MC_URL_CHANGE_ENABLED` Deprecated. Enable or disable the `RestEndpointGroup.CLUSTER_WRITE` group in `RestApiConfig` instead.
`static HazelcastProperty`	`MEMBER_LIST_PUBLISH_INTERVAL_SECONDS` The interval at which the master sends the member lists are sent to other non-master members
`static HazelcastProperty`	`MEMCACHE_ENABLED` Deprecated. Use `MemcacheProtocolConfig` instead.
`static HazelcastProperty`	`MERGE_FIRST_RUN_DELAY_SECONDS` The delay until the first run of the `SplitBrainHandler`
`static HazelcastProperty`	`MERGE_NEXT_RUN_DELAY_SECONDS` The interval between invocations of the `SplitBrainHandler`
`static HazelcastProperty`	`OPERATION_BACKUP_TIMEOUT_MILLIS` If an operation has backups, this property specifies how long the invocation will wait for acks from the backup replicas.
`static HazelcastProperty`	`OPERATION_CALL_TIMEOUT_MILLIS`
`static HazelcastProperty`	`PARTITION_BACKUP_SYNC_INTERVAL`
`static HazelcastProperty`	`PARTITION_COUNT` Total number of partitions in the Hazelcast cluster.
`static HazelcastProperty`	`PARTITION_FRAGMENTED_MIGRATION_ENABLED`
`static HazelcastProperty`	`PARTITION_MAX_PARALLEL_REPLICATIONS`
`static HazelcastProperty`	`PARTITION_MIGRATION_INTERVAL` Time in seconds to sleep after a migration task.
`static HazelcastProperty`	`PARTITION_MIGRATION_TIMEOUT` Timeout in seconds for all migration operations.
`static HazelcastProperty`	`PARTITION_OPERATION_THREAD_COUNT` The number of partition operation handler threads per member.
`static HazelcastProperty`	`PARTITION_TABLE_SEND_INTERVAL`
`static HazelcastProperty`	`PARTITIONING_STRATEGY_CLASS`
`static HazelcastProperty`	`PHONE_HOME_ENABLED`
`static HazelcastProperty`	`PREFER_IPv4_STACK`
`static HazelcastProperty`	`PRIORITY_GENERIC_OPERATION_THREAD_COUNT` The number of priority generic operation handler threads per member.
`static HazelcastProperty`	`QUERY_MAX_LOCAL_PARTITION_LIMIT_FOR_PRE_CHECK` Maximum value of local partitions to trigger local pre-check for `TruePredicate` query operations on maps.
`static HazelcastProperty`	`QUERY_OPTIMIZER_TYPE` Type of Query Optimizer.
`static HazelcastProperty`	`QUERY_PREDICATE_PARALLEL_EVALUATION` Run Query Evaluations for multiple partitions in parallel.
`static HazelcastProperty`	`QUERY_RESULT_SIZE_LIMIT` Result size limit for query operations on maps.
`static HazelcastProperty`	`RESPONSE_THREAD_COUNT` The number of threads that process responses.
`static HazelcastProperty`	`REST_ENABLED` Deprecated. Use `RestEndpointGroups` in `RestApiConfig` instead.
`static HazelcastProperty`	`SEARCH_DYNAMIC_CONFIG_FIRST` By default, search for data structures config is performed within static configuration first: Exact match in static config Wildcard match in static config Exact match in dynamic config Wildcard match in dynamic config Fallback to default But sometimes it makes sense to perform search within dynamic configs first.
`static HazelcastProperty`	`SERIALIZATION_VERSION` Hazelcast serialization version.
`static HazelcastProperty`	`SHUTDOWNHOOK_ENABLED`
`static HazelcastProperty`	`SHUTDOWNHOOK_POLICY` Behaviour when JVM is about to exit while Hazelcast instance is still running.
`static HazelcastProperty`	`SLOW_INVOCATION_DETECTOR_THRESHOLD_MILLIS` Deprecated.
`static HazelcastProperty`	`SLOW_OPERATION_DETECTOR_ENABLED` Enables or disables the `SlowOperationDetector`.
`static HazelcastProperty`	`SLOW_OPERATION_DETECTOR_LOG_PURGE_INTERVAL_SECONDS` Purge interval for slow operation logs.
`static HazelcastProperty`	`SLOW_OPERATION_DETECTOR_LOG_RETENTION_SECONDS` This value defines the retention time of invocations in slow operation logs.
`static HazelcastProperty`	`SLOW_OPERATION_DETECTOR_STACK_TRACE_LOGGING_ENABLED` Defines if the stacktraces of slow operations are logged in the log file.
`static HazelcastProperty`	`SLOW_OPERATION_DETECTOR_THRESHOLD_MILLIS` Defines a threshold above which a running operation in `OperationService` is considered to be slow.
`static HazelcastProperty`	`SOCKET_BIND_ANY`
`static HazelcastProperty`	`SOCKET_BUFFER_DIRECT` If the bytebuffers used in the socket should be a direct bytebuffer (true) or a regular bytebuffer (false).
`static HazelcastProperty`	`SOCKET_CLIENT_BIND`
`static HazelcastProperty`	`SOCKET_CLIENT_BIND_ANY`
`static HazelcastProperty`	`SOCKET_CLIENT_BUFFER_DIRECT`
`static HazelcastProperty`	`SOCKET_CLIENT_RECEIVE_BUFFER_SIZE` Overrides receive buffer size for connections opened by clients.
`static HazelcastProperty`	`SOCKET_CLIENT_SEND_BUFFER_SIZE` Overrides send buffer size for connections opened by clients.
`static HazelcastProperty`	`SOCKET_CONNECT_TIMEOUT_SECONDS`
`static HazelcastProperty`	`SOCKET_KEEP_ALIVE`
`static HazelcastProperty`	`SOCKET_LINGER_SECONDS`
`static HazelcastProperty`	`SOCKET_NO_DELAY`
`static HazelcastProperty`	`SOCKET_RECEIVE_BUFFER_SIZE`
`static HazelcastProperty`	`SOCKET_SEND_BUFFER_SIZE`
`static HazelcastProperty`	`SOCKET_SERVER_BIND_ANY`
`static HazelcastProperty`	`TASK_SCHEDULER_REMOVE_ON_CANCEL` This is a Java 6 specific property.
`static HazelcastProperty`	`TCP_JOIN_PORT_TRY_COUNT` The number of incremental ports, starting with port number defined in network configuration, that will be used to connect to a host which is defined without a port in the TCP-IP member list while a node is searching for a cluster.
`static HazelcastProperty`	`USE_LEGACY_MEMBER_LIST_FORMAT` Enables legacy (pre-3.9) member list format which is printed in logs.
`static HazelcastProperty`	`VERSION_CHECK_ENABLED` Deprecated.
`static HazelcastProperty`	`WAIT_SECONDS_BEFORE_JOIN`

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

- Field Detail
  - APPLICATION_VALIDATION_TOKEN
```
public static final HazelcastProperty APPLICATION_VALIDATION_TOKEN
```
    Use this property to verify that Hazelcast nodes only join the cluster when their 'application' level configuration is the same.
    If you have multiple machines, you want to make sure that each machine that joins the cluster has exactly the same 'application level' settings (such as settings that are not part of the Hazelcast configuration, maybe some file path). To prevent the machines with potentially different application level configuration from forming a cluster, you can set this property.
    You could use actual values, such as string paths, but you can also use an md5 hash. We make a guarantee that nodes will form a cluster (become a member) only if the token is an exact match. If this token is different, the member can't be started and therefore you will get the guarantee that all members in the cluster will have exactly the same application validation token.
    This validation token will be checked before a member joins the cluster.
  - PARTITION_COUNT
```
public static final HazelcastProperty PARTITION_COUNT
```
    Total number of partitions in the Hazelcast cluster.
  - PARTITION_OPERATION_THREAD_COUNT
```
public static final HazelcastProperty PARTITION_OPERATION_THREAD_COUNT
```
    The number of partition operation handler threads per member.
    If this is less than the number of partitions on a member, partition operations will queue behind other operations of different partitions.
    The default is -1, which means that the value is determined dynamically.
  - GENERIC_OPERATION_THREAD_COUNT
```
public static final HazelcastProperty GENERIC_OPERATION_THREAD_COUNT
```
    The number of generic operation handler threads per member.
    The default is -1, which means that the value is determined dynamically.
  - PRIORITY_GENERIC_OPERATION_THREAD_COUNT
```
public static final HazelcastProperty PRIORITY_GENERIC_OPERATION_THREAD_COUNT
```
    The number of priority generic operation handler threads per member.
    The default is 1.
    Having at least 1 priority generic operation thread helps to improve cluster stability since a lot of cluster operations are generic priority operations and they should get executed as soon as possible. If there is a dedicated generic operation thread then these operations don't get delayed because the generic threads are busy executing regular user operations. So unless memory consumption is an issue, make sure there is at least 1 thread.
  - RESPONSE_THREAD_COUNT
```
public static final HazelcastProperty RESPONSE_THREAD_COUNT
```
    The number of threads that process responses.
    By default there are 2 response threads; this gives stable and good performance.
    If set to 0, the response threads are bypassed and the response handling is done on the IO threads. Under certain conditions this can give a higher throughput, but setting it to 0 should be regarded an experimental feature.
  - CLIENT_ENGINE_THREAD_COUNT
```
public static final HazelcastProperty CLIENT_ENGINE_THREAD_COUNT
```
    The number of threads that the client engine has available for processing requests that are not partition specific. Most of the requests, such as map.put and map.get, are partition specific and will use a partition-specific operation thread, but there are also requests that can't be executed on a partition-specific operation thread, such as multimap.containsValue(value), because they need to access all partitions on a given member. When not set it is set as core-size
  - CLIENT_ENGINE_QUERY_THREAD_COUNT
```
public static final HazelcastProperty CLIENT_ENGINE_QUERY_THREAD_COUNT
```
    The number of threads that the client engine has available for processing requests that are related to transactions When not set it is set as core-size.
  - CLIENT_ENGINE_BLOCKING_THREAD_COUNT
```
public static final HazelcastProperty CLIENT_ENGINE_BLOCKING_THREAD_COUNT
```
    The number of threads that the client engine has available for processing requests that are blocking (example: related to transactions) When not set it is set as core-size * 20.
  - CLIENT_ENDPOINT_REMOVE_DELAY_SECONDS
```
public static final HazelcastProperty CLIENT_ENDPOINT_REMOVE_DELAY_SECONDS
```
    Time after which client connection is removed or owner node of a client is removed from the cluster.
    ClientDisconnectionOperation runs and cleans all resources of a client (listeners are removed, locks/txn are released). With this property, client has a window to connect back and prevent cleaning up its resources.
  - EVENT_THREAD_COUNT
```
public static final HazelcastProperty EVENT_THREAD_COUNT
```
    Number of threads for the EventServiceImpl executor. The executor is responsible for executing the events. If you process a lot of events and have many cores, setting a higher value is a good practice. This way, more events can be processed in parallel.
  - EVENT_QUEUE_CAPACITY
```
public static final HazelcastProperty EVENT_QUEUE_CAPACITY
```
    The capacity of the EventServiceImpl executor. The executor is responsible for executing the events. If the events are produced at a higher rate than they are consumed, the queue grows in size. This can lead to an OutOfMemoryError if the accumulated events are not small enough to fit in memory. This capacity is shared between event topics. When the maximum capacity is reached, the items are dropped. This means that the event system is a 'best effort' system and there is no guarantee that you are going to get an event. Since the capacity is shared between topics, one topic might fill the entire queue and cause other topics to drop their messages.
  - EVENT_QUEUE_TIMEOUT_MILLIS
```
public static final HazelcastProperty EVENT_QUEUE_TIMEOUT_MILLIS
```
    The timeout for offering an event to the event executor for processing. If the event queue is full, the event might not be accepted to the queue and it will be dropped. This applies only to processing of local events. Remote events (events on a remote subscriber) have no timeout, meaning that the event can be rejected immediately.
  - EVENT_SYNC_TIMEOUT_MILLIS
```
public static final HazelcastProperty EVENT_SYNC_TIMEOUT_MILLIS
```
    To prevent overloading of the outbound connections, once in a while an event is made synchronous by wrapping it in a fake operation and waiting for a fake response. This causes the outbound write queue of the connection to get drained.
    This timeout configures the maximum amount of waiting time for this fake response. Setting it to a too low value can lead to an uncontrolled growth of the outbound write queue of the connection.
  - HEALTH_MONITORING_LEVEL
```
public static final HazelcastProperty HEALTH_MONITORING_LEVEL
```
  - HEALTH_MONITORING_DELAY_SECONDS
```
public static final HazelcastProperty HEALTH_MONITORING_DELAY_SECONDS
```
  - HEALTH_MONITORING_THRESHOLD_MEMORY_PERCENTAGE
```
public static final HazelcastProperty HEALTH_MONITORING_THRESHOLD_MEMORY_PERCENTAGE
```
  - HEALTH_MONITORING_THRESHOLD_CPU_PERCENTAGE
```
public static final HazelcastProperty HEALTH_MONITORING_THRESHOLD_CPU_PERCENTAGE
```
  - IO_THREAD_COUNT
```
public static final HazelcastProperty IO_THREAD_COUNT
```
    The number of threads doing socket input and the number of threads doing socket output.
    E.g., if 3 is configured, then you get 3 threads doing input and 3 doing output. For individual control, check IO_INPUT_THREAD_COUNT and IO_OUTPUT_THREAD_COUNT.
    The default is 3 (i.e. 6 threads).
  - IO_INPUT_THREAD_COUNT
```
public static final HazelcastProperty IO_INPUT_THREAD_COUNT
```
    Controls the number of socket input threads. By default it is the same as IO_THREAD_COUNT.
  - IO_OUTPUT_THREAD_COUNT
```
public static final HazelcastProperty IO_OUTPUT_THREAD_COUNT
```
    Controls the number of socket output threads. By default it is the same as IO_THREAD_COUNT.
  - IO_BALANCER_INTERVAL_SECONDS
```
public static final HazelcastProperty IO_BALANCER_INTERVAL_SECONDS
```
    The interval in seconds between IOBalancer executions. The shorter intervals will catch I/O Imbalance faster, but they will cause higher overhead.
    Please see the documentation of IOBalancer for a detailed explanation of the problem.
    The default is 20 seconds. A value smaller than 1 disables the balancer.
  - PREFER_IPv4_STACK
```
public static final HazelcastProperty PREFER_IPv4_STACK
```
  - VERSION_CHECK_ENABLED
```
@Deprecated
public static final HazelcastProperty VERSION_CHECK_ENABLED
```
    Deprecated.
  - PHONE_HOME_ENABLED
```
public static final HazelcastProperty PHONE_HOME_ENABLED
```
  - CONNECT_ALL_WAIT_SECONDS
```
public static final HazelcastProperty CONNECT_ALL_WAIT_SECONDS
```
  - MEMCACHE_ENABLED
```
@Deprecated
public static final HazelcastProperty MEMCACHE_ENABLED
```
    Deprecated. Use MemcacheProtocolConfig instead.
  - REST_ENABLED
```
@Deprecated
public static final HazelcastProperty REST_ENABLED
```
    Deprecated. Use RestEndpointGroups in RestApiConfig instead.
  - HTTP_HEALTHCHECK_ENABLED
```
@Deprecated
public static final HazelcastProperty HTTP_HEALTHCHECK_ENABLED
```
    Deprecated. Enable or disable the RestEndpointGroup.HEALTH_CHECK group in RestApiConfig instead.
  - MAP_LOAD_CHUNK_SIZE
```
public static final HazelcastProperty MAP_LOAD_CHUNK_SIZE
```
    The maximum size of the key batch sent to the partition owners for value loading and the maximum size of a key batch for which values are loaded in a single partition.
  - MERGE_FIRST_RUN_DELAY_SECONDS
```
public static final HazelcastProperty MERGE_FIRST_RUN_DELAY_SECONDS
```
    The delay until the first run of the SplitBrainHandler
  - MERGE_NEXT_RUN_DELAY_SECONDS
```
public static final HazelcastProperty MERGE_NEXT_RUN_DELAY_SECONDS
```
    The interval between invocations of the SplitBrainHandler
  - OPERATION_CALL_TIMEOUT_MILLIS
```
public static final HazelcastProperty OPERATION_CALL_TIMEOUT_MILLIS
```
  - OPERATION_BACKUP_TIMEOUT_MILLIS
```
public static final HazelcastProperty OPERATION_BACKUP_TIMEOUT_MILLIS
```
    If an operation has backups, this property specifies how long the invocation will wait for acks from the backup replicas. If acks are not received from some backups, there will not be any rollback on other successful replicas.
  - FAIL_ON_INDETERMINATE_OPERATION_STATE
```
public static final HazelcastProperty FAIL_ON_INDETERMINATE_OPERATION_STATE
```
    When this configuration is enabled, if an operation has sync backups and acks are not received from backup replicas in time, or the member which owns primary replica of the target partition leaves the cluster, then the invocation fails with IndeterminateOperationStateException. However, even if the invocation fails, there will not be any rollback on other successful replicas.
  - INVOCATION_MAX_RETRY_COUNT
```
public static final HazelcastProperty INVOCATION_MAX_RETRY_COUNT
```
    Maximum number of retries for an invocation. After threshold is reached, invocation is assumed as failed.
  - INVOCATION_RETRY_PAUSE
```
public static final HazelcastProperty INVOCATION_RETRY_PAUSE
```
    Pause time between each retry cycle of an invocation in milliseconds.
  - SOCKET_BIND_ANY
```
public static final HazelcastProperty SOCKET_BIND_ANY
```
  - SOCKET_SERVER_BIND_ANY
```
public static final HazelcastProperty SOCKET_SERVER_BIND_ANY
```
  - SOCKET_CLIENT_BIND_ANY
```
public static final HazelcastProperty SOCKET_CLIENT_BIND_ANY
```
  - SOCKET_CLIENT_BIND
```
public static final HazelcastProperty SOCKET_CLIENT_BIND
```
  - SOCKET_RECEIVE_BUFFER_SIZE
```
public static final HazelcastProperty SOCKET_RECEIVE_BUFFER_SIZE
```
  - SOCKET_SEND_BUFFER_SIZE
```
public static final HazelcastProperty SOCKET_SEND_BUFFER_SIZE
```
  - SOCKET_BUFFER_DIRECT
```
public static final HazelcastProperty SOCKET_BUFFER_DIRECT
```
    If the bytebuffers used in the socket should be a direct bytebuffer (true) or a regular bytebuffer (false).
  - SOCKET_CLIENT_RECEIVE_BUFFER_SIZE
```
public static final HazelcastProperty SOCKET_CLIENT_RECEIVE_BUFFER_SIZE
```
    Overrides receive buffer size for connections opened by clients.
    Hazelcast creates all connections with receive buffer size set according to #PROP_SOCKET_RECEIVE_BUFFER_SIZE. When it detects a connection was opened by a client then it adjusts receive buffer size according to this property.
    Size is in kilobytes.
    The default is -1 (same as receive buffer size for connections opened by members).
  - SOCKET_CLIENT_SEND_BUFFER_SIZE
```
public static final HazelcastProperty SOCKET_CLIENT_SEND_BUFFER_SIZE
```
    Overrides send buffer size for connections opened by clients.
    Hazelcast creates all connections with send buffer size set according to #PROP_SOCKET_SEND_BUFFER_SIZE. When it detects a connection was opened by a client then it adjusts send buffer size according to this property.
    Size is in kilobytes.
    The default is -1 (same as receive buffer size for connections opened by members).
  - SOCKET_CLIENT_BUFFER_DIRECT
```
public static final HazelcastProperty SOCKET_CLIENT_BUFFER_DIRECT
```
  - SOCKET_LINGER_SECONDS
```
public static final HazelcastProperty SOCKET_LINGER_SECONDS
```
  - SOCKET_CONNECT_TIMEOUT_SECONDS
```
public static final HazelcastProperty SOCKET_CONNECT_TIMEOUT_SECONDS
```
  - SOCKET_KEEP_ALIVE
```
public static final HazelcastProperty SOCKET_KEEP_ALIVE
```
  - SOCKET_NO_DELAY
```
public static final HazelcastProperty SOCKET_NO_DELAY
```
  - SHUTDOWNHOOK_ENABLED
```
public static final HazelcastProperty SHUTDOWNHOOK_ENABLED
```
  - SHUTDOWNHOOK_POLICY
```
public static final HazelcastProperty SHUTDOWNHOOK_POLICY
```
    Behaviour when JVM is about to exit while Hazelcast instance is still running. Possible values: TERMINATE: Terminate Hazelcast immediately GRACEFUL: Initiate graceful shutdown. This can significantly slow-down JVM exit process, but it's tries to retain data safety. Default: TERMINATE You should always shutdown Hazelcast explicitly via HazelcastInstance.shutdown() It's not recommended to rely on shutdown hook, this is a last-effort measure.
  - WAIT_SECONDS_BEFORE_JOIN
```
public static final HazelcastProperty WAIT_SECONDS_BEFORE_JOIN
```
  - MAX_WAIT_SECONDS_BEFORE_JOIN
```
public static final HazelcastProperty MAX_WAIT_SECONDS_BEFORE_JOIN
```
  - MAX_JOIN_SECONDS
```
public static final HazelcastProperty MAX_JOIN_SECONDS
```
  - MAX_JOIN_MERGE_TARGET_SECONDS
```
public static final HazelcastProperty MAX_JOIN_MERGE_TARGET_SECONDS
```
  - HEARTBEAT_INTERVAL_SECONDS
```
public static final HazelcastProperty HEARTBEAT_INTERVAL_SECONDS
```
    The interval at which member heartbeat messages are sent
  - MASTERSHIP_CLAIM_TIMEOUT_SECONDS
```
public static final HazelcastProperty MASTERSHIP_CLAIM_TIMEOUT_SECONDS
```
    The timeout which defines when master candidate gives up waiting for response to its mastership claim. After timeout happens, non-responding member will be removed from member list.
  - MAX_NO_HEARTBEAT_SECONDS
```
public static final HazelcastProperty MAX_NO_HEARTBEAT_SECONDS
```
    The timeout which defines when a cluster member is removed because it has not sent any heartbeats.
  - MASTER_CONFIRMATION_INTERVAL_SECONDS
```
@Deprecated
public static final HazelcastProperty MASTER_CONFIRMATION_INTERVAL_SECONDS
```
    Deprecated. since 3.10
    
    The interval at which master confirmations are sent from non-master nodes to the master node
  - MAX_NO_MASTER_CONFIRMATION_SECONDS
```
@Deprecated
public static final HazelcastProperty MAX_NO_MASTER_CONFIRMATION_SECONDS
```
    Deprecated. since 3.10
    
    The timeout which defines when a cluster member is removed because it has not sent any master confirmations.
  - HEARTBEAT_FAILURE_DETECTOR_TYPE
```
public static final HazelcastProperty HEARTBEAT_FAILURE_DETECTOR_TYPE
```
    Heartbeat failure detector type. Available options are:
    - deadline: A deadline based failure detector uses an absolute timeout for missing/lost heartbeats. After timeout member is considered as dead/unavailable.
    - phi-accrual: Implementation of 'The Phi Accrual Failure Detector' by Hayashibara et al. as defined in their paper. Phi Accrual Failure Detector is adaptive to network/environment conditions, that's why a lower MAX_NO_HEARTBEAT_SECONDS (for example 10 or 15 seconds) can be used to provide faster detection of unavailable members.
    Default failure detector is deadline.
  - MEMBER_LIST_PUBLISH_INTERVAL_SECONDS
```
public static final HazelcastProperty MEMBER_LIST_PUBLISH_INTERVAL_SECONDS
```
    The interval at which the master sends the member lists are sent to other non-master members
  - CLIENT_HEARTBEAT_TIMEOUT_SECONDS
```
public static final HazelcastProperty CLIENT_HEARTBEAT_TIMEOUT_SECONDS
```
  - CLUSTER_SHUTDOWN_TIMEOUT_SECONDS
```
public static final HazelcastProperty CLUSTER_SHUTDOWN_TIMEOUT_SECONDS
```
  - ICMP_ENABLED
```
public static final HazelcastProperty ICMP_ENABLED
```
    Deprecated. as of 3.10 this can be configured through IcmpFailureDetectorConfig This will be removed in future versions. Until this is done, if the IcmpFailureDetectorConfig is null we will still fall back to this
    
    If a member should be pinged when a sufficient amount of heartbeats have passed and the member has not sent any heartbeats. If the member is not reachable, it will be removed.
  - ICMP_PARALLEL_MODE
```
public static final HazelcastProperty ICMP_PARALLEL_MODE
```
    Deprecated. as of 3.10 this can be configured through IcmpFailureDetectorConfig This will be removed in future versions. Until this is done, if the IcmpFailureDetectorConfig is null we will still fall back to this
    
    Run ICMP detection in parallel with the Heartbeat failure detector.
  - ICMP_ECHO_FAIL_FAST
```
public static final HazelcastProperty ICMP_ECHO_FAIL_FAST
```
    Deprecated. as of 3.10 this can be configured through IcmpFailureDetectorConfig This will be removed in future versions. Until this is done, if the IcmpFailureDetectorConfig is null we will still fall back to this
    
    Enforce ICMP Echo Request mode for ping-detector. If OS is not supported, or not configured correctly as per reference-manual, hazelcast will fail to start.
  - ICMP_TIMEOUT
```
public static final HazelcastProperty ICMP_TIMEOUT
```
    Deprecated. as of 3.10 this can be configured through IcmpFailureDetectorConfig This will be removed in future versions. Until this is done, if the IcmpFailureDetectorConfig is null we will still fall back to this
    
    Ping timeout in milliseconds. This cannot be more than the interval value. Should always be smaller.
  - ICMP_INTERVAL
```
public static final HazelcastProperty ICMP_INTERVAL
```
    Deprecated. as of 3.10 this can be configured through IcmpFailureDetectorConfig This will be removed in future versions. Until this is done, if the IcmpFailureDetectorConfig is null we will still fall back to this
    
    Interval between ping attempts in milliseconds. Default and min allowed, 1 second.
  - ICMP_MAX_ATTEMPTS
```
public static final HazelcastProperty ICMP_MAX_ATTEMPTS
```
    Deprecated. as of 3.10 this can be configured through IcmpFailureDetectorConfig This will be removed in future versions. Until this is done, if the IcmpFailureDetectorConfig is null we will still fall back to this
    
    Max ping attempts before suspecting a member
  - ICMP_TTL
```
public static final HazelcastProperty ICMP_TTL
```
    Deprecated. as of 3.10 this can be configured through IcmpFailureDetectorConfig This will be removed in future versions. Until this is done, if the IcmpFailureDetectorConfig is null we will still fall back to this
    
    Ping TTL, the maximum number of hops the packets should go through or 0 for the default. Zero in this case means unlimited hops.
  - INITIAL_MIN_CLUSTER_SIZE
```
public static final HazelcastProperty INITIAL_MIN_CLUSTER_SIZE
```
  - INITIAL_WAIT_SECONDS
```
public static final HazelcastProperty INITIAL_WAIT_SECONDS
```
  - TCP_JOIN_PORT_TRY_COUNT
```
public static final HazelcastProperty TCP_JOIN_PORT_TRY_COUNT
```
    The number of incremental ports, starting with port number defined in network configuration, that will be used to connect to a host which is defined without a port in the TCP-IP member list while a node is searching for a cluster.
  - MAP_REPLICA_SCHEDULED_TASK_DELAY_SECONDS
```
public static final HazelcastProperty MAP_REPLICA_SCHEDULED_TASK_DELAY_SECONDS
```
  - MAP_EXPIRY_DELAY_SECONDS
```
public static final HazelcastProperty MAP_EXPIRY_DELAY_SECONDS
```
    You can use MAP_EXPIRY_DELAY_SECONDS to deal with some possible edge cases, such as using EntryProcessor. Without this delay, you may see that an EntryProcessor running on the owner partition found a key, but EntryBackupProcessor did not find it on backup, and as a result when backup promotes to owner you will end up with an unprocessed key.
  - MAP_EVICTION_BATCH_SIZE
```
public static final HazelcastProperty MAP_EVICTION_BATCH_SIZE
```
    Maximum number of IMap entries Hazelcast will evict during a single eviction cycle. Eviction cycle is triggered by a map mutation. Typically it's OK to evict at most a single entry. However imagine the scenario where you are inserting values in a loop and in each iteration you double entry size. In this situation Hazelcast has to evict more than just a single entry - as all existing entries are smaller than the entry which is about to be added and removing any old entry cannot make sufficient room for the new entry. Default: 1
  - MAP_LOAD_ALL_PUBLISHES_ADDED_EVENT
```
public static final HazelcastProperty MAP_LOAD_ALL_PUBLISHES_ADDED_EVENT
```
    This property is a switch between old and new event publishing behavior of map#loadAll. When it is true, map#loadAll publishes entry ADDED events, when false, map#loadAll publishes entry LOADED events. By default LOADED events will be published.
    
    Since:
    
    3.11
  - LOGGING_TYPE
```
public static final HazelcastProperty LOGGING_TYPE
```
  - ENABLE_JMX
```
public static final HazelcastProperty ENABLE_JMX
```
  - JMX_UPDATE_INTERVAL_SECONDS
```
public static final HazelcastProperty JMX_UPDATE_INTERVAL_SECONDS
```
  - MC_MAX_VISIBLE_SLOW_OPERATION_COUNT
```
public static final HazelcastProperty MC_MAX_VISIBLE_SLOW_OPERATION_COUNT
```
  - MC_URL_CHANGE_ENABLED
```
@Deprecated
public static final HazelcastProperty MC_URL_CHANGE_ENABLED
```
    Deprecated. Enable or disable the RestEndpointGroup.CLUSTER_WRITE group in RestApiConfig instead.
  - CONNECTION_MONITOR_INTERVAL
```
public static final HazelcastProperty CONNECTION_MONITOR_INTERVAL
```
  - CONNECTION_MONITOR_MAX_FAULTS
```
public static final HazelcastProperty CONNECTION_MONITOR_MAX_FAULTS
```
  - PARTITION_MIGRATION_INTERVAL
```
public static final HazelcastProperty PARTITION_MIGRATION_INTERVAL
```
    Time in seconds to sleep after a migration task.
  - PARTITION_MIGRATION_TIMEOUT
```
public static final HazelcastProperty PARTITION_MIGRATION_TIMEOUT
```
    Timeout in seconds for all migration operations.
  - PARTITION_FRAGMENTED_MIGRATION_ENABLED
```
public static final HazelcastProperty PARTITION_FRAGMENTED_MIGRATION_ENABLED
```
  - DISABLE_STALE_READ_ON_PARTITION_MIGRATION
```
public static final HazelcastProperty DISABLE_STALE_READ_ON_PARTITION_MIGRATION
```
  - PARTITION_TABLE_SEND_INTERVAL
```
public static final HazelcastProperty PARTITION_TABLE_SEND_INTERVAL
```
  - PARTITION_BACKUP_SYNC_INTERVAL
```
public static final HazelcastProperty PARTITION_BACKUP_SYNC_INTERVAL
```
  - PARTITION_MAX_PARALLEL_REPLICATIONS
```
public static final HazelcastProperty PARTITION_MAX_PARALLEL_REPLICATIONS
```
  - PARTITIONING_STRATEGY_CLASS
```
public static final HazelcastProperty PARTITIONING_STRATEGY_CLASS
```
  - GRACEFUL_SHUTDOWN_MAX_WAIT
```
public static final HazelcastProperty GRACEFUL_SHUTDOWN_MAX_WAIT
```
  - SLOW_OPERATION_DETECTOR_ENABLED
```
public static final HazelcastProperty SLOW_OPERATION_DETECTOR_ENABLED
```
    Enables or disables the SlowOperationDetector.
  - SLOW_OPERATION_DETECTOR_THRESHOLD_MILLIS
```
public static final HazelcastProperty SLOW_OPERATION_DETECTOR_THRESHOLD_MILLIS
```
    Defines a threshold above which a running operation in OperationService is considered to be slow. These operations will log a warning and will be shown in the Management Center with detailed information, e.g. stacktrace.
  - SLOW_OPERATION_DETECTOR_LOG_RETENTION_SECONDS
```
public static final HazelcastProperty SLOW_OPERATION_DETECTOR_LOG_RETENTION_SECONDS
```
    This value defines the retention time of invocations in slow operation logs.
    If an invocation is older than this value, it will be purged from the log to prevent unlimited memory usage. When all invocations are purged from a log, the log itself will be deleted.
    
    See Also:
    
    SLOW_OPERATION_DETECTOR_LOG_PURGE_INTERVAL_SECONDS
  - SLOW_OPERATION_DETECTOR_LOG_PURGE_INTERVAL_SECONDS
```
public static final HazelcastProperty SLOW_OPERATION_DETECTOR_LOG_PURGE_INTERVAL_SECONDS
```
    Purge interval for slow operation logs.
    
    See Also:
    
    SLOW_OPERATION_DETECTOR_LOG_RETENTION_SECONDS
  - SLOW_OPERATION_DETECTOR_STACK_TRACE_LOGGING_ENABLED
```
public static final HazelcastProperty SLOW_OPERATION_DETECTOR_STACK_TRACE_LOGGING_ENABLED
```
    Defines if the stacktraces of slow operations are logged in the log file. Stacktraces will always be reported to the Management Center, but by default they are not printed to keep the log size small.
  - SLOW_INVOCATION_DETECTOR_THRESHOLD_MILLIS
```
@Deprecated
public static final HazelcastProperty SLOW_INVOCATION_DETECTOR_THRESHOLD_MILLIS
```
    Deprecated.
    
    Property isn't used anymore.
  - LOCK_MAX_LEASE_TIME_SECONDS
```
public static final HazelcastProperty LOCK_MAX_LEASE_TIME_SECONDS
```
  - ENTERPRISE_LICENSE_KEY
```
public static final HazelcastProperty ENTERPRISE_LICENSE_KEY
```
  - MAP_WRITE_BEHIND_QUEUE_CAPACITY
```
public static final HazelcastProperty MAP_WRITE_BEHIND_QUEUE_CAPACITY
```
    Setting this capacity is valid if you set MapStoreConfig.writeCoalescing to false. Otherwise its value will not be taken into account.
    The per node maximum write-behind queue capacity is the total of all write-behind queue sizes in a node, including backups.
    The maximum value which can be set is Integer.MAX_VALUE
  - CACHE_INVALIDATION_MESSAGE_BATCH_ENABLED
```
public static final HazelcastProperty CACHE_INVALIDATION_MESSAGE_BATCH_ENABLED
```
    Defines cache invalidation event batch sending is enabled or not.
  - CACHE_INVALIDATION_MESSAGE_BATCH_SIZE
```
public static final HazelcastProperty CACHE_INVALIDATION_MESSAGE_BATCH_SIZE
```
    Defines the maximum number of cache invalidation events to be drained and sent to the event listeners in a batch.
  - CACHE_INVALIDATION_MESSAGE_BATCH_FREQUENCY_SECONDS
```
public static final HazelcastProperty CACHE_INVALIDATION_MESSAGE_BATCH_FREQUENCY_SECONDS
```
    Defines the cache invalidation event batch sending frequency in seconds.
    When the number of events do not come up to CACHE_INVALIDATION_MESSAGE_BATCH_SIZE in the given time period (which is defined by this property); those events are gathered into a batch and sent to target.
  - MAP_INVALIDATION_MESSAGE_BATCH_ENABLED
```
public static final HazelcastProperty MAP_INVALIDATION_MESSAGE_BATCH_ENABLED
```
    Defines Near Cache invalidation event batch sending is enabled or not.
  - MAP_INVALIDATION_MESSAGE_BATCH_SIZE
```
public static final HazelcastProperty MAP_INVALIDATION_MESSAGE_BATCH_SIZE
```
    Defines the maximum number of Near Cache invalidation events to be drained and sent to the event Near Cache in a batch.
  - MAP_INVALIDATION_MESSAGE_BATCH_FREQUENCY_SECONDS
```
public static final HazelcastProperty MAP_INVALIDATION_MESSAGE_BATCH_FREQUENCY_SECONDS
```
    Defines the Near Cache invalidation event batch sending frequency in seconds.
    When the number of events do not come up to MAP_INVALIDATION_MESSAGE_BATCH_SIZE in the given time period (which is defined by this property); those events are gathered into a batch and sent to target.
  - BACKPRESSURE_ENABLED
```
public static final HazelcastProperty BACKPRESSURE_ENABLED
```
    Using back pressure, you can prevent an overload of pending asynchronous backups. With a map with a single asynchronous backup, producing asynchronous backups could happen at a higher rate than the consumption of the backup. This can eventually lead to an OOME (especially if the backups are slow).
    With back-pressure enabled, this can't happen.
    Back pressure is implemented by making asynchronous backups operations synchronous. This prevents the internal queues from overflowing because the invoker will wait for the primary and for the backups to complete. The frequency of this is determined by the sync-window. To deal with overloads of backups, the property 'hazelcast.operation.backup.timeout.millis' should be set to a larger value; above 60000 is recommended. Otherwise it can still happen backups accumulate.
  - BACKPRESSURE_SYNCWINDOW
```
public static final HazelcastProperty BACKPRESSURE_SYNCWINDOW
```
    Controls the frequency of a BackupAwareOperation getting its async backups converted to a sync backups. This is needed to prevent an accumulation of asynchronous backups and eventually running into stability issues.
    A sync window of 10 means that 1 in 10 BackupAwareOperations get their async backups convert to sync backups.
    A sync window of 1 means that every BackupAwareOperation get their async backups converted to sync backups. 1 is also the smallest legal value for the sync window.
    There is some randomization going on to prevent resonance. Therefore, with a sync window of n, not every Nth BackupAwareOperation operation gets its async backups converted to sync.
    This property only has meaning when backpressure is enabled.
  - BACKPRESSURE_BACKOFF_TIMEOUT_MILLIS
```
public static final HazelcastProperty BACKPRESSURE_BACKOFF_TIMEOUT_MILLIS
```
    Control the maximum timeout in millis to wait for an invocation space to be available.
    If an invocation can't be made because there are too many pending invocations, then an exponential backoff is done to give the system time to deal with the backlog of invocations. This property controls how long an invocation is allowed to wait before getting a HazelcastOverloadException.
    The value needs to be equal or larger than 0.
  - BACKPRESSURE_MAX_CONCURRENT_INVOCATIONS_PER_PARTITION
```
public static final HazelcastProperty BACKPRESSURE_MAX_CONCURRENT_INVOCATIONS_PER_PARTITION
```
    The maximum number of concurrent invocations per partition.
    To prevent the system from overloading, HZ can apply a constraint on the number of concurrent invocations. If the maximum number of concurrent invocations has been exceeded and a new invocation comes in, then an exponential back-off is applied till eventually a timeout happens or there is room for the invocation.
    By default it is configured as 100. With 271 partitions, that would give (271 + 1) * 100 = 27200 concurrent invocations from a single member. The +1 is for generic operations. The reasons why 100 is chosen are: - there can be concurrent operations that touch a lot of partitions which consume more than 1 invocation, and - certain methods like those from the IExecutor or ILock are also invocations and they can be very long running.
    No promise is made for the invocations being tracked per partition, or if there is a general pool of invocations.
  - QUERY_PREDICATE_PARALLEL_EVALUATION
```
public static final HazelcastProperty QUERY_PREDICATE_PARALLEL_EVALUATION
```
    Run Query Evaluations for multiple partitions in parallel.
    Each Hazelcast member evaluates query predicates using a single thread by default. In most cases the overhead of inter-thread communication overweight benefit of parallel execution.
    When you have a large dataset and/or slow predicate you may benefit from parallel predicate evaluations. Set to true if you are using slow predicates or have > 100,000s entries per member.
    The default is false.
  - AGGREGATION_ACCUMULATION_PARALLEL_EVALUATION
```
public static final HazelcastProperty AGGREGATION_ACCUMULATION_PARALLEL_EVALUATION
```
    Run aggregation accumulation for multiple entries in parallel.
    Each Hazelcast member executes the accumulation stage of an aggregation using a single thread by default. In most cases it pays off to do it in parallel.
    The default is true.
  - QUERY_RESULT_SIZE_LIMIT
```
public static final HazelcastProperty QUERY_RESULT_SIZE_LIMIT
```
    Result size limit for query operations on maps.
    This value defines the maximum number of returned elements for a single query result. If a query exceeds this number of elements, a QueryResultSizeExceededException will be thrown.
    This feature prevents an OOME if a single node is requesting the whole data set of the cluster, such as by executing a query with TruePredicate. This applies internally for the IMap.values(), IMap.keySet() and IMap.entrySet() methods, which are good candidates for OOME in large clusters.
    This feature depends on an equal distribution of the data on the cluster nodes to calculate the result size limit per node. Therefore, there is a minimum value of defined in QueryResultSizeLimiter. Configured values below the minimum will be increased to the minimum.
    The feature can be disabled by setting its value to -1 (which is the default value).
  - QUERY_MAX_LOCAL_PARTITION_LIMIT_FOR_PRE_CHECK
```
public static final HazelcastProperty QUERY_MAX_LOCAL_PARTITION_LIMIT_FOR_PRE_CHECK
```
    Maximum value of local partitions to trigger local pre-check for TruePredicate query operations on maps.
    To limit the result size of a query (PROP_QUERY_RESULT_SIZE_LIMIT); a local pre-check on the requesting node can be done before the query is sent to the cluster. Since this may increase the latency, the pre-check is limited to a maximum number of local partitions.
    By increasing this parameter, you can prevent the execution of the query on the cluster. Increasing this parameter increases the latency due to the prolonged local pre-check.
    The pre-check can be disabled by setting the value to -1.
    
    See Also:
    
    QUERY_RESULT_SIZE_LIMIT
  - QUERY_OPTIMIZER_TYPE
```
public static final HazelcastProperty QUERY_OPTIMIZER_TYPE
```
    Type of Query Optimizer. Valid Values:
    - RULES - for optimizations based on static rules
    - NONE - optimization are disabled
    Values are case sensitive
  - INDEX_COPY_BEHAVIOR
```
public static final HazelcastProperty INDEX_COPY_BEHAVIOR
```
    Type of Query Index result copying behavior. Defines the behavior for index copying on index read/write. Supported in BINARY and OBJECT in-memory-formats. Ignored in NATIVE in-memory-format. Why is it needed? In order to support correctness the internal data-structures used by indexes need to do some copying. The copying may take place on-read or on-write: -> Copying on-read means that each index-read operation will copy the result of the query before returning it to the caller.This copying may be expensive, depending on the size of the result, since the result is stored in a map, which means that all entries need to have the hash calculated before being stored in a bucket. Each index-write operation however will be fast, since there will be no copying taking place. -> Copying on-write means that each index-write operation will completely copy the underlying map to provide the copy-on-write semantics. Depending on the index size, it may be a very expensive operation. Each index-read operation will be very fast, however, since it may just access the map and return it to the caller. -> Never copying is tricky. It means that the internal data structures of the index are concurrently modified without copy-on-write semantics. Index reads never copy the results of a query to a separate map. It means that the results backed by the underlying index-map can change after the query has been executed. Specifically an entry might have been added / removed from an index, or it might have been remapped. Should be used in cases when a the caller expects "mostly correct" results - specifically, if it's ok if some entries returned in the result set do not match the initial query criteria. The fastest solution for read and writes, since no copying takes place. It's a tuneable trade-off - the user may decide. Valid Values:
    - COPY_ON_READY - Internal data structures of the index are concurrently modified without copy-on-write semantics. Index queries copy the results of a query on index read to detach the result from the source map. Should be used in index-write intensive cases, since the reads will slow down due to the copying. Default value.
    - COPY_ON_WRITE - Internal data structures of the index are modified with copy-on-write semantics. Previously returned index query results reflect the state of the index at the time of the query and are not affected by future index modifications. Should be used in index-read intensive cases, since the writes will slow down due to the copying.
    - NEVER - Internal data structures of the index are concurrently modified without copy-on-write semantics. Index reads never copy the results of a query to a separate map. It means that the results backed by the underlying index-map can change after the query has been executed. Specifically an entry might have been added / removed from an index, or it might have been remapped. Should be used in cases when a the caller expects "mostly correct" results - specifically, if it's ok if some entries returned in the result set do not match the initial query criteria. The fastest solution for read and writes, since no copying takes place.
  - JCACHE_PROVIDER_TYPE
```
public static final HazelcastProperty JCACHE_PROVIDER_TYPE
```
    Forces the JCache provider, which can have values client or server, to force the provider type. If not provided, the provider will be client or server, whichever is found on the classpath first respectively.
  - DISCOVERY_SPI_ENABLED
```
public static final HazelcastProperty DISCOVERY_SPI_ENABLED
```
    Enables the Discovery SPI lookup over the old native implementations. This property is temporary and will eventually be removed when the experimental marker is removed.
    
    Discovery SPI is disabled by default
  - DISCOVERY_SPI_PUBLIC_IP_ENABLED
```
public static final HazelcastProperty DISCOVERY_SPI_PUBLIC_IP_ENABLED
```
    Enables the Discovery Joiner to use public ips from DiscoveredNode. This property is temporary and will eventually be removed when the experimental marker is removed.
    
    Discovery SPI is disabled by default
  - COMPATIBILITY_3_6_CLIENT_ENABLED
```
public static final HazelcastProperty COMPATIBILITY_3_6_CLIENT_ENABLED
```
    When this property is true, if the server can not determine the connected client version, it shall assume that it is of 3.6.x version client. This property is especially needed if you are using ICache (or JCache).
  - SERIALIZATION_VERSION
```
public static final HazelcastProperty SERIALIZATION_VERSION
```
    Hazelcast serialization version. This is single byte value between 1 and Max supported serialization version.
    
    See Also:
    
    BuildInfo.getSerializationVersion()
  - INIT_CLUSTER_VERSION
```
public static final HazelcastProperty INIT_CLUSTER_VERSION
```
    Override cluster version to use while node is not yet member of a cluster. The cluster version assumed before joining a cluster may affect the serialization format of cluster discovery & join operations and its compatibility with members of a cluster running on different Hazelcast codebase versions. The default is to use the node's codebase version. You may need to override it for your node to join a cluster running on a previous cluster version.
  - USE_LEGACY_MEMBER_LIST_FORMAT
```
public static final HazelcastProperty USE_LEGACY_MEMBER_LIST_FORMAT
```
    Enables legacy (pre-3.9) member list format which is printed in logs. New format is introduced by 3.9 includes member list version.
  - BIND_SPOOFING_CHECKS
```
public static final HazelcastProperty BIND_SPOOFING_CHECKS
```
    Controls whether we apply more strict checks upon BIND requests towards a cluster member. The checks mainly validate the remote BIND request against the remote address as found in the socket. By default they are disabled, to avoid connectivity issues when deployed under NAT'ed infrastructure.
  - TASK_SCHEDULER_REMOVE_ON_CANCEL
```
public static final HazelcastProperty TASK_SCHEDULER_REMOVE_ON_CANCEL
```
    This is a Java 6 specific property. In Java 7+ tasks are always removed on cancellation due to the explicit java.util.concurrent.ScheduledThreadPoolExecutor#setRemoveOnCancelPolicy(boolean) and constant time removal. In Java 6 there is no out-of-the-box support for removal of cancelled tasks, and the only way to implement this is using a linear scan of all pending tasks. Therefore in Java 6 there is a performance penalty. Using this property, in Java 6, one can control if cancelled tasks are removed. By default tasks are removed, because it can lead to temporary retention of memory if there a large volume of pending cancelled tasks. And this can lead to gc/performance problems as we saw with the transaction tests. However if this automatic removal of cancelled tasks start to become a performance problem, it can be disabled in Java 6. For more information see the LoggingScheduledExecutor.
  - SEARCH_DYNAMIC_CONFIG_FIRST
```
public static final HazelcastProperty SEARCH_DYNAMIC_CONFIG_FIRST
```
    By default, search for data structures config is performed within static configuration first:
    - Exact match in static config
    - Wildcard match in static config
    - Exact match in dynamic config
    - Wildcard match in dynamic config
    - Fallback to default
    But sometimes it makes sense to perform search within dynamic configs first. If this property is set to true, search algorithm changes to:
    - Exact match in dynamic config
    - Wildcard match in dynamic config
    - Exact match in static config
    - Wildcard match in static config
    - Fallback to default

Class GroupProperty

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

APPLICATION_VALIDATION_TOKEN

PARTITION_COUNT

PARTITION_OPERATION_THREAD_COUNT

GENERIC_OPERATION_THREAD_COUNT

PRIORITY_GENERIC_OPERATION_THREAD_COUNT

RESPONSE_THREAD_COUNT

CLIENT_ENGINE_THREAD_COUNT

CLIENT_ENGINE_QUERY_THREAD_COUNT

CLIENT_ENGINE_BLOCKING_THREAD_COUNT

CLIENT_ENDPOINT_REMOVE_DELAY_SECONDS

EVENT_THREAD_COUNT

EVENT_QUEUE_CAPACITY

EVENT_QUEUE_TIMEOUT_MILLIS

EVENT_SYNC_TIMEOUT_MILLIS

HEALTH_MONITORING_LEVEL

HEALTH_MONITORING_DELAY_SECONDS

HEALTH_MONITORING_THRESHOLD_MEMORY_PERCENTAGE

HEALTH_MONITORING_THRESHOLD_CPU_PERCENTAGE

IO_THREAD_COUNT

IO_INPUT_THREAD_COUNT

IO_OUTPUT_THREAD_COUNT

IO_BALANCER_INTERVAL_SECONDS

PREFER_IPv4_STACK

VERSION_CHECK_ENABLED

PHONE_HOME_ENABLED

CONNECT_ALL_WAIT_SECONDS

MEMCACHE_ENABLED

REST_ENABLED

HTTP_HEALTHCHECK_ENABLED

MAP_LOAD_CHUNK_SIZE

MERGE_FIRST_RUN_DELAY_SECONDS

MERGE_NEXT_RUN_DELAY_SECONDS

OPERATION_CALL_TIMEOUT_MILLIS

OPERATION_BACKUP_TIMEOUT_MILLIS

FAIL_ON_INDETERMINATE_OPERATION_STATE

INVOCATION_MAX_RETRY_COUNT

INVOCATION_RETRY_PAUSE

SOCKET_BIND_ANY

SOCKET_SERVER_BIND_ANY

SOCKET_CLIENT_BIND_ANY

SOCKET_CLIENT_BIND

SOCKET_RECEIVE_BUFFER_SIZE

SOCKET_SEND_BUFFER_SIZE

SOCKET_BUFFER_DIRECT

SOCKET_CLIENT_RECEIVE_BUFFER_SIZE

SOCKET_CLIENT_SEND_BUFFER_SIZE

SOCKET_CLIENT_BUFFER_DIRECT

SOCKET_LINGER_SECONDS

SOCKET_CONNECT_TIMEOUT_SECONDS

SOCKET_KEEP_ALIVE

SOCKET_NO_DELAY

SHUTDOWNHOOK_ENABLED

SHUTDOWNHOOK_POLICY

WAIT_SECONDS_BEFORE_JOIN

MAX_WAIT_SECONDS_BEFORE_JOIN

MAX_JOIN_SECONDS

MAX_JOIN_MERGE_TARGET_SECONDS

HEARTBEAT_INTERVAL_SECONDS

MASTERSHIP_CLAIM_TIMEOUT_SECONDS

MAX_NO_HEARTBEAT_SECONDS

MASTER_CONFIRMATION_INTERVAL_SECONDS

MAX_NO_MASTER_CONFIRMATION_SECONDS

HEARTBEAT_FAILURE_DETECTOR_TYPE

MEMBER_LIST_PUBLISH_INTERVAL_SECONDS

CLIENT_HEARTBEAT_TIMEOUT_SECONDS

CLUSTER_SHUTDOWN_TIMEOUT_SECONDS

ICMP_ENABLED

ICMP_PARALLEL_MODE

ICMP_ECHO_FAIL_FAST

ICMP_TIMEOUT

ICMP_INTERVAL

ICMP_MAX_ATTEMPTS

ICMP_TTL

INITIAL_MIN_CLUSTER_SIZE

INITIAL_WAIT_SECONDS