From b566ce0ea7f3cdf55ac14949400fcb5c33822cea Mon Sep 17 00:00:00 2001 From: Petr Aubrecht Date: Wed, 12 Feb 2025 15:06:53 +0100 Subject: [PATCH 01/11] FISH-8302 add checks during creation of MES, make the it more reliable Introduce fallback in case a creation of an implementation of a ManagedExecutorService (virtual or fork&join) fails. --- .../concurrent/runtime/ConcurrentRuntime.java | 61 ++++++++++++------- 1 file changed, 38 insertions(+), 23 deletions(-) diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java index 304ebcb8ddb..44a4059a46a 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java @@ -37,7 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ -// Portions Copyright [2016-2024] [Payara Foundation and/or its affiliates] +// Portions Copyright 2016-2025 [Payara Foundation and/or its affiliates] package org.glassfish.concurrent.runtime; @@ -104,7 +104,7 @@ public class ConcurrentRuntime implements PostConstruct, PreDestroy { public static final String CONTEXT_INFO_ALL = CONTEXT_INFO_CLASSLOADER + "," + CONTEXT_INFO_JNDI + "," + CONTEXT_INFO_SECURITY + "," + CONTEXT_INFO_WORKAREA; private ScheduledExecutorService internalScheduler; - private static final Logger logger = LogFacade.getLogger(); + private static final Logger logger = LogFacade.getLogger(); @Inject InvocationManager invocationManager; @@ -231,27 +231,42 @@ public synchronized AbstractManagedExecutorService createManagedExecutorService( config.getJndiName() + "-managedThreadFactory", null, config.getThreadPriority()); - AbstractManagedExecutorService mes; - if (config.getUseVirtualThread()) { - mes = new VirtualThreadsManagedExecutorService(config.getJndiName(), - null, - config.getHungAfterSeconds() * 1_000L, // in milliseconds - config.isLongRunningTasks(), - config.getMaximumPoolSize(), - config.getTaskQueueCapacity(), - contextService, - AbstractManagedExecutorService.RejectPolicy.ABORT); - } else if (config.getUseForkJoinPool()) { - mes = new ForkJoinManagedExecutorService(config.getJndiName(), - managedThreadFactory, - config.getHungAfterSeconds() * 1_000L, // in milliseconds - config.isLongRunningTasks(), - config.getMaximumPoolSize(), - config.getKeepAliveSeconds(), TimeUnit.SECONDS, - config.getThreadLifeTimeSeconds(), - contextService, - AbstractManagedExecutorService.RejectPolicy.ABORT); - } else { + AbstractManagedExecutorService mes = null; + boolean useVirtualThread = config.getUseVirtualThread(); + boolean useForkJoinPool = config.getUseForkJoinPool(); + if (useVirtualThread) { + try { + mes = new VirtualThreadsManagedExecutorService(config.getJndiName(), + null, + config.getHungAfterSeconds() * 1_000L, // in milliseconds + config.isLongRunningTasks(), + config.getMaximumPoolSize(), + config.getTaskQueueCapacity(), + contextService, + AbstractManagedExecutorService.RejectPolicy.ABORT); + } catch (Exception e) { + logger.log(Level.SEVERE, "Unable to start virtual threads managed executor service, JNDI '" + config.getJndiName() + "', fallback to " + (useVirtualThread ? "virtual threads" : "platform threads"), e); + } + } + if (mes == null && useForkJoinPool) { + try { + if (config.getMaximumPoolSize() > 0x7fff /*ForkJoinPool.MAX_CAP*/) { + throw new IllegalArgumentException("Maximum size for ForkJoinPool managed executor service is too high, " + config.getMaximumPoolSize() + " > " + 0x7fff); + } + mes = new ForkJoinManagedExecutorService(config.getJndiName(), + managedThreadFactory, + config.getHungAfterSeconds() * 1_000L, // in milliseconds + config.isLongRunningTasks(), + config.getMaximumPoolSize(), + config.getKeepAliveSeconds(), TimeUnit.SECONDS, + config.getThreadLifeTimeSeconds(), + contextService, + AbstractManagedExecutorService.RejectPolicy.ABORT); + } catch (Exception e) { + logger.log(Level.SEVERE, "Unable to start ForkJoinPool managed executor service, JNDI '" + config.getJndiName() + "', fallback to platform threads", e); + } + } + if (mes == null) { mes = new ManagedExecutorServiceImpl(config.getJndiName(), managedThreadFactory, config.getHungAfterSeconds() * 1_000L, // in milliseconds From 98d615666f49f055fbcf94781a8e11c9e78433b5 Mon Sep 17 00:00:00 2001 From: Petr Aubrecht Date: Wed, 12 Feb 2025 15:08:39 +0100 Subject: [PATCH 02/11] FISH-8302 configure virtual threads option for managedexecutorservice Both AdminUI and command-line asadmin are implemented. --- .../resources/managedExecutorServiceAttr.inc | 5 +++ .../resources/managedExecutorServiceEdit.jsf | 3 +- .../resources/managedExecutorServiceNew.jsf | 4 +- .../concurrent/admingui/Strings.properties | 2 + .../admin/CreateManagedExecutorService.java | 9 +++- .../admin/ManagedExecutorServiceManager.java | 41 +++++++++++-------- .../admin/create-managed-executor-service.1 | 10 +++++ .../admin/cli/ResourceConstants.java | 3 +- 8 files changed, 56 insertions(+), 21 deletions(-) diff --git a/appserver/admingui/concurrent/src/main/resources/managedExecutorServiceAttr.inc b/appserver/admingui/concurrent/src/main/resources/managedExecutorServiceAttr.inc index f2d62955531..b7cd5836b30 100644 --- a/appserver/admingui/concurrent/src/main/resources/managedExecutorServiceAttr.inc +++ b/appserver/admingui/concurrent/src/main/resources/managedExecutorServiceAttr.inc @@ -39,6 +39,7 @@ holder. --> + @@ -85,6 +86,10 @@ + + + + diff --git a/appserver/admingui/concurrent/src/main/resources/managedExecutorServiceEdit.jsf b/appserver/admingui/concurrent/src/main/resources/managedExecutorServiceEdit.jsf index 65b11b2e8ea..8ca3fb112f7 100644 --- a/appserver/admingui/concurrent/src/main/resources/managedExecutorServiceEdit.jsf +++ b/appserver/admingui/concurrent/src/main/resources/managedExecutorServiceEdit.jsf @@ -39,6 +39,7 @@ holder. --> + + @@ -55,7 +56,7 @@ setPageSessionAttribute(key="parentPage" value="#{request.contextPath}/concurrent/managedExecutorServices.jsf"); setPageSessionAttribute(key="childType" value="managed-executor-service"); setPageSessionAttribute(key="isConcurrent" value="true"); - setPageSessionAttribute(key="convertToFalseList" value={"enabled", "contextInfoEnabled", "longRunningTasks", "useForkJoinPool" }); + setPageSessionAttribute(key="convertToFalseList" value={"enabled", "contextInfoEnabled", "longRunningTasks", "useVirtualThreads", "useForkJoinPool" }); setPageSessionAttribute(key="parentUrl", value="#{sessionScope.REST_URL}/resources"); gf.getDefaultValues(endpoint="#{pageSession.parentUrl}/#{pageSession.childType}", valueMap="#{pageSession.valueMap}"); setPageSessionAttribute(key="edit" value="#{false}" ); @@ -64,6 +65,7 @@ mapPut(map="#{pageSession.valueMap2}" key="enabled" value="true"); setPageSessionAttribute(key="showMaxPoolSize" value="#{true}"); setPageSessionAttribute(key="showTaskQueue" value="#{true}"); + setPageSessionAttribute(key="showVirtualThreads" value="#{true}"); setPageSessionAttribute(key="showForkJoin" value="#{true}"); /> diff --git a/appserver/admingui/concurrent/src/main/resources/org/glassfish/concurrent/admingui/Strings.properties b/appserver/admingui/concurrent/src/main/resources/org/glassfish/concurrent/admingui/Strings.properties index 9b15478951f..aa3aa6db5bd 100644 --- a/appserver/admingui/concurrent/src/main/resources/org/glassfish/concurrent/admingui/Strings.properties +++ b/appserver/admingui/concurrent/src/main/resources/org/glassfish/concurrent/admingui/Strings.properties @@ -37,6 +37,7 @@ # only if the new code is made subject to such option by the copyright # holder. # +# Portions Copyright 2022-2025 Payara Foundation and/or affiliates ## Concurrent @@ -114,6 +115,7 @@ contextInfoLabelHelp=Container contexts to propagate to other threads. If disabl threadPriorityLabel=Thread Priority: threadPriorityLabelHelp=Priority to assign to created threads longRunningTasks=Long-Running Tasks: +usevirtualthreads=Use Virtual Threads: useforkjoinpool=Use ForkJoinPool: longRunningTasksHelp=Use the resource for long-running tasks. If enabled, long-running tasks are not reported as stuck. hungAfterSeconds=Hung After: diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedExecutorService.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedExecutorService.java index 9ad8b4e11d1..fb1a686d8c3 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedExecutorService.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedExecutorService.java @@ -37,7 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ -// Portions Copyright [2016-2021] [Payara Foundation and/or its affiliates] +// Portions Copyright [2016-2025] [Payara Foundation and/or its affiliates] package org.glassfish.concurrent.admin; @@ -77,7 +77,10 @@ public class CreateManagedExecutorService extends CreateManagedExecutorServiceBa @Param(name="taskqueuecapacity", alias="taskQueueCapacity", defaultValue=""+Integer.MAX_VALUE, optional=true) private Integer taskqueuecapacity; - @Param(name="useforkjoinpool", alias="useForkJoinPool", defaultValue="false", optional=true) + @Param(name = "usevirtualthreads", alias = "useVirtualThreads", defaultValue = "false", optional = true) + protected Boolean usevirtualthreads; + + @Param(name = "useforkjoinpool", alias = "useForkJoinPool", defaultValue = "false", optional = true) protected Boolean useforkjoinpool; @Inject @@ -92,6 +95,8 @@ protected void setAttributeList(HashMap attrList) { maximumpoolsize.toString()); attrList.put(ResourceConstants.TASK_QUEUE_CAPACITY, taskqueuecapacity.toString()); + attrList.put(ResourceConstants.USE_VIRTUAL_THREADS, + usevirtualthreads.toString()); attrList.put(ResourceConstants.USE_FORK_JOIN_POOL, useforkjoinpool.toString()); } diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedExecutorServiceManager.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedExecutorServiceManager.java index 966a52476c8..b6ce8cae578 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedExecutorServiceManager.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedExecutorServiceManager.java @@ -38,7 +38,7 @@ * holder. */ -// Portions Copyright 2022 Payara Foundation and/or its affiliates +// Portions Copyright 2022-2025 Payara Foundation and/or its affiliates package org.glassfish.concurrent.admin; @@ -59,9 +59,8 @@ import java.beans.PropertyVetoException; /** - * - * The managed executor service manager allows you to create and delete - * the managed-executor-service config element + * The managed executor service manager allows you to create and delete the + * managed-executor-service configuration element. */ @Service (name=ServerTags.MANAGED_EXECUTOR_SERVICE) @I18n("managed.executor.service.manager") @@ -70,6 +69,7 @@ public class ManagedExecutorServiceManager extends ManagedExecutorServiceBaseMan private String maximumPoolSize = ""+Integer.MAX_VALUE; private String taskQueueCapacity = ""+Integer.MAX_VALUE; + private String useVirtualThreads = Boolean.FALSE.toString(); private String useForkJoinPool = Boolean.FALSE.toString(); @Override @@ -77,37 +77,46 @@ protected void setAttributes(HashMap attributes, String target) { super.setAttributes(attributes, target); maximumPoolSize = (String) attributes.get(MAXIMUM_POOL_SIZE); taskQueueCapacity = (String) attributes.get(TASK_QUEUE_CAPACITY); - useForkJoinPool = (String) attributes.get(USE_FORK_JOIN_POOL); + useVirtualThreads = (String) attributes.getOrDefault(USE_VIRTUAL_THREADS, Boolean.FALSE.toString()); + useForkJoinPool = (String) attributes.getOrDefault(USE_FORK_JOIN_POOL, Boolean.FALSE.toString()); } @Override - protected ResourceStatus isValid(Resources resources, boolean validateResourceRef, String target){ - if ("false".equals(useForkJoinPool)) { - if (Integer.parseInt(corePoolSize) == 0 && - Integer.parseInt(maximumPoolSize) == 0) { - String msg = localStrings.getLocalString("coresize.maxsize.both.zero", "Options corepoolsize and maximumpoolsize cannot both have value 0."); - return new ResourceStatus(ResourceStatus.FAILURE, msg); + protected ResourceStatus isValid(Resources resources, boolean validateResourceRef, String target) { + String errorMsg = null; + boolean doUseForkJoinPool = Boolean.parseBoolean(useForkJoinPool); + int intCorePoolSize = Integer.parseInt(corePoolSize); + int intMaximumPoolSize = Integer.parseInt(maximumPoolSize); + if (doUseForkJoinPool == false && Boolean.parseBoolean(useVirtualThreads) == false) { + if (intCorePoolSize == 0 && intMaximumPoolSize == 0) { + errorMsg = localStrings.getLocalString("coresize.maxsize.both.zero", "Options corepoolsize and maximumpoolsize cannot both have value 0."); } } - - if (Integer.parseInt(corePoolSize) > - Integer.parseInt(maximumPoolSize)) { - String msg = localStrings.getLocalString("coresize.biggerthan.maxsize", "Option corepoolsize cannot have a bigger value than option maximumpoolsize."); - return new ResourceStatus(ResourceStatus.FAILURE, msg); + if (intCorePoolSize > intMaximumPoolSize) { + errorMsg = localStrings.getLocalString("coresize.biggerthan.maxsize", "Option corepoolsize cannot have a bigger value than option maximumpoolsize."); + } + if (doUseForkJoinPool && intMaximumPoolSize > 0x7fff /*ForkJoinPool.MAX_CAP*/) { + errorMsg = localStrings.getLocalString("coresize.biggerthan.maxsize", "Option corepoolsize cannot have a bigger value than option maximumpoolsize."); + } + if (errorMsg != null) { + return new ResourceStatus(ResourceStatus.FAILURE, errorMsg); } return super.isValid(resources, validateResourceRef, target); } + @Override protected ManagedExecutorServiceBase createConfigBean(Resources param, Properties properties) throws PropertyVetoException, TransactionFailure { ManagedExecutorService managedExecutorService = param.createChild(ManagedExecutorService.class); setAttributesOnConfigBean(managedExecutorService, properties); managedExecutorService.setMaximumPoolSize(maximumPoolSize); managedExecutorService.setTaskQueueCapacity(taskQueueCapacity); + managedExecutorService.setUseVirtualThreads(useVirtualThreads); managedExecutorService.setUseForkJoinPool(useForkJoinPool); return managedExecutorService; } + @Override public String getResourceType () { return ServerTags.MANAGED_EXECUTOR_SERVICE; } diff --git a/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-executor-service.1 b/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-executor-service.1 index 02977bfcbe3..8fe3507815b 100644 --- a/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-executor-service.1 +++ b/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-executor-service.1 @@ -17,6 +17,7 @@ SYNOPSIS [--keepaliveseconds keepaliveseconds] [--threadlifetimeseconds threadlifetimeseconds] [--taskqueuecapacity taskqueuecapacity] + [--usevirtualthreads={false|true}] [--useforkjoinpool={false|true}] [--description description] [--property property] @@ -99,6 +100,15 @@ OPTIONS which means that the task queue is essentially unbounded and can store any number of submitted tasks. + --usevirtualthreads + If enabled, virtual threads will be used instead of the default + thread pool. They provide a quick creation, minimal overhead and + fast thread switching, but executed on a limited "carrying threads". + Use virtual threads for tasks, which depend on external resources + like database, microservices etc. Do not use them for long + calculation. Available only on Java 21 and later. + The default value is false. + --useforkjoinpool If enabled, a ForkJoinPool will be used instead of the default thread pool. This pool uses the Fork/Join framework, where all diff --git a/appserver/resources/resources-connector/src/main/java/org/glassfish/resources/admin/cli/ResourceConstants.java b/appserver/resources/resources-connector/src/main/java/org/glassfish/resources/admin/cli/ResourceConstants.java index 8ebdd6933bd..f8341a7f228 100644 --- a/appserver/resources/resources-connector/src/main/java/org/glassfish/resources/admin/cli/ResourceConstants.java +++ b/appserver/resources/resources-connector/src/main/java/org/glassfish/resources/admin/cli/ResourceConstants.java @@ -37,7 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ -// Portions Copyright [2017-2022] [Payara Foundation and/or its affiliates] +// Portions Copyright 2017-2025 [Payara Foundation and/or its affiliates] package org.glassfish.resources.admin.cli; @@ -252,6 +252,7 @@ public final class ResourceConstants { public static final String THREAD_PRIORITY = "thread-priority"; public static final String LONG_RUNNING_TASKS = "long-runnings-tasks"; public static final String USE_FORK_JOIN_POOL = "use-fork-join-pool"; + public static final String USE_VIRTUAL_THREADS = "use-virtual-threads"; public static final String HUNG_AFTER_SECONDS = "hung-after-seconds"; public static final String CORE_POOL_SIZE = "core-pool-size"; public static final String MAXIMUM_POOL_SIZE = "maximum-pool-size"; From fb2155ec516a01e060e3fc8df6c630ae4deb6bc6 Mon Sep 17 00:00:00 2001 From: Petr Aubrecht Date: Fri, 14 Feb 2025 19:22:31 +0100 Subject: [PATCH 03/11] FISH-8302 add configuration for virtual threads --- .../concurrent/config/ManagedExecutorService.java | 15 --------------- .../config/ManagedExecutorServiceBase.java | 15 +++++++++++++++ .../concurrent/config/ManagedThreadFactory.java | 15 +++++++++++++++ ...anagedScheduledExecutorDefinitionDeployer.java | 15 ++++++++++++--- .../ManagedScheduledExecutorServiceConfig.java | 6 ++++++ .../deployer/ManagedThreadFactoryConfig.java | 6 ++++++ .../ManagedThreadFactoryDescriptorDeployer.java | 8 ++++++++ .../ManagedThreadFactoryDefinitionHandler.java | 1 + .../ManagedThreadFactoryDefinitionDescriptor.java | 9 +++++++++ 9 files changed, 72 insertions(+), 18 deletions(-) diff --git a/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorService.java b/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorService.java index ceafa9aedc3..bcf7576e7c4 100644 --- a/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorService.java +++ b/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorService.java @@ -125,21 +125,6 @@ public interface ManagedExecutorService extends ConfigBeanProxy, Resource, */ void setUseForkJoinPool(String value) throws PropertyVetoException; - /** - * Gets the value of the useVirtualThreads property. - * - * @return possible object is {@link String } - */ - @Attribute(defaultValue = "false", dataType = Boolean.class) - String getUseVirtualThreads(); - - /** - * Sets the value of the useVirtualThreads property. - * - * @param value allowed object is {@link String } - */ - void setUseVirtualThreads(String value) throws PropertyVetoException; - @DuckTyped String getIdentity(); diff --git a/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorServiceBase.java b/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorServiceBase.java index fca5b8fb2c1..f1c3929e8fe 100644 --- a/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorServiceBase.java +++ b/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorServiceBase.java @@ -160,6 +160,21 @@ public interface ManagedExecutorServiceBase extends ConfigBeanProxy, */ void setThreadLifetimeSeconds(String value) throws PropertyVetoException; + /** + * Gets the value of the useVirtualThreads property. + * + * @return possible object is {@link String } + */ + @Attribute(defaultValue = "false", dataType = Boolean.class) + String getUseVirtualThreads(); + + /** + * Sets the value of the useVirtualThreads property. + * + * @param value allowed object is {@link String } + */ + void setUseVirtualThreads(String value) throws PropertyVetoException; + /** * Gets the value of the context property. * diff --git a/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedThreadFactory.java b/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedThreadFactory.java index ed374f3154e..c5ec72b8742 100644 --- a/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedThreadFactory.java +++ b/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedThreadFactory.java @@ -94,6 +94,21 @@ public interface ManagedThreadFactory extends ConfigBeanProxy, Resource, */ void setThreadPriority(String value) throws PropertyVetoException; + /** + * Gets the value of the useVirtualThreads property. + * + * @return possible object is {@link String } + */ + @Attribute(defaultValue = "false", dataType = Boolean.class) + String getUseVirtualThreads(); + + /** + * Sets the value of the useVirtualThreads property. + * + * @param value allowed object is {@link String } + */ + void setUseVirtualThreads(String value) throws PropertyVetoException; + /** * Gets the value of the context property. * diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java index 904c7909af1..cba5a33171d 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java @@ -62,8 +62,8 @@ import java.util.List; import java.util.logging.Logger; import org.glassfish.concurrent.runtime.ConcurrentRuntime; +import org.glassfish.concurro.AbstractManagedExecutorService; import org.glassfish.concurro.ContextServiceImpl; -import org.glassfish.concurro.ManagedScheduledExecutorServiceImpl; @Service @ResourceDeployerInfo(ManagedScheduledExecutorDefinitionDescriptor.class) @@ -94,7 +94,7 @@ public void deployResource(Object resource, String applicationName, String modul mseDefinitionDescriptor.getName(), mseDefinitionDescriptor.getResourceType()); ResourceInfo resourceInfo = new ResourceInfo(customNameOfResource, applicationName, moduleName); - ManagedScheduledExecutorServiceImpl managedScheduledExecutorService = concurrentRuntime.createManagedScheduledExecutorService(resourceInfo, mseConfig, contextService); + AbstractManagedExecutorService managedScheduledExecutorService = concurrentRuntime.createManagedScheduledExecutorService(resourceInfo, mseConfig, contextService); resourceNamingService.publishObject(resourceInfo, customNameOfResource, managedScheduledExecutorService, true); } @@ -185,7 +185,7 @@ public void setContextInfo(String value) throws PropertyVetoException { @Override public String getDescription() { - return null; + return "Managed Scheduled Executor Definition"; } @Override @@ -243,6 +243,15 @@ public void setThreadPriority(String value) throws PropertyVetoException { } + @Override + public String getUseVirtualThreads() { + return Boolean.toString(descriptor.getVirtual()); + } + + @Override + public void setUseVirtualThreads(String value) throws PropertyVetoException { + } + @Override public String getLongRunningTasks() { return null; diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorServiceConfig.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorServiceConfig.java index a1d70b02868..af4792522db 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorServiceConfig.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorServiceConfig.java @@ -49,6 +49,7 @@ public class ManagedScheduledExecutorServiceConfig extends BaseConfig { private int hungAfterSeconds; private boolean longRunningTasks; + private boolean useVirtualThread; private int threadPriority; private int corePoolSize; private long keepAliveSeconds; @@ -59,6 +60,7 @@ public ManagedScheduledExecutorServiceConfig(ManagedScheduledExecutorService con super(config.getJndiName(), config.getContextInfo(), config.getContextInfoEnabled()); hungAfterSeconds = parseInt(config.getHungAfterSeconds(), 0); longRunningTasks = Boolean.valueOf(config.getLongRunningTasks()); + useVirtualThread = Boolean.valueOf(config.getUseVirtualThreads()); threadPriority = parseInt(config.getThreadPriority(), Thread.NORM_PRIORITY); corePoolSize = parseInt(config.getCorePoolSize(), 0); keepAliveSeconds = parseLong(config.getKeepAliveSeconds(), 60); @@ -74,6 +76,10 @@ public boolean isLongRunningTasks() { return longRunningTasks; } + public boolean getUseVirtualThread() { + return useVirtualThread; + } + public int getThreadPriority() { return threadPriority; } diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryConfig.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryConfig.java index 4dd2a2a9e51..97f3248578b 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryConfig.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryConfig.java @@ -49,11 +49,13 @@ public class ManagedThreadFactoryConfig extends BaseConfig { private int threadPriority; + private boolean useVirtualThread; private String context; public ManagedThreadFactoryConfig(ManagedThreadFactory config) { super(config.getJndiName(), config.getContextInfo(), config.getContextInfoEnabled()); threadPriority = parseInt(config.getThreadPriority(), Thread.NORM_PRIORITY); + useVirtualThread = Boolean.valueOf(config.getUseVirtualThreads()); context = config.getContext(); } @@ -61,6 +63,10 @@ public int getThreadPriority() { return threadPriority; } + public boolean getUseVirtualThread() { + return useVirtualThread; + } + public String getContext() { return context; } diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java index daa861f755b..1e99e5aa815 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java @@ -317,6 +317,14 @@ public ConfigBeanProxy deepCopy(ConfigBeanProxy parent) throws TransactionFailur return null; } + @Override + public String getUseVirtualThreads() { + return Boolean.toString(descriptor.getVirtual()); + } + + @Override + public void setUseVirtualThreads(String value) throws PropertyVetoException { + } } } diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployment/annotation/handlers/ManagedThreadFactoryDefinitionHandler.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployment/annotation/handlers/ManagedThreadFactoryDefinitionHandler.java index ba558c8dbb6..01aed334ea8 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployment/annotation/handlers/ManagedThreadFactoryDefinitionHandler.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployment/annotation/handlers/ManagedThreadFactoryDefinitionHandler.java @@ -95,6 +95,7 @@ public ManagedThreadFactoryDefinitionDescriptor createDescriptor(ManagedThreadFa mtfdd.setMetadataSource(MetadataSource.ANNOTATION); mtfdd.setName(TranslatedConfigView.expandValue(managedThreadFactoryDefinition.name())); mtfdd.setContext(TranslatedConfigView.expandValue(managedThreadFactoryDefinition.context())); + mtfdd.setVirtual(managedThreadFactoryDefinition.virtual()); if(managedThreadFactoryDefinition.priority() <= 0) { mtfdd.setPriority(Thread.NORM_PRIORITY); } else { diff --git a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ManagedThreadFactoryDefinitionDescriptor.java b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ManagedThreadFactoryDefinitionDescriptor.java index 65ad2c92609..279f8da61ac 100644 --- a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ManagedThreadFactoryDefinitionDescriptor.java +++ b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ManagedThreadFactoryDefinitionDescriptor.java @@ -50,6 +50,7 @@ public class ManagedThreadFactoryDefinitionDescriptor extends ConcurrencyQualifi private String name; private String context; + private Boolean virtual = null; private int priority = Thread.NORM_PRIORITY; private Properties properties = new Properties(); @@ -96,6 +97,14 @@ public void setProperties(Properties properties) { this.properties = properties; } + public Boolean getVirtual() { + return virtual; + } + + public void setVirtual(Boolean virtual) { + this.virtual = virtual; + } + @Override public boolean equals(Object obj) { if (obj instanceof ManagedThreadFactoryDefinitionDescriptor) { From e3370cea6ed6a005ff78bc7afe12a6d48d1ec6f2 Mon Sep 17 00:00:00 2001 From: Petr Aubrecht Date: Fri, 14 Feb 2025 19:33:37 +0100 Subject: [PATCH 04/11] FISH-8302 use virtual threads classes for MSES and MTF if configured It the configuration specifies to use virtual threads, the new code uses the respective classes for managed scheduled executor service and managed thread factory. Managed executor service was already implemented. --- ...ScheduledExecutorServiceStatsProvider.java | 7 +- .../concurrent/runtime/ConcurrentRuntime.java | 117 +++++++++--------- .../deployer/ConcurrentObjectFactory.java | 12 +- 3 files changed, 69 insertions(+), 67 deletions(-) diff --git a/appserver/concurrent/concurrent-impl/src/main/java/fish/payara/concurrent/monitoring/ManagedScheduledExecutorServiceStatsProvider.java b/appserver/concurrent/concurrent-impl/src/main/java/fish/payara/concurrent/monitoring/ManagedScheduledExecutorServiceStatsProvider.java index 4e97be470ec..9730c95c69f 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/fish/payara/concurrent/monitoring/ManagedScheduledExecutorServiceStatsProvider.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/fish/payara/concurrent/monitoring/ManagedScheduledExecutorServiceStatsProvider.java @@ -20,7 +20,7 @@ import org.glassfish.concurrent.config.ManagedScheduledExecutorService; import org.glassfish.concurrent.runtime.ConcurrentRuntime; import org.glassfish.concurrent.runtime.deployer.ManagedScheduledExecutorServiceConfig; -import org.glassfish.concurro.ManagedScheduledExecutorServiceImpl; +import org.glassfish.concurro.AbstractManagedExecutorService; import org.glassfish.external.probe.provider.StatsProviderManager; import org.glassfish.external.statistics.CountStatistic; import org.glassfish.external.statistics.impl.CountStatisticImpl; @@ -41,9 +41,8 @@ public class ManagedScheduledExecutorServiceStatsProvider { private final String name; private boolean registered = false; - private final ManagedScheduledExecutorServiceImpl - managedScheduledExecutorServiceImpl; - + private final AbstractManagedExecutorService managedScheduledExecutorServiceImpl; + private CountStatisticImpl completedTaskCount = new CountStatisticImpl( "CompletedTaskCount", "count", "Number of tasks completed"); diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java index 44a4059a46a..d5ed1feaba3 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java @@ -45,6 +45,7 @@ import com.sun.enterprise.container.common.spi.util.ComponentEnvManager; import com.sun.enterprise.transaction.api.JavaEETransactionManager; import com.sun.enterprise.util.Utility; +import jakarta.enterprise.concurrent.ManagedThreadFactory; import org.glassfish.api.invocation.InvocationManager; import org.glassfish.concurrent.LogFacade; import org.glassfish.concurrent.runtime.deployer.ContextServiceConfig; @@ -79,6 +80,8 @@ import org.glassfish.concurro.ManagedScheduledExecutorServiceImpl; import org.glassfish.concurro.ManagedThreadFactoryImpl; import org.glassfish.concurro.virtualthreads.VirtualThreadsManagedExecutorService; +import org.glassfish.concurro.virtualthreads.VirtualThreadsManagedScheduledExecutorService; +import org.glassfish.concurro.virtualthreads.VirtualThreadsManagedThreadFactory; import org.glassfish.concurro.spi.ContextHandle; import org.glassfish.resourcebase.resources.naming.ResourceNamingService; @@ -91,8 +94,8 @@ public class ConcurrentRuntime implements PostConstruct, PreDestroy { private static ConcurrentRuntime _runtime; - private Map managedExecutorServiceMap; - private Map managedScheduledExecutorServiceMap; + private Map managedExecutorServiceMap = new HashMap(); + private Map managedScheduledExecutorServiceMap = new HashMap(); private Map contextServiceMap = new HashMap(); private Map managedThreadFactoryMap; @@ -208,7 +211,7 @@ public void shutdownContextService(String jndiName) { public synchronized AbstractManagedExecutorService getManagedExecutorService(ResourceInfo resourceInfo, ManagedExecutorServiceConfig config) { String jndiName = config.getJndiName(); - if (managedExecutorServiceMap != null && managedExecutorServiceMap.containsKey(jndiName)) { + if (managedExecutorServiceMap.containsKey(jndiName)) { return managedExecutorServiceMap.get(jndiName); } @@ -218,10 +221,6 @@ public synchronized AbstractManagedExecutorService getManagedExecutorService(Res config.isContextInfoEnabledBoolean(), true); AbstractManagedExecutorService mes = createManagedExecutorService(resourceInfo, config, contextService); - if (managedExecutorServiceMap == null) { - managedExecutorServiceMap = new HashMap(); - } - managedExecutorServiceMap.put(jndiName, mes); return mes; } @@ -290,57 +289,69 @@ public synchronized AbstractManagedExecutorService createManagedExecutorService( public void shutdownManagedExecutorService(String jndiName) { AbstractManagedExecutorService mes = null; synchronized(this) { - if (managedExecutorServiceMap != null) { - mes = managedExecutorServiceMap.remove(jndiName); - } + mes = managedExecutorServiceMap.remove(jndiName); } if (mes != null) { mes.shutdownNow(); } } - public synchronized ManagedScheduledExecutorServiceImpl getManagedScheduledExecutorService(ResourceInfo resource, - ManagedScheduledExecutorServiceConfig config) { + public synchronized AbstractManagedExecutorService getManagedScheduledExecutorService(ResourceInfo resource, + ManagedScheduledExecutorServiceConfig config) { String jndiName = config.getJndiName(); - if (managedScheduledExecutorServiceMap != null && managedScheduledExecutorServiceMap.containsKey(jndiName)) { - return managedScheduledExecutorServiceMap.get(jndiName); - } - ContextServiceImpl contextService = prepareContextService(createContextServiceName(config.getContext(), config.getJndiName()), - config.getContextInfo(), config.isContextInfoEnabledBoolean(), true); + AbstractManagedExecutorService mes = managedScheduledExecutorServiceMap.get(jndiName); + if (mes == null) { + ContextServiceImpl contextService = prepareContextService(createContextServiceName(config.getContext(), config.getJndiName()), + config.getContextInfo(), config.isContextInfoEnabledBoolean(), true); - ManagedScheduledExecutorServiceImpl mes = createManagedScheduledExecutorService(resource, config, contextService); + mes = createManagedScheduledExecutorService(resource, config, contextService); - if (managedScheduledExecutorServiceMap == null) { - managedScheduledExecutorServiceMap = new HashMap(); - } - managedScheduledExecutorServiceMap.put(jndiName, mes); - if (config.getHungAfterSeconds() > 0L && !config.isLongRunningTasks()) { - scheduleInternalTimer(); + managedScheduledExecutorServiceMap.put(jndiName, mes); + if (config.getHungAfterSeconds() > 0L && !config.isLongRunningTasks()) { + scheduleInternalTimer(); + } } return mes; } - public ManagedScheduledExecutorServiceImpl createManagedScheduledExecutorService(ResourceInfo resource, - ManagedScheduledExecutorServiceConfig config, ContextServiceImpl contextService) { + public AbstractManagedExecutorService createManagedScheduledExecutorService(ResourceInfo resource, + ManagedScheduledExecutorServiceConfig config, ContextServiceImpl contextService) { ManagedThreadFactoryImpl managedThreadFactory = new ThreadFactoryWrapper( config.getJndiName() + "-managedThreadFactory", null, config.getThreadPriority()); - // TODO: eventually use VT base MSES - ManagedScheduledExecutorServiceImpl mes = new ManagedScheduledExecutorServiceImpl(config.getJndiName(), - managedThreadFactory, - config.getHungAfterSeconds() * 1000L, // in millseconds - config.isLongRunningTasks(), - config.getCorePoolSize(), - config.getKeepAliveSeconds(), TimeUnit.SECONDS, - config.getThreadLifeTimeSeconds(), - contextService, - AbstractManagedExecutorService.RejectPolicy.ABORT); + AbstractManagedExecutorService mes = null; + boolean useVirtualThread = config.getUseVirtualThread(); + if (useVirtualThread) { + try { + mes = new VirtualThreadsManagedScheduledExecutorService(config.getJndiName(), + null, + config.getHungAfterSeconds() * 1_000L, // in milliseconds + config.isLongRunningTasks(), + Integer.MAX_VALUE, + Integer.MAX_VALUE, + contextService, + AbstractManagedExecutorService.RejectPolicy.ABORT); + } catch (Exception e) { + logger.log(Level.SEVERE, "Unable to start virtual threads managed executor service, JNDI '" + config.getJndiName() + "', fallback to " + (useVirtualThread ? "virtual threads" : "platform threads"), e); + } + } + if (mes == null) { + mes = new ManagedScheduledExecutorServiceImpl(config.getJndiName(), + managedThreadFactory, + config.getHungAfterSeconds() * 1000L, // in millseconds + config.isLongRunningTasks(), + config.getCorePoolSize(), + config.getKeepAliveSeconds(), TimeUnit.SECONDS, + config.getThreadLifeTimeSeconds(), + contextService, + AbstractManagedExecutorService.RejectPolicy.ABORT); + } return mes; } public void shutdownScheduledManagedExecutorService(String jndiName) { - ManagedScheduledExecutorServiceImpl mses = null; + AbstractManagedExecutorService mses = null; synchronized(this) { if (managedScheduledExecutorServiceMap != null) { mses = managedScheduledExecutorServiceMap.remove(jndiName); @@ -351,7 +362,7 @@ public void shutdownScheduledManagedExecutorService(String jndiName) { } } - public synchronized ManagedThreadFactoryImpl getManagedThreadFactory(ResourceInfo resource, ManagedThreadFactoryConfig config) { + public synchronized ManagedThreadFactory getManagedThreadFactory(ResourceInfo resource, ManagedThreadFactoryConfig config) { String jndiName = config.getJndiName(); if (managedThreadFactoryMap != null && managedThreadFactoryMap.containsKey(jndiName)) { return managedThreadFactoryMap.get(jndiName); @@ -370,9 +381,14 @@ public synchronized ManagedThreadFactoryImpl getManagedThreadFactory(ResourceInf } public ManagedThreadFactoryImpl createManagedThreadFactory(ResourceInfo resource, ManagedThreadFactoryConfig config, ContextServiceImpl contextService) { - ManagedThreadFactoryImpl managedThreadFactory = new ThreadFactoryWrapper(config.getJndiName(), contextService, - config.getThreadPriority()); - return managedThreadFactory; + if (config.getUseVirtualThread()) { + ManagedThreadFactoryImpl virtFactory = new VirtualThreadsManagedThreadFactory(config.getJndiName(), contextService); + return virtFactory; + } else { + ManagedThreadFactoryImpl managedThreadFactory = new ThreadFactoryWrapper(config.getJndiName(), contextService, + config.getThreadPriority()); + return managedThreadFactory; + } } public void shutdownManagedThreadFactory(String jndiName) { @@ -515,27 +531,16 @@ class HungTasksLogger implements Runnable { public void run() { ArrayList executorServices = new ArrayList(); - ArrayList scheduledExecutorServices = new ArrayList(); synchronized (ConcurrentRuntime.this) { - if (managedExecutorServiceMap != null) { - Collection mesColl = managedExecutorServiceMap.values(); - executorServices.addAll(mesColl); - } - } - synchronized (ConcurrentRuntime.this) { - if (managedScheduledExecutorServiceMap != null) { - Collection msesColl = managedScheduledExecutorServiceMap.values(); - scheduledExecutorServices.addAll(msesColl); - } + Collection mesColl = managedExecutorServiceMap.values(); + executorServices.addAll(mesColl); + Collection msesColl = managedScheduledExecutorServiceMap.values(); + executorServices.addAll(msesColl); } for (AbstractManagedExecutorService mes : executorServices) { Collection hungThreads = mes.getHungThreads(); logHungThreads(hungThreads, mes.getManagedThreadFactory(), mes.getName()); } - for (ManagedScheduledExecutorServiceImpl mses: scheduledExecutorServices) { - Collection hungThreads = mses.getHungThreads(); - logHungThreads(hungThreads, mses.getManagedThreadFactory(), mses.getName()); - } } private void logHungThreads(Collection hungThreads, ManagedThreadFactoryImpl mtf, String mesName) { diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ConcurrentObjectFactory.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ConcurrentObjectFactory.java index ebbf7d72ee0..83a44baee96 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ConcurrentObjectFactory.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ConcurrentObjectFactory.java @@ -42,12 +42,10 @@ package org.glassfish.concurrent.runtime.deployer; import jakarta.enterprise.concurrent.ManagedExecutorService; +import jakarta.enterprise.concurrent.ManagedThreadFactory; import org.glassfish.concurrent.runtime.ConcurrentRuntime; import org.glassfish.concurro.AbstractManagedExecutorService; import org.glassfish.concurro.ContextServiceImpl; -import org.glassfish.concurro.ManagedScheduledExecutorServiceAdapter; -import org.glassfish.concurro.ManagedScheduledExecutorServiceImpl; -import org.glassfish.concurro.ManagedThreadFactoryImpl; import org.glassfish.resourcebase.resources.api.ResourceInfo; import javax.naming.Context; @@ -95,8 +93,8 @@ private ContextServiceImpl getContextService(ContextServiceConfig config, Resour return contextService; } - private ManagedThreadFactoryImpl getManagedThreadFactory(ManagedThreadFactoryConfig config, ResourceInfo resourceInfo) { - ManagedThreadFactoryImpl managedThreadFactory = getRuntime().getManagedThreadFactory(resourceInfo, config); + private ManagedThreadFactory getManagedThreadFactory(ManagedThreadFactoryConfig config, ResourceInfo resourceInfo) { + ManagedThreadFactory managedThreadFactory = getRuntime().getManagedThreadFactory(resourceInfo, config); return managedThreadFactory; } @@ -105,8 +103,8 @@ private ManagedExecutorService getManagedExecutorService(ManagedExecutorServiceC return mes.getAdapter(); } - private ManagedScheduledExecutorServiceAdapter getManagedScheduledExecutorService(ManagedScheduledExecutorServiceConfig config, ResourceInfo resourceInfo) { - ManagedScheduledExecutorServiceImpl mes = getRuntime().getManagedScheduledExecutorService(resourceInfo, config); + private ManagedExecutorService getManagedScheduledExecutorService(ManagedScheduledExecutorServiceConfig config, ResourceInfo resourceInfo) { + AbstractManagedExecutorService mes = getRuntime().getManagedScheduledExecutorService(resourceInfo, config); return mes.getAdapter(); } From da9732a5b256d7614d9ca26a396c496a049c01fe Mon Sep 17 00:00:00 2001 From: Petr Aubrecht Date: Fri, 14 Feb 2025 19:39:37 +0100 Subject: [PATCH 05/11] FISH-8302 update copyright year --- .../org/glassfish/concurrent/config/ManagedExecutorService.java | 2 +- .../glassfish/concurrent/config/ManagedExecutorServiceBase.java | 2 +- .../org/glassfish/concurrent/config/ManagedThreadFactory.java | 2 +- .../ManagedScheduledExecutorServiceStatsProvider.java | 2 +- .../concurrent/runtime/deployer/ConcurrentObjectFactory.java | 2 +- .../deployer/ManagedScheduledExecutorDefinitionDeployer.java | 2 +- .../runtime/deployer/ManagedScheduledExecutorServiceConfig.java | 2 +- .../concurrent/runtime/deployer/ManagedThreadFactoryConfig.java | 2 +- .../deployer/ManagedThreadFactoryDescriptorDeployer.java | 2 +- .../handlers/ManagedThreadFactoryDefinitionHandler.java | 2 +- .../deployment/ManagedThreadFactoryDefinitionDescriptor.java | 2 +- 11 files changed, 11 insertions(+), 11 deletions(-) diff --git a/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorService.java b/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorService.java index bcf7576e7c4..d12f356f22e 100644 --- a/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorService.java +++ b/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorService.java @@ -37,7 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ -// Portions Copyright [2022-2024] Payara Foundation and/or affiliates +// Portions Copyright 2022-2025 Payara Foundation and/or affiliates package org.glassfish.concurrent.config; import com.sun.enterprise.config.modularity.ConfigBeanInstaller; diff --git a/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorServiceBase.java b/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorServiceBase.java index f1c3929e8fe..6f910b6022a 100644 --- a/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorServiceBase.java +++ b/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedExecutorServiceBase.java @@ -37,7 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ -// Portions Copyright [2022] Payara Foundation and/or affiliates +// Portions Copyright [2022-2025] Payara Foundation and/or affiliates package org.glassfish.concurrent.config; diff --git a/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedThreadFactory.java b/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedThreadFactory.java index c5ec72b8742..ee4e3e0ae22 100644 --- a/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedThreadFactory.java +++ b/appserver/concurrent/concurrent-connector/src/main/java/org/glassfish/concurrent/config/ManagedThreadFactory.java @@ -37,7 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ -// Portions Copyright [2022] Payara Foundation and/or affiliates +// Portions Copyright [2022-2025] Payara Foundation and/or affiliates package org.glassfish.concurrent.config; diff --git a/appserver/concurrent/concurrent-impl/src/main/java/fish/payara/concurrent/monitoring/ManagedScheduledExecutorServiceStatsProvider.java b/appserver/concurrent/concurrent-impl/src/main/java/fish/payara/concurrent/monitoring/ManagedScheduledExecutorServiceStatsProvider.java index 9730c95c69f..97decb1ba2e 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/fish/payara/concurrent/monitoring/ManagedScheduledExecutorServiceStatsProvider.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/fish/payara/concurrent/monitoring/ManagedScheduledExecutorServiceStatsProvider.java @@ -1,7 +1,7 @@ /** * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * - * Copyright (c) 2016-2024 Payara Foundation and/or its affiliates. + * Copyright (c) 2016-2025 Payara Foundation and/or its affiliates. * All rights reserved. * * The contents of this file are subject to the terms of the Common Development diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ConcurrentObjectFactory.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ConcurrentObjectFactory.java index 83a44baee96..de73d1c146a 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ConcurrentObjectFactory.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ConcurrentObjectFactory.java @@ -37,7 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ -// Portions Copyright [2018-2024] Payara Foundation and/or affiliates +// Portions Copyright [2018-2025] Payara Foundation and/or affiliates package org.glassfish.concurrent.runtime.deployer; diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java index cba5a33171d..b61fc7d88c3 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java @@ -1,7 +1,7 @@ /* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * - * Copyright (c) [2022-2024] Payara Foundation and/or its affiliates. All rights reserved. + * Copyright (c) [2022-2025] Payara Foundation and/or its affiliates. All rights reserved. * * The contents of this file are subject to the terms of either the GNU * General Public License Version 2 only ("GPL") or the Common Development diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorServiceConfig.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorServiceConfig.java index af4792522db..b24d21977df 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorServiceConfig.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorServiceConfig.java @@ -37,7 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ -// Portions Copyright [2022] Payara Foundation and/or affiliates +// Portions Copyright [2022-2025] Payara Foundation and/or affiliates package org.glassfish.concurrent.runtime.deployer; import org.glassfish.concurrent.config.ManagedScheduledExecutorService; diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryConfig.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryConfig.java index 97f3248578b..3af365f81a5 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryConfig.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryConfig.java @@ -37,7 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ -// Portions Copyright [2022] Payara Foundation and/or affiliates +// Portions Copyright [2022-2025] Payara Foundation and/or affiliates package org.glassfish.concurrent.runtime.deployer; diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java index 1e99e5aa815..735f11505b6 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java @@ -1,7 +1,7 @@ /* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * - * Copyright (c) [2022-2024] Payara Foundation and/or its affiliates. All rights reserved. + * Copyright (c) [2022-2025] Payara Foundation and/or its affiliates. All rights reserved. * * The contents of this file are subject to the terms of either the GNU * General Public License Version 2 only ("GPL") or the Common Development diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployment/annotation/handlers/ManagedThreadFactoryDefinitionHandler.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployment/annotation/handlers/ManagedThreadFactoryDefinitionHandler.java index 01aed334ea8..ba173c6c58c 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployment/annotation/handlers/ManagedThreadFactoryDefinitionHandler.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployment/annotation/handlers/ManagedThreadFactoryDefinitionHandler.java @@ -1,7 +1,7 @@ /* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * - * Copyright (c) [2022-2024] Payara Foundation and/or its affiliates. All rights reserved. + * Copyright (c) [2022-2025] Payara Foundation and/or its affiliates. All rights reserved. * * The contents of this file are subject to the terms of either the GNU * General Public License Version 2 only ("GPL") or the Common Development diff --git a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ManagedThreadFactoryDefinitionDescriptor.java b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ManagedThreadFactoryDefinitionDescriptor.java index 279f8da61ac..a72ecf7b555 100644 --- a/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ManagedThreadFactoryDefinitionDescriptor.java +++ b/appserver/deployment/dol/src/main/java/com/sun/enterprise/deployment/ManagedThreadFactoryDefinitionDescriptor.java @@ -1,7 +1,7 @@ /* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * - * Copyright (c) [2022-2024] Payara Foundation and/or its affiliates. All rights reserved. + * Copyright (c) 2022-2025 Payara Foundation and/or its affiliates. All rights reserved. * * The contents of this file are subject to the terms of either the GNU * General Public License Version 2 only ("GPL") or the Common Development From aa3851a229ac16a7aae1aa006039a1db8ac6d3b5 Mon Sep 17 00:00:00 2001 From: Petr Aubrecht Date: Mon, 17 Feb 2025 17:53:14 +0100 Subject: [PATCH 06/11] FISH-8302 finish virtual thread configurations for MSES and MTF --- .../src/main/resources/managedExecutorServiceEdit.jsf | 1 + .../resources/managedScheduledExecutorServiceEdit.jsf | 4 +++- .../resources/managedScheduledExecutorServiceNew.jsf | 4 +++- .../src/main/resources/managedThreadFactoryAttr.inc | 7 ++++++- .../src/main/resources/managedThreadFactoryEdit.jsf | 4 +++- .../src/main/resources/managedThreadFactoryNew.jsf | 4 +++- .../concurrent/admin/CreateManagedExecutorService.java | 5 ----- .../admin/CreateManagedExecutorServiceBase.java | 9 +++++++-- .../concurrent/admin/CreateManagedThreadFactory.java | 9 +++++++-- .../admin/ManagedExecutorServiceBaseManager.java | 4 +++- .../admin/ManagedExecutorServiceManager.java | 2 -- .../admin/ManagedScheduledExecutorServiceManager.java | 2 ++ .../concurrent/admin/ManagedThreadFactoryManager.java | 4 ++++ .../concurrent/runtime/ConcurrentRuntime.java | 2 +- .../admin/create-managed-scheduled-executor-service.1 | 10 ++++++++++ .../concurrent/admin/create-managed-thread-factory.1 | 10 ++++++++++ 16 files changed, 63 insertions(+), 18 deletions(-) diff --git a/appserver/admingui/concurrent/src/main/resources/managedExecutorServiceEdit.jsf b/appserver/admingui/concurrent/src/main/resources/managedExecutorServiceEdit.jsf index 8ca3fb112f7..3882e5c0220 100644 --- a/appserver/admingui/concurrent/src/main/resources/managedExecutorServiceEdit.jsf +++ b/appserver/admingui/concurrent/src/main/resources/managedExecutorServiceEdit.jsf @@ -74,6 +74,7 @@ setPageSessionAttribute(key="convertToFalseList2" value={"enabled"}); setPageSessionAttribute(key="showMaxPoolSize" value="#{true}"); setPageSessionAttribute(key="showForkJoin" value="#{true}"); + setPageSessionAttribute(key="showVirtualThreads" value="#{true}"); setPageSessionAttribute(key="showTaskQueue" value="#{true}"); setPageSessionAttribute(key="listCommand" value="list-managed-executor-services"); setPageSessionAttribute(key="logicalJndiMapKey" value="managedExecutorServices"); diff --git a/appserver/admingui/concurrent/src/main/resources/managedScheduledExecutorServiceEdit.jsf b/appserver/admingui/concurrent/src/main/resources/managedScheduledExecutorServiceEdit.jsf index 5c3daaa6ace..0c08cb8ba53 100644 --- a/appserver/admingui/concurrent/src/main/resources/managedScheduledExecutorServiceEdit.jsf +++ b/appserver/admingui/concurrent/src/main/resources/managedScheduledExecutorServiceEdit.jsf @@ -39,6 +39,7 @@ holder. --> + + @@ -55,7 +56,7 @@ setPageSessionAttribute(key="parentPage" value="#{request.contextPath}/concurrent/managedScheduledExecutorServices.jsf"); setPageSessionAttribute(key="childType" value="managed-scheduled-executor-service"); setPageSessionAttribute(key="isConcurrent" value="true"); - setPageSessionAttribute(key="convertToFalseList" value={"enabled", "contextInfoEnabled", "longRunningTasks" }); + setPageSessionAttribute(key="convertToFalseList" value={"enabled", "contextInfoEnabled", "longRunningTasks", "useVirtualThreads" }); setPageSessionAttribute(key="parentUrl", value="#{sessionScope.REST_URL}/resources"); gf.getDefaultValues(endpoint="#{pageSession.parentUrl}/#{pageSession.childType}", valueMap="#{pageSession.valueMap}"); setPageSessionAttribute(key="edit" value="#{false}" ); @@ -66,6 +67,7 @@ setPageSessionAttribute(key="showMaxPoolSize" value="#{false}"); setPageSessionAttribute(key="showTaskQueue" value="#{false}"); setPageSessionAttribute(key="showForkJoin" value="#{false}"); + setPageSessionAttribute(key="showVirtualThreads" value="#{true}"); /> " diff --git a/appserver/admingui/concurrent/src/main/resources/managedThreadFactoryAttr.inc b/appserver/admingui/concurrent/src/main/resources/managedThreadFactoryAttr.inc index 98d1626c594..918652b0c36 100644 --- a/appserver/admingui/concurrent/src/main/resources/managedThreadFactoryAttr.inc +++ b/appserver/admingui/concurrent/src/main/resources/managedThreadFactoryAttr.inc @@ -39,6 +39,7 @@ holder. --> + @@ -83,6 +84,10 @@ + + + + @@ -92,4 +97,4 @@ "

- \ No newline at end of file + diff --git a/appserver/admingui/concurrent/src/main/resources/managedThreadFactoryEdit.jsf b/appserver/admingui/concurrent/src/main/resources/managedThreadFactoryEdit.jsf index 4eeb782aa66..7a08c9f1e03 100644 --- a/appserver/admingui/concurrent/src/main/resources/managedThreadFactoryEdit.jsf +++ b/appserver/admingui/concurrent/src/main/resources/managedThreadFactoryEdit.jsf @@ -39,6 +39,7 @@ holder. --> + diff --git a/appserver/admingui/concurrent/src/main/resources/managedThreadFactoryNew.jsf b/appserver/admingui/concurrent/src/main/resources/managedThreadFactoryNew.jsf index 738e451d184..e18c1435d1e 100644 --- a/appserver/admingui/concurrent/src/main/resources/managedThreadFactoryNew.jsf +++ b/appserver/admingui/concurrent/src/main/resources/managedThreadFactoryNew.jsf @@ -39,6 +39,7 @@ holder. --> + @@ -55,10 +56,11 @@ setPageSessionAttribute(key="parentPage" value="#{request.contextPath}/concurrent/managedThreadFactories.jsf"); setPageSessionAttribute(key="childType" value="managed-thread-factory"); setPageSessionAttribute(key="isConcurrent" value="true"); - setPageSessionAttribute(key="convertToFalseList" value={"enabled", "contextInfoEnabled"}); + setPageSessionAttribute(key="convertToFalseList" value={"enabled", "contextInfoEnabled", "useVirtualThreads"}); setPageSessionAttribute(key="parentUrl", value="#{sessionScope.REST_URL}/resources"); gf.getDefaultValues(endpoint="#{pageSession.parentUrl}/#{pageSession.childType}", valueMap="#{pageSession.valueMap}"); setPageSessionAttribute(key="edit" value="#{false}" ); + setPageSessionAttribute(key="showVirtualThreads" value="#{true}"); createMap(result="#{pageSession.valueMap2}") mapPut(map="#{pageSession.valueMap}" key="enabled" value="true"); mapPut(map="#{pageSession.valueMap2}" key="enabled" value="true"); diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedExecutorService.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedExecutorService.java index fb1a686d8c3..67d7e083fd6 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedExecutorService.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedExecutorService.java @@ -77,9 +77,6 @@ public class CreateManagedExecutorService extends CreateManagedExecutorServiceBa @Param(name="taskqueuecapacity", alias="taskQueueCapacity", defaultValue=""+Integer.MAX_VALUE, optional=true) private Integer taskqueuecapacity; - @Param(name = "usevirtualthreads", alias = "useVirtualThreads", defaultValue = "false", optional = true) - protected Boolean usevirtualthreads; - @Param(name = "useforkjoinpool", alias = "useForkJoinPool", defaultValue = "false", optional = true) protected Boolean useforkjoinpool; @@ -95,8 +92,6 @@ protected void setAttributeList(HashMap attrList) { maximumpoolsize.toString()); attrList.put(ResourceConstants.TASK_QUEUE_CAPACITY, taskqueuecapacity.toString()); - attrList.put(ResourceConstants.USE_VIRTUAL_THREADS, - usevirtualthreads.toString()); attrList.put(ResourceConstants.USE_FORK_JOIN_POOL, useforkjoinpool.toString()); } diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedExecutorServiceBase.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedExecutorServiceBase.java index 58ddf14eb90..b3cfce10f8e 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedExecutorServiceBase.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedExecutorServiceBase.java @@ -37,7 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ -// Portions Copyright [2016-2018] [Payara Foundation and/or its affiliates] +// Portions Copyright [2016-2025] [Payara Foundation and/or its affiliates] package org.glassfish.concurrent.admin; @@ -89,7 +89,10 @@ public class CreateManagedExecutorServiceBase { @Param(name="threadlifetimeseconds", alias="threadLifetimeSeconds", defaultValue="0", optional=true) protected Integer threadlifetimeseconds; - @Param(optional=true) + @Param(name = "usevirtualthreads", alias = "useVirtualThreads", defaultValue = "false", optional = true) + protected Boolean usevirtualthreads; + + @Param(optional = true) protected String description; @Param(name="property", optional=true, separator=':') @@ -114,6 +117,8 @@ protected void setAttributeList(HashMap attrList) { keepaliveseconds.toString()); attrList.put(ResourceConstants.THREAD_LIFETIME_SECONDS, threadlifetimeseconds.toString()); + attrList.put(ResourceConstants.USE_VIRTUAL_THREADS, + usevirtualthreads.toString()); attrList.put(ServerTags.DESCRIPTION, description); attrList.put(ResourceConstants.ENABLED, enabled.toString()); } diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedThreadFactory.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedThreadFactory.java index f0ab3fc6caa..48ee6202b80 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedThreadFactory.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/CreateManagedThreadFactory.java @@ -37,7 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ -// Portions Copyright [2016-2021] [Payara Foundation and/or its affiliates] +// Portions Copyright [2016-2025] [Payara Foundation and/or its affiliates] package org.glassfish.concurrent.admin; @@ -92,7 +92,10 @@ public class CreateManagedThreadFactory implements AdminCommand { @Param(name="threadpriority", alias="threadPriority", defaultValue=""+Thread.NORM_PRIORITY, optional=true) private Integer threadpriority; - @Param(optional=true) + @Param(name = "usevirtualthreads", alias = "useVirtualThreads", defaultValue = "false", optional = true) + protected Boolean usevirtualthreads; + + @Param(optional = true) private String description; @Param(name="property", optional=true, separator=':') @@ -122,6 +125,8 @@ public void execute(AdminCommandContext context) { attrList.put(ResourceConstants.CONTEXT_INFO, contextinfo); attrList.put(ResourceConstants.THREAD_PRIORITY, threadpriority.toString()); + attrList.put(ResourceConstants.USE_VIRTUAL_THREADS, + usevirtualthreads.toString()); attrList.put(ServerTags.DESCRIPTION, description); attrList.put(ResourceConstants.ENABLED, enabled.toString()); ResourceStatus rs; diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedExecutorServiceBaseManager.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedExecutorServiceBaseManager.java index 79cb4a6b4f5..66f8b2152c4 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedExecutorServiceBaseManager.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedExecutorServiceBaseManager.java @@ -37,7 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ -// Portions Copyright [2016-2021] [Payara Foundation] +// Portions Copyright [2016-2025] [Payara Foundation] package org.glassfish.concurrent.admin; import com.sun.appserv.connectors.internal.api.ConnectorsUtil; @@ -87,6 +87,7 @@ public abstract class ManagedExecutorServiceBaseManager implements ResourceManag protected String corePoolSize = "0"; protected String keepAliveSeconds = "60"; protected String threadLifetimeSeconds = "0"; + protected String useVirtualThreads = Boolean.FALSE.toString(); protected String enabled = Boolean.TRUE.toString(); protected String enabledValueForTarget = Boolean.TRUE.toString(); @@ -173,6 +174,7 @@ protected void setAttributes(HashMap attributes, String target) { corePoolSize = (String) attributes.get(CORE_POOL_SIZE); keepAliveSeconds = (String) attributes.get(KEEP_ALIVE_SECONDS); threadLifetimeSeconds = (String) attributes.get(THREAD_LIFETIME_SECONDS); + useVirtualThreads = (String) attributes.getOrDefault(USE_VIRTUAL_THREADS, Boolean.FALSE.toString()); if(target != null){ enabled = resourceUtil.computeEnabledValueForResourceBasedOnTarget((String)attributes.get(ENABLED), target); }else{ diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedExecutorServiceManager.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedExecutorServiceManager.java index b6ce8cae578..0f4fbd7ab7e 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedExecutorServiceManager.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedExecutorServiceManager.java @@ -69,7 +69,6 @@ public class ManagedExecutorServiceManager extends ManagedExecutorServiceBaseMan private String maximumPoolSize = ""+Integer.MAX_VALUE; private String taskQueueCapacity = ""+Integer.MAX_VALUE; - private String useVirtualThreads = Boolean.FALSE.toString(); private String useForkJoinPool = Boolean.FALSE.toString(); @Override @@ -77,7 +76,6 @@ protected void setAttributes(HashMap attributes, String target) { super.setAttributes(attributes, target); maximumPoolSize = (String) attributes.get(MAXIMUM_POOL_SIZE); taskQueueCapacity = (String) attributes.get(TASK_QUEUE_CAPACITY); - useVirtualThreads = (String) attributes.getOrDefault(USE_VIRTUAL_THREADS, Boolean.FALSE.toString()); useForkJoinPool = (String) attributes.getOrDefault(USE_FORK_JOIN_POOL, Boolean.FALSE.toString()); } diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedScheduledExecutorServiceManager.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedScheduledExecutorServiceManager.java index 9eef8ea696f..7703feb08af 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedScheduledExecutorServiceManager.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedScheduledExecutorServiceManager.java @@ -37,6 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ +// Portions Copyright 2025 Payara Foundation and/or its affiliates package org.glassfish.concurrent.admin; @@ -68,6 +69,7 @@ public String getResourceType () { protected ManagedExecutorServiceBase createConfigBean(Resources param, Properties properties) throws PropertyVetoException, TransactionFailure { ManagedScheduledExecutorService managedExecutorService = param.createChild(ManagedScheduledExecutorService.class); + managedExecutorService.setUseVirtualThreads(useVirtualThreads); setAttributesOnConfigBean(managedExecutorService, properties); return managedExecutorService; } diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedThreadFactoryManager.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedThreadFactoryManager.java index 8d8ba748ce1..8c9c0c58664 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedThreadFactoryManager.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/admin/ManagedThreadFactoryManager.java @@ -37,6 +37,7 @@ * only if the new code is made subject to such option by the copyright * holder. */ +// Portions Copyright 2025 Payara Foundation and/or its affiliates package org.glassfish.concurrent.admin; @@ -87,6 +88,7 @@ public class ManagedThreadFactoryManager implements ResourceManager { private String threadPriority = ""+Thread.NORM_PRIORITY; private String contextInfoEnabled = Boolean.TRUE.toString(); private String contextInfo = CONTEXT_INFO_DEFAULT_VALUE; + private String useVirtualThreads = Boolean.FALSE.toString(); private String enabled = Boolean.TRUE.toString(); private String enabledValueForTarget = Boolean.TRUE.toString(); @@ -152,6 +154,7 @@ private void setAttributes(HashMap attributes, String target) { contextInfoEnabled = (String) attributes.get(CONTEXT_INFO_ENABLED); contextInfo = (String) attributes.get(CONTEXT_INFO); threadPriority = (String) attributes.get(THREAD_PRIORITY); + useVirtualThreads = (String) attributes.getOrDefault(USE_VIRTUAL_THREADS, Boolean.FALSE.toString()); if(target != null){ enabled = resourceUtil.computeEnabledValueForResourceBasedOnTarget((String)attributes.get(ENABLED), target); }else{ @@ -177,6 +180,7 @@ private ManagedThreadFactory createConfigBean(Resources param, Properties proper managedThreadFactory.setContextInfoEnabled(contextInfoEnabled); managedThreadFactory.setContextInfo(contextInfo); managedThreadFactory.setThreadPriority(threadPriority); + managedThreadFactory.setUseVirtualThreads(useVirtualThreads); managedThreadFactory.setEnabled(enabled); if (properties != null) { for ( Map.Entry e : properties.entrySet()) { diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java index d5ed1feaba3..7b71a86b167 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/ConcurrentRuntime.java @@ -316,7 +316,7 @@ public synchronized AbstractManagedExecutorService getManagedScheduledExecutorSe public AbstractManagedExecutorService createManagedScheduledExecutorService(ResourceInfo resource, ManagedScheduledExecutorServiceConfig config, ContextServiceImpl contextService) { - ManagedThreadFactoryImpl managedThreadFactory = new ThreadFactoryWrapper( + ManagedThreadFactoryImpl managedThreadFactory = new ThreadFactoryWrapper( // FIXME: move to the next if config.getJndiName() + "-managedThreadFactory", null, config.getThreadPriority()); diff --git a/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-scheduled-executor-service.1 b/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-scheduled-executor-service.1 index ce299bf5c4f..23ab6debd86 100644 --- a/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-scheduled-executor-service.1 +++ b/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-scheduled-executor-service.1 @@ -15,6 +15,7 @@ SYNOPSIS [--corepoolsize corepoolsize] [--keepaliveseconds keepaliveseconds] [--threadlifetimeseconds threadlifetimeseconds] + [--usevirtualthreads={false|true}] [--description description] [--property property] [--target target] @@ -77,6 +78,15 @@ OPTIONS idle. The default value is 0, which means that threads are never purged. + --usevirtualthreads + If enabled, virtual threads will be used instead of the default + thread pool. They provide a quick creation, minimal overhead and + fast thread switching, but executed on a limited "carrying threads". + Use virtual threads for tasks, which depend on external resources + like database, microservices etc. Do not use them for long + calculation. Available only on Java 21 and later. + The default value is false. + --description Descriptive details about the resource. diff --git a/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-thread-factory.1 b/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-thread-factory.1 index 06303db9c6e..f262ad61958 100644 --- a/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-thread-factory.1 +++ b/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-thread-factory.1 @@ -10,6 +10,7 @@ SYNOPSIS [--contextinfoenabled={false|true}] [--contextinfo={Classloader|JNDI|Security|WorkArea}] [--threadpriority threadpriority] + [--usevirtualthreads={false|true}] [--description description] [--property property] [--target target] @@ -45,6 +46,15 @@ OPTIONS Specifies the priority to assign to created threads. The default value is 5. + --usevirtualthreads + If enabled, virtual threads will be used instead of the default + thread pool. They provide a quick creation, minimal overhead and + fast thread switching, but executed on a limited "carrying threads". + Use virtual threads for tasks, which depend on external resources + like database, microservices etc. Do not use them for long + calculation. Available only on Java 21 and later. + The default value is false. + --description Descriptive details about the resource. From f08037f29528819041e8c2144b393065a0c24167 Mon Sep 17 00:00:00 2001 From: Petr Aubrecht Date: Wed, 19 Feb 2025 21:40:21 +0100 Subject: [PATCH 07/11] FISH-8302 improve create mes documentation Based on Andrew's review suggestion. Co-authored-by: Andrew Pielage --- .../admin/create-managed-executor-service.1 | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-executor-service.1 b/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-executor-service.1 index 8fe3507815b..feaa0cfec57 100644 --- a/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-executor-service.1 +++ b/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-executor-service.1 @@ -101,12 +101,12 @@ OPTIONS store any number of submitted tasks. --usevirtualthreads - If enabled, virtual threads will be used instead of the default - thread pool. They provide a quick creation, minimal overhead and - fast thread switching, but executed on a limited "carrying threads". - Use virtual threads for tasks, which depend on external resources - like database, microservices etc. Do not use them for long - calculation. Available only on Java 21 and later. + If enabled, virtual threads will be used instead of the default platform + thread pool. They provide quick creation, minimal overhead, and + fast thread switching, but are executed on limited "carrying threads". + Use virtual threads for tasks which depend on external resources + like databases, micro-services, etc. Do not use them for long + calculation. The default value is false. --useforkjoinpool From d26fc87260e671eda123fb0e2712f25d6f211437 Mon Sep 17 00:00:00 2001 From: Petr Aubrecht Date: Wed, 19 Feb 2025 21:40:50 +0100 Subject: [PATCH 08/11] FISH-8302 improve create mses documentation Based on Andrew's review suggestion. Co-authored-by: Andrew Pielage --- .../create-managed-scheduled-executor-service.1 | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-scheduled-executor-service.1 b/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-scheduled-executor-service.1 index 23ab6debd86..d392e8a42ae 100644 --- a/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-scheduled-executor-service.1 +++ b/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-scheduled-executor-service.1 @@ -79,12 +79,12 @@ OPTIONS purged. --usevirtualthreads - If enabled, virtual threads will be used instead of the default - thread pool. They provide a quick creation, minimal overhead and - fast thread switching, but executed on a limited "carrying threads". - Use virtual threads for tasks, which depend on external resources - like database, microservices etc. Do not use them for long - calculation. Available only on Java 21 and later. + If enabled, virtual threads will be used instead of the default platform + thread pool. They provide quick creation, minimal overhead, and + fast thread switching, but are executed on limited "carrying threads". + Use virtual threads for tasks which depend on external resources + like databases, micro-services, etc. Do not use them for long + calculation. The default value is false. --description From a220e5b27570059752c0ab178426088444834bca Mon Sep 17 00:00:00 2001 From: Petr Aubrecht Date: Wed, 19 Feb 2025 21:41:16 +0100 Subject: [PATCH 09/11] FISH-8302 improve create mtf documentation Based on Andrew's review suggestion. Co-authored-by: Andrew Pielage --- .../concurrent/admin/create-managed-thread-factory.1 | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-thread-factory.1 b/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-thread-factory.1 index f262ad61958..a5b22c8fec4 100644 --- a/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-thread-factory.1 +++ b/appserver/concurrent/concurrent-impl/src/main/manpages/org/glassfish/concurrent/admin/create-managed-thread-factory.1 @@ -47,12 +47,12 @@ OPTIONS value is 5. --usevirtualthreads - If enabled, virtual threads will be used instead of the default - thread pool. They provide a quick creation, minimal overhead and - fast thread switching, but executed on a limited "carrying threads". - Use virtual threads for tasks, which depend on external resources - like database, microservices etc. Do not use them for long - calculation. Available only on Java 21 and later. + If enabled, virtual threads will be used instead of the default platform + thread pool. They provide quick creation, minimal overhead, and + fast thread switching, but are executed on limited "carrying threads". + Use virtual threads for tasks which depend on external resources + like databases, micro-services, etc. Do not use them for long + calculation. The default value is false. --description From a6e5c0162db8b31de974a6bd5d03d8dd80546d2e Mon Sep 17 00:00:00 2001 From: Petr Aubrecht Date: Thu, 20 Feb 2025 02:20:25 +0100 Subject: [PATCH 10/11] FISH-8302 use descriptor description in concurrency definition deployers --- .../runtime/deployer/ManagedExecutorDescriptorDeployer.java | 2 +- .../deployer/ManagedScheduledExecutorDefinitionDeployer.java | 2 +- .../deployer/ManagedThreadFactoryDescriptorDeployer.java | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedExecutorDescriptorDeployer.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedExecutorDescriptorDeployer.java index d8f567f8ccd..77083011f55 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedExecutorDescriptorDeployer.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedExecutorDescriptorDeployer.java @@ -313,7 +313,7 @@ public void setContextInfo(String value) throws PropertyVetoException { @Override public String getDescription() { - return "Managed Executor Definition"; + return managedExecutorDefinitionDescriptor.getDescription(); } @Override diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java index b61fc7d88c3..f9479f3f5bd 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java @@ -185,7 +185,7 @@ public void setContextInfo(String value) throws PropertyVetoException { @Override public String getDescription() { - return "Managed Scheduled Executor Definition"; + return descriptor.getDescription(); } @Override diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java index 735f11505b6..87ed4dfaa76 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java @@ -184,7 +184,7 @@ public void setContextInfo(String value) throws PropertyVetoException { @Override public String getDescription() { - return null; + return descriptor.getDescription(); } @Override From a19931661e51611d9cc31e6b58ed0eeb7e86a856 Mon Sep 17 00:00:00 2001 From: Petr Aubrecht Date: Thu, 20 Feb 2025 22:17:18 +0100 Subject: [PATCH 11/11] FISH-8302 return false for of virtual threads in definition deployers if not specified --- .../deployer/ManagedScheduledExecutorDefinitionDeployer.java | 3 ++- .../deployer/ManagedThreadFactoryDescriptorDeployer.java | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java index f9479f3f5bd..6ef54a6008e 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedScheduledExecutorDefinitionDeployer.java @@ -245,7 +245,8 @@ public void setThreadPriority(String value) throws PropertyVetoException { @Override public String getUseVirtualThreads() { - return Boolean.toString(descriptor.getVirtual()); + Boolean virtualFromDefinition = descriptor.getVirtual(); + return (virtualFromDefinition == null ? Boolean.FALSE : virtualFromDefinition).toString(); } @Override diff --git a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java index 87ed4dfaa76..6e330bff03b 100644 --- a/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java +++ b/appserver/concurrent/concurrent-impl/src/main/java/org/glassfish/concurrent/runtime/deployer/ManagedThreadFactoryDescriptorDeployer.java @@ -319,7 +319,8 @@ public ConfigBeanProxy deepCopy(ConfigBeanProxy parent) throws TransactionFailur @Override public String getUseVirtualThreads() { - return Boolean.toString(descriptor.getVirtual()); + Boolean virtualFromDefinition = descriptor.getVirtual(); + return (virtualFromDefinition == null ? Boolean.FALSE : virtualFromDefinition).toString(); } @Override