当前位置：文江博客话题详情

调整Spring容器的任务支持使用的线程

发布于 2024-09-04 01:29:24 字数 33 浏览 3 评论 0原文

是否可以调整Spring容器的任务支持使用的线程数？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

等你爱我 2024-09-11 01:29:24

如果您想在运行时调整它，那么我相信您唯一的选择是以编程方式进行。

将 java.util.concurrent.ExecutorService 注入到 Spring 的任务支持中，如下所示：

<bean id="executorService" class="java.util.concurrent.Executors"
    factory-method="newFixedThreadPool">
    <constructor-arg value="5" />
</bean>

<task:annotation-driven executor="executorService" />

然后您可以像这样调整 ExecutorService 使用的线程：

@Inject
ExecutorService executorService;

public void adjustPoolSize() {
    ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executorService;
    threadPoolExecutor.setMaximumPoolSize(10);
    threadPoolExecutor.setCorePoolSize(20);
}

我已经写了更多关于并发的文章Spring 这里。

If you want to adjust it at runtime, then I believe your only choice is to do it programatically.

Inject a java.util.concurrent.ExecutorServiceinto Spring's task support like this:

<bean id="executorService" class="java.util.concurrent.Executors"
    factory-method="newFixedThreadPool">
    <constructor-arg value="5" />
</bean>

<task:annotation-driven executor="executorService" />

Then you can adjust the threads used by the ExecutorService like this:

@Inject
ExecutorService executorService;

public void adjustPoolSize() {
    ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executorService;
    threadPoolExecutor.setMaximumPoolSize(10);
    threadPoolExecutor.setCorePoolSize(20);
}

I have written more about concurrency with Spring here.

回复收藏 0 原文

秋日私语 2024-09-11 01:29:24

如果你的意思是任务，就像计划任务一样，那么我不相信，至少不直接相信，因为任务执行通常是同步的 - 也就是说，同一任务的两次调用在同一个线程上执行 - 这至少是对于 JDK Timer 类为 true，该类为每个 Timer 使用专用线程 - 因此计时器的多次触发在同一线程上执行。

如果您希望针对线程池执行任务，最好的办法是将任务与计时器分开，并让计时器在线程池上调用您的任务。您可以配置运行任务的线程池，这样您就可以完全控制线程数量。

计时器调用的任务

   public class TimerTaskInvoker extends TimerTask
   {
       TaskExecutor  executor;
       Runnable      taskToRun;

       public void run() {
          executor.execute(taskRoRun);
       }
   }

在您的 spring 配置中如下所示

<!-- the thread pool for executing tasks -->
<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
  <property name="corePoolSize" value="5" />
  <property name="maxPoolSize" value="10" />
  <property name="queueCapacity" value="25" />
</bean>

<!-- invokes your actual task from the timer -->
<bean id="yourTaskInvoker" class="TimerTaskInvoker">
    <property name="executor" value="taskExecutor"/>
    <property name="taskToRun">
       <bean class="YourTaskClass">
          <!-- your task properties etc... -->
       </bean>
    </property>
</bean>

<!-- schedules execution of yourTaskInvoker -->    
<bean id="scheduledTask" class="org.springframework.scheduling.timer.ScheduledTimerTask">
    <!-- wait 10 seconds before starting repeated execution -->
    <property name="delay" value="10000" />
    <!-- run every 50 seconds -->
    <property name="period" value="50000" />
    <property name="timerTask" ref="yourTaskInvoker" />
</bean>

If you mean tasks, as in scheduled tasks, then I don't believe so, at least not directly, since task execution is normally synchronous - that is, two invocations of the same task are executed on the same thread - this is at least true for the JDK Timer class which uses a dedicated thread for each Timer - so multiple firings of the timer execute on the same thread.

If you want to have tasks executed against a thread pool, your best bet is to separate the task from the timer, and have the timer invoke your task on a thread pool. You get to configure the thread pool running the task and so you have full control over the number of threads.

The task invoked by the Timer looks like this

   public class TimerTaskInvoker extends TimerTask
   {
       TaskExecutor  executor;
       Runnable      taskToRun;

       public void run() {
          executor.execute(taskRoRun);
       }
   }

In your spring config

<!-- the thread pool for executing tasks -->
<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
  <property name="corePoolSize" value="5" />
  <property name="maxPoolSize" value="10" />
  <property name="queueCapacity" value="25" />
</bean>

<!-- invokes your actual task from the timer -->
<bean id="yourTaskInvoker" class="TimerTaskInvoker">
    <property name="executor" value="taskExecutor"/>
    <property name="taskToRun">
       <bean class="YourTaskClass">
          <!-- your task properties etc... -->
       </bean>
    </property>
</bean>

<!-- schedules execution of yourTaskInvoker -->    
<bean id="scheduledTask" class="org.springframework.scheduling.timer.ScheduledTimerTask">
    <!-- wait 10 seconds before starting repeated execution -->
    <property name="delay" value="10000" />
    <!-- run every 50 seconds -->
    <property name="period" value="50000" />
    <property name="timerTask" ref="yourTaskInvoker" />
</bean>

回复收藏 0 原文

~没有更多了~