posts - 203,comments - 37,trackbacks - 0

  Java中多线程的应用是非常多的,我们在Java中又该如何去创建线程呢?

  http://www.jianshu.com/p/40d4c7aebd66

一、常用的有三种方法来创建多线程

  • 新建一个类继承自Thread类,具体步骤如下:

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

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

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

       1 public class FirstThreadTest extends Thread{  
       2     int i = 0;  
       3     //重写run方法,run方法的方法体就是现场执行体  
       4     public void run()  
       5     {  
       6         for(;i<100;i++){  
       7         System.out.println(getName()+"  "+i);  
       8           
       9         }  
      10     }  
      11     public static void main(String[] args)  
      12     {  
      13         for(int i = 0;i< 100;i++)  
      14         {  
      15             System.out.println(Thread.currentThread().getName()+"  : "+i);  
      16             if(i==20)  
      17             {  
      18                 //创建实例,并调用其start()方法启动线程
      19                 new FirstThreadTest().start();  
      20                 new FirstThreadTest().start();  
      21             }  
      22         }  
      23     }  
      24 }
  • 新建一个类实现接口Runnable,具体步骤如下:

    1. 定义runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
    2. 创建 Runnable实现类的实例,并依此实例作为Thread的target来创建Thread对象,该Thread对象才是真正的线程对象。

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

       1 public class RunnableThreadTest implements Runnable  
       2 {  
       3     private int i;  
       4     //重写run()方法
       5     public void run()  
       6     {  
       7         for(i = 0;i <100;i++)  
       8         {  
       9             System.out.println(Thread.currentThread().getName()+" "+i);  
      10         }  
      11     }  
      12     public static void main(String[] args)  
      13     {  
      14         for(int i = 0;i < 100;i++)  
      15         {  
      16             System.out.println(Thread.currentThread().getName()+" "+i);  
      17             if(i==20)  
      18             {  
      19                 //用实现类的对象作为参数传入new Thread(Runnable obj)来创建Thread对象,然后调用start()方法启动线程
      20                 RunnableThreadTest rtt = new RunnableThreadTest();  
      21                 new Thread(rtt,"新线程1").start();  
      22                 new Thread(rtt,"新线程2").start();  
      23             }  
      24         }  
      25     }  
      26 }
  • 通过Callable和Future创建线程,具体步骤如下:

    1. 创建Callable接口的实现类,并实现call()方法,该call()方法将作为线程执行体,并且有返回值。
    2. 创建Callable实现类的实例,使用FutureTask类来包装Callable对象,该FutureTask对象封装了该Callable对象的call()方法的返回值

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

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

       1 public class CallableThreadTest implements Callable<Integer>  
       2 {  
       3   
       4     public static void main(String[] args)  
       5     {  
       6         CallableThreadTest ctt = new CallableThreadTest();  
       7         FutureTask<Integer> ft = new FutureTask<>(ctt);  
       8         for(int i = 0;i < 100;i++)  
       9         {  
      10             System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
      11             if(i==20)  
      12             {  
      13                 new Thread(ft,"有返回值的线程").start();  
      14             }  
      15         }  
      16         try  
      17         {  
      18             System.out.println("子线程的返回值:"+ft.get());  
      19         } catch (InterruptedException e)  
      20         {  
      21             e.printStackTrace();  
      22         } catch (ExecutionException e)  
      23         {  
      24             e.printStackTrace();  
      25         }   
      26     }  
      27   
      28     @Override  
      29     public Integer call() throws Exception  
      30     {  
      31         int i = 0;  
      32         for(;i<100;i++)  
      33         {  
      34             System.out.println(Thread.currentThread().getName()+" "+i);  
      35         }  
      36         return i;  
      37     }  
      38 }

二、创建线程的三种方式的对比

  采用实现Runnable、Callable接口的方式创见多线程时,优势是

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

  劣势是:

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

  使用继承Thread类的方式创建多线程时优势是:

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

  劣势是:

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

 

posted on 2016-07-27 09:52  mukekeheart  阅读(...)  评论(...编辑  收藏