java多线程（2）线程的创建和启动

1. 首先需要指出，java程序在执行main方法的时候就创建了一个名字为main的线程了
2. 还有一个重要的点既是，在mian方法中开启的子线程不是要等待main方法执行完之后再开始执行，也不是再调用start方法的时候就开始执行，可以说它执行的时间是随机的
3. 以下介绍三种创建和启动子线程的方法，具体的讲解穿插再代码中

   //通过继承Thread类来实创建线程类，需要指出的是，两个再main线程中开启的线程
   //将共享成员变量i，就是说如果再其中一个线程中对i进行了加1的操作，那么再另一个
   //线程里i也会被看做加了1
   
   public class FirstThread extends Thread{
       private int i;
   
   //    run方法是子线程的执行体
       public void run(){
           for(; i<100; i++){
               System.out.println(getName() + " " + i);
           }
       }
   
       public static void main(String args[]){
           for(int i=0; i<100; i++){
   
               System.out.println(Thread.currentThread().getName() + " " + i);
   //            Thread.currentThread().getName()方法可以获取当前线程的名称，main方法的线程
   //            名称是main
   
   //            当i==20的时候，开启子线程
               if(i == 20){
                   new FirstThread().start();
                   new FirstThread().start();
               }
           }
           System.out.println("finish");
       }
   }
   

   //通过实现Runnable接口创建线程类
   //步骤：
   //  1、定义Runnable接口的实现类，并且重写接口的run方法，该方法的方法体同样是该线程的执行体
   //  2、创建Runnable实现类的示例，并以此示例作为Thread的target来创建Thread对象，这个Thread对象才是真正
   //     的线程对象
   
   public class SecondThread implements Runnable {
       private int i;
   
   //   run方法是线程的执行体
       public void run(){
           for(; i<100; i++){
               System.out.println(Thread.currentThread().getName() + "  " + i);
           }
       }
   
   
       public static void main(String args[]){
           for(int i=0; i<100; i++){
               System.out.println(Thread.currentThread().getName() + "" + i);
               if(i == 20){
   
   
                   SecondThread st = new SecondThread();
   //                创建Runnable实现类的实例
   
   //                通过该实现类的实例化对象为target来创建Thread对象，这个Thread对象才是真正的线程对象
                   new Thread(st, "新线程1").start();
                   new Thread(st, "新线程2").start();
               }
           }
           System.out.println("finish");
       }
   
   }
   

   //使用callable和future创建线程
   //acllcble接口提供了一个call方法可以作为线程的执行体，和run不同的是，call方法可以有返回值以及call
   //方法可以声明抛出异常
   //使用步骤
   //  1、创建callable接口的实现类，并实现call方法，call方法为线程的执行体，并call方法具有返回值
   //  2、创建callable实现类的实例，并使用futureTask来包装它，这个futureTask对象封装callable对象call方法
   //   的返回值
   //  3、使用futureTask对象作为Thread对象的target创建并且启动新线程
   //  4、使用future对象的get方法来获得子线程执行后的返回值
   
   import java.util.concurrent.Callable;
   import java.util.concurrent.FutureTask;
   
   public class ThirdThread implements Callable<Integer> {
       //  1、创建callable接口的实现类，并实现call方法，call方法为线程的执行体，并call方法具有返回值
   
       public Integer call(){
           int i = 0;
           for(; i<100; i++){
               System.out.println(Thread.currentThread().getName()+ "的循环变量i的值为" +i);
           }
           return i;
       }
       public static void main(String args[]){
   
   //  1、创建callable接口的实现类，并实现call方法，call方法为线程的执行体，并call方法具有返回值
           ThirdThread rt = new ThirdThread();
           FutureTask<Integer> task = new FutureTask<Integer>(rt);
   
           for(int  i=0; i<100; i++){
               System.out.println(Thread.currentThread().getName() + "的循环变量i的值为" + i);
               if(i == 20){
   
                   new Thread(task, "有返回值的线程").start();
   //  3、使用futureTask对象作为Thread对象的target创建并且启动新线程
   
               }
           }
           try{
   
               System.out.println("子线程的返回值为：" + task.get());
   //  4、使用future对象的get方法来获得子线程执行后的返回值,因为call方法可以声明抛出异常，所以必须把它放在异常捕获块里
   
           }catch (Exception ex){
               ex.printStackTrace();
           }
       }
   }
   

    

4. 一般推荐实现Runnable接口，Callable接口的方式来创建多线程