Spring Quartz uses multithreaded concurrency "traps"

Define a job:ranjob, set to execute once per second, set does not allow overwriting concurrent execution

    <BeanID= "Rankjob"class= "Com.chinacache.www.logstat.job.RankJob" />      <BeanID= "Rankjobdetail"class= "Org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">          < Propertyname= "TargetObject"ref= "Rankjob" />          < Propertyname= "Targetmethod"value= "Execute" />          < Propertyname= "Concurrent"value="false"/></Bean>      <BeanID= "Rankjobtrigger"class= "Org.springframework.scheduling.quartz.SimpleTriggerBean">          < Propertyname= "Jobdetail"ref= "Rankjobdetail" />          <!--unit MS, half-hour 1800000 Ms -          < Propertyname= "Repeatinterval"value= "/> </bean>

Java code

 Public voidExecute ()throwsinterruptedexception {System.out.println ("Start Job"); Executorservice exec= Executors.newfixedthreadpool (1); Thread Thread=NewThread (NewRunnable () {@Override Public voidrun () {System.out.println ("Thread Start"); Try{Thread.Sleep (3000); } Catch(interruptedexception e) {//TODO auto-generated Catch blockE.printstacktrace (); } System.out.println ("Thread End");          }          });          Exec.execute (thread);             Exec.shutdown ();  while(!exec.isterminated ()) {                 //waits for all child threads to end before exiting the main thread} System.out.println ("End Job"); }  

The printing results are as follows:

    Start Job      thread start      thread end      End job            start Job      thread start      thread end      End Job            Start Job      thread start      thread end      End Job  

Use the isterminated () method to end the job after multiple threads have ended, and after the multi-threaded task is dispatched, use the shutdown () method to close the thread (waiting for the task to be performed and not accepting new tasks)

Define a job:ranjob, set to execute once per second, set does not allow overwriting concurrent execution

2. <Bean id= "rankjob" class="Com.chinacache.www.logstat.job.RankJob" />
4. <Bean id="Rankjobdetail"
6. class="Org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
8. <property name= "targetObject" ref="rankjob" />
10. <property name="Targetmethod" value="execute" />
12. <property name="concurrent" value= "<span style="color: #ff0000; "  ><strong>false</strong></span> " />
14. </Bean>
16. <Bean id= "rankjobtrigger" class="Org.springframework.scheduling.quartz.SimpleTriggerBean" >
18. <property name= "jobdetail" ref="Rankjobdetail" />
20. <!--unit MS, half-hour 1800000 ms---
22. <property name="Repeatinterval" value= "<span style="color: #ff0000; "  ><strong>1000</strong></span> " />
24. </Bean>

Job Code:

2. System.out.println ("Start job");
4. Executorservice exec = Executors.newfixedthreadpool (1);
8. Thread thread = new Thread (new Runnable () {
10. @Override
12. public Void Run () {
14. System.out.println ("thread Start");
16. try {
18. Thread.Sleep (3000);
20. } catch (Interruptedexception e) {
22. //TODO auto-generated catch block
24. E.printstacktrace ();
26. }
28. System.out.println ("thread End");
30. }
32. });
34. Exec.execute (thread);
36. System.out.println ("End Job");

Program Output Result:

1. Start Job
2. End Job
3. <span style="color: #ff0000;" ><strong>thread start</strong></span>
4. Start Job
5. End Job
6. Thread Start
7. Start Job
8. End Job
9. Thread Start
10. Start Job
11. End Job
12. Thread Start
13. <strong><span style="color: #ff0000;" >thread end</span></strong>

As you can see from the results, the concurrency override configuration for the job does not seem to be effective at all because the job is not focused on multithreaded execution

Modify the job code to add the following code at the end of the job access, the thread finishes processing the job,

1. while (!exec.isterminated ()) {
2. //wait for all child threads to end before exiting the main thread
3. }

Program results after modifying code:

1. Start Job
2. Thread Start
3. Thread End

You can see that the job never ends, stating that Executorservice never terminates, look at the document, add the Shutdonw () method, and the job all code is as follows:

2. Public Void Execute () throws interruptedexception {
4. System.out.println ("Start job");
6. Executorservice exec = Executors.newfixedthreadpool (1);
10. Thread thread = new Thread (new Runnable () {
12. @Override
14. public Void Run () {
16. System.out.println ("thread Start");
18. try {
20. Thread.Sleep (3000);
22. } catch (Interruptedexception e) {
24. //TODO auto-generated catch block
26. E.printstacktrace ();
28. }
30. System.out.println ("thread End");
32. }
34. });
36. Exec.execute (thread);
38. Exec.shutdown ();
40. While (!exec.isterminated ()) {
42. //wait for all child threads to end before exiting the main thread
44. }
46. System.out.println ("End Job");
48. }

The printing results are as follows:

1. Start Job
2. Thread Start
3. Thread End
4. End Job
6. Start Job
7. Thread Start
8. Thread End
9. End Job
11. Start Job
12. Thread Start
13. Thread End
14. End Job

OK, this spring quartz multithreading concurrency problem solved. In retrospect, we're going to use the isterminated () method to end the job after multiple threads are finished, and after the multi-threaded task is dispatched, use the shutdown () method to close the thread (waiting for the task to be performed, not accepting new tasks)

Spring Quartz uses multithreading concurrency "traps" (go)