Package com.hazelcast.spi.properties

Class ClusterProperty

java.lang.Object
com.hazelcast.spi.properties.ClusterProperty
public final class ClusterProperty extends Object
Defines the name and default value for Hazelcast properties.

  • Field Details

    • NETWORK_STATS_REFRESH_INTERVAL_SECONDS

      public static final HazelcastProperty NETWORK_STATS_REFRESH_INTERVAL_SECONDS
      The interval at which network stats (bytes sent and received) are re-calculated and published. Used only when Advanced Networking is enabled.

    • CHANNEL_COUNT

      public static final HazelcastProperty CHANNEL_COUNT
      Number of parallel connection between members.

      There is no point in having more connections than IO threads.

    • 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
      Prefer IPv4 network interface when picking a local address.

    • SOCKET_BIND_ANY

      public static final HazelcastProperty SOCKET_BIND_ANY
      Bind both server-socket and client-sockets to any local interface.

    • SOCKET_SERVER_BIND_ANY

      public static final HazelcastProperty SOCKET_SERVER_BIND_ANY
      Bind server-socket to any local interface. If not set, SOCKET_BIND_ANY is used as the default.

    • SOCKET_CLIENT_BIND_ANY

      public static final HazelcastProperty SOCKET_CLIENT_BIND_ANY
      Bind client-sockets to any local interface. If not set, SOCKET_BIND_ANY is used as the default.

    • SOCKET_CLIENT_BIND

      public static final HazelcastProperty SOCKET_CLIENT_BIND
      Bind client socket to an interface when connecting to a remote server socket. When set to false, client socket is not bound to any interface.

    • SOCKET_RECEIVE_BUFFER_SIZE

      public static final HazelcastProperty SOCKET_RECEIVE_BUFFER_SIZE
      Socket receive buffer (SO_RCVBUF) size in KB. If you have a very fast network, e.g., 10gbit) and/or you have large entries, then you may benefit from increasing sender/receiver buffer sizes. Use this property and the next one below tune the size.

    • SOCKET_SEND_BUFFER_SIZE

      public static final HazelcastProperty SOCKET_SEND_BUFFER_SIZE
      Socket send buffer (SO_SNDBUF) size in KB.

    • 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 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 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
      If the bytebuffers used in the socket should be a direct bytebuffer (true) or a regular bytebuffer (false).

    • SOCKET_LINGER_SECONDS

      public static final HazelcastProperty SOCKET_LINGER_SECONDS
      Set socket SO_LINGER option.

    • SOCKET_CONNECT_TIMEOUT_SECONDS

      public static final HazelcastProperty SOCKET_CONNECT_TIMEOUT_SECONDS
      Socket connection timeout in seconds. Socket.connect() is blocked until either connection is established or connection is refused or this timeout passes. Default is 10, 0 means infinite.

    • SOCKET_KEEP_ALIVE

      public static final HazelcastProperty SOCKET_KEEP_ALIVE
      Socket set keep alive (SO_KEEPALIVE).

    • SOCKET_KEEP_IDLE

      public static final HazelcastProperty SOCKET_KEEP_IDLE
      Keep-Alive idle time: the number of seconds of idle time before keep-alive initiates a probe.

      Caveats:

      Since:
      5.3.0
      See Also:

    • SOCKET_KEEP_INTERVAL

      public static final HazelcastProperty SOCKET_KEEP_INTERVAL
      Keep-Alive interval: the number of seconds between keep-alive probes.

      Caveats:

      Since:
      5.3.0
      See Also:

    • SOCKET_KEEP_COUNT

      public static final HazelcastProperty SOCKET_KEEP_COUNT
      Keep-Alive count: the maximum number of TCP keep-alive probes to send before giving up and closing the connection if no response is obtained from the other side.

      Caveats:

      Since:
      5.3.0
      See Also:

    • SOCKET_NO_DELAY

      public static final HazelcastProperty SOCKET_NO_DELAY
      Socket set TCP no delay.

    • 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 depends on the number of available processors. If the available processors count is smaller than 20, there will be 3+3 io threads, otherwise 4+4.

      If SSL is enabled, then the default number of IO threads will be corecount/2.

    • 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_WRITE_THROUGH_ENABLED

      public static final HazelcastProperty IO_WRITE_THROUGH_ENABLED
      Optimization that allows sending of packets over the network to be done on the calling thread if the conditions are right. This can reduce latency and increase performance for low threaded environments.

      It is enabled by default.

    • CONCURRENT_WINDOW_MS

      public static final HazelcastProperty CONCURRENT_WINDOW_MS
      Property needed for concurrency detection so that write through can be done correctly. This property sets the window the concurrency detection will signalling that concurrency has been detected, even if there are no further updates in that window.

      Normally in a concurrent system the window keeps sliding forward so it will always remain concurrent.

      Setting it too high effectively disables the optimization because once concurrency has been detected it will keep that way. Setting it too low could lead to suboptimal performance because the system will try write through and other optimizations even though the system is concurrent.

    • CONNECTION_MONITOR_INTERVAL

      public static final HazelcastProperty CONNECTION_MONITOR_INTERVAL
      Minimum interval in milliseconds to consider a connection error as critical.

    • CONNECTION_MONITOR_MAX_FAULTS

      public static final HazelcastProperty CONNECTION_MONITOR_MAX_FAULTS
      Maximum I/O error count before disconnecting from a member.

    • CLIENT_PROTOCOL_UNVERIFIED_MESSAGE_BYTES

      public static final HazelcastProperty CLIENT_PROTOCOL_UNVERIFIED_MESSAGE_BYTES
      Client protocol message size limit (in bytes) for unverified connections (i.e. maximal length of authentication message).

    • PARTITION_COUNT

      public static final HazelcastProperty PARTITION_COUNT
      Total number of partitions in the Hazelcast cluster.

    • INITIAL_MIN_CLUSTER_SIZE

      public static final HazelcastProperty INITIAL_MIN_CLUSTER_SIZE
      Initial expected cluster size to wait before member to start completely.

    • INITIAL_WAIT_SECONDS

      public static final HazelcastProperty INITIAL_WAIT_SECONDS
      Initial time in seconds to wait before member to start completely.

    • 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.

    • TCP_PREVIOUSLY_JOINED_MEMBER_ADDRESS_RETENTION_DURATION

      public static final HazelcastProperty TCP_PREVIOUSLY_JOINED_MEMBER_ADDRESS_RETENTION_DURATION
      Specifies how long the address of a member that has previously joined the cluster will be retained/remembered in the TcpIpJoiner after it leaves the cluster. The remembered member addresses is used to discover other cluster by split-brain handler.

    • MULTICAST_SOCKET_SET_INTERFACE

      public static final HazelcastProperty MULTICAST_SOCKET_SET_INTERFACE
      Allows explicitly control if the MulticastSocket.setInterface(java.net.InetAddress) method is called in the Hazelcast multicast discovery service. This configuration may affect the multicast behavior on some platforms. The default value is not specified here and in such case Hazelcast multicast service itself decides if the setInterface() call should be called.

    • MULTICAST_GROUP

      public static final HazelcastProperty MULTICAST_GROUP
      IP address of a multicast group. If not set, then the configuration is read from the MulticastConfig configuration.

    • CONNECT_ALL_WAIT_SECONDS

      public static final HazelcastProperty CONNECT_ALL_WAIT_SECONDS
      Timeout to connect all other cluster members when a member is joining to a cluster.

    • DISCOVERY_SPI_ENABLED

      public static final HazelcastProperty DISCOVERY_SPI_ENABLED

      Enables the Discovery SPI lookup

      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 IP from DiscoveredNode.

      Discovery SPI is disabled by default

    • MERGE_FIRST_RUN_DELAY_SECONDS

      public static final HazelcastProperty MERGE_FIRST_RUN_DELAY_SECONDS
      The delay until the first run of the split-brain handler.

    • MERGE_NEXT_RUN_DELAY_SECONDS

      public static final HazelcastProperty MERGE_NEXT_RUN_DELAY_SECONDS
      The interval between invocations of the split-brain handler.

    • 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
      When enabled, which is the default behavior, partitions are migrated/replicated in small fragments instead of one big chunk. Migrating partitions in fragments reduces pressure on the memory and network since smaller packets are created in the memory and sent through the network. Note that it can increase the migration time to complete.

    • PARTITION_CHUNKED_MIGRATION_ENABLED

      public static final HazelcastProperty PARTITION_CHUNKED_MIGRATION_ENABLED
      Enable to subdivide fragments into chunks.

      Default enabled.

      See Also:

    • PARTITION_CHUNKED_MAX_MIGRATING_DATA_IN_MB

      public static final HazelcastProperty PARTITION_CHUNKED_MAX_MIGRATING_DATA_IN_MB
      Total size of all chunks in bytes during a single partition migration.

      If you have parallel migrations, max migrating data equals number-of-parallel-migrations times this value.

      Default is 250 MB.

    • WAIT_SECONDS_BEFORE_JOIN

      public static final HazelcastProperty WAIT_SECONDS_BEFORE_JOIN
      The time that a newly-appointed master node waits before forming a cluster. Once a cluster is being started, a newly-appointed master node may receive a flurry of join requests. If these requests were processed immediately, the master node would have the overhead of processing each join request individually and informing the existing cluster members of the membership changes. Instead, the master will wait for some time to "batch" the initial join requests. This parameter defines time that the master node will wait since the last received join request (a pre-join window) before it starts processing the join requests and forming a cluster. Alternatively, if the pre-join phase has lasted for over MAX_WAIT_SECONDS_BEFORE_JOIN seconds, the master node will proceed with processing the join requests and forming the cluster, regardless of the time elapsed since the last join request.

      After the master node has started processing join requests, it will no longer introduce any more waiting and join requests will be processed as they arrive. The only exception to this is if the master state is reset, which may happen in some cases like split-brain healing.

    • MAX_WAIT_SECONDS_BEFORE_JOIN

      public static final HazelcastProperty MAX_WAIT_SECONDS_BEFORE_JOIN
      The maximum time that a newly-appointed master node waits before forming a cluster. Once a cluster is being started, a newly-appointed master node may receive a flurry of join requests. If these requests were processed immediately, the master node would have the overhead of processing each join request individually and informing the existing cluster members of the membership changes. Instead, the master will wait for some time to "batch" the initial join requests. This parameter defines maximum time that the master node will wait since the first received join request (a pre-join window) before it starts processing the join requests and forming a cluster. This is an upper limit on the cluster’s pre-join phase duration. Alternatively, if WAIT_SECONDS_BEFORE_JOIN seconds have passed since the last join request, the master node will proceed with processing the join requests and forming the cluster, regardless of the time elapsed since the first join request.

      After the master node has started processing join requests, it will no longer introduce any more waiting and join requests will be processed as they arrive. The only exception to this is if the master state is reset, which may happen in some cases like split-brain healing.

    • ASYNC_JOIN_STRATEGY_ENABLED

      public static final HazelcastProperty ASYNC_JOIN_STRATEGY_ENABLED
      Controls how WAIT_SECONDS_BEFORE_JOIN and MAX_WAIT_SECONDS_BEFORE_JOIN behave. If async is true, the joining member's HazelcastInstance constructor returns right away without blocking. Cluster remains in the same state as before until the configured timeouts have expired, and the new member will behave as if it was a lite member until they expire. After the timeouts expire and no other joining members are in the queue, cluster repartitioning will be performed in the background.

      Async reduces latency significantly when new members join clusters, often reducing startup time.

      Since:
      5.4.0

    • MAX_JOIN_SECONDS

      public static final HazelcastProperty MAX_JOIN_SECONDS
      Join timeout, maximum time to try to join before giving up.

    • MAX_JOIN_MERGE_TARGET_SECONDS

      public static final HazelcastProperty MAX_JOIN_MERGE_TARGET_SECONDS
      Split-brain merge timeout for a specific target.

    • 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.

    • PARTIAL_MEMBER_DISCONNECTION_RESOLUTION_HEARTBEAT_COUNT

      public static final HazelcastProperty PARTIAL_MEMBER_DISCONNECTION_RESOLUTION_HEARTBEAT_COUNT
      The master member, i.e, the first member in the cluster member list administrates the cluster and kicks unreachable members with the heartbeat mechanism. It means that a non-master member (i.e, any member other than the master) does not send heartbeats to the master for the "heartbeat timeout" duration, it is kicked from the cluster. However, there can be heartbeat problems between non-master members as well. Since the master member is the single authority to update the cluster member list, non-master members report their heartbeat problems to the master so that the master can update the cluster member list.

      When the master receives a heartbeat problem report from another member, it first waits for a number of heartbeat rounds to allow other members to report their problems if there is any. After that, it takes all reports received so far and checks if it can update the cluster member in a way that the minimum number of members will be kicked from the cluster and there won't be any heartbeat problem between the remaining members.

      If this configuration option is set to 0, this functionality is disabled. It is recommended to be set to at least 3 or 5 so that the master will wait long enough to collect heartbeat problem reports. Otherwise, the master member can make sub-optimal decisions.

    • PARTIAL_MEMBER_DISCONNECTION_RESOLUTION_ALGORITHM_TIMEOUT_SECONDS

      public static final HazelcastProperty PARTIAL_MEMBER_DISCONNECTION_RESOLUTION_ALGORITHM_TIMEOUT_SECONDS
      The partial member disconnection resolution mechanism uses a graph algorithm that finds a max-clique in non-polynomial time. Since it could take a lot of time to find a max-clique in a large graph, i.e, in a large cluster with lots of random network disconnections, we use a timeout mechanism to stop execution of the algorithm.

    • 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
      Time after which the member assumes the client is dead and closes its connections to the client.

    • CLUSTER_SHUTDOWN_TIMEOUT_SECONDS

      public static final HazelcastProperty CLUSTER_SHUTDOWN_TIMEOUT_SECONDS
      Once a member initiates cluster shutdown, it will either wait for all members to leave the cluster before shutting itself down. This parameter defines a timeout after which there may still be some members in the cluster but the initiator will give up and shut itself down regardless.

    • GRACEFUL_SHUTDOWN_MAX_WAIT

      public static final HazelcastProperty GRACEFUL_SHUTDOWN_MAX_WAIT
      Maximum wait in seconds during graceful shutdown.

    • PARTITION_TABLE_SEND_INTERVAL

      public static final HazelcastProperty PARTITION_TABLE_SEND_INTERVAL
      Interval for publishing partition table periodically to all cluster members in seconds.

    • PARTITION_BACKUP_SYNC_INTERVAL

      public static final HazelcastProperty PARTITION_BACKUP_SYNC_INTERVAL
      Interval for syncing backup replicas in seconds.

    • PARTITION_MAX_PARALLEL_MIGRATIONS

      public static final HazelcastProperty PARTITION_MAX_PARALLEL_MIGRATIONS
      Maximum number of partition migrations to be executed concurrently on a member. Member can be either source or target of the migration.
      • Having too much parallelization can increase the heap memory usage and overload the network during partition rebalance.
      • Having less parallelization can increase the total migration completion time.

    • PARTITION_MAX_PARALLEL_REPLICATIONS

      public static final HazelcastProperty PARTITION_MAX_PARALLEL_REPLICATIONS
      Maximum number of anti-entropy partition replications to be executed on a member. By default equals to PARTITION_MAX_PARALLEL_MIGRATIONS.

    • PARTITIONING_STRATEGY_CLASS

      public static final HazelcastProperty PARTITIONING_STRATEGY_CLASS
      Class name implementing PartitioningStrategy, which defines key to partition mapping. Member-side equivalent of client property ClientProperty.PARTITIONING_STRATEGY_CLASS.

    • CLIENT_CLEANUP_PERIOD

      public static final HazelcastProperty CLIENT_CLEANUP_PERIOD
      Time period to check if a client is still part of the cluster.

    • CLIENT_CLEANUP_TIMEOUT

      public static final HazelcastProperty CLIENT_CLEANUP_TIMEOUT
      Timeout duration to decide if a client is still part of the cluster. If a member can not find any connection to a client in the cluster, it will clean up local resources that is owned by that client.

    • 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.

    • METRICS_ENABLED

      public static final HazelcastProperty METRICS_ENABLED
      Enables/disables metrics collection altogether. This is a master switch for all metrics related functionality.

      NOTE: This property overrides BaseMetricsConfig.isEnabled().

      Using BaseMetricsConfig.setEnabled(boolean) and the declarative counterparts are preferred over using this property. The main purpose of making metrics collection configurable from properties too is allowing operators to configure the metrics subsystem from the outside during investigation without touching or copying the configuration potentially embedded into a signed artifact.

    • METRICS_MC_ENABLED

      public static final HazelcastProperty METRICS_MC_ENABLED
      Enables/disables collecting metrics for Management Center. If disabled, Management Center can't consume the metrics from this member.

      NOTE: This property overrides MetricsManagementCenterConfig.isEnabled().

      Using MetricsManagementCenterConfig.setEnabled(boolean) and the declarative counterparts are preferred over using this property. The main purpose of making metrics collection configurable from properties too is allowing operators to configure the metrics subsystem from the outside during investigation without touching or copying the configuration potentially embedded into a signed artifact.

    • METRICS_MC_RETENTION

      public static final HazelcastProperty METRICS_MC_RETENTION
      Sets the duration in seconds for which the collected metrics are retained and Management Center can consume them.

      NOTE: This property overrides MetricsManagementCenterConfig.getRetentionSeconds().

      Using MetricsManagementCenterConfig.setRetentionSeconds(int) and the declarative counterparts are preferred over using this property. The main purpose of making metrics collection configurable from properties too is allowing operators to configure the metrics subsystem from the outside during investigation without touching or copying the configuration potentially embedded into a signed artifact.

    • METRICS_JMX_ENABLED

      public static final HazelcastProperty METRICS_JMX_ENABLED
      Enables/disables exposing metrics on JMX.

      NOTE: This property overrides MetricsJmxConfig.isEnabled().

      Using MetricsJmxConfig.setEnabled(boolean) and the declarative counterparts are preferred over using this property. The main purpose of making metrics collection configurable from properties too is allowing operators to configure the metrics subsystem from the outside during investigation without touching or copying the configuration potentially embedded into a signed artifact.

    • HEALTH_MONITORING_LEVEL

      public static final HazelcastProperty HEALTH_MONITORING_LEVEL
      Health monitoring log level. When SILENT, logs are printed only when values exceed some predefined threshold. When NOISY, logs are always printed periodically. Set OFF to turn off completely.

    • HEALTH_MONITORING_DELAY_SECONDS

      public static final HazelcastProperty HEALTH_MONITORING_DELAY_SECONDS
      Health monitoring logging interval in seconds.

    • HEALTH_MONITORING_THRESHOLD_MEMORY_PERCENTAGE

      public static final HazelcastProperty HEALTH_MONITORING_THRESHOLD_MEMORY_PERCENTAGE
      When the health monitoring level is SILENT, logs are printed only when the memory usage exceeds this threshold.

    • HEALTH_MONITORING_THRESHOLD_CPU_PERCENTAGE

      public static final HazelcastProperty HEALTH_MONITORING_THRESHOLD_CPU_PERCENTAGE
      When the health monitoring level is SILENT, logs are printed only when the CPU usage exceeds this threshold.

    • ENABLE_JMX

      public static final HazelcastProperty ENABLE_JMX
      Enable JMX agent.

    • JMX_UPDATE_INTERVAL_SECONDS

      public static final HazelcastProperty JMX_UPDATE_INTERVAL_SECONDS
      Some JMX MBeans are cached (e.g. map, multimap, queue and replicated map) to reduce the overhead of calculating statistics. This parameter determines how much the MBeans can go stale, meaning after how much time elapses since the last calculated statistics should the MBean be refreshed.

    • MC_MAX_VISIBLE_SLOW_OPERATION_COUNT

      public static final HazelcastProperty MC_MAX_VISIBLE_SLOW_OPERATION_COUNT
      Management Center maximum visible slow operations count.

    • MC_EXECUTOR_THREAD_COUNT

      public static final HazelcastProperty MC_EXECUTOR_THREAD_COUNT
      The number of threads that the Management Center service has available for processing operations sent from connected Management Center instance.

    • METRICS_DEBUG

      public static final HazelcastProperty METRICS_DEBUG
      Enables collecting debug metrics.

    • METRICS_DATASTRUCTURES

      public static final HazelcastProperty METRICS_DATASTRUCTURES
      Enables/disables collecting metrics from the distributed data structures. By default, data structure metrics collection is enabled.

    • METRICS_USER_CODE_NAMESPACES

      public static final HazelcastProperty METRICS_USER_CODE_NAMESPACES
      Enables/disables collecting metrics from user code namespaces. By default, user code namespaces metrics collection is enabled.

    • METRICS_COLLECTION_FREQUENCY

      public static final HazelcastProperty METRICS_COLLECTION_FREQUENCY
      Sets the metrics collection frequency in seconds.

      NOTE: This property overrides BaseMetricsConfig.getCollectionFrequencySeconds().

      Using BaseMetricsConfig.setCollectionFrequencySeconds(int) and the declarative counterparts are preferred over using this property. The main purpose of making metrics collection configurable from properties too is allowing operators to configure the metrics subsystem from the outside during investigation without touching or copying the configuration potentially embedded into a signed artifact.

    • 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

      public static final HazelcastProperty SLOW_OPERATION_DETECTOR_LOG_PURGE_INTERVAL_SECONDS
      Purge interval for slow operation logs.
      See Also:

    • 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.

    • 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.

    • GLOBAL_HD_INDEX_ENABLED

      public static final HazelcastProperty GLOBAL_HD_INDEX_ENABLED
      Enables use of the concurrent HD index introduced in 4.1 for the IMDG predicate API (old query engine) and reverts to using the per-partition indexes. You may disable this property in case you encounter any regressions when using the query API and when upgrading to 4.1.

      The newly introduced SQL engine (see SqlService) will still use the concurrent HD index since it cannot use the partitioned indexes.

      Since:
      4.1

    • TIERED_STORE_HYBRID_LOG_PAGE_SIZE_IN_MEGABYTES

      public static final HazelcastProperty TIERED_STORE_HYBRID_LOG_PAGE_SIZE_IN_MEGABYTES
      Page size for every instance of Hybrid Log on member.

      Default value is 1MB, must be a power of 2, the minimum value is 1MB, the maximum is 16MB.

      Since:
      5.4

    • 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 Predicates.alwaysTrue() predicate. 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 100000 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 Predicates.alwaysTrue() predicate query operations on maps.

      To limit the result size of a query (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_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.

    • 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 the query engine. When not set it is set as core-size.

    • WAN_CONSUMER_INVOCATION_THRESHOLD

      public static final HazelcastProperty WAN_CONSUMER_INVOCATION_THRESHOLD
      Defines the pending invocation threshold for the Enterprise WAN replication implementation. Exceeding this threshold on a WAN consumer member makes the member delaying the WAN acknowledgment, thus slowing down the WAN publishers on the source side that send WAN events to the given WAN consumer. Setting this value to negative turns off the acknowledgement delaying feature.
      See Also:

    • WAN_CONSUMER_ACK_DELAY_BACKOFF_INIT_MS

      public static final HazelcastProperty WAN_CONSUMER_ACK_DELAY_BACKOFF_INIT_MS
      Defines the initial backoff delay for the Enterprise WAN implementation's consumer. It is used if the acknowledgment delaying feature is enabled by setting WAN_CONSUMER_INVOCATION_THRESHOLD to a non-negative value and that the threshold is exceeded.
      See Also:

    • WAN_CONSUMER_ACK_DELAY_BACKOFF_MAX_MS

      public static final HazelcastProperty WAN_CONSUMER_ACK_DELAY_BACKOFF_MAX_MS
      Defines the maximum backoff delay for the Enterprise WAN implementation's consumer. It is used if the acknowledgment delaying feature is enabled by setting WAN_CONSUMER_INVOCATION_THRESHOLD to a non-negative value and that the threshold is exceeded.
      See Also:

    • WAN_CONSUMER_ACK_DELAY_BACKOFF_MULTIPLIER

      public static final HazelcastProperty WAN_CONSUMER_ACK_DELAY_BACKOFF_MULTIPLIER
      Defines the multiplier (the speed of the function) for the backoff delay for the Enterprise WAN implementation's consumer. It is used if the acknowledgment delaying feature is enabled by setting WAN_CONSUMER_INVOCATION_THRESHOLD to a non-negative value and that the threshold is exceeded.
      See Also:

    • 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.

    • MAP_REPLICA_SCHEDULED_TASK_DELAY_SECONDS

      public static final HazelcastProperty MAP_REPLICA_SCHEDULED_TASK_DELAY_SECONDS
      Scheduler delay for map tasks those are executed on backup members.

    • 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 entry backup processor 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_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.

    • MAP_WRITE_BEHIND_QUEUE_CAPACITY

      public static final HazelcastProperty MAP_WRITE_BEHIND_QUEUE_CAPACITY
      Setting this capacity is valid if you set writeCoalescing to false (see MapStoreConfig.setWriteCoalescing(boolean)). 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

    • OPERATION_CALL_TIMEOUT_MILLIS

      public static final HazelcastProperty OPERATION_CALL_TIMEOUT_MILLIS
      Timeout to wait for a response when a remote call is sent, in milliseconds.

    • 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.

    • 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 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 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.

    • DISABLE_STALE_READ_ON_PARTITION_MIGRATION

      public static final HazelcastProperty DISABLE_STALE_READ_ON_PARTITION_MIGRATION
      Hazelcast allows read operations to be performed while a partition is being migrated. This can lead to stale reads for some scenarios. You can disable stale read operations by setting this system property’s value to "true". Its default value is "false", meaning that stale reads are allowed.

    • 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.

    • GENERIC_OPERATION_THREAD_COUNT

      public static final HazelcastProperty GENERIC_OPERATION_THREAD_COUNT
      The number of generic operation handler threads per member.

      The default is max(2, processors/2);

    • 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.

    • 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.

    • 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.

    • 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_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.

    • 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.

    • PHONE_HOME_ENABLED

      public static final HazelcastProperty PHONE_HOME_ENABLED
      Enable or disable the sending of phone home data to Hazelcast’s phone home server.

    • SHUTDOWNHOOK_ENABLED

      public static final HazelcastProperty SHUTDOWNHOOK_ENABLED
      Enable Hazelcast shutdownhook thread. When this is enabled, this thread terminates the Hazelcast instance without waiting to shutdown gracefully.

    • 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.

    • LOGGING_TYPE

      public static final HazelcastProperty LOGGING_TYPE
      Name of logging framework type to send logging events.

    • LOGGING_ENABLE_DETAILS

      public static final HazelcastProperty LOGGING_ENABLE_DETAILS
      Controls whether cluster name, ip and version should be included in all log messages.

    • LOGGING_SHUTDOWN

      public static final HazelcastProperty LOGGING_SHUTDOWN
      Controls whether Hazelcast will explicitly shutdown the logging implementation as part of Hazelcast graceful shutdown procedure. Default value is false.

      This property can be enabled when Hazelcast is the only application being executed in the JVM, for example, when running a Hazelcast cluster member in its own process. If the JVM process is expected to continue executing other application bits after Hazelcast is shut down, then if this property is true, logging may be disrupted.

      Since:
      5.4.0

    • LOCK_MAX_LEASE_TIME_SECONDS

      public static final HazelcastProperty LOCK_MAX_LEASE_TIME_SECONDS
      All locks which are acquired without an explicit lease time use this value (in seconds) as the lease time. When you want to set an explicit lease time for your locks, you cannot set it to a longer time than this value.

    • ENTERPRISE_LICENSE_KEY

      public static final HazelcastProperty ENTERPRISE_LICENSE_KEY
      Hazelcast Enterprise license key.

    • 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()

    • 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

    • MOBY_NAMING_ENABLED

      public static final HazelcastProperty MOBY_NAMING_ENABLED
      Defines whether Moby Names should be used for instance name generating when it is not provided by user.

      Moby Name is a short human-readable name consisting of randomly chosen adjective and the surname of a famous person.

      If set to true, Moby Name will be chosen, otherwise a name that is concatenation of static prefix, number and cluster name.

      By default is true.

    • JOB_SCAN_PERIOD

      public static final HazelcastProperty JOB_SCAN_PERIOD
      Jet will periodically check for new jobs to start and perform cleanup of unused resources. This property configures how often this check and cleanup will be done. Value is in milliseconds.
      Since:
      Jet 3.2

    • JOB_RESULTS_TTL_SECONDS

      public static final HazelcastProperty JOB_RESULTS_TTL_SECONDS
      Maximum number of time in seconds the job results will be kept in the cluster. They will be automatically deleted after this period is reached.

      Default value is 7 days.

      Since:
      Jet 3.2

    • JOB_RESULTS_MAX_SIZE

      public static final HazelcastProperty JOB_RESULTS_MAX_SIZE
      Maximum number of job results to keep in the cluster, the oldest results will be automatically deleted after this size is reached.

      Default value is 1,000 jobs.

      Since:
      Jet 3.2

    • JET_IDLE_COOPERATIVE_MIN_MICROSECONDS

      public static final HazelcastProperty JET_IDLE_COOPERATIVE_MIN_MICROSECONDS
      The minimum time in microseconds the cooperative worker threads will sleep if none of the tasklets made any progress. Lower values increase idle CPU usage but may result in decreased latency. Higher values will increase latency and very high values (>10000µs) will also limit the throughput.

      The default is value is 25µs.

      Note: the underlying LockSupport.parkNanos(long) call may actually sleep longer depending on the operating system (up to 15000µs on Windows). See the Hazelcast blog post about this subject for more details.

      See also: JET_IDLE_COOPERATIVE_MAX_MICROSECONDS

      Since:
      Jet 3.2

    • JET_IDLE_COOPERATIVE_MAX_MICROSECONDS

      public static final HazelcastProperty JET_IDLE_COOPERATIVE_MAX_MICROSECONDS
      The maximum time in microseconds the cooperative worker threads will sleep if none of the tasklets made any progress. Lower values increase idle CPU usage but may result in decreased latency. Higher values will increase latency and very high values (>10000µs) will also limit the throughput.

      The default is value is 500µs.

      Note: the underlying LockSupport.parkNanos(long) call may actually sleep longer depending on the operating system (up to 15000µs on Windows). See the Hazelcast blog post about this subject for more details.

      See also: JET_IDLE_COOPERATIVE_MIN_MICROSECONDS

      Since:
      Jet 3.2

    • JET_IDLE_NONCOOPERATIVE_MIN_MICROSECONDS

      public static final HazelcastProperty JET_IDLE_NONCOOPERATIVE_MIN_MICROSECONDS
      The minimum time in microseconds the non-cooperative worker threads will sleep if none of the tasklets made any progress. Lower values increase idle CPU usage but may result in decreased latency. Higher values will increase latency and very high values (>10000µs) will also limit the throughput.

      The default is value is 25µs.

      Note: the underlying LockSupport.parkNanos(long) call may actually sleep longer depending on the operating system (up to 15000µs on Windows). See the Hazelcast blog post about this subject for more details.

      See also: JET_IDLE_NONCOOPERATIVE_MAX_MICROSECONDS

      Since:
      Jet 3.2

    • JET_IDLE_NONCOOPERATIVE_MAX_MICROSECONDS

      public static final HazelcastProperty JET_IDLE_NONCOOPERATIVE_MAX_MICROSECONDS
      The maximum time in microseconds the non-cooperative worker threads will sleep if none of the tasklets made any progress. Lower values increase idle CPU usage but may result in decreased latency. Higher values will increase latency and very high values (>10000µs) will also limit the throughput.

      The default is value is 5000µs.

      Note: the underlying LockSupport.parkNanos(long) call may actually sleep longer depending on the operating system (up to 15000µs on Windows). See the Hazelcast blog post about this subject for more details.

      See also: JET_IDLE_NONCOOPERATIVE_MIN_MICROSECONDS

      Since:
      Jet 3.2

    • PROCESSOR_CUSTOM_LIB_DIR

      public static final HazelcastProperty PROCESSOR_CUSTOM_LIB_DIR
      The directory containing jars, that can be used to specify custom classpath for a stage in a pipeline. The default value is `custom-lib`, relative to the current directory.
      Since:
      5.0

    • LOG_EMOJI_ENABLED

      public static final HazelcastProperty LOG_EMOJI_ENABLED
      Controls whether cluster emojis can be used in log messages. This is just a hint for components calling the logging.
      Since:
      5.0

    • SECURITY_RECOMMENDATIONS

      public static final HazelcastProperty SECURITY_RECOMMENDATIONS
      When set to any not-null value, security recommendations are logged on INFO level during the node start. The default value is null.
      Since:
      5.0

    • SQL_CUSTOM_CYCLIC_TYPES_ENABLED

      @Beta public static final HazelcastProperty SQL_CUSTOM_CYCLIC_TYPES_ENABLED
      Enable experimental support for accessing cyclic nested fields by using custom types in SQL. The feature is unstable in 5.4, this property will be removed once the feature is stable.
      Since:
      5.4

    • SQL_TSTORE_ENABLED

      @Beta public static final HazelcastProperty SQL_TSTORE_ENABLED
      Enable experimental support for querying Tiered Storage IMaps via SQL.
      Since:
      5.4

    • PERSISTENCE_AUTO_CLUSTER_STATE

      public static final HazelcastProperty PERSISTENCE_AUTO_CLUSTER_STATE
      When true, enables monitoring of the runtime environment to detect the intent of shutdown and automate cluster state management decisions. Supported when persistence is enabled and Hazelcast is executed in a Kubernetes StatefulSet.

      The default value is true.

      Since:
      5.2

    • PERSISTENCE_AUTO_CLUSTER_STATE_STRATEGY

      public static final HazelcastProperty PERSISTENCE_AUTO_CLUSTER_STATE_STRATEGY
      Select which cluster state to use when dealing with missing members in a managed runtime environment. Used when PERSISTENCE_AUTO_CLUSTER_STATE and persistence are both enabled. Valid values are FROZEN or NO_MIGRATION.
      Since:
      5.2

    • JAR_UPLOAD_DIR_PATH

      public static final HazelcastProperty JAR_UPLOAD_DIR_PATH
      The directory path to be used for jar uploading. The path must exist and must have read + write + execute permissions for the Hazelcast process

      A different path can be specified for each member

      The path can be absolute or relative to current working directory of Hazelcast process

      Since:
      5.3

    • WAN_REPLICATE_IMAP_EVICTIONS

      public static final HazelcastProperty WAN_REPLICATE_IMAP_EVICTIONS
      Defines whether WAN replication events should be fired when values are evicted from IMap objects.

      The default value is false.

      NOTE: The expected use-case for this property to be enabled is very specific, namely where an exact copy of a source is wanted on a target with no evictions enabled; however in this scenario, the target cluster would need to have evictions enabled if it were to become the active cluster - failing to do so could lead to Out Of Memory or data inconsistency issues. The reverse would also be necessary if returning back to the original cluster. Ensure you have a plan for handling these scenarios (such as using Management Centre to configure evictions manually) before enabling this property and changing between active clusters.

      Since:
      5.4

    • WAN_REPLICATE_ICACHE_EVICTIONS

      public static final HazelcastProperty WAN_REPLICATE_ICACHE_EVICTIONS
      Defines whether WAN replication events should be fired when values are evicted from ICache objects.

      The default value is false.

      NOTE: The expected use-case for this property to be enabled is very specific, namely where an exact copy of a source is wanted on a target with no evictions enabled; however in this scenario, the target cluster would need to have evictions enabled if it were to become the active cluster - failing to do so could lead to Out Of Memory or data inconsistency issues. The reverse would also be necessary if returning back to the original cluster. Ensure you have a plan for handling these scenarios (such as using Management Centre to configure evictions manually) before enabling this property and changing between active clusters.

      Since:
      5.4

    • DEMOTE_MAX_WAIT

      public static final HazelcastProperty DEMOTE_MAX_WAIT
      Maximum wait in seconds during member demotion to a lite member.
      Since:
      5.4