java new 新线程 java启用新线程

转载

GhostLover 2023-08-23 13:38:49

文章标签 java new 新线程多线程线程池 System 缓存 文章分类 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方法
    @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。因此任务队列的缓冲区应为空，否则即便系统有可用的线程资源，当有新的任务时也不会被执行，而是进入任务队列排队直至队列满，这显然是不合理的。同样由于队列缓冲区为空，每来一个任务时，都会在必要时新建线程执行任务，这就有可能导致大量的线程被创建，进而系统瘫痪。

１　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 {
    @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有助于大家明确线程池的运行规则，创建符合自己的业务场景需要的线程池，避免资源耗尽的风险。

线程池不允许使用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);

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。