线程创建：三种方式。

多线程的原理： 多个线程是并发执行的，所以多线程的执行会出现随机性。

多线程优点：可以提高程序效率，可以设计一些业务模型。

多线程的创建方式：
   （1）继承Thread类。
   （2）实现Runnable接口。
   （3）实现Callable接口。（有返回值的）
目标：线程的创建方式一

（1）继承Thread类。

总结：
    a.线程创建建议放在前面，不要把主线程任务先执行。
    b.启动线程必须用start方法，如果直接调用run()方法，将变成普通类调用执行！
    线程创建方式一的优缺点：
       优点：编码简单。
       缺点：线程类已经继承了Thread类，无法再继承其他类 ，本身的功能就不够强大。
            不适合做线程池，不能得到线程执行的结果。

public class ThreadDemo01 {
    // 进程：ThreadDemo01
    // 主线程：main方法。
    public static void main(String[] args) {
        // 创建一个子线程
        MyThread t = new MyThread();
        // 线程启动必须用start方法，如果用run方法，就失去了线程特征。
        t.start();


        for (int i = 0 ; i < 5 ; i++ ){
            System.out.println("main线程输出："+i);
        }

    }
}

// 线程类，线程类适用于创建线程的
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0 ; i < 5 ; i++ ){
            System.out.println("子线程输出："+i);
        }
    }
}

（2）实现Runnable接口

创建方式二的优缺点：

                            缺点：编码相对复杂，不能得到线程执行的结果。

                            优点：线程任务对象只是实现了Runnable接口，可以继续继承其他类，

                                      可以继续实现其他接口。 线程任务对象的本身的功能可以增强，

                                      非常适合做线程池。 非常适合做共享资源的访问。

ublic class ThreadDemo01 {
    public static void main(String[] args) {
        //（3）创建线程任务类对象，。
        RunnableTarget target = new RunnableTarget();
        // Thread(Runnable target)
        // Thread(Runnable target,String name)
        // 创建一个Thread线程对象包装线程任务对象
        Thread t = new Thread(target,"子线程1号");
        t.start();

        Thread t1 = new Thread(target,"子线程2号");
        t1.start();

        for (int i = 0 ; i < 5 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"=>输出："+i);
        }
    }
}

// （1）定义一个线程任务类实现Runnable接口。
class RunnableTarget  implements Runnable{
    // （2）重写run()方法。
    @Override
    public void run() {
        for (int i = 0 ; i < 5 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"=>输出："+i);
        }
    }
}

（3）实现Callable接口。（有返回值的）

创建方式三的优缺点：
    缺点：编码复杂。
    优点：
        线程任务对象只是实现了Callable接口，可以继续继承其他类，可以继续实现其他接口。

        线程任务对象的本身的功能可以增强，非常适合做线程池。

        非常适合做共享资源的访问。可以得到线程执行的结果

public class ThreadDemo01 {
    public static void main(String[] args) {
        // （2）创建一个未来任务对象FutureTask对象，包装Callable实现类对象。
        CallableTarger targer = new CallableTarger();
        //  未来任务对象的功能：可以在线程执行完毕以后得到线程的执行结果。
        //  未来任务对象实际上就是一个Runnable对象
        FutureTask<String> task = new FutureTask<>(targer);
        // public Thread(Runnable task)
        // （3）创建一个线程对象Thread来包装FutureTask对象
        Thread t = new Thread(task);
        // （4）启动线程。
        t.start();

        for(int i = 1 ; i <= 5 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"=>输出："+i);
        }

        // （5）获取线程执行的结果。
        try {
            String rs = task.get();
            System.out.println(rs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//  （1）创建一个线程任务对象，实现Callable接口，申明线程执行的结果类型。
// 需求：让线程求和，求 1-5的和返回。
class CallableTarger implements Callable<String>{
    @Override
    public String call() throws Exception {
        int sum = 0 ;
        for(int i = 1 ; i <= 5 ; i++ ){
            sum+=i;
            System.out.println(Thread.currentThread().getName()+"=>输出："+i);
        }
        return Thread.currentThread().getName()+"求和返回："+sum;
    }
}