java多线程的三种创建方式

1.继承Thread

1.定义一个类继承Thread类。
2.覆盖重写Thread类中的run方法。该run方法的方法体就代表线程要完成的任务，因此被称为线程执行体。
3.直接创建Thread的子类对象的实例。即创建了线程对象。
4.调用线程对象的start方法开启线程并调用线程的任务，run方法执行。

public class ThreadDemo extends Thread {
    int i;
    @Override
    public synchronized void run() {
        for (; i < 20; i++) {
            System.out.println("线程名："+getName()+"::"+i);
        }
    }

    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();
        ThreadDemo threadDemo1 = new ThreadDemo();
        threadDemo.start();
        threadDemo1.start();
    }
}

注意事项：
1.可以通过Thread的方法获取线程名称：
currentThread（）：Thread的静态方法，返回当前运行的线程对象。

getName（）：Thread的实例方法，获取线程的名称。默认情况下主线程名字为main，用户启动的名字为Thread-编号（从0开始）。
（因为是继承的Thread类，所以可以直接用this获得当前线程，直接使用getName（）方法。不过其他创建方式就不行了）

2.使用继承Thread类的方法来创建线程时，多个线程间无法共享线程类的实例变量。
运行上方代码可以发现两个线程都运行了20次。

2.实现Runnable接口

1.定义类实现Ruannble接口。
2.覆盖接口中的run方法，将线程的任务代码封装到run方法中。
3.通过Thread类创建线程对象，并将Runnable接口的实现类对象作为构造方法的参数进行传递。
实际的线程对象仍是Thread实例，只不过这个Thread负责执行Runnable实现类的run方法，
线程的任务都封装在了Runnable接口实现类对象的run方法中。

4.调用线程对象的start方法开启线程。

public class RunnableDemo implements Runnable {
    int i;

    @Override
    public void run() {
        show();
    }

    public void show() {
        for (; i < 20; i++) {
            System.out.println("线程名：" + Thread.currentThread().getName()+"::"+i);
        }
    }

    public static void main(String[] args) {
        RunnableDemo demo = new RunnableDemo();
        Thread thread = new Thread(demo, "可以顺手指定个线程名字");
        Thread thread1 = new Thread(demo, "北京汉堡");

        thread.start();
        thread1.start();
    }
}

实现Runnable接口的好处：
1.将线程的任务从线程的子类中分离出来，进行了单独的封装。
按照面向对象的思想将任务封装为对象。
2.避免了java单继承的局限性。

3.可以共享线程类的成员变量，这是因为在这种方法下，程序所创建的Runnable
对象只是线程的target，可以理解为要执行的任务，多个线程可以共享一个
任务，所以多个线程可以共享同一个成员变量。

运行上方代码可以发现两个线程一共执行了20次。

3.使用Callable和Future创建线程

步骤：
1.创建Callable接口的实现类，并实现call()方法。该call就是线程执行体，且该方法有返回值。
2.使用FutrueTask类来包装Callable对象。该FutrueTask对象封装了该Callable对象的call()方法的返回值。
3.使用FutrueTask对象作为Thread的参数并启动新线程。
4.使用FutrueTask对象的get()方法获得子线程执行结束后的返回值。

public class CallableDemo implements Callable {
    int i;
    @Override
    public Object call() throws Exception {
        show();
        return "大笨蛋"+i;
    }
    public void show() {
        for (; i < 20; i++) {
            System.out.println("线程名：" + Thread.currentThread().getName()+"::"+i);
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableDemo demo = new CallableDemo();
        FutureTask<String> futureTask = new FutureTask<String>(demo);
        Thread thread = new Thread(futureTask);
        Thread thread1 = new Thread(futureTask);
        thread.start();
        thread1.start();
        System.out.println(futureTask.get());

    }
}

注意事项：
1.FutrueTask实现了Futrue接口和Runnable接口，Futrun接口来代表Callable接口里的call()方法的返回值，Runnable让其可以作为Thread的target。
2.实现Runnable接口和Callable接口并无太大区别，只不过Callable的call（）方法允许声明抛出异常，并且允许带返回值。

第一次写博客，排版与表达还有诸多不足之处，有错误或问题请下方评论或私信我~