Java线程创建方式

一.继承Thread类来创建线程

新建一个类，来继承Thread类，然后重写run方法。main线程中创建新线程的实例，然后调用start()方法即可。

public class MyThread extends Thread{
     @Override
     public void run() {
          //用来描述线程的执行任务
          for(int i=1; i<=5; i++){
               System.out.println("MyThread线程输出" + i);
          }
     }
}

/**
 * 多线程创建方式1
 * 创建新线程类继承Thread类并且重写run方法
 */
public class TreadTest {
     public static void main(String[] args) {
          //创建MyThread线程类对象代表一个线程
          Thread t = new MyThread();
          t.start();    //main线程  t线程  t线程自动执行run方法
          for(int i=1; i<=5; i++){
               System.out.println("主线程main输出" + i);
          }
     }
}

总结:这种线程创建方式的优点是编码比较简单，缺点是线程类已经继承Thread，无法继承其他类，不利于功能的扩展。

注意事项：

1.不能调用子线程的run方法，一定调用start方法

如果调用run方法，会把子线程当作一个普通Java对象来处理，那么run方法就会先执行。相当于只有一条主线程在跑。start的方法是向cpu或操作系统注册线程。

2.不能把主线程的任务放在子线程之前

容易理解，因为如果放在子线程之前，会先执行主线程的任务，就达不到两条线程并行的效果。

二.实现Runnable接口创建线程

首先创建一个线程任务类MyRunnable实现Runnable接口，重写run方法

主线程中创建线程任务类MyRunnable对象

把MyRunnable任务对象交给Thread处理(Thread类有一个有参构造器，可以传线程人物类对象)

调用线程对象的start方法启动线程

/***
 * 定义一个任务类，实现runnable接口,重写run方法
 */
public class ThreadTest2 {
     public static void main(String[] args) {
          //创建任务对象
          Runnable target = new MyRunnable();
          //任务对象交给线程对象处理
          
/*          public Thread(Runnable target) {
               this(null, target, "Thread-" + nextThreadNum(), 0);
          }
          
 */
          new Thread(target).start();
          for(int i=1; i<=5; i++){
               System.out.println("主线程输出" + i);
          }
     }
}

public class MyRunnable implements Runnable{
     @Override
     public void run() {
          //线程要执行的任务
          for(int i=1; i<=5; i++){
               System.out.println("子线程输出" + i);
          }
     }
}

总结：这种线程创建方式优点是任务类只是实现接口，可以继承其他类，实现其他接口，扩展性更强

简化形式1.

new Thread(new Runnable() {
               @Override
               public void run() {
                    for(int i=1; i<=5; i++){
                         System.out.println("子线程输出" + i);
                    }
               }
          }).start();

简化形式二

由于Runnable是函数式的接口，可以通过lambda表达式来简化

 //简化形式lambda表达式
          new Thread(()->{
               for(int i=1; i<=5; i++){
                    System.out.println("子线程3输出" + i);
               }
          }).start();

三.实现Callable接口创建线程

前面两种线程创建方式，他们重写run方法均不能返回结果(如果有数据要返回的话)

创建方式：利用Callable接口，FutureTask类来实现

 定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据

把Callable类型对象封装程FutureTask(线程任务对象)

把线程任务对象交给Thread对象，调用start方法

线程执行完毕后，通过FutureTask对象的get方法获取线程任务执行结果

public class MyClass implements Callable<String> {
     private int n;

     public MyClass(int n) {
          this.n = n;
     }

     @Override
     public String call() throws Exception {
          //描述线程任务，返回线程执行返回后的结果
          //需求，求1~n的和返回
          int sum = 0;
          for (int i = 1; i <= n; i++) {
               sum += i;
          }
          return "线程求出了1~" + n + "的和" + sum;
     }
}

public class ThreadTest3 {
     public static void main(String[] args) throws Exception {
          //创建Callable对象
          Callable<String> callable = new MyClass(100);
          //把Callable对象封装成一个FutureTask对象
          //因为FutureTask对象实现了Runnable接口，是一个线程任务对象
          //可以在线程执行完毕后，用未来任务对象调用get方法获取线程执行完毕的结果
          FutureTask<String> futureTask = new FutureTask<>(callable);
          new Thread(futureTask).start();

          //这里再创建一个线程执行计算1~200的和
          Callable<String> callable2 = new MyClass(200);
          FutureTask<String> futureTask2 = new FutureTask<>(callable2);
          new Thread(futureTask2).start();

          //获取线程执行完毕后返回的结果
          //如果上面线程还没执行完，这里是会暂停执行，直至线程跑完
          String s = futureTask.get();
          System.out.println(s);

          String s2 = futureTask2.get();
          System.out.println(s2);
     }
}

总结：

优点:线程任务类只是实现接口，可以继承继承类和实现接口，扩展性强，并且可以在线程执行完毕后获取线程执行的结果。

缺点：编码复杂