精华内容
下载资源
问答
  • 启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM调度并执行,这并不意味着线程就会立即运行。run()方法线程启动后要进行回调(callback)的方法。 ...

    分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net 

    启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM调度并执行,这并不意味着线程就会立即运行。run()方法是线程启动后要进行回调(callback)的方法。

    展开全文
  • java开启新线程的三种方法方法1:继承Thread类 ...4):在main方法(线程)中,创建一个线程对象并启动线程。 (1)创建线程类对象: A类 a = new A类(); (2)调用线程对象的start方法: a.start();...

    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);

    展开全文
  • 启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM 调度并执行,这并不意味着线程就会立即运行。 run()方法线程启动后要进行回调(callback)的方法。...

    启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM 调度并执行,这并不意味着线程就会立即运行。

    run()方法是线程启动后要进行回调(callback)的方法。

    展开全文
  • 启动一个异步线程去执行一个任务

    万次阅读 2018-01-19 21:54:48
    1.业务场景: 浦发银行...银行充值接口实现业务都是预计2小时到账,但如果需求修改发送充值接口后,立马去调用银行提供的状态查询接口,将状态查询回来时,需要启动一个异步线程将结果查询回来. 代码编辑如下: ...

    1.业务场景:

     浦发银行充值接口,他行卡充值不是实时将充值结果返回的,需要我们自己去手动去查。银行充值接口实现业务都是预计2小时到账,但如果需求修改发送充值接口后,立马去调用银行提供的状态查询接口,将状态查询回来时,需要启动一个异步线程将结果查询回来.

    代码编辑如下:
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:p="http://www.springframework.org/schema/p"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop" 
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans  
               http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
               http://www.springframework.org/schema/aop   
               http://www.springframework.org/schema/aop/spring-aop-3.2.xsd  
               http://www.springframework.org/schema/tx  
               http://www.springframework.org/schema/tx/spring-tx-3.2.xsd  
               http://www.springframework.org/schema/context  
               http://www.springframework.org/schema/context/spring-context-3.2.xsd"
        default-autowire="byName" default-lazy-init="false">
    
        <!-- 使用spring提供的线程池 -->
        <bean id="executePool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
            <!-- 线程池维护线程的最小数量 -->
            <property name="corePoolSize" value="1"></property>
            <!-- 线程池维护线程所允许的空闲时间 -->
            <property name="maxPoolSize" value="5"></property>
            <!-- 线程池所使用的最大数量 -->
            <property name="keepAliveSeconds" value="30000" />
            <!-- 线程池所使用的缓冲队列 -->
            <property name="queueCapacity" value="1000" />
        </bean>
    
        <bean id="asyExecuteService" class="com.adai.asy.service.imp.AsyExecuteServiceImp" destroy-method="destory">
            <property name="executePool"  ref="executePool" />
        </bean>
        
        <context:annotation-config/>
        <context:component-scan base-package="com.adai"/>
    </beans>
    
    package com.adai.asy.service;
    
    import java.util.Map;
    /**
     * 异步服务接口
     * @author v-chenk25
     * @since 2018-01-19 21:35
     *
     */
    public interface AsyExecuteService {
    	/**
    	 * 异步服务
    	 * @param taskId  服务id
    	 * @param sendMap 请求参数
    	 */
    	public void execute(String taskId , Map<String,Object> sendMap);
    }
    
    package com.adai.asy.service;
    
    import java.util.Map;
    
    /**
     * 异步接口
     * @author v-chenk25
     * @since 2018-01-19 21:35
     *
     */
    public interface AsyService {
    	/**
    	 * 异步交易接口
    	 * @param sendMap 请求参数
    	 */
    	public void execute(Map<String,Object> sendMap) ;
    }
    
    package com.adai.asy.service.imp;
    
    import java.util.Date;
    import java.util.Map;
    
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    import com.adai.asy.service.AsyExecuteService;
    import com.adai.asy.service.AsyService;
    import com.adai.constant.Dict;
    import com.adai.util.Utils;
    /**
     * 异步服务实现类:这里需要注入线程池启动一个线程去执行任务
     * @author v-chenk25
     * @since 2018-01-19 21:35
     */
    public  class AsyExecuteServiceImp implements AsyExecuteService , ApplicationContextAware{
    	private ApplicationContext context ;
    	private ThreadPoolTaskExecutor executePool ;
    	public void execute(String taskId, final Map<String, Object> sendMap) {
    		sendMap.put(Dict.TASKID, taskId) ;
    		final AsyService asyService = (AsyService) this.context.getBean(taskId) ;
    		this.executePool.execute(new Runnable() {
    			public void run() {
    				asyService.execute(sendMap);
    			}
    		});
    		
    		
    	}
    	
    	public Map<String,Object> prepareReq(Map<String,Object> sendMap){
    		sendMap.put(Dict.ORDERID, Utils.getCurrentFormat(new Date(), Dict.YNRH)) ;
    		return sendMap;
    	}
    	
    	public void destory() {
    		if(this.executePool != null) {
    			this.executePool.shutdown();
    		}
    	}
    	
    	public void setApplicationContext(ApplicationContext context) throws BeansException {
    		this.context = context ;
    	}
    	public void setExecutePool(ThreadPoolTaskExecutor executePool) {
    		this.executePool = executePool;
    	}
    	
    }
    
    package com.adai.asy.service.imp;
    
    import java.util.Map;
    
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    
    import com.adai.asy.service.AsyService;
    import com.adai.constant.Dict;
    /**
     * 异步服务接口实现类
     * 这里主要时为了打印每一个任务需要执行的时间,正真执行业务逻辑的方法是executeInnert
     * @author v-chenk25
     *
     */
    public abstract class AsyServiceImp implements AsyService{
    	private Log log = LogFactory.getLog(AsyServiceImp.class) ;
    	public void execute(Map<String,Object> sendMap) {
    		long start = System.currentTimeMillis();
    		log.info("异步线程开始执行:"+sendMap.get(Dict.TASKID)+"任务");
    		executeInnert(sendMap) ;
    		long end = System.currentTimeMillis();
    		log.info("异步线程执行结束,任务执行时间为:"+(end-start));
    	}
    	
    	/** 真正执行业务逻辑 **/
    	public abstract void executeInnert(Map<String,Object> sendMap);
    }
    
    package com.adai.asy.service.imp;
    
    import java.util.Map;
    
    import org.springframework.stereotype.Service;
    
    import com.adai.asy.service.AsyService;
    /**
     * 需要异步执行任务的具体实现类
     * @author v-chenk25
     *
     */
    @Service("myTaskAsyService1")
    public class MyTaskAsyServiceImp extends AsyServiceImp implements AsyService  {
    
    	@Override
    	public void executeInnert(Map<String, Object> sendMap) {
    		//做自己的业务逻辑处理 , 比如发银行的接口,调用dubbo服务
    		System.out.println(this.getClass().getName());
    		System.out.println(sendMap);
    	}
    
    
    }
    
    package com.adai.constant;
    /**
     * 常量字典
     * @author v-chenk25
     *
     */
    public class Dict {
    	/**交易流水号**/
    	public static final String ORDERID = "OrderId" ;
    	/** 日期格式 **/
    	public static final String YND = "yyyyMMdd" ;
    	/**时间戳格式**/
    	public static final String YNRH = "yyyyMMdd HH:mm:ss sss" ;
    	/**时间格式**/
    	public static final String HOUR = "HH:mm:ss" ;
    	/**交易id**/
    	public static final String TASKID = "taskId" ;
    	
    }
    
    package com.adai.util;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    /**
     * 工具类
     * @author v-chenk25
     *
     */
    public class Utils {
    	
    	/**当前日期指定格式字符串**/
    	public static String getCurrentFormat(Date date ,String format) {
    		return new SimpleDateFormat(format).format(date);
    	}
    }
    
    package com.adai.asy.service.imp;
    
    import java.util.Map;
    
    import org.springframework.stereotype.Service;
    
    import com.adai.asy.service.AsyService;
    /**
     * 需要异步执行任务的具体实现类
     * @author v-chenk25
     *
     */
    @Service("myTaskAsyService2")
    public class MyTaskAsyServiceImp2 extends AsyServiceImp implements AsyService  {
    
    	@Override
    	public void executeInnert(Map<String, Object> sendMap) {
    		//做自己的业务逻辑处理
    		System.out.println(this.getClass().getName());
    		System.out.println(sendMap);
    	}
    
    
    }
    
    package com.adai;
    
    import java.util.HashMap;
    import java.util.Map;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.adai.asy.service.AsyExecuteService;
    
    public class TestAsy {
    	public static void main(String[] args) {
    		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"classpath:spring-activemq.xml"}) ;
    		context.start();
    		AsyExecuteService asyService = (AsyExecuteService) context.getBean("asyExecuteService") ;
    		for(int i=1 ; i<10 ;i++) {
    			Map<String,Object> sendMap = new HashMap<String,Object>() ;
    			sendMap.put(i+"", i) ;
    			asyService.execute("myTaskAsyService"+1, sendMap);
    		}
    	}
    }
    
    总结:设计思路为:使用一个线程池开启一个线程去执行一个任务,任务id就是spring bean的名字,通ApplicationContextAware 来获取spring容器的bean,然后调用execute方法执行具体的业务逻辑。为了扩展,所以要求需要异步执行的类需要现实统一的接口,也就是AsyService接口。
    展开全文
  • MFC启动一个线程的三种方法

    千次阅读 2019-03-11 16:40:39
    转载于:... 第一种AfxBeginThread() 用AfxBeginThread()函数来创建一个线程来执行任务,工作者线程的AfxBeginThread的原型如下: CWinThread* AfxBeginThread(AFX_THREADPROC pfnThreadProc, ...
  • java方法启动一个新的线程

    万次阅读 2017-12-20 10:45:15
    1 要想在java方法启动一个新的线程。通过new Thread(){public void run(){...}}.start()即可。 如:public static void main(String[] args) { System.out.println("新建议一个线程"); //启动一个新的线程 ...
  • QT (启动一个线程)

    万次阅读 2018-12-01 17:06:47
    启动一个线程的步骤: (1) 创建一个自己的线程类继承QT中的QThread类 创建线程类WorkThread; (2) 在自己的WorkThreak类中重新实现run()函数, 该函数是一个死循环, 主要是完成自己需要的功能代码 (3) 使用自己的类...
  • java同时启动个线程

    千次阅读 2019-03-11 14:59:51
    当我们需要同时启动N个线程时, 可以使用java.util.concurrent.CyclicBarrier 类解决。 demo: import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; public class...
  • Java中main方法启动的是一个线程也是一个进程,一个java程序启动后它就是一个进程,进程相当于一个空盒,它只提供资源装载的空间,具体的调度并不是由进程来完成的,而是由线程来完成的。一个java程序从main开始之后...
  • 详情请见======&gt;转自:https://blog.csdn.net/it_beecoder/article/details/78446747
  • 启动一个线程是用run还是start

    千次阅读 2018-08-24 15:34:53
    启动线程肯定要用start()方法。当用start()开始一个线程后,线程就进入就绪状态,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。当cpu分配给它时间时,才...
  • 如何创建和启动一个线程

    千次阅读 2015-09-02 13:05:39
     此类中有run()方法,应该注意其用法: public void run()如果该线程是使用独立的 Runnable 运行对象构造的,则调用该 Runnable 对象的 run 方法;否则,该方法不执行任何操作并返回。 Thread
  • 启动一个线程是调用start()方法,使线程就绪状态,以后可以被jvm调度为运行状态,一个线程必须关联一些具体的执行代码,run()方法是该线程所关联的执行代码。 实现并启动线程有两种方法: 1、写一个类继承自Thread类...
  • java方法中开启一个线程

    万次阅读 2019-07-01 08:50:07
    很多业务场景下需要你在一个方法中去开启一个线程,去跑一些处理时间较长的代码,这样调用方就不必经过长时间的等待了.好了 话不多说 先上代码: package test; public class ThreadTest { public static void ...
  • 有时开启一个线程是为了把耗时的操作转移到线程中执行,主进程中可以执行其它的任务,避免了因为大量的重复性操作导致主进程阻塞。 控制线程暂停的方法线程的同步用到了QMutex类,作为一个互斥锁控制进行保护。...
  • java同时启动个线程(二)

    万次阅读 2019-03-11 15:13:58
    当我们需要同时启动N个线程时, 可以使用java.util.concurrent.CountDownLatch 类解决。 demo: import java.util.concurrent.CountDownLatch; public class TestCountDownLatch { public static void main...
  • 、准备工作 在Application类上加上EnableAsync注解开启异步 在被调用的方法上面加上@Async,也可以直接在类上加此注解,会标识所有方法为异步方法 ...要实现在启动时加载此异步方法,加@PostConstruct注
  • http://note.youdao.com/noteshare?id=85febc3ab33cc00102c024d04ef2ee09&amp;sub=A04A4A13DDBC44EAA651E29383940738
  • 1.start()方法启动线程,真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码: 通过调用Thread类的start()方法来启动一个线程,  这时此线程是处于就绪状态,  并没
  • JavaWeb 服务启动时,在后台启动加载一个线程。 目前,我所掌握的一共有两种方法,第一种是监听(Listener),第二种是配置随项目启动启动的Servlet。 下面对这两种方法做一简单的介绍,(Mark一下,防止...
  • python3-启动个线程

    千次阅读 2018-10-26 22:45:42
    问题:在for循环里面想同时启动多个线程,但是程序运行过程中产生的是线程一个一个启动,即:启动第一个线程之后主线程等待子线程运行完成之后才启动第二个,代码如下: import threading import time def thread...
  • public class MyTest { public static void main(String[] args) ... System.out.println("main方法调用method,得到了结果"+result+":"+new Date().toLocaleString()); } public static String method(){ .
  • 启动线程肯定要用start()方法。当用start()开始一个线程后,线程就进入就绪状态,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。当cpu分配给它时间时,才...
  • 简单启动一个main程序时,有多少个线程被创建呢? public class OnlyMain { public static void main(String[] args) { //虚拟机线程管理的接口 ThreadMXBean threadMXBean = ManagementFactory....
  • 功能: 在tomcat启动时,就自动执行servlet,此servlet隔段时间处理某操作。
  • springboot启动时候开启异步线程或者启动方法 、准备工作 在Application类上加上EnableAsync注解开启异步 在被调用的方法上面加上@Async,也可以直接在类上加此注解,会标识所有方法为异步方法 *注意事项* 必须...
  • VC启动一个线程的三种方法

    万次阅读 2015-03-14 19:53:43
    用CreateThread()函数创建线程将返回一个线程句柄,通过该句柄你可以控制和操作该线程,当你不用时可以一创建该线程后就关闭该句柄,有专门的函CloseHandle()。关闭句柄不代表关闭线程,只是你不能在外部控制该...
  • 首先Thread类中run()和start()方法的区别如下: ... start()方法:启动一个线程,调用该Runnable对象的run()方法,不能多次启动一个线程; public class Test implements Runnable{ public st...
  •  前几天,manager问道一个问题:能不能实现类似于cron的后台管理方式。问题解决后,想对这几个问题进行一下简单的总结。以便抛砖引玉!首先简单的提及一下cron。  Cron,计划任务,是任务在约定的时间执行已经...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 965,144
精华内容 386,057
关键字:

启动一个线程的方法