SSM use @async and create threadpooltaskexecutor thread pool

Please see the specific configuration suggestions of thread pool : http://t.csdn.cn/nWaGH

Thread pool used directly in the project

stay applicationContext.xml Add in

    <bean id="userService" class="com.ssm.service.impl.UserServiceImpl">
        <property name="executor">
            <bean class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
                <property name="threadNamePrefix" value="user-"/>
                <property name="corePoolSize" value="20"/>
                <property name="maxPoolSize" value="20"/>
                <property name="keepAliveSeconds" value="300"/>
                <property name="queueCapacity" value="100"/>
            </bean>
        </property>
    </bean>

public class UserServiceImpl implements UserService {
    
    @Resource
    private UserDao userDao;

    private AsyncTaskExecutor executor;
    public void setExecutor(AsyncTaskExecutor executor) {
    
        this.executor = executor;
    }

    public void  getUserList() {
    
        // Multithreading 
        executor.execute(()->{
    
            System.out.println("========");
        });
    }
}

Configure asynchrony @Async

stay applicationContext.xml Create files in the same directory threadPool.xml file

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">

    <!--  Open asynchronous , And introduce thread pool   This tag is used to enable detection of any  Spring Managed bean Upper @Async and @Scheduled annotation  -->
    <task:annotation-driven executor="threadPool" />

    <!--  Define thread pool  -->
    <bean id="threadPool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <!--  Number of core threads , This is used by the whole system, so it is calculated according to the visits of the system  ( Peak second visits *1.5) -->
        <property name="corePoolSize" value="1000" />

        <!--  Maximum number of threads , The default is Integer.MAX_VALUE -->
        <property name="maxPoolSize" value="1000" />

        <!--  The maximum queue length is recommended (corePoolSize*2) -->
        <property name="queueCapacity" value="2000" />

        <!--  The thread pool maintains the free time allowed for threads , The default is 60s -->
        <property name="keepAliveSeconds" value="300" />

        <!--  Thread pool to reject task （ No threads available ） Handling strategy of , Currently only supported AbortPolicy、CallerRunsPolicy; Default to the latter  -->
        <property name="rejectedExecutionHandler">
            <!-- CallerRunsPolicy: As long as the thread pool is not closed , The policy is directly in the caller thread , Run the current discarded task .-->
            <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
        </property>
    </bean>
</beans>

Then later in applicationContext.xml Introduction in threadPool.xml：<import resource="threadPool.xml" />

test

The defined asynchronous method cannot be in the same class as the called asynchronous method , Otherwise it will not work

Here we simulate sending SMS after canceling the order , There are two ways to send text messages

@Service
public class TranTest2Service {
    


    //  Send a reminder message  1
    @Async("threadPool")
    public void sendMessage1() throws InterruptedException {
    

        System.out.println(" How to send SMS ---- 1  Execution start ");
        Thread.sleep(5000); //  Simulation takes time 
        System.out.println(" How to send SMS ---- 1  end of execution ");
    }

    //  Send a reminder message  2
    @Async("threadPool")
    public void sendMessage2() throws InterruptedException {
    

        System.out.println(" How to send SMS ---- 2  Execution start ");
        Thread.sleep(2000); //  Simulation takes time 
        System.out.println(" How to send SMS ---- 2  end of execution ");
    }
}

Call the method of sending text messages

    @Autowired
    private TranTest2Service tranTest2Service;

    //  Order processing task 
    @GetMapping(path = "/orderTask")
    public void orderTask() throws InterruptedException {
    
        tranTest2Service.sendMessage1(); //  How to send text messages  1
        tranTest2Service.sendMessage2(); //  How to send text messages  2
    }

Use @Async effect

Don't use @Async effect

be based on @Async Call to return value

@Async("threadPool")
public Future<String> asyncMethodWithReturnType() {
    
    System.out.println("Execute method asynchronously - "
      + Thread.currentThread().getName());
    try {
    
        Thread.sleep(5000);
        return new AsyncResult<String>("hello world !!!!");
    } catch (InterruptedException e) {
    
        //
    }
 
    return null;
}

The above example shows , The data type returned is Future type , It's an interface . The specific result type is AsyncResult, This is what needs attention .
An example of an asynchronous method that returns a result ：

public void testAsyncAnnotationForMethodsWithReturnType()
   throws InterruptedException, ExecutionException {
    
    System.out.println("Invoking an asynchronous method. "
      + Thread.currentThread().getName());
    Future<String> future = asyncAnnotationExample.asyncMethodWithReturnType();
 	// After blocking all threads , Get the content returned by the thread 
	future.get()
}

be based on @Async Exception handling mechanism in call

In asynchronous methods , If there is an anomaly , For the caller caller for , Is imperceptible . If you really need exception handling , Then proceed as follows ：

    <task:annotation-driven executor="exceptionHandlingTaskExecutor" />
    <bean id="exceptionHandlingTaskExecutor" class=" com.ssm.service.impl.ExceptionHandlingAsyncTaskExecutor">
        <constructor-arg ref="threadPool" />
    </bean>

public class ExceptionHandlingAsyncTaskExecutor implements AsyncTaskExecutor {
    
    private AsyncTaskExecutor executor;
    public ExceptionHandlingAsyncTaskExecutor(AsyncTaskExecutor executor) {
    
        this.executor = executor;
    }
    // Wrap... With separate threads ,@Async This is the essence of it 
    @Override
    public void execute(Runnable task) {
    
        executor.execute(createWrappedRunnable(task));
    }
    @Override
    public void execute(Runnable task, long startTimeout) {
    
        // Wrap... With separate threads ,@Async This is the essence of it 
        executor.execute(createWrappedRunnable(task), startTimeout);
    }
    @Override
    public Future submit(Runnable task) {
    
        // Wrap... With separate threads ,@Async This is the essence of it . 
        return executor.submit(createWrappedRunnable(task));
    }
    @Override
    public Future submit(final Callable task) {
    
        // Wrap... With separate threads ,@Async This is the essence of it .
        return executor.submit(createCallable(task));
    }

    private Callable createCallable(final Callable task) {
    
        return new Callable() {
    
            @Override
            public Object call() throws Exception {
    
                try {
    
                    return task.call();
                } catch (Exception ex) {
    
                    handle(ex);
                    throw ex;
                }
            }
        };
    }

    private Runnable createWrappedRunnable(final Runnable task) {
    
        return new Runnable() {
    
            @Override
            public void run() {
    
                try {
    
                    task.run();
                } catch (Exception ex) {
    
                    handle(ex);
                }
            }
        };
    }
    private void handle(Exception ex) {
    
        // Specific exception logic processing place 
        System.err.println("Error during @Async execution: " + ex);
    }
}

give the thumbs-up - Collection - Focus on - Easy to review and receive the latest content in the future There are other questions to discuss in the comments section - Or believe me - I will reply as soon as I receive it The technology learned in this blog should not be directly or indirectly engaged in any way in violation of the laws of the people's Republic of China , The content is for learning only 、 Communication and reference disclaimer ： Part of the material in this paper comes from the Internet , The copyright belongs to the creator , If articles exist / picture / Improper use of audio and video , Please feel free to contact me by private letter 、 To take prompt and appropriate measures , Avoid unnecessary economic losses to both parties . thank , coordination , I hope my efforts will help you ^_^