admin管理员组文章数量:1026989
java中如何启动一个新的线程三种方法
java开启新线程的三种方法：
方法1：继承Thread类
1）：定义bai一个继承自Java.lang.Thread类的du类A.
2）：覆盖zhiA类Thread类中的run方法。
3）：我们编写需要在run方法中执行的操作：run方法中的代码，线程执行体。
4）：在main方法（线程）中，创建一个线程对象并启动线程。
(1)创建线程类对象:
A类 a = new A类();
(2)调用线程对象的start方法:
a.start();//启动一个线程
注意：不要调用run方法。如果run方法被称为对象调用方法，则仍然只有一个线程，并且没有启动新线程。
创建启动线程实例：
//定义一个类A 继承java.lang.Thread
class A extends Thread{//A类 覆盖Thread类中的 run方法@Overridepublic void run(){//在run方法填写要执行的操作for (int j = 0 ;j<10;j++){System.out.println("执行方法A的逻辑"+j);}}
}public Class B{public static void main(String[] args){for (int i = 0;i<50 ;i++){System.out.println(i);if(i==10){// 在线程中重开一个线程执行其他操作A a = new A();a.start();}try {if (i==10){Thread.sleep(1000);}}catch (InterruptedException e){e.printStackTrace();}}}
}方法2：实现Runnable接口1）：定义要在java.lang.Runnable接口中实现的类A.请注意，A类不是线程类。2）：覆盖A类Runnable接口中的run方法。3）：我们编写需要在run方法中执行的操作：在run方法中，线程执行。4）：在main方法（线程）中，创建一个线程对象并启动线程。(1)创建线程类对象:Thread t = new Thread(new A()); (2)调用线程对象的start方法:t.start();
代码实例：
//定义一个类C 实现java.lang.Runnable 接口 C类不是线程类
class C implements Runnable{//C类 覆盖Runnable接口中的 run方法@Overridepublic void run(){//在run方法填写要执行的操作for (int j = 0 ;j<10;j++){System.out.println("执行方法C的逻辑"+j);}}
}public Class B{public static void main(String[] args){for (int i = 0;i<100 ;i++){System.out.println(i);if(i==10){// 在线程中重开一个线程执行其他操作C c = new C();Thread t = new Thread(c);t.start();}try {if (i==10){System.out.println(Thread.currentThread().getName());Thread.sleep(1000);}}catch (InterruptedException e){e.printStackTrace();}}}
}方法3：直接在函数体使用
public static void main(String[] args){for (int i=0;i<20;i++){System.out.println(i);if(i==10){Thread thread = new Thread(new Runnable() {@Overridepublic void run() {for(int j=0;j<10;j++){System.out.println("j"+j);}}});thread.start();try {if (i==10){System.out.println(Thread.currentThread().getName());Thread.sleep(1000);}}catch (InterruptedException e){e.printStackTrace();}}}}弊端：
1、每次都要new thread,新建了一个对象，导致对象性能差。
2、线程缺乏统一管理，可能无限制新建线程，相互之间出现竞争，极可能占用过多系统资源导致死机或者oom。
3、缺乏更多功能，比如：定时定时执行，定期执行，线程中断。
相比new Thread而言，Java提供的四种线程池的好处在于：
①可复用存在的线程，减少对象的创建、消亡，性能较高。
②有效控制并发线程数，提高了系统资源的使用率，避免了过多争夺系统资源，导致的堵塞。
③提供了定时执行、定期执行、单线程、并发数控制等功能。
Java通过Executors提供了四种线程池
- newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。线程池的规模不存在限制。
- newFixedThreadPool 创建一个固定长度线程池，可控制线程最大并发数，超出的线程会在队列中等待。
- newScheduledThreadPool 创建一个固定长度线程池，支持定时及周期性任务执行。
- newSingleThreadPool 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
newCachedThreadPool:
创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，如无回收，则新建线程
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();for(int i=0; i<10;i++){final int index=i;try{Thread.sleep(index*1000);}catch(InterruptedException e){e.printStackTrace();}cachedThreadPool.execute(new Runnable(){@overridepublic void run(){System.out.println(index);}});} newFixedThreadPool:
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待，定长线程池的大小最好根据系统资源进行设置。
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {final int index = i;fixedThreadPool.execute(new Runnable() {@Overridepublic void run() {try {System.out.println(index);Thread.sleep(2000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}});
}newScheduledThreadPool:
创建一个定长线程池，支持定时及周期性任务执行，ScheduledExecutorService比Timer更安全，功能更强大。
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {@Overridepublic void run() {System.out.println("delay 3 seconds");}
}, 3, TimeUnit.SECONDS);
此表示为延迟3秒执行
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {System.out.println("delay 1 seconds, and excute every 3 seconds");}
}, 1, 3, TimeUnit.SECONDS);
此表示为延迟1秒后每3秒执行一次newSingleThreadPool:
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {final int index = i;singleThreadExecutor.execute(new Runnable() {@Overridepublic void run() {try {System.out.println(index);Thread.sleep(2000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}});
}
newCachedThreadPool 特点：
1.核心线程数为零 2.最大线程数为无限 3.无任务时，线程存活的最大时间为60s 4.任务队列为同步移交队列，该队列没有缓冲区，即不会有任务会在该队列中排队，每当有任务要入队时，队列都会将任务移交给一个可用的线程
为什么叫缓存线程池，类比于redis缓存：
前者缓存的是频繁要用到的线程；后者缓存的是频繁要用到的数据
前者通过缓存线程，避免了每次执行任务都要创建、销毁线程的开销；后者通过缓存数据，避免了每次用到数据都要操作db
两者都有缓存失效的时间，前者对应keepAliveTime参数，超过该参数对应的时间后，销毁线程；后者当缓存对应的真实数据被修改时，缓存失效，清除数据
为了尽量重复利用缓存的线程，而不是每次要执行任务时创建新的线程，应尽量使执行任务的时间小于keepAliveTime参数，默认是60s
因为是一个“缓存”线程池，没有缓存可以永久有效，因此核心线程数为0。因此任务队列的缓冲区应为空，否则即便系统有可用的线程资源，当有新的任务时也不会被执行，而是进入任务队列排队直至队列满，这显然是不合理的。同样由于队列缓冲区为空，每来一个任务时，都会在必要时新建线程执行任务，这就有可能导致大量的线程被创建，进而系统瘫痪。
１ newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。Executors.newCachedThreadPool(); 缺点：大家一般不用是因为newCachedThreadPool 可以无线的新建线程，容易造成堆外内存溢出，因为它的最大值是在初始化的时候设置为 Integer.MAX_VALUE，一般来说机器都没那么大内存给它不断使用。当然知道可能出问题的点，就可以去重写一个方法限制一下这个最大值
２ newFixedThreadPool Executors.newFixedThreadPool(3);创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。可参考PreloadDataCache。其实newFixedThreadPool()在严格上说并不会复用线程，每运行一个Runnable都会通过ThreadFactory创建一个线程
３ newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。Executors.newScheduledThreadPool(5);与Timer 对比：Timer 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务（比如：一个任务出错，以后的任务都无法继续）。
ScheduledThreadPoolExecutor的设计思想是，每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰。需要注意的是，只有当任务的执行时间到来时，ScheduedExecutor 才会真正启动一个线程，其余时间 ScheduledExecutor 都是在轮询任务的状态。
通过对比可以发现ScheduledExecutorService比Timer更安全，功能更强大，在以后的开发中尽可能使用ScheduledExecutorService(JDK1.5以后)替代Timer
４ newSingleThreadExecutor Executors.newSingleThreadExecutor() 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。现行大多数GUI程序都是单线程的。Android中单线程可用于数据库操作，文件操作，应用批量安装，应用批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。
下面举一个newFixedThreadPool 应用示例：
import AThreadService;//调用自己写好的异步处理逻辑的方法
public A {@Autowiredprivate AThreadService AThreadService;public static void main (String [] args){AThreadService.AThread((String)A,(Object)B, (String)C);}
}// 接口
public interface AThreadService {/*** 方法名称: AThread* @throws*/public void AThread(String A, Object B, String C);}//实现类
public class AThreadSpringImpl implements AThreadService{@Autowiredprivate AService AService;//线程根据实际情况设置大小private static final ExecutorService AThreadPool = Executors.newFixedThreadPool(10);public void AThread(String A, Object B,String C) {// TODO Auto-generated method stubAThread aThread = new AThread(A,B,C);AThread.setAService(AService);AThreadPool.execute(AThread);}}//线程类实现runable接口
public class AThread implements Runnable {private Log log = LogFactory.getLog(AThread.class);private static final long serialVersionUID = 1L;private String A;private Object B;private String C;private AService AService;public AService AService() {return aService;}public void setAService(AService aService) {this.aService = aService;}public AThread(String A, Object B, String C){this.A=A;this.B=B;this.C=C;}public void run() {// TODO Auto-generated method stublog.info("-----------开始----------");aService.afunction(A, B, C);log.info("-----------结束----------");}}// 实现类实现方法
public class AServiceSpringImpl implements AService {/** * * 方法名称: afunction * @throws */ public void afunction(String A,Object B,String C){ //Do something;System.out.println("业务逻辑");}
} 在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等创建线程池的方法，但都有其局限性，不够灵活；另外由于前面几种方法内部也是通过ThreadPoolExecutor方式实现，使用ThreadPoolExecutor有助于大家明确线程池的运行规则，创建符合自己的业务场景需要的线程池，避免资源耗尽的风险。
详细内容参考：.html
线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors返回的线程池对象的弊端如下：
1）FixedThreadPool和SingleThreadPool:
允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2）CachedThreadPool:
允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。
Positive example 1：
//org.apachemons.lang3.concurrent.BasicThreadFactory
ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,
new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());
Positive example 2：
ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
.setNameFormat("demo-pool-%d").build();
//Common Thread Pool
ExecutorService pool = new ThreadPoolExecutor(5, 200,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
pool.execute(()-> System.out.println(Thread.currentThread().getName()));
pool.shutdown();//gracefully shutdown
Positive example 3：
<bean id="userThreadPool"
class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="10" />
<property name="maxPoolSize" value="100" />
<property name="queueCapacity" value="2000" />
<property name="threadFactory" value= threadFactory />
<property name="rejectedExecutionHandler">
<ref local="rejectedExecutionHandler" />
</property>
</bean>
//in code
userThreadPool.execute(thread);
java中如何启动一个新的线程三种方法
java开启新线程的三种方法：
方法1：继承Thread类
1）：定义bai一个继承自Java.lang.Thread类的du类A.
2）：覆盖zhiA类Thread类中的run方法。
3）：我们编写需要在run方法中执行的操作：run方法中的代码，线程执行体。
4）：在main方法（线程）中，创建一个线程对象并启动线程。
(1)创建线程类对象:
A类 a = new A类();
(2)调用线程对象的start方法:
a.start();//启动一个线程
注意：不要调用run方法。如果run方法被称为对象调用方法，则仍然只有一个线程，并且没有启动新线程。
创建启动线程实例：
//定义一个类A 继承java.lang.Thread
class A extends Thread{//A类 覆盖Thread类中的 run方法@Overridepublic void run(){//在run方法填写要执行的操作for (int j = 0 ;j<10;j++){System.out.println("执行方法A的逻辑"+j);}}
}public Class B{public static void main(String[] args){for (int i = 0;i<50 ;i++){System.out.println(i);if(i==10){// 在线程中重开一个线程执行其他操作A a = new A();a.start();}try {if (i==10){Thread.sleep(1000);}}catch (InterruptedException e){e.printStackTrace();}}}
}方法2：实现Runnable接口1）：定义要在java.lang.Runnable接口中实现的类A.请注意，A类不是线程类。2）：覆盖A类Runnable接口中的run方法。3）：我们编写需要在run方法中执行的操作：在run方法中，线程执行。4）：在main方法（线程）中，创建一个线程对象并启动线程。(1)创建线程类对象:Thread t = new Thread(new A()); (2)调用线程对象的start方法:t.start();
代码实例：
//定义一个类C 实现java.lang.Runnable 接口 C类不是线程类
class C implements Runnable{//C类 覆盖Runnable接口中的 run方法@Overridepublic void run(){//在run方法填写要执行的操作for (int j = 0 ;j<10;j++){System.out.println("执行方法C的逻辑"+j);}}
}public Class B{public static void main(String[] args){for (int i = 0;i<100 ;i++){System.out.println(i);if(i==10){// 在线程中重开一个线程执行其他操作C c = new C();Thread t = new Thread(c);t.start();}try {if (i==10){System.out.println(Thread.currentThread().getName());Thread.sleep(1000);}}catch (InterruptedException e){e.printStackTrace();}}}
}方法3：直接在函数体使用
public static void main(String[] args){for (int i=0;i<20;i++){System.out.println(i);if(i==10){Thread thread = new Thread(new Runnable() {@Overridepublic void run() {for(int j=0;j<10;j++){System.out.println("j"+j);}}});thread.start();try {if (i==10){System.out.println(Thread.currentThread().getName());Thread.sleep(1000);}}catch (InterruptedException e){e.printStackTrace();}}}}弊端：
1、每次都要new thread,新建了一个对象，导致对象性能差。
2、线程缺乏统一管理，可能无限制新建线程，相互之间出现竞争，极可能占用过多系统资源导致死机或者oom。
3、缺乏更多功能，比如：定时定时执行，定期执行，线程中断。
相比new Thread而言，Java提供的四种线程池的好处在于：
①可复用存在的线程，减少对象的创建、消亡，性能较高。
②有效控制并发线程数，提高了系统资源的使用率，避免了过多争夺系统资源，导致的堵塞。
③提供了定时执行、定期执行、单线程、并发数控制等功能。
Java通过Executors提供了四种线程池
- newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。线程池的规模不存在限制。
- newFixedThreadPool 创建一个固定长度线程池，可控制线程最大并发数，超出的线程会在队列中等待。
- newScheduledThreadPool 创建一个固定长度线程池，支持定时及周期性任务执行。
- newSingleThreadPool 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
newCachedThreadPool:
创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，如无回收，则新建线程
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();for(int i=0; i<10;i++){final int index=i;try{Thread.sleep(index*1000);}catch(InterruptedException e){e.printStackTrace();}cachedThreadPool.execute(new Runnable(){@overridepublic void run(){System.out.println(index);}});} newFixedThreadPool:
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待，定长线程池的大小最好根据系统资源进行设置。
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {final int index = i;fixedThreadPool.execute(new Runnable() {@Overridepublic void run() {try {System.out.println(index);Thread.sleep(2000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}});
}newScheduledThreadPool:
创建一个定长线程池，支持定时及周期性任务执行，ScheduledExecutorService比Timer更安全，功能更强大。
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {@Overridepublic void run() {System.out.println("delay 3 seconds");}
}, 3, TimeUnit.SECONDS);
此表示为延迟3秒执行
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {System.out.println("delay 1 seconds, and excute every 3 seconds");}
}, 1, 3, TimeUnit.SECONDS);
此表示为延迟1秒后每3秒执行一次newSingleThreadPool:
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {final int index = i;singleThreadExecutor.execute(new Runnable() {@Overridepublic void run() {try {System.out.println(index);Thread.sleep(2000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}});
}
newCachedThreadPool 特点：
1.核心线程数为零 2.最大线程数为无限 3.无任务时，线程存活的最大时间为60s 4.任务队列为同步移交队列，该队列没有缓冲区，即不会有任务会在该队列中排队，每当有任务要入队时，队列都会将任务移交给一个可用的线程
为什么叫缓存线程池，类比于redis缓存：
前者缓存的是频繁要用到的线程；后者缓存的是频繁要用到的数据
前者通过缓存线程，避免了每次执行任务都要创建、销毁线程的开销；后者通过缓存数据，避免了每次用到数据都要操作db
两者都有缓存失效的时间，前者对应keepAliveTime参数，超过该参数对应的时间后，销毁线程；后者当缓存对应的真实数据被修改时，缓存失效，清除数据
为了尽量重复利用缓存的线程，而不是每次要执行任务时创建新的线程，应尽量使执行任务的时间小于keepAliveTime参数，默认是60s
因为是一个“缓存”线程池，没有缓存可以永久有效，因此核心线程数为0。因此任务队列的缓冲区应为空，否则即便系统有可用的线程资源，当有新的任务时也不会被执行，而是进入任务队列排队直至队列满，这显然是不合理的。同样由于队列缓冲区为空，每来一个任务时，都会在必要时新建线程执行任务，这就有可能导致大量的线程被创建，进而系统瘫痪。
１ newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。Executors.newCachedThreadPool(); 缺点：大家一般不用是因为newCachedThreadPool 可以无线的新建线程，容易造成堆外内存溢出，因为它的最大值是在初始化的时候设置为 Integer.MAX_VALUE，一般来说机器都没那么大内存给它不断使用。当然知道可能出问题的点，就可以去重写一个方法限制一下这个最大值
２ newFixedThreadPool Executors.newFixedThreadPool(3);创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。可参考PreloadDataCache。其实newFixedThreadPool()在严格上说并不会复用线程，每运行一个Runnable都会通过ThreadFactory创建一个线程
３ newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。Executors.newScheduledThreadPool(5);与Timer 对比：Timer 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务（比如：一个任务出错，以后的任务都无法继续）。
ScheduledThreadPoolExecutor的设计思想是，每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰。需要注意的是，只有当任务的执行时间到来时，ScheduedExecutor 才会真正启动一个线程，其余时间 ScheduledExecutor 都是在轮询任务的状态。
通过对比可以发现ScheduledExecutorService比Timer更安全，功能更强大，在以后的开发中尽可能使用ScheduledExecutorService(JDK1.5以后)替代Timer
４ newSingleThreadExecutor Executors.newSingleThreadExecutor() 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。现行大多数GUI程序都是单线程的。Android中单线程可用于数据库操作，文件操作，应用批量安装，应用批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。
下面举一个newFixedThreadPool 应用示例：
import AThreadService;//调用自己写好的异步处理逻辑的方法
public A {@Autowiredprivate AThreadService AThreadService;public static void main (String [] args){AThreadService.AThread((String)A,(Object)B, (String)C);}
}// 接口
public interface AThreadService {/*** 方法名称: AThread* @throws*/public void AThread(String A, Object B, String C);}//实现类
public class AThreadSpringImpl implements AThreadService{@Autowiredprivate AService AService;//线程根据实际情况设置大小private static final ExecutorService AThreadPool = Executors.newFixedThreadPool(10);public void AThread(String A, Object B,String C) {// TODO Auto-generated method stubAThread aThread = new AThread(A,B,C);AThread.setAService(AService);AThreadPool.execute(AThread);}}//线程类实现runable接口
public class AThread implements Runnable {private Log log = LogFactory.getLog(AThread.class);private static final long serialVersionUID = 1L;private String A;private Object B;private String C;private AService AService;public AService AService() {return aService;}public void setAService(AService aService) {this.aService = aService;}public AThread(String A, Object B, String C){this.A=A;this.B=B;this.C=C;}public void run() {// TODO Auto-generated method stublog.info("-----------开始----------");aService.afunction(A, B, C);log.info("-----------结束----------");}}// 实现类实现方法
public class AServiceSpringImpl implements AService {/** * * 方法名称: afunction * @throws */ public void afunction(String A,Object B,String C){ //Do something;System.out.println("业务逻辑");}
} 在《阿里巴巴java开发手册》中指出了线程资源必须通过线程池提供，不允许在应用中自行显示的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由于jdk中Executor框架虽然提供了如newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool()等创建线程池的方法，但都有其局限性，不够灵活；另外由于前面几种方法内部也是通过ThreadPoolExecutor方式实现，使用ThreadPoolExecutor有助于大家明确线程池的运行规则，创建符合自己的业务场景需要的线程池，避免资源耗尽的风险。
详细内容参考：.html
线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors返回的线程池对象的弊端如下：
1）FixedThreadPool和SingleThreadPool:
允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2）CachedThreadPool:
允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。
Positive example 1：
//org.apachemons.lang3.concurrent.BasicThreadFactory
ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,
new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());
Positive example 2：
ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
.setNameFormat("demo-pool-%d").build();
//Common Thread Pool
ExecutorService pool = new ThreadPoolExecutor(5, 200,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
pool.execute(()-> System.out.println(Thread.currentThread().getName()));
pool.shutdown();//gracefully shutdown
Positive example 3：
<bean id="userThreadPool"
class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="10" />
<property name="maxPoolSize" value="100" />
<property name="queueCapacity" value="2000" />
<property name="threadFactory" value= threadFactory />
<property name="rejectedExecutionHandler">
<ref local="rejectedExecutionHandler" />
</property>
</bean>
//in code
userThreadPool.execute(thread);
本文标签： java中如何启动一个新的线程三种方法
版权声明：本文标题：java中如何启动一个新的线程三种方法 内容由热心网友自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：http://it.en369.cn/IT/1694664696a254773.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。
发表评论