java线程池大小多少才合适（java线程池）

你们好，最近小时发现有诸多的小伙伴们对于java线程池大小多少才合适，java线程池这个问题都颇为感兴趣的，今天小活为大家梳理了下，一起往下看看吧。

1、 首先，了解线程是如何创建的：

2、 Tread类用于创建thread new Thread()，使用它时必须重写它的方法。@覆盖；一次创建9个线程，输出任务数。

3、 代码如下所示

4、 public class TestThread {

5、 public static void main(String[] args) {

6、 for(int i=1;i10;i++){

7、 final int task=i;

8、 new Thread(new Runnable(){

9、 @Override

10、 public void run(){

11、 System.out.println('task:'+task);

12、 }

13、 }).start();

14、 }

15、 }

16、 }

17、 (1)newFixedThreadPool:

18、 创建一个具有固定数量线程的线程池，并将任务分配给线程。

19、 创建一个定长线程池，可以控制并发线程的最大数量，多余的线程会在队列中等待。

20、 package testexcutor;

21、 import java.util.concurrent.ExecutorService;

22、 import java.util.concurrent.Executors;

23、 public class TestExcutor {

24、 public static void main(String[] args) {

25、 ExecutorService fixThreadPool=Executors.newFixedThreadPool(5);

26、 for(int i=1;i=5;i++){

27、 final int task=i;

28、 fixThreadPool.execute(new Runnable(){

29、 @Override

30、 public void run(){

31、 for(int j=1;j=5;j++){

32、 System.out.println(Thread.currentThread().getName()+' '+'task:'+task+'times:'+j);

33、 }

34、 }

35、 });

36、 }

37、 fixThreadPool.shutdown();

38、 }

39、 }

40、 (2)newCachedThreadPool创建一个可缓存的线程池。如果线程池的长度超过处理需要，空闲线程可以灵活回收。如果没有回收，就会创建新的线程。示例代码如下：

41、 package testexcutor;

42、 import java.util.concurrent.ExecutorService;

43、 import java.util.concurrent.Executors;

44、 public class TestExcutor {

45、 public static void main(String[] args) {

46、 ExecutorService cashedThreadPool=Executors.newCachedThreadPool();

47、 for(int i=1;i=100;i++){

48、 final int task=i;

49、 cashedThreadPool.execute(new Runnable(){

50、 @Override

51、 public void run(){

52、 for(int j=1;j=5;j++){

53、 System.out.println(Thread.currentThread().getName()+' '+'task:'+task+'times:'+j);

54、 }

55、 }

56、 });

57、 }

58、 cashedThreadPool.shutdown();

59、 }

60、 }

61、 创建100个线程，但是因为有线程结束，所以所有线程都可以回收。当它不够时，创建一个新的线程。

62、 (3) newScheduledThreadPool创建一个固定长度的线程池来支持调度的和周期性的任务执行。

63、 代码：

64、 import java.util.concurrent.Executors;

65、 import java.util.concurrent.ScheduledExecutorService;

66、 import java.util.concurrent.TimeUnit;

67、 public class TsetThreads {

68、 public static void main(String[] args) {

69、 ScheduledExecutorService scheduledThreadPool=Executors.newScheduledThreadPool(5);

70、 scheduledThreadPool.schedule(new Runnable() {

71、 public void run() {

72、 System.out.println('delay 10 seconds');

73、 }

74、 }, 10, TimeUnit.SECONDS);

75、 scheduledThreadPool.shutdown();

76、 }

77、 }

78、 创建一个线程，并将其执行延迟10秒。

79、 (4) newSingleThreadExecutor创建一个单线程线程池，只使用一个工作线程执行任务，保证所有任务都按照指定的顺序(FIFO，LIFO，priority)执行。

80、 代码：

81、 package testexcutor;

82、 import java.util.concurrent.ExecutorService;

83、 import java.util.concurrent.Executors;

84、 public class TestExcutor {

85、 public static void main(String[] args) {

86、 ExecutorService singleThreadExecutor=Executors.newSingleThreadExecutor();

87、 for (int i=0; i 10; i++) {

88、 final int index=i;

89、 singleThreadExecutor.execute(new Runnable() {

90、 @Override

91、 public void run() {

92、 try {

93、 System.out.println(Thread.currentThread().getName()+' '+'task'+index);

94、 Thread.sleep(200);

95、 } catch (InterruptedException e) {

96、 e.printStackTrace();

97、 }

98、 }

99、 });

100、 }

101、 singleThreadExecutor.shutdown();

102、 }

103、 }

104、 只能创建一个线程，因此线程名称是相同的。

105、 Java线程池总结：Java通过执行器提供了四个线程池，分别是：newCachedThreadPool创建一个可缓存的线程池。如果线程池的长度超过处理需要，空闲线程可以灵活回收。如果没有回收，

106、 创建了一个新线程。NewFixedThreadPool创建一个定长线程池，可以控制并发线程的最大数量，多余的线程会在队列中等待。NewScheduledThreadPool创建一个固定长度的线程池，

107、 支持定时和周期性的任务执行。NewSingleThreadExecutor创建一个单线程线程池，该线程池只使用一个唯一的工作线程来执行任务，确保所有任务都按照指定的顺序(FIFO、LIFO、priority)执行。

以上就是java线程池这篇文章的一些介绍，希望对大家有所帮助。

　　免责声明：本文由用户上传，与本网站立场无关。财经信息仅供读者参考，并不构成投资建议。投资者据此操作，风险自担。 如有侵权请联系删除！