Java并发线程--多线程的创建

线程是java语言中不可或缺的重要功能，它能使复杂的异步代码变得更简单，从而极大地简化了复杂系统的开发，如何高效的使用并发变得越来越重要。

得当的使用线程，可以有效地降低程序的开发和维护成本，同时提升复杂应用程序的性能。线程能够将大部分的异步工作流转换成串行工作流，因此能更好地模拟人类的工作方式和交互方式。此外，线程还可以降低代码的复杂度，使代码更容易编写、阅读和维护。

创建线程的三种方式

◎定义线程类实现Runnable接口

◎定义线程类继承Thread类

◎定义线程类实现Callable接口

每个线程都是启动和执行两个步骤来操作的。其中，线程启动是调用thread类的start()方法，线程执行的任务是调用thread类的run()方法来完成其操作的。

注意，不是调用run()方法启动线程，run方法中只是定义需要执行的任务，如果调用run方法，即相当于在主线程中执行run方法，跟普通的方法调用没有任何区别，此时并不会创建一个新的线程来执行定义的任务。如下所示：

public class TestThread1 {

  public static void main(String args[]){
    Runner1 runner1=new Runner1();
    runner1.run();//1.这里直接调用自定义线程类的run方法，为非线程操作

    for(int i=0;i<100;i++){
        System.out.println("Main Thread："+i);
    }   
  }

}

class Runner1 implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("Runner1："+i);
        }   
    }   
}

控制台输出结果

代码执行路径如下图所示，main方法执行到runner1.run()进入阻塞状态，直到run（）方法执行完才再次运行。

方式一：实现runnable接口

public class TestThread1 {

  public static void main(String args[]){
    Runner1 runner1=new Runner1();
    Thread thread=new Thread(runner1);//创建线程实例
    thread.start();//启动线程

    for(int i=0;i<100;i++){
        System.out.println("Main Thread："+i);
    }   
  }

}

class Runner1 implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("Runner1："+i);
        }   
    }   
}

控制台输出结果

从输出结果可以看出，main()方法和run()方法交替执行，执行路径如下图所示：

方式二：继承thread类

public class TestThread2 {

  public static void main(String args[]){
    Runner2 runner2=new Runner2();
    runner2.start();
    for(int i=0;i<100;i++){
        System.out.println("Main Thread："+i);
    }   
  }

}

class Runner2 extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("Runner1："+i);
        }   
    }   
}

线程执行路线和上图相同，不在重复。

方式三：实现callable接口

public class TestThread3 {
    public static void main(String[] args){
        FutureTask< Integer>  task=new FutureTask<Integer>(new caller());
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"的循环变量i的值："+i);
            if(i==20){
                new Thread(task,"有返回值的线程").start();//以callable对象来创建并启动线程
            }
        }
        try {
            System.out.println("子线程的返回值："+task.get());
        } catch (Exception e) {
            e.printStackTrace();
        }       
    }       
}

class caller implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int i=0;
        for(;i<100;i++){
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值："+i);
        }
        return i;
    }

}

控制台输出结果

… …

三种方式对比

通过继承thread类或实现callable接口、runnable接口都可以实现多线程，不过实现runnable接口与实现callable接口方式基本相同，只是callable接口定义的方法有返回值，可以声明抛出异常而已，因此可以统称为实现接口。

实现接口–优势

◎实现runnable或callable接口，线程类还可以继承其他类，也可以实现其他接口，比较灵活。
◎多个线程可以共享同一个target对象，适合多个相同线程来 处理同一份资源的情况。

实现接口–劣势

◎编程相对复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

继承Thread–优势

◎编写简单，如果需要访问当前线程，直接使用this即可获得当前线程。

继承Thread–劣势

◎不能多类继承，比较保守。

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

综上所述，一般能用接口不用继承。