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方法
@Override
public 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方法
@Override
public 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() {
@Override
public 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(){
@override
public 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() {
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
newScheduledThreadPool:
创建一个定长线程池,支持定时及周期性任务执行,ScheduledExecutorService比Timer更安全,功能更强大。
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);
此表示为延迟3秒执行
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public 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() {
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
newCachedThreadPool 特点:
1.核心线程数为零 2.最大线程数为无限 3.无任务时,线程存活的最大时间为60s 4.任务队列为同步移交队列,该队列没有缓冲区,即不会有任务会在该队列中排队,每当有任务要入队时,队列都会将任务移交给一个可用的线程
为什么叫缓存线程池,类比于redis缓存:
前者缓存的是频繁要用到的线程;后者缓存的是频繁要用到的数据
前者通过缓存线程,避免了每次执行任务都要创建、销毁线程的开销;后者通过缓存数据,避免了每次用到数据都要操作db
两者都有缓存失效的时间,前者对应keepAliveTime参数,超过该参数对应的时间后,销毁线程;后者当缓存对应的真实数据被修改时,缓存失效,清除数据
为了尽量重复利用缓存的线程,而不是每次要执行任务时创建新的线程,应尽量使执行任务的时间小于keepAliveTime参数,默认是60s
因为是一个“缓存”线程池,没有缓存可以永久有效,因此核心线程数为0。因此任务队列的缓冲区应为空,否则即便系统有可用的线程资源,当有新的任务时也不会被执行,而是进入任务队列排队直至队列满,这显然是不合理的。同样由于队列缓冲区为空,每来一个任务时,都会在必要时新建线程执行任务,这就有可能导致大量的线程被创建,进而系统瘫痪。
1 newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。Executors.newCachedThreadPool(); 缺点:大家一般不用是因为newCachedThreadPool 可以无线的新建线程,容易造成堆外内存溢出,因为它的最大值是在初始化的时候设置为 Integer.MAX_VALUE,一般来说机器都没那么大内存给它不断使用。当然知道可能出问题的点,就可以去重写一个方法限制一下这个最大值
2 newFixedThreadPool Executors.newFixedThreadPool(3);创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。可参考PreloadDataCache。其实newFixedThreadPool()在严格上说并不会复用线程,每运行一个Runnable都会通过ThreadFactory创建一个线程
3 newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。Executors.newScheduledThreadPool(5);与Timer 对比:Timer 的优点在于简单易用,但由于所有任务都是由同一个线程来调度,因此所有任务都是串行执行的,同一时间只能有一个任务在执行,前一个任务的延迟或异常都将会影响到之后的任务(比如:一个任务出错,以后的任务都无法继续)。
ScheduledThreadPoolExecutor的设计思想是,每一个被调度的任务都会由线程池中一个线程去执行,因此任务是并发执行的,相互之间不会受到干扰。需要注意的是,只有当任务的执行时间到来时,ScheduedExecutor 才会真正启动一个线程,其余时间 ScheduledExecutor 都是在轮询任务的状态。
通过对比可以发现ScheduledExecutorService比Timer更安全,功能更强大,在以后的开发中尽可能使用ScheduledExecutorService(JDK1.5以后)替代Timer
4 newSingleThreadExecutor Executors.newSingleThreadExecutor() 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。现行大多数GUI程序都是单线程的。Android中单线程可用于数据库操作,文件操作,应用批量安装,应用批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。
下面举一个newFixedThreadPool 应用示例:
import AThreadService;
//调用自己写好的异步处理逻辑的方法
public A {
@Autowired
private 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{
@Autowired
private AService AService;
//线程根据实际情况设置大小
private static final ExecutorService AThreadPool = Executors.newFixedThreadPool(10);
public void AThread(String A, Object B,String C) {
// TODO Auto-generated method stub
AThread 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 stub
log.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有助于大家明确线程池的运行规则,创建符合自己的业务场景需要的线程池,避免资源耗尽的风险。
详细内容参考:https://www.cnblogs.com/dafanjoy/p/9729358.html
线程池不允许使用Executors去创建,而是通过ThreadPoolExecutor的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。 说明:Executors返回的线程池对象的弊端如下:
1)FixedThreadPool和SingleThreadPool:
允许的请求队列长度为Integer.MAX_VALUE,可能会堆积大量的请求,从而导致OOM。
2)CachedThreadPool:
允许的创建线程数量为Integer.MAX_VALUE,可能会创建大量的线程,从而导致OOM。
Positive example 1:
//org.apache.commons.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);