当前位置:首页 > 嵌入式培训 > 嵌入式学习 > 讲师博文 > Java开发:线程创建的三种方式

Java开发:线程创建的三种方式 时间:2019-03-13      来源:华清远见

线程的创建大多使用Thread类或者Runnable,其实还有第三种Callable。

相比之下Thread类比较简单但使用限制比较大。

Runnable应用灵活也是最常用的一种方式。

Callable应用较少,但可以及时返回线程处理的结果。

一、继承Thread类创建线程类

(1)定义Thread类的子类,并重写该类的run方法,该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。

(2)创建Thread子类的实例,即创建了线程对象。

(3)调用线程对象的start()方法来启动该线程。

public class Main {            

      public static void main(String[] args) throws Exception {     

          myThread th1 = new myThread();

          myThread th2 = new myThread();

          th1.start();

          th2.start();

     }           

}

 

class myThread extends Thread {    

    public void run() {

        for(int i = 0; i < 5; i++) {

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

        }

    }

}

二、通过Runnable接口创建线程类

(1)定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。

(2)创建 Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。

(3)调用线程对象的start()方法来启动该线程。

事实上,当传入一个Runnable target参数给Thread后,Thread的run()方法就会调用target.run(),参考JDK源代码:

public void run() {

  if (target != null) {

   target.run();

  }

}

示例代码为:

public class Main {            

      public static void main(String[] args) throws Exception {   

          myThread myth = new myThread();

          Thread th1 = new Thread(myth);

          Thread th2 = new Thread(myth);

          th1.start();

          th2.start();

     }           

}

 

class myThread implements Runnable {

    

    public void run() {

        for(int i = 0; i < 5; i++) {

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

        }

    }

}

三、通过Callable和Future创建线程

(1)创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。

(2)创建实现了Callable接口的实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值。

(3)使用FutureTask对象作为Thread对象的target创建并启动新线程。

(4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

实例代码:

package test4;

 

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

 

public class Main {

 

    public static void main(String[] args) {

        ThreadDemo td = new ThreadDemo();

 

        // 1.执行Callable方式,需要FutureTask实现类的支持,用于接收运算结果

        FutureTask<Integer> result = new FutureTask<>(td);

        new Thread(result).start();

 

        // 2.接收线程运算后的结果

        Integer sum;

        try {

            //等所有线程执行完,获取值,因此FutureTask 可用于 闭锁

            sum = result.get();

            System.out.println("-----------------------------");

            System.out.println(sum);

        } catch (InterruptedException | ExecutionException e) {

            e.printStackTrace();

        }

    }

class ThreadDemo implements Callable<Integer> {

 

    @Override

    public Integer call() throws Exception {

        int sum = 0;

        for (int i = 0; i <= 10; i++) {

            System.out.println(i);

            sum += i;

        }

        return sum;

    }

}

结果

0

1

2

3

4

5

6

7

8

9

10

-----------------------------

55

实际开发中应该在具体的情况下分析使用哪一种开始线程的方式。

上一篇:嵌入式Linux:组播

下一篇:C++覆盖和遮蔽

热点文章推荐
华清学员就业榜单
高薪学员经验分享
热点新闻推荐
前台专线:010-82525158 企业培训洽谈专线:010-82525379 院校合作洽谈专线:010-82525379 Copyright © 2004-2018 北京华清远见科技发展有限公司 版权所有 ,京ICP备16055225号,京公海网安备11010802025203号