springboot多线程注解Async

在数据处理中，多线程用到的场景很多，在满足计算机CPU处理能力的情况下，使用多线程可以明显提高程序运行效率，缩短大数据处理的能力。作为java程序开发，离不开spring,那么在spring中怎么创建多线程并将注册到spring的类在多线程中使用呢？我自己总结了一下，可以有两种方式，使用线程池和spring自带多线程注解使用。

使用线程池

我一般使用固定线程数量的线程池，假如数据量很大，我会将数据放到一个大集合中，然后按照一定的比例分配数目，同时我自己写了一个分页类，线程的数量可以根据分页类来自动调整。看代码:
分页类

1. package com.yiche.tag.model;

3. import java.util.List;

5. public class DataPage {

6. private int page = 1; // 当前页

8. public int totalPages = 0; // 总页数

10. private int pageRecorders;// 每页5条数据

12. private int totalRows = 0; // 总数据数

14. private int pageStartRow = 0;// 每页的起始数

16. private int pageEndRow = 0; // 每页显示数据的终止数

18. private boolean hasNextPage = false; // 是否有下一页

20. private boolean hasPreviousPage = false; // 是否有前一页

22. private List list;

24. // private Iterator it;

26. public DataPage(List list, int pageRecorders) {

27. init(list, pageRecorders);// 通过对象集，记录总数划分

28. }

30. /** *//**

31. * 初始化list，并告之该list每页的记录数

32. * @param list

33. * @param pageRecorders

34. */

35. public void init(List list, int pageRecorders) {

36. this.pageRecorders = pageRecorders;

37. this.list = list;

38. totalRows = list.size();

39. // it = list.iterator();

40. hasPreviousPage = false;

41. if ((totalRows % pageRecorders) == 0) {

42. totalPages = totalRows / pageRecorders;

43. } else {

44. totalPages = totalRows / pageRecorders + 1;

45. }

47. if (page >= totalPages) {

48. hasNextPage = false;

49. } else {

50. hasNextPage = true;

51. }

53. if (totalRows < pageRecorders) {

54. this.pageStartRow = 0;

55. this.pageEndRow = totalRows;

56. } else {

57. this.pageStartRow = 0;

58. this.pageEndRow = pageRecorders;

59. }

60. }

63. // 判断要不要分页

64. public boolean isNext() {

65. return list.size() > 5;

66. }

68. public void setHasPreviousPage(boolean hasPreviousPage) {

69. this.hasPreviousPage = hasPreviousPage;

70. }

72. public String toString(int temp) {

73. String str = Integer.toString(temp);

74. return str;

75. }

77. public void description() {

79. String description = "共有数据数:" + this.getTotalRows() +

81. "共有页数: " + this.getTotalPages() +

83. "当前页数为:" + this.getPage() +

85. " 是否有前一页: " + this.isHasPreviousPage() +

87. " 是否有下一页:" + this.isHasNextPage() +

89. " 开始行数:" + this.getPageStartRow() +

91. " 终止行数:" + this.getPageEndRow();

93. System.out.println(description);

94. }

96. public List getNextPage() {

97. page = page + 1;

99. disposePage();

101. System.out.println("用户凋用的是第" + page + "页");

102. this.description();

103. return getObjects(page);

104. }

106. /** *//**

107. * 处理分页

108. */

109. private void disposePage() {

111. if (page == 0) {

112. page = 1;

113. }

115. if ((page - 1) > 0) {

116. hasPreviousPage = true;

117. } else {

118. hasPreviousPage = false;

119. }

121. if (page >= totalPages) {

122. hasNextPage = false;

123. } else {

124. hasNextPage = true;

125. }

126. }

128. public List getPreviousPage() {

130. page = page - 1;

132. if ((page - 1) > 0) {

133. hasPreviousPage = true;

134. } else {

135. hasPreviousPage = false;

136. }

137. if (page >= totalPages) {

138. hasNextPage = false;

139. } else {

140. hasNextPage = true;

141. }

142. this.description();

143. return getObjects(page);

144. }

146. /** *//**

147. * 获取第几页的内容

148. *

149. * @param page 从1开始

150. * @return

151. */

152. public List getObjects(int page) {

153. if (page == 0)

154. this.setPage(1);

155. else

156. this.setPage(page);

157. this.disposePage();

158. if (page * pageRecorders < totalRows) {// 判断是否为最后一页

159. pageEndRow = page * pageRecorders;

160. pageStartRow = pageEndRow - pageRecorders;

161. } else {

162. pageEndRow = totalRows;

163. pageStartRow = pageRecorders * (totalPages - 1);

164. }

166. List objects = null;

167. if (!list.isEmpty()) {

168. objects = list.subList(pageStartRow, pageEndRow);

169. }

170. //this.description();

171. return objects;

172. }

174. public List getFistPage() {

175. if (this.isNext()) {

176. return list.subList(0, pageRecorders);

177. } else {

178. return list;

179. }

180. }

182. public boolean isHasNextPage() {

183. return hasNextPage;

184. }

187. public void setHasNextPage(boolean hasNextPage) {

188. this.hasNextPage = hasNextPage;

189. }

192. public List getList() {

193. return list;

194. }

197. public void setList(List list) {

198. this.list = list;

199. }

202. public int getPage() {

203. return page;

204. }

207. public void setPage(int page) {

208. this.page = page;

209. }

212. public int getPageEndRow() {

213. return pageEndRow;

214. }

217. public void setPageEndRow(int pageEndRow) {

218. this.pageEndRow = pageEndRow;

219. }

222. public int getPageRecorders() {

223. return pageRecorders;

224. }

227. public void setPageRecorders(int pageRecorders) {

228. this.pageRecorders = pageRecorders;

229. }

232. public int getPageStartRow() {

233. return pageStartRow;

234. }

237. public void setPageStartRow(int pageStartRow) {

238. this.pageStartRow = pageStartRow;

239. }

242. public int getTotalPages() {

243. return totalPages;

244. }

247. public void setTotalPages(int totalPages) {

248. this.totalPages = totalPages;

249. }

252. public int getTotalRows() {

253. return totalRows;

254. }

257. public void setTotalRows(int totalRows) {

258. this.totalRows = totalRows;

259. }

262. public boolean isHasPreviousPage() {

263. return hasPreviousPage;

264. }

266. }

这个分页类可以多个项目复用，既可以实现分页，还可以用到线程池中给线程分配数量使用。以下代码为如何使用该分页类给线程池使用的。

1. List<Integer> carModelIds = carsTagService.getAllCarModelIds();

2. DataPage dataPage = new DataPage(carModelIds, 300);

3. ExecutorService executorService = Executors.newFixedThreadPool(dataPage.totalPages);

4. for (int i = 0; i < dataPage.totalPages; i++) {

5. final int index = i + 1;

6. executorService.execute(new Runnable() {

7. List<Integer> temp = dataPage.getObjects(index);

8. @Override

9. public void run() {

10. try {

11. if (temp != null && temp.size() > 0) {

12. temp=Collections.synchronizedList(temp);

13. int sum = 0;

14. for (Integer carId : temp) {

15. try {

16. carsTagService.insertCarTagByCarId(carId);

17. sum++;

18. if (sum % 100 == 0) {

19. System.out.println("线程" + index + "当前执行了" + sum + "条,当前进度是" + sum * 100/ temp.size() + "%");

20. }

21. } catch (Exception ex) {

22. ex.printStackTrace();

23. }

24. }

25. System.out.println("线程" + index + "执行CarTagInitTask任务成功:" + temp.size());

26. } else {

27. System.out.println("CarTagInitTask任务执行完成:未读取到数据！");

28. }

29. } catch (Exception e) {

30. e.printStackTrace();

31. }

32. }

33. });

34. }

35. executorService.shutdown();

36. while (true) {

37. if (executorService.isTerminated()) {

38. System.out.println("所有的子线程都结束了！");

39. break;

40. }

41. try {

42. Thread.sleep(2000);

43. } catch (InterruptedException e) {

44. e.printStackTrace();

45. }

46. }

上述代码中carModelIds就是要处理的数据集合，数目很大，如果直接for循环将会消耗很多的时间，利用线程池可以解决这个问题。但是如果直接创建多线程，线程中使用的对象需要final修饰，这对于spring管理的类不适用。使用线程池可以解决这个问题。

使用springboot自带@Async注解创建异步线程

在springboot中，可以使用@Async注解来将一个方法设置为异步方法，调用该方法的时候，是新开一个线程去调用。代码如下：

1. @Component

2. public class Task {

3. @Async

4. public void doTaskOne() throws Exception {

5. System.out.println("开始做任务一");

6. long start = System.currentTimeMillis();

7. Thread.sleep(random.nextInt(10000));

8. long end = System.currentTimeMillis();

9. System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");

10. }

11. @Async

12. public void doTaskTwo() throws Exception {

13. System.out.println("开始做任务二");

14. long start = System.currentTimeMillis();

15. Thread.sleep(random.nextInt(10000));

16. long end = System.currentTimeMillis();

17. System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");

18. }

19. @Async

20. public void doTaskThree() throws Exception {

21. System.out.println("开始做任务三");

22. long start = System.currentTimeMillis();

23. Thread.sleep(random.nextInt(10000));

24. long end = System.currentTimeMillis();

25. System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");

26. }

27. }

为了让@Async注解能够生效，还需要在Spring Boot的主程序中配置@EnableAsync，如下所示：

1. @SpringBootApplication

2. @EnableAsync

3. public class Application {

4. public static void main(String[] args) {

5. SpringApplication.run(Application.class, args);

6. }

7. }

此时可以反复执行单元测试，您可能会遇到各种不同的结果，比如：

• 没有任何任务相关的输出
• 有部分任务相关的输出
• 乱序的任务相关的输出

原因是目前doTaskOne、doTaskTwo、doTaskThree三个函数的时候已经是异步执行了。主程序在异步调用之后，主程序并不会理会这三个函数是否执行完成了，由于没有其他需要执行的内容，所以程序就自动结束了，导致了不完整或是没有输出任务相关内容的情况。

注： @Async所修饰的函数不要定义为static类型，这样异步调用不会生效

异步回调

为了让doTaskOne、doTaskTwo、doTaskThree能正常结束，假设我们需要统计一下三个任务并发执行共耗时多少，这就需要等到上述三个函数都完成调动之后记录时间，并计算结果。

那么我们如何判断上述三个异步调用是否已经执行完成呢？我们需要使用Future<T>来返回异步调用的结果，就像如下方式改造doTaskOne函数：

1. @Async

2. public Future<String> doTaskOne() throws Exception {

3. System.out.println("开始做任务一");

4. long start = System.currentTimeMillis();

5. Thread.sleep(random.nextInt(10000));

6. long end = System.currentTimeMillis();

7. System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");

8. return new AsyncResult<>("任务一完成");

9. }

按照如上方式改造一下其他两个异步函数之后，下面我们改造一下测试用例，让测试在等待完成三个异步调用之后来做一些其他事情：

1. @Test

2. public void test() throws Exception {

3. long start = System.currentTimeMillis();

4. Future<String> task1 = task.doTaskOne();

5. Future<String> task2 = task.doTaskTwo();

6. Future<String> task3 = task.doTaskThree();

7. while(true) {

8. if(task1.isDone() && task2.isDone() && task3.isDone()) {

9. // 三个任务都调用完成，退出循环等待

10. break;

11. }

12. Thread.sleep(1000);

13. }

14. long end = System.currentTimeMillis();

15. System.out.println("任务全部完成，总耗时：" + (end - start) + "毫秒");

16. }

看看我们做了哪些改变：

在测试用例一开始记录开始时间
在调用三个异步函数的时候，返回Future<String>类型的结果对象
在调用完三个异步函数之后，开启一个循环，根据返回的Future<String>对象来判断三个异步函数是否都结束了。若都结束，就结束循环；若没有都结束，就等1秒后再判断。
跳出循环之后，根据结束时间 - 开始时间，计算出三个任务并发执行的总耗时。
执行一下上述的单元测试，可以看到如下结果：

开始做任务一
开始做任务二
开始做任务三
完成任务三，耗时：37毫秒
完成任务二，耗时：3661毫秒
完成任务一，耗时：7149毫秒
任务全部完成，总耗时：8025毫秒

需要注意，spring管理的异步线程数量有限，如果是web项目的话，线程数量由tomcat的线程池配置有关系，所以如果可以，最好自己配置线程配置类。

1. /**

2. * springboot里面创建异步线程配置类

3. * @author kouyy

4. */

5. @Configuration

6. @EnableAsync

7. public class ThreadAsyncConfigurer implements AsyncConfigurer {

9. @Bean

10. public Executor getAsyncExecutor() {

11. ThreadPoolTaskExecutor threadPool = new ThreadPoolTaskExecutor();

12. //设置核心线程数

13. threadPool.setCorePoolSize(10);

14. //设置最大线程数

15. threadPool.setMaxPoolSize(100);

16. //线程池所使用的缓冲队列

17. threadPool.setQueueCapacity(10);

18. //等待任务在关机时完成--表明等待所有线程执行完

19. threadPool.setWaitForTasksToCompleteOnShutdown(true);

20. // 等待时间 （默认为0，此时立即停止），并没等待xx秒后强制停止

21. threadPool.setAwaitTerminationSeconds(60);

22. // 线程名称前缀

23. threadPool.setThreadNamePrefix("MyAsync-");

24. // 初始化线程

25. threadPool.initialize();

26. return threadPool;

27. }

29. @Override

30. public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {

31. return null;

32. }

33. }

配置类创建之后，以后再使用@Async创建异步线程就可以按照自己配置来使用了。不用担心和spring线程池数量冲突了。