精华内容
下载资源
问答
  • 启动线程三种方式

    千次阅读 2021-01-01 07:41:29
    启动线程一共有三种方法:继承类,实现接口,匿名内部类。 一、启动线程的第一种方法:继承类 start()方法的作用是启动一个分支线程,在JVM中开辟一个新的栈空间。 只要新的栈空间,myThread.start()瞬间就结束了...


    前言

    启动线程一共有三种方法:继承类,实现接口,匿名内部类。


    一、启动线程的第一种方法:继承Thread类

    start()方法的作用是启动一个分支线程,在JVM中开辟一个新的栈空间。
    只要新的栈空间,myThread.start()瞬间就结束了,线程就启动成功了。
    启动成功的线程会自动调用run方法,并且run方法在分支线的栈底部。

    代码如下(示例):

    public class Thread01  {
        public static void main(String[] args) {
            //创建线程对象
            MyThread myThread = new MyThread();
            //启动线程
            myThread.start();
    
            //主线程
            for (int i = 0; i <100 ; i++) {
                System.out.println("main主线程--->" + i);
            }
    
        }
    }
    class MyThread extends Thread{
        @Override
        public void run() {
            for (int i = 0; i <100 ; i++) {
                System.out.println("分支线程---->"+ i);
            }
        }
    }
    

    二、启动线程的第二种方式:实现Runnable接口

    代码如下(示例):

    public class Thread02 {
        public static void main(String[] args) {
            //创建线程对象
            Thread thread = new Thread(new MyRunnable());
            //启动线程
            thread.start();
    
            //主线程
            for (int i = 0; i <100 ; i++) {
                System.out.println("main主线程--->" + i);
            }
        }
    }
    class MyRunnable implements Runnable{
    
        @Override
        public void run() {
            for (int i = 0; i <100 ; i++) {
                System.out.println("分支线程---->"+ i);
            }
        }
    }
    

    实现接口启动线程是最常用的方法


    也可以使用匿名内部类的方式启动线程

    代码如下(示例):

    public class Thread03 {
        public static void main(String[] args) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i <1000 ; i++) {
                        System.out.println("分支线程-->" + i);
                    }
                }
            });
    
            //启动线程
            thread.start();
    
            //主线程
            for (int i = 0; i <1000 ; i++) {
                System.out.println("main主线程--->"+ i);
            }
        }
    }
    

    三、启动线程的第三种方式:实现Callable接口

    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    /***
     * 启动线程的第三种方法:实现Callable接口,重写call()方法
     */
    public class ThreadTest04 {
        public static void main(String[] args) {
            //创建一个“未来任务类”对象
            FutureTask futureTask = new FutureTask(new Callable() {
                @Override
                public Object call() throws Exception { //call()方法相当与run()方法,比run方法好,有返回值
                    System.out.println("call mothed begin!");
                    Thread.sleep(1000 * 10);
                    System.out.println("call mothed over!");
    
                    int x = 100;
                    int y = 200;
    
                    return x + y;//自动装箱
                }
            });
    
            //创建线程对象
            Thread t = new Thread(futureTask);
    
            //启动线程
            t.start();
    
            Object obj = null;
            //获得分支线程返回值
            try {
                //get()方法的执行会导致主线程的阻塞
                obj = futureTask.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
    
            System.out.println("获得分支线程的返回值:" + obj );
    
            //如下的代码会等到分支线程执行结束后,才回到主线程中继续执行
            System.out.println("Hello CSDN");
        }
    }
    
    
    展开全文
  • java开启新线程三种方法: 方法1:继承Thread类 1):定义bai一个继承自Java.lang.Thread类的du类A. 2):覆盖zhiA类Thread类中的run方法。 3):我们编写需要在run方法中执行的操作:run方法中的代码,线程...

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

    展开全文
  • JAVA中,启动线程三种方法

    千次阅读 2018-06-19 01:32:45
    1、继承Thread类, 重写run方法,在main函数中,调用start方法。代码如下: //播放音乐线程类  class MusicThread extends Thread {   public void run() {   for (int i = 0; ...

    1、继承Thread类, 重写run方法,在main函数中,调用start方法。代码如下:

    1. //播放音乐线程类  

    2. class MusicThread extends Thread {  

    3.     public void run() {  

    4.         for (int i = 0; i < 50; i++) {  

    5.             System.out.println("播放音乐" + i);  

    6.         }  

    7.     }  

    8. }  

    9.   

    10. //主线程类  

    11. public class ThreadDemo3 {  

    12.     public static void main(String[] args) {  

    13.   

    14.         //启动播放音乐的线程  

    15.         MusicThread thread1 = new MusicThread();  

    16.         thread1.start();  

    17.   

    18.         //主线程  

    19.         for (int i = 0; i < 50; i++) {  

    20.             System.out.println("打游戏" + i);  

    21.         }  

    22.     }  

    23. }  

     

    2、实现Runnable接口,重写run方法,在main函数中,调用start方法。代码如下:

     

    1. //1):定义一个类A实现于java.lang.Runnable接口,注意A类不是线程类.  

    2. class MusicImplements implements Runnable{  

    3.     //2):在A类中覆盖Runnable接口中的run方法.  

    4.     public void run() {  

    5.         //3):在run方法中编写需要执行的操作  

    6.         for(int i = 0; i < 50; i ++){  

    7.             System.out.println("播放音乐"+i);  

    8.         }  

    9.           

    10.     }  

    11. }  

    12.   

    13. public class ImplementsRunnableDemo {  

    14.     public static void main(String[] args) {  

    15.         for(int j = 0; j < 50; j ++){  

    16.             System.out.println("运行游戏"+j);  

    17.             if(j == 10){  

    18.                 //4):在main方法(线程)中,创建线程对象,并启动线程  

    19.                 MusicImplements mi = new MusicImplements();  

    20.                 Thread t = new Thread(mi);  

    21.                 t.start();  

    22.             }  

    23.         }  

    24.     }  

    25.   

    26. }  

    3、实现Callable接口,重写call()方法,在main函数中调用start()方法。

    import java.util.concurrent.Callable;

    public class ThreadImplementsCallable implements Callable<Integer> {

      private int i; 

      @Override

      public Integer call() throws Exception {

        for(; i < 100; i++){

          System.out.println(Thread.currentThread().getName() + " " + i);

        }

        return i;

      }

    }

     

    import java.util.concurrent.Callable;

    import java.util.concurrent.FutureTask;

    public class Main {

      public static void main(String[] args) {

        Callable<Integer> callable = new ThreadImplementsCallable();

        FutureTask<Integer> futureTask = new FutureTask<>(callable);

        for(i = 0; i < 100; i++){

          System.out.println(Thread.currentThread().getName() + " " + i);

          if (i == 5) {

            new Thread(futureTask).start();

            new Thread(futureTask).start();

          }

        }

        try {

          System.out.println("futureTask ruturn: " + futureTask.get());

        } catch (Exception e) {

          e.printStackTrace();

        }

      }

    }

    展开全文
  • Java启动线程三种方式

    千次阅读 2019-10-24 19:02:22
    Thread 继承自Thread。 public class ThreadDemo extends Thread { @Override ... System.out.println(Thread.currentThread().getName() + "-启动了..."); } public static void main(String[] arg...

    Thread

    继承自Thread。

    public class ThreadDemo extends Thread {
    	@Override
    	public void run() {
    		System.out.println(Thread.currentThread().getName() + "-启动了...");
    	}
    
    	public static void main(String[] args) {
    		ThreadDemo thread = new ThreadDemo();
    		thread.start();
    		System.out.println(Thread.currentThread().getName() + "-启动了...");
    	}
    }
    输出:
    main-启动了...
    Thread-0-启动了...
    

    缺点:Java只能单继承,程序不好扩展。

    Runnable

    实现自Runnable。

    public class RunnableDemo implements Runnable {
    	@Override
    	public void run() {
    		System.out.println(Thread.currentThread().getName() + "-启动了...");
    	}
    
    	public static void main(String[] args) {
    		Runnable runnable = new RunnableDemo();
    		new Thread(runnable).start();
    		System.out.println(Thread.currentThread().getName() + "-启动了...");
    	}
    }
    输出:
    main-启动了...
    Thread-0-启动了...
    

    Java可以多实现,解决了 Thread 不好扩展的问题,推荐使用。

    Callable

    支持返回值。

    public class CallableDemo implements Callable<String> {
    	@Override
    	public String call() throws Exception {
    		System.out.println(Thread.currentThread().getName()+"-启动了...");
    		Thread.sleep(3000);
    		return "Lisa";
    	}
    
    	public static void main(String[] args) throws Exception {
    		Callable callable = new CallableDemo();
    		FutureTask<String> task = new FutureTask(callable);
    		Thread thread = new Thread(task);
    		thread.start();
    		// get()方法会阻塞
    		String result = task.get();
    		System.out.println(result);
    		System.out.println(Thread.currentThread().getName()+"-运行结束.");
    	}
    }
    输出:
    Thread-0-启动了...
    Lisa
    main-运行结束.
    

    get源码

    通过FutureTask的get()源码可以看一下具体实现。

    /**
     * @throws CancellationException {@inheritDoc}
     */
    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }
    

    重点是 awaitDone

    private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
            if (Thread.interrupted()) {
                removeWaiter(q);
                throw new InterruptedException();
            }
    
            int s = state;
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;
                return s;
            }
            else if (s == COMPLETING) // cannot time out yet
                Thread.yield();
            else if (q == null)
                q = new WaitNode();
            else if (!queued)
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                     q.next = waiters, q);
            else if (timed) {
                nanos = deadline - System.nanoTime();
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                LockSupport.parkNanos(this, nanos);
            }
            else
                LockSupport.park(this);
        }
    }
    

    通过一个 for ( ; ; ) 死循环监听线程状态,线程运行完毕才返回结果值。

    展开全文
  • java多线程之启动线程三种方式

    万次阅读 多人点赞 2018-08-12 14:42:08
    java对多线程有着良好的支持,java创建和启动线程较为常用的方式有继承Thread类、实现Runnable接口和匿名内部类的方式。 1.继承Thread类: 通过继承Thread类来创建并启动多线程步骤如下: 1、定义Thread类的子类...
  • MFC启动一个新线程三种方法

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

    千次阅读 2019-02-15 10:20:09
    启动线程方式第一: 1】d定义Thread类的子类,并重写该类的run()方法,该方法方法体就是线程需要完成的任务,run()方法也称为线程执行体。 2】创建Thread子类的实例,也就是创建了线程对象 3】启动线程,...
  • 创建线程三种方法

    万次阅读 2016-04-16 21:34:01
    第一种方法:继承Thread类,重写run()方法,run()方法代表线程要执行的任务。...第三种方法:实现callable接口,重写call()方法,call()作为线程的执行体,具有返回值,并且可以对异常进行声明和抛出
  • Python创建多线程三种方法

    千次阅读 2019-05-30 12:05:02
    Python创建多线程三种方法thread模块函数式创建线程继承threading类创建多线程threading模块函数式创建线程使用总结 thread模块函数式创建线程 调用thread模块中的start_new_thread()函数来产生新线程。语法如下: ...
  • 创建并启动线程方式

    千次阅读 2017-12-14 23:26:12
    第一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法,然后在run方法里填写相应的逻辑代码。class ThreadDemo1 extends Thread{ @Override public void run() { for(int i =0;i;i++){ Sys
  • VC启动一个新线程三种方法

    万次阅读 2015-03-14 19:53:43
    三种_beginthread() 函数原型为:intptr_t _beginthread(  void( *start_address )( void * ), //指向新线程调用的函数的起始地址  unsigned stack_size, //堆栈大小,设置0为系统默认值  void ...
  • 开启线程三种方式?

    千次阅读 2019-07-25 13:05:58
    一、继承Thread类创建线程类 (1)定义Thread类的子类,并重写该类...(3)调用线程对象的start()方法启动线程。 二、通过Runnable接口创建线程类 (1)定义runnable接口的实现类,并重写该接口的run()方法...
  • java线程的两种启动方式

    千次阅读 2018-04-11 20:34:26
    /** * 实现Runnable接口 * @author dell */public class TicketRunnable implements Runnable{ //实现run方法 @Override public void run() { for(int i=0; i&lt;10; i++){ System.out.println(i+" ...
  • java开启新线程三种方法

    万次阅读 2017-02-28 09:12:51
    4):在main方法(线程)中,创建线程对象,并启动线程. (1)创建线程类对象: A类 a = new A类(); (2)调用线程对象的start方法: a.start();//启动一个线程 注意:千万不要调用run方法,如果调用run方法好比是对象调用方法,...
  • c++11多线程编程(一):创建线程三种方法

    万次阅读 多人点赞 2017-11-03 14:45:08
    c++11线程库 原始的c++标准仅支持单线程编程,新的c++标准(c++11或c++0x)于2011年发布,引入了新的线程库。 编译器要求: Linux: gcc 4.8.1 (完全并发...在linux下的编译方法:g++ -std=c++11 sample.cpp -lpthread
  • 在项目中可能遇到这样的问题,在springboot容器启动之后执行特定的方法或者类。 ApplicationRunner接口,这个接口中有一个run方法,我们只需要实现这个方法即可 ApplicationRunner接口,这个接口中有一个run方法,...
  • 线程面试题(值得收藏)

    万次阅读 多人点赞 2019-08-16 09:41:18
    1、并发编程要素? 1)原子性 原子性指的是一个或者多个操作,要么全部执行并且在执行的过程中不被其他操作打断,要么就全部都不执行。 2)可见性 可见性指多个线程操作一个共享变量时,其中一个线程对变量进行修....
  • 线程三种实现方式

    千次阅读 2018-11-13 16:08:17
    Java中线程的实现有三种方式,分别是继承Thread类、实现Runnable接口和实现Callable接口。 继承Thread类 Thread类是Java.lang包中的一个类,从这个类中实例化的对象代表线程,程序员启动一个新的线程需要建立...
  • Java多线程(一)

    千次阅读 多人点赞 2019-12-02 13:15:43
    目录Java多线程(一)前言线程与进程概念关系Thread、Runnable、 Java多线程(一) 前言 线程与进程 概念 关系 Thread、Runnable、
  • JAVA多线程三种创建方式

    万次阅读 多人点赞 2019-03-03 16:24:47
    一、概述 在JAVA中,用Thread类代表线程,所有线程对象,都必须是Thread类或者Thread类子类的实例。...二、三种创建方式 2.1第一种,通过继承Thread类创建线程类 通过继承Thread类来创建并启动线程的步骤...
  • C++/MFC创建多线程三种方法(转载)

    万次阅读 多人点赞 2017-12-08 10:24:17
    这篇博客对多线程讲解的非常好,因此转载原文作者文章,希望对大家和自己的多线程编程能力有所...第一AfxBeginThread() 用AfxBeginThread()函数来创建一个新线程来执行任务,工作者线程的AfxBeginThread的原型如下:
  • Java中启动线程start和run方法

    千次阅读 2018-07-21 21:31:44
    Java中启动线程有两种方法,继承Thread类和实现Runnable接口,由于Java无法实现多重继承,所以一般通过实现Runnable接口来创建线程。但是无论哪种方法都可以通过start()和run()方法来启动线程,下面就来介绍一下他们...
  • Qt创建多线程的两种方法

    万次阅读 多人点赞 2017-12-25 15:33:54
    1.摘要 Qt有两种多线程的方法,其中一种是继承QThread的run函数,另外一种是把一个继承于QObject的类转移到一个Thread里。 Qt4.8之前都是使用继承QThread的run这种方法,但是Qt4.8之后,Qt官方...两种方法区别不大...
  • 线程 创建和启动线程的两方式 实现Runnable接口 继承Thread类 重写唯一方法run() 1.实现Runnable接口,必须重写Runnable接口的唯一run()方法启动线程方法(在主程序中):启动线程需要由步来执行。 1).首先...
  • java 创建线程三种方式、创建线程池的四种方式

    万次阅读 多人点赞 2019-02-23 21:01:44
    java创建线程三种方式: 继承Thread类创建线程类 实现Runnable接口 通过Callable和Future创建线程 java创建线程池的四种方式: newCachedThreadPool 创建一个可缓存的线程池,如果线程池长度超过处理...
  • Java实现多线程三种方式

    千次阅读 多人点赞 2020-02-02 11:03:20
    在Java中可通过三种方式来实现多线程:1、继承Thread类,重写run( )方法;2、实现Runnable接口,重写run( )方法;3、实现Callable接口,重写call( )方法并使用FutureTask获取call( )方法的返回结果
  • Java多线程实现的三种方式、区别

    千次阅读 2019-06-30 16:28:52
    1.1.三种使用线程方法 实现 Runnable 接口; 实现 Callable 接口; 继承 Thread 类。 实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务,不是真正意义上的线程,因此最后还需要通过 ...
  • 实现线程三种方式

    千次阅读 2018-02-25 21:58:57
    在java语言中,多线程的实现一般有以下三种方式: 1)实现runnable接口,并实现该接口的run()方法。 以下是主要步骤: ①自定义类并实现Ruannable接口,实现run()方法。 ②创建Thread对象,用实现Ruannable接口...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 390,875
精华内容 156,350
关键字:

启动线程的三种方法