foundation/org.eclipse.persistence.core/src/main/java/org/eclipse/persistence/config/SystemProperties.java - eclipselink - Git at Google

 /*
  * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0,
  * or the Eclipse Distribution License v. 1.0 which is available at
  * http://www.eclipse.org/org/documents/edl-v10.php.
  *
  * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
  */

 // Contributors:
 //     tware - added to allow pluggage archive factory
 //     05/11/2020-2.7.0 Jody Grassel
 //       - 538296: Wrong month is returned if OffsetDateTime is used in JPA 2.2 code
 package org.eclipse.persistence.config;

 import java.util.concurrent.TimeUnit;

 /**
  * This class provides the list of System properties that are recognized by EclipseLink.
  * @author tware
  *
  */
 public class SystemProperties {

     /**
      * Configures the factory class we use to produce instances of org.eclispe.persistence.jpa.Archive
      * These instances are used to examine persistence units and the files within them and are used for discovery
      * of classes in the persistence unit
      * Allows user-provided ArchiveFactory and Archive
      */
     public static final String ARCHIVE_FACTORY = "eclipselink.archive.factory";

     /**
      * This property is used to debug weaving issues.   When it is set, weaved classes will be
      * output to the given path as they are weaved
      */
     public static final String WEAVING_OUTPUT_PATH = "eclipselink.weaving.output.path";

     /**
      * This property is used in conjunction with WEAVING_OUTPUT_PATH.  By default, existing classes
      * on the path provided to WEAVING_OUTPUT_PATH will not be overridden.  If this is set to true, they will be
      */
     public static final String WEAVING_SHOULD_OVERWRITE = "eclipselink.weaving.overwrite.existing";

     /**
      * This property can be used to tell EclipseLink to process classes in the ASM Default manner.  The fix for bug
      * 370975 changes EclipseLink's weaving support to use ASM itself to examine class hierarchies.  Setting this flag to
      * true will cause us to use the default reflection mechanism again.  This flag provides a means to workaround any issues encountered with
      * the ASM-based weaving introspection
      */
     public static final String WEAVING_REFLECTIVE_INTROSPECTION = "eclipselink.weaving.reflective-introspection";

     /**
      * This property is used in conjunction with
      * org.eclipse.persistence.sessions.IdentityMapAccessor.printIdentityMapLocks().
      * Setting this property will cause EclipseLink to record the stack trace of
      * the lock acquisition and print it along with the identity map locks. This
      * should only be set if the thread that owns a lock is not 'stuck' but
      * still owns the lock when a normal printIdentityMapLocks is done.
      *
      * This can also be set in code statically through ConcurrencyManager.setShouldTrackStack(true)
      */
     public static final String RECORD_STACK_ON_LOCK = "eclipselink.cache.record-stack-on-lock";

     /**
      * This property can be set to disable processing of X-Many relationship
      * attributes for Query By Example objects. In previous versions of
      * EclipseLink these attributes would have been ignored but as of this
      * release they will be processed into the expression.
      */
     public static final String DO_NOT_PROCESS_XTOMANY_FOR_QBE = "eclipselink.query.query-by-example.ignore-xtomany";

     /**
      * This system property can be set to override target server platform set by the Java EE container
      * with the one either set in persistence.xml or auto detected.
      */
     public static final String ENFORCE_TARGET_SERVER = "eclipselink.target-server.enforce";

     /**
      * This system property can be set the specific time zone used by ConversionManager to convert
      * LocalDateTime, OffsetDateTime, and OffsetTime types.
      */
     public static final String CONVERSION_USE_TIMEZONE = "org.eclipse.persistence.conversion.useTimeZone";

     /**
      * This system property can be set to restore ConversionManager behavior with converting
      * LocalDateTime, OffsetDateTime, and OffsetTime types back to using the JVM's default time zone instead
      * of UTC.  This restores behavior prior to fixing Bug 538296.  This property is ignored if the
      * System Property CONVERSION_USE_TIMEZONE has been set.
      */
     public static final String CONVERSION_USE_DEFAULT_TIMEZONE = "org.eclipse.persistence.conversion.useDefaultTimeZoneForJavaTime";

     /**
      * This property can be set to <code>false</code> to enable UPDATE call to set
      * foreign key value in the target row in unidirectional 1-Many mapping
      * with not nullable FK. In previous versions of EclipseLink this was
      * the default behaviour.
      * Allowed values are: true/false.
      */
     public static final String ONETOMANY_DEFER_INSERTS = "eclipselink.mapping.onetomany.defer-inserts";

     /**
      * This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager.
      * It control how much time loop wait before it try acquire lock for current thread again. It value is set above above 0 dead lock detection
      * mechanism and related extended logging will be activated.
      * Default value is 0 (unit is ms). Allowed values are: long
      */
     public static final String CONCURRENCY_MANAGER_ACQUIRE_WAIT_TIME = "eclipselink.concurrency.manager.waittime";

     /**
      * This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager.
      * It control how much time ConcurrencyManager will wait before it will identify, that thread which builds new object/entity instance
      * should be identified as a potential dead lock source. It leads into some additional log messages.
      * Default value is 0 (unit is ms). In this case extended logging is not active. Allowed values are: long
      */
     public static final String CONCURRENCY_MANAGER_BUILD_OBJECT_COMPLETE_WAIT_TIME = "eclipselink.concurrency.manager.build.object.complete.waittime";

     /**
      * This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager.
      * It control how long we are willing to wait before firing up an exception
      * Default value is 40000 (unit is ms). Allowed values are: long
      */
     public static final String CONCURRENCY_MANAGER_MAX_SLEEP_TIME  = "eclipselink.concurrency.manager.maxsleeptime";

     /**
      * This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager and org.eclipse.persistence.internal.helper.ConcurrencyUtil.
      * It control how frequently the tiny dump log message is created.
      * Default value is 40000 (unit is ms). Allowed values are: long
      */
     public static final String CONCURRENCY_MANAGER_MAX_FREQUENCY_DUMP_TINY_MESSAGE = "eclipselink.concurrency.manager.maxfrequencytodumptinymessage";

     /**
      * This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager and org.eclipse.persistence.internal.helper.ConcurrencyUtil.
      * It control how frequently the massive dump log message is created.
      * Default value is 60000 (unit is ms). Allowed values are: long
      */
     public static final String CONCURRENCY_MANAGER_MAX_FREQUENCY_DUMP_MASSIVE_MESSAGE  = "eclipselink.concurrency.manager.maxfrequencytodumpmassivemessage";

     /**
      * <p>
      * This property control (enable/disable) if <code>InterruptedException</code> fired when dead-lock diagnostic is enabled.
      * <p>
      * <b>Allowed Values</b> (case sensitive String)<b>:</b>
      * <ul>
      * <li>"<code>false</code>" - if aborting frozen thread is not effective it is preferable to not fire the interrupted exception let the system
      * In the places where use this property normally if a thread is stuck it is because it is doing object building.
      * Blowing the threads ups is not that dangerous. It can be very dangerous for production if the dead lock ends up
      * not being resolved because the productive business transactions will become cancelled if the application has a
      * limited number of retries to for example process an MDB. However, the code spots where we use this constant are
      * not as sensible as when the write lock manager is starving to run commit.
      * <li>"<code>true</code>" (DEFAULT) - if we want the to fire up an exception to try to get the current thread to release all of its acquired locks and allow other
      * threads to progress.
      * </ul>
      */
     public static final String CONCURRENCY_MANAGER_ALLOW_INTERRUPTED_EXCEPTION  = "eclipselink.concurrency.manager.allow.interruptedexception";

     /**
      * <p>
      * This property control (enable/disable) if <code>ConcurrencyException</code> fired when dead-lock diagnostic is enabled.
      * <p>
      * <b>Allowed Values</b> (case sensitive String)<b>:</b>
      * <ul>
      * <li>"<code>false</code>" - if aborting frozen thread is not effective it is preferable to not fire the concurrency exception let the system
      * freeze and die and force the administration to kill the server. This is preferable to aborting the transactions
      * multiple times without success in resolving the dead lock and having business critical messages that after 3 JMS
      * retries are discarded out. Failing to resolve a dead lock can have terrible impact in system recovery unless we
      * have infinite retries for the business transactions.
      * <li>"<code>true</code>" (DEFAULT) - if we want the to fire up an exception to try to get the current thread to release all of its acquired
      * locks and allow other threads to progress.
      * </ul>
      */
     public static final String CONCURRENCY_MANAGER_ALLOW_CONCURRENCY_EXCEPTION  = "eclipselink.concurrency.manager.allow.concurrency.exception";

     /**
      * <p>
      * This property control (enable/disable) collection debug/trace information during ReadLock acquisition, when dead-lock diagnostic is enabled.
      * <p>
      * <b>Allowed Values</b> (case sensitive String)<b>:</b>
      * <ul>
      * <li>"<code>false</code>" (DEFAULT) - don't collect debug/trace information during ReadLock acquisition
      * <li>"<code>true</code>" - collect debug/trace information during ReadLock acquisition. Has negative impact to the performance.
      * </ul>
      */
     public static final String CONCURRENCY_MANAGER_ALLOW_STACK_TRACE_READ_LOCK = "eclipselink.concurrency.manager.allow.readlockstacktrace";

     /**
      * <p>
      * This property control (enable/disable) semaphore in {@link org.eclipse.persistence.internal.descriptors.ObjectBuilder}
      * </p>
      * Object building see {@link org.eclipse.persistence.internal.descriptors.ObjectBuilder} could be one of the
      * primary sources pressure on concurrency manager. Most of the cache key acquisition and releasing is taking place during object building.
      * Enable <code>true</code> this property to try reduce the likelihood of having dead locks is to allow less threads to start object
      * building in parallel. In this case there should be negative impact to the performance.
      * Note: Parallel access to the same entity/entity tree from different threads is not recommended technique in EclipseLink.
      * <ul>
      * <li>"<code>true</code>" - means we want to override vanilla behavior and use a semaphore to not allow too many
      * threads in parallel to do object building
      * <li>"<code>false</code>" (DEFAULT) - means just go ahead and try to build the object without any semaphore (false is
      * vanilla behavior).
      * </ul>
      */
     public static final String CONCURRENCY_MANAGER_USE_SEMAPHORE_TO_SLOW_DOWN_OBJECT_BUILDING = "eclipselink.concurrency.manager.object.building.semaphore";

     /**
      * <p>
      * This property control (enable/disable) semaphore in {@link org.eclipse.persistence.internal.helper.WriteLockManager#acquireRequiredLocks}
      * </p>
      * This algorithm
      * {@link org.eclipse.persistence.internal.helper.WriteLockManager#acquireRequiredLocks}
      * is being used when a transaction is committing and it is acquire locks to merge the change set.
      * It should happen if algorithm has trouble when multiple threads report change sets on the same entity (e.g.
      * one-to-many relations of master detail being enriched with more details on this master).
      * Note: Parallel access to the same entity/entity tree from different threads is not recommended technique in EclipseLink.
      * <ul>
      * <li>"<code>true</code>" - means we want to override vanilla behavior and use a semaphore to not allow too many
      * threads. In this case there should be negative impact to the performance.
      * <li>"<code>false</code>" (DEFAULT) - means just go ahead and try to build the object without any semaphore (false is
      * vanilla behavior).
      * </ul>
      */
     public static final String CONCURRENCY_MANAGER_USE_SEMAPHORE_TO_SLOW_DOWN_WRITE_LOCK_MANAGER_ACQUIRE_REQUIRED_LOCKS = "eclipselink.concurrency.manager.write.lock.manager.semaphore";

     /**
      * <p>
      * This property control number of threads in semaphore in {@link org.eclipse.persistence.internal.descriptors.ObjectBuilder}
      * If "eclipselink.concurrency.manager.object.building.semaphore" property is <code>true</code> default value is 10. Allowed values are: int
      * If "eclipselink.concurrency.manager.object.building.semaphore" property is <code>false</code> (DEFAULT) number of threads is unlimited.
      * </p>
      */
     public static final String CONCURRENCY_MANAGER_OBJECT_BUILDING_NO_THREADS = "eclipselink.concurrency.manager.object.building.no.threads";

     /**
      * <p>
      * This property control number of threads in semaphore in {@link org.eclipse.persistence.internal.helper.WriteLockManager#acquireRequiredLocks}
      * If "eclipselink.concurrency.manager.write.lock.manager.semaphore" property is <code>true</code> default value is 2. Allowed values are: int
      * If "eclipselink.concurrency.manager.write.lock.manager.semaphore" property is <code>false</code> (DEFAULT) number of threads is unlimited.
      * </p>
      */
     public static final String CONCURRENCY_MANAGER_WRITE_LOCK_MANAGER_ACQUIRE_REQUIRED_LOCKS_NO_THREADS = "eclipselink.concurrency.manager.write.lock.manager.no.threads";

     /**
      * <p>
      * This property control semaphore the maximum time to wait for a permit in {@link org.eclipse.persistence.internal.helper.ConcurrencySemaphore#acquireSemaphoreIfAppropriate(boolean)}
      * It's passed to {@link java.util.concurrent.Semaphore#tryAcquire(long, TimeUnit)}
      * Default value is 2000 (unit is ms). Allowed values are: long
      * </p>
      */
     public static final String CONCURRENCY_SEMAPHORE_MAX_TIME_PERMIT = "eclipselink.concurrency.semaphore.max.time.permit";

     /**
      * <p>
      * This property control timeout between log messages in {@link org.eclipse.persistence.internal.helper.ConcurrencySemaphore#acquireSemaphoreIfAppropriate(boolean)} when method/thread tries to get permit for the execution.
      * Default value is 10000 (unit is ms). Allowed values are: long
      * </p>
      */
     public static final String CONCURRENCY_SEMAPHORE_LOG_TIMEOUT = "eclipselink.concurrency.semaphore.log.timeout";
 }
	/*
	* Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0,
	* or the Eclipse Distribution License v. 1.0 which is available at
	* http://www.eclipse.org/org/documents/edl-v10.php.
	*
	* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
	*/

	// Contributors:
	// tware - added to allow pluggage archive factory
	// 05/11/2020-2.7.0 Jody Grassel
	// - 538296: Wrong month is returned if OffsetDateTime is used in JPA 2.2 code
	package org.eclipse.persistence.config;

	import java.util.concurrent.TimeUnit;

	/**
	* This class provides the list of System properties that are recognized by EclipseLink.
	* @author tware
	*
	*/
	public class SystemProperties {

	/**
	* Configures the factory class we use to produce instances of org.eclispe.persistence.jpa.Archive
	* These instances are used to examine persistence units and the files within them and are used for discovery
	* of classes in the persistence unit
	* Allows user-provided ArchiveFactory and Archive
	*/
	public static final String ARCHIVE_FACTORY = "eclipselink.archive.factory";

	/**
	* This property is used to debug weaving issues. When it is set, weaved classes will be
	* output to the given path as they are weaved
	*/
	public static final String WEAVING_OUTPUT_PATH = "eclipselink.weaving.output.path";

	/**
	* This property is used in conjunction with WEAVING_OUTPUT_PATH. By default, existing classes
	* on the path provided to WEAVING_OUTPUT_PATH will not be overridden. If this is set to true, they will be
	*/
	public static final String WEAVING_SHOULD_OVERWRITE = "eclipselink.weaving.overwrite.existing";

	/**
	* This property can be used to tell EclipseLink to process classes in the ASM Default manner. The fix for bug
	* 370975 changes EclipseLink's weaving support to use ASM itself to examine class hierarchies. Setting this flag to
	* true will cause us to use the default reflection mechanism again. This flag provides a means to workaround any issues encountered with
	* the ASM-based weaving introspection
	*/
	public static final String WEAVING_REFLECTIVE_INTROSPECTION = "eclipselink.weaving.reflective-introspection";

	/**
	* This property is used in conjunction with
	* org.eclipse.persistence.sessions.IdentityMapAccessor.printIdentityMapLocks().
	* Setting this property will cause EclipseLink to record the stack trace of
	* the lock acquisition and print it along with the identity map locks. This
	* should only be set if the thread that owns a lock is not 'stuck' but
	* still owns the lock when a normal printIdentityMapLocks is done.
	*
	* This can also be set in code statically through ConcurrencyManager.setShouldTrackStack(true)
	*/
	public static final String RECORD_STACK_ON_LOCK = "eclipselink.cache.record-stack-on-lock";

	/**
	* This property can be set to disable processing of X-Many relationship
	* attributes for Query By Example objects. In previous versions of
	* EclipseLink these attributes would have been ignored but as of this
	* release they will be processed into the expression.
	*/
	public static final String DO_NOT_PROCESS_XTOMANY_FOR_QBE = "eclipselink.query.query-by-example.ignore-xtomany";

	/**
	* This system property can be set to override target server platform set by the Java EE container
	* with the one either set in persistence.xml or auto detected.
	*/
	public static final String ENFORCE_TARGET_SERVER = "eclipselink.target-server.enforce";

	/**
	* This system property can be set the specific time zone used by ConversionManager to convert
	* LocalDateTime, OffsetDateTime, and OffsetTime types.
	*/
	public static final String CONVERSION_USE_TIMEZONE = "org.eclipse.persistence.conversion.useTimeZone";

	/**
	* This system property can be set to restore ConversionManager behavior with converting
	* LocalDateTime, OffsetDateTime, and OffsetTime types back to using the JVM's default time zone instead
	* of UTC. This restores behavior prior to fixing Bug 538296. This property is ignored if the
	* System Property CONVERSION_USE_TIMEZONE has been set.
	*/
	public static final String CONVERSION_USE_DEFAULT_TIMEZONE = "org.eclipse.persistence.conversion.useDefaultTimeZoneForJavaTime";

	/**
	* This property can be set to <code>false</code> to enable UPDATE call to set
	* foreign key value in the target row in unidirectional 1-Many mapping
	* with not nullable FK. In previous versions of EclipseLink this was
	* the default behaviour.
	* Allowed values are: true/false.
	*/
	public static final String ONETOMANY_DEFER_INSERTS = "eclipselink.mapping.onetomany.defer-inserts";

	/**
	* This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager.
	* It control how much time loop wait before it try acquire lock for current thread again. It value is set above above 0 dead lock detection
	* mechanism and related extended logging will be activated.
	* Default value is 0 (unit is ms). Allowed values are: long
	*/
	public static final String CONCURRENCY_MANAGER_ACQUIRE_WAIT_TIME = "eclipselink.concurrency.manager.waittime";

	/**
	* This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager.
	* It control how much time ConcurrencyManager will wait before it will identify, that thread which builds new object/entity instance
	* should be identified as a potential dead lock source. It leads into some additional log messages.
	* Default value is 0 (unit is ms). In this case extended logging is not active. Allowed values are: long
	*/
	public static final String CONCURRENCY_MANAGER_BUILD_OBJECT_COMPLETE_WAIT_TIME = "eclipselink.concurrency.manager.build.object.complete.waittime";

	/**
	* This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager.
	* It control how long we are willing to wait before firing up an exception
	* Default value is 40000 (unit is ms). Allowed values are: long
	*/
	public static final String CONCURRENCY_MANAGER_MAX_SLEEP_TIME = "eclipselink.concurrency.manager.maxsleeptime";

	/**
	* This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager and org.eclipse.persistence.internal.helper.ConcurrencyUtil.
	* It control how frequently the tiny dump log message is created.
	* Default value is 40000 (unit is ms). Allowed values are: long
	*/
	public static final String CONCURRENCY_MANAGER_MAX_FREQUENCY_DUMP_TINY_MESSAGE = "eclipselink.concurrency.manager.maxfrequencytodumptinymessage";

	/**
	* This system property in milliseconds can control thread management in org.eclipse.persistence.internal.helper.ConcurrencyManager and org.eclipse.persistence.internal.helper.ConcurrencyUtil.
	* It control how frequently the massive dump log message is created.
	* Default value is 60000 (unit is ms). Allowed values are: long
	*/
	public static final String CONCURRENCY_MANAGER_MAX_FREQUENCY_DUMP_MASSIVE_MESSAGE = "eclipselink.concurrency.manager.maxfrequencytodumpmassivemessage";

	/**
	* <p>
	* This property control (enable/disable) if <code>InterruptedException</code> fired when dead-lock diagnostic is enabled.
	* <p>
	* <b>Allowed Values</b> (case sensitive String)<b>:</b>
	* <ul>
	* <li>"<code>false</code>" - if aborting frozen thread is not effective it is preferable to not fire the interrupted exception let the system
	* In the places where use this property normally if a thread is stuck it is because it is doing object building.
	* Blowing the threads ups is not that dangerous. It can be very dangerous for production if the dead lock ends up
	* not being resolved because the productive business transactions will become cancelled if the application has a
	* limited number of retries to for example process an MDB. However, the code spots where we use this constant are
	* not as sensible as when the write lock manager is starving to run commit.
	* <li>"<code>true</code>" (DEFAULT) - if we want the to fire up an exception to try to get the current thread to release all of its acquired locks and allow other
	* threads to progress.
	* </ul>
	*/
	public static final String CONCURRENCY_MANAGER_ALLOW_INTERRUPTED_EXCEPTION = "eclipselink.concurrency.manager.allow.interruptedexception";

	/**
	* <p>
	* This property control (enable/disable) if <code>ConcurrencyException</code> fired when dead-lock diagnostic is enabled.
	* <p>
	* <b>Allowed Values</b> (case sensitive String)<b>:</b>
	* <ul>
	* <li>"<code>false</code>" - if aborting frozen thread is not effective it is preferable to not fire the concurrency exception let the system
	* freeze and die and force the administration to kill the server. This is preferable to aborting the transactions
	* multiple times without success in resolving the dead lock and having business critical messages that after 3 JMS
	* retries are discarded out. Failing to resolve a dead lock can have terrible impact in system recovery unless we
	* have infinite retries for the business transactions.
	* <li>"<code>true</code>" (DEFAULT) - if we want the to fire up an exception to try to get the current thread to release all of its acquired
	* locks and allow other threads to progress.
	* </ul>
	*/
	public static final String CONCURRENCY_MANAGER_ALLOW_CONCURRENCY_EXCEPTION = "eclipselink.concurrency.manager.allow.concurrency.exception";

	/**
	* <p>
	* This property control (enable/disable) collection debug/trace information during ReadLock acquisition, when dead-lock diagnostic is enabled.
	* <p>
	* <b>Allowed Values</b> (case sensitive String)<b>:</b>
	* <ul>
	* <li>"<code>false</code>" (DEFAULT) - don't collect debug/trace information during ReadLock acquisition
	* <li>"<code>true</code>" - collect debug/trace information during ReadLock acquisition. Has negative impact to the performance.
	* </ul>
	*/
	public static final String CONCURRENCY_MANAGER_ALLOW_STACK_TRACE_READ_LOCK = "eclipselink.concurrency.manager.allow.readlockstacktrace";

	/**
	* <p>
	* This property control (enable/disable) semaphore in {@link org.eclipse.persistence.internal.descriptors.ObjectBuilder}
	* </p>
	* Object building see {@link org.eclipse.persistence.internal.descriptors.ObjectBuilder} could be one of the
	* primary sources pressure on concurrency manager. Most of the cache key acquisition and releasing is taking place during object building.
	* Enable <code>true</code> this property to try reduce the likelihood of having dead locks is to allow less threads to start object
	* building in parallel. In this case there should be negative impact to the performance.
	* Note: Parallel access to the same entity/entity tree from different threads is not recommended technique in EclipseLink.
	* <ul>
	* <li>"<code>true</code>" - means we want to override vanilla behavior and use a semaphore to not allow too many
	* threads in parallel to do object building
	* <li>"<code>false</code>" (DEFAULT) - means just go ahead and try to build the object without any semaphore (false is
	* vanilla behavior).
	* </ul>
	*/
	public static final String CONCURRENCY_MANAGER_USE_SEMAPHORE_TO_SLOW_DOWN_OBJECT_BUILDING = "eclipselink.concurrency.manager.object.building.semaphore";

	/**
	* <p>
	* This property control (enable/disable) semaphore in {@link org.eclipse.persistence.internal.helper.WriteLockManager#acquireRequiredLocks}
	* </p>
	* This algorithm
	* {@link org.eclipse.persistence.internal.helper.WriteLockManager#acquireRequiredLocks}
	* is being used when a transaction is committing and it is acquire locks to merge the change set.
	* It should happen if algorithm has trouble when multiple threads report change sets on the same entity (e.g.
	* one-to-many relations of master detail being enriched with more details on this master).
	* Note: Parallel access to the same entity/entity tree from different threads is not recommended technique in EclipseLink.
	* <ul>
	* <li>"<code>true</code>" - means we want to override vanilla behavior and use a semaphore to not allow too many
	* threads. In this case there should be negative impact to the performance.
	* <li>"<code>false</code>" (DEFAULT) - means just go ahead and try to build the object without any semaphore (false is
	* vanilla behavior).
	* </ul>
	*/
	public static final String CONCURRENCY_MANAGER_USE_SEMAPHORE_TO_SLOW_DOWN_WRITE_LOCK_MANAGER_ACQUIRE_REQUIRED_LOCKS = "eclipselink.concurrency.manager.write.lock.manager.semaphore";

	/**
	* <p>
	* This property control number of threads in semaphore in {@link org.eclipse.persistence.internal.descriptors.ObjectBuilder}
	* If "eclipselink.concurrency.manager.object.building.semaphore" property is <code>true</code> default value is 10. Allowed values are: int
	* If "eclipselink.concurrency.manager.object.building.semaphore" property is <code>false</code> (DEFAULT) number of threads is unlimited.
	* </p>
	*/
	public static final String CONCURRENCY_MANAGER_OBJECT_BUILDING_NO_THREADS = "eclipselink.concurrency.manager.object.building.no.threads";

	/**
	* <p>
	* This property control number of threads in semaphore in {@link org.eclipse.persistence.internal.helper.WriteLockManager#acquireRequiredLocks}
	* If "eclipselink.concurrency.manager.write.lock.manager.semaphore" property is <code>true</code> default value is 2. Allowed values are: int
	* If "eclipselink.concurrency.manager.write.lock.manager.semaphore" property is <code>false</code> (DEFAULT) number of threads is unlimited.
	* </p>
	*/
	public static final String CONCURRENCY_MANAGER_WRITE_LOCK_MANAGER_ACQUIRE_REQUIRED_LOCKS_NO_THREADS = "eclipselink.concurrency.manager.write.lock.manager.no.threads";

	/**
	* <p>
	* This property control semaphore the maximum time to wait for a permit in {@link org.eclipse.persistence.internal.helper.ConcurrencySemaphore#acquireSemaphoreIfAppropriate(boolean)}
	* It's passed to {@link java.util.concurrent.Semaphore#tryAcquire(long, TimeUnit)}
	* Default value is 2000 (unit is ms). Allowed values are: long
	* </p>
	*/
	public static final String CONCURRENCY_SEMAPHORE_MAX_TIME_PERMIT = "eclipselink.concurrency.semaphore.max.time.permit";

	/**
	* <p>
	* This property control timeout between log messages in {@link org.eclipse.persistence.internal.helper.ConcurrencySemaphore#acquireSemaphoreIfAppropriate(boolean)} when method/thread tries to get permit for the execution.
	* Default value is 10000 (unit is ms). Allowed values are: long
	* </p>
	*/
	public static final String CONCURRENCY_SEMAPHORE_LOG_TIMEOUT = "eclipselink.concurrency.semaphore.log.timeout";
	}