多线程—3种创建线程的方法

 

一、继承Thread类创建线程类

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

（2）创建Thread子类的实例，即创建了线程对象。

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

[java] view plain copy

1.  package com.thread;  

2.    

3.  public class FirstThreadTest extends Thread{  

4.      int i = 0;  

5.      //重写run方法，run方法的方法体就是现场执行体  

6.      public void run()  

7.      {  

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

9.          System.out.println(getName()+"  "+i);  

10.           

11.         }  

12.     }  

13.     public static void main(String[] args)  

14.     {  

15.         for(int i = 0;i< 100;i++)  

16.         {  

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

18.             if(i==20)  

19.             {  

20.                 new FirstThreadTest().start();  

21.                 new FirstThreadTest().start();  

22.             }  

23.         }  

24.     }  

25.   

26. }  

   

上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。

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

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

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

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

   

三：Java多线程之Callable和Future接口的实现

 

Callable接口定义了一个call（）方法可以作为线程的执行体，call方法比run方法更强大：

 

    A、call方法可以有返回值

（FutureTask：它实现了Futrue和Runnable接口，可以作为Thread的入参启动线程）

    B、call方法可以申明抛出异常 

    C、Callable接口是JDK5后新增的接口，而且不是Runnable的子接口，所以Callable对象不能直接作为Thread的target。而且call方法还有一个返回值，

       JDK1.5提供了Future接口来代表Callable接口里的call方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现Future接口，也实现了Runnable接口，可以作为Thread的target入参。

   

  Future接口里定义了如下几个公共方法控制他关联的Callable任务：*******(核心)*******

      

    A、boolean cancel(Boolean mayInterruptlfRunning):试图取消该Future里关联的Callable任务

    B、V get()：返回Callable任务里的call方法的返回值，调用该方法将导致线程阻塞，必须等到子线程结束才得到返回值

    C、V get(long timeout, TimeUnit unit)：返回Callable任务里的call方法的返回值，该方法让程序最多阻塞timeout和unit指定的时间。

        如果经过指定时间后Callable任务依然没有返回值，将会抛出TimeoutException。

    D、boolean isCancelled()：如果在Callable任务正常完成前被取消，则返回true。

    E、boolean isDone()：如果Callable任务已经完成，则返回true

   

创建、并启动有返回值的线程的实例代码如下：    

    一、创建Callable接口的实现类，并实现call方法，该call方法的返回值，并作为线程的执行体。

    二、创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call方法的返回值

    三、使用FutureTask对象作为Thread对象的target创建、并启动新线程

    四、调用FutureTask对象的方法来获得子线程执行结束后的返回值

===================================================================

package com.del;

import java.util.concurrent.Callable;

import java.util.concurrent.FutureTask;

   

public class TestCallable {

     

    public static void main(String[] args) {

        

        //1.创建Callable实现类的实例

        ThreadDemo td = new ThreadDemo();

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

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

       //3.FutureTask实现了Runnable, Future<V>,接口，Thread也实现了Runnable接口，所以 FutureTask可以入参

        new Thread(result).start();

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

        try {

        //调用get()方法将导致线程阻塞，必须等到子线程结束才得到返回值

            Integer sum = result.get(); 

            System.out.println("call方法的返回值："+sum);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

   

class ThreadDemo implements Callable<Integer> {

       

    /**

      * 重写call()方法

      */

    @Override

    public Integer call() throws Exception {

        int sum = 0;

   

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

            sum += i;

        }

   

        return sum;

    }

}

===================================================================

说明：

1.       Thread2类通过实现Runnable接口，使得该类有了多线程类的特征。run（）方法是多线程程序的一个约定。所有的多线程代码都在run方法里面。Runnable接口没有strar()方法，只能由Thread来启动！Thread类实际上也是实现了Runnable接口的类。

2.       在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。

3.       实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

4.  在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。

   

总结：创建线程的三种方式的对比

1：使用继承Thread类的方式创建多线程

优势：

编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

劣势是：

线程类已经继承了Thread类，所以不能再继承其他父类。

:2：采用实现Runnable、Callable接口的方式创见多线程

优势：

线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

劣势：

编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。:

3：Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

总结：

多实现Runnable接口比单继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

4）： 线程池只能放入实现Runable或callable类线程，不能直接放入继承

Thread的类

4：Callable和Runnable的区别

1.   Callable和Runnable有几点不同：  

2.   * （1）Callable规定的方法是call()，而Runnable规定的方法是run(). 

3.   * （2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。  

4.   * （3）call()方法可抛出异常，而run()方法是不能抛出异常的。 

5.   * （4）运行Callable任务可拿到一个Future对象， Future表示异步计算的结果。 

6.   *  它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。 

7.   *  通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。 

转载于:https://www.cnblogs.com/domi22/p/8046845.html