public class ThreadTest01 {
    public static void main(String[] args) {
        System.out.println("main begin");
        m1();
        System.out.println("main over");
    }
    private static void m1() {
        System.out.println("m1 begin");
        m2();
        System.out.println("m1 over");
    }
    private static void m2() {
        System.out.println("m2 begin");
        m3();
        System.out.println("m2 over");
    }
    private static void m3() {
        System.out.println("m3 execute!");
    }
}
运行结果：
main begin
m1 begin
m2 begin
m3 execute!
m2 over
m1 over
main over

public class ThreadTest02 {
    public static void main(String[] args) {
        // 这里是main方法，这里的代码属于主线程，在主栈中运行。
        //创建分支线程对象
        MyThread myThread = new MyThread();
        //开启分支线程
        // 启动线程
        //myThread.run(); // 不会启动线程，不会分配新的分支栈。（这种方式就是单线程。）
        // start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。
        // 这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了。线程就启动成功了。
        // 启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。
        // run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。
        myThread.start();//立马结束，开始执行线程内容
        //运行主线程// 这里的代码还是运行在主线程中。
        for(int i=0;i<100;i++){
            System.out.println("主线程： " + i);
        }
    }
}
class MyThread extends Thread {
    @Override
    public void run() {
        // 编写程序，这段程序运行在分支线程中（分支栈）。
            for(int i=0;i<100;i++){
                System.out.println("分支线程： " + i);
            }
        }
}

public class ThreadTest03 {
    public static void main(String[] args) {
        //创建MyRunnable对象// 创建一个可运行的对象
        //MyRunnable m = new MyRunnable();
        //创建线程类，把MyRunnable类传到Thread类的构造器中// 将可运行的对象封装成一个线程对象
        //Thread t = new Thread(m);
        //合并代码
        Thread t = new Thread(new MyRunnable());
        //启动线程
        t.start();
        //执行主线程任务
        for(int i=0;i<100;i++){
            System.out.println("主线程： " + i);
        }
    }
}
// 这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("分支线程： " + i);
        }
    }
}

/*
* 采用匿名内部类的方式创建多线程
* */
public class ThreadTest04 {
    public static void main(String[] args) {
        //创建线程对象，以匿名内部类的方式创建多线程
        // 这是通过一个没有名字的类，new出来的对象。
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                //执行分支线程任务
                for(int i=0;i<100;i++){
                    System.out.println("分支线程： " + i);
                }
            }
        });
        //启动线程
        t.start();
        //执行主线程任务
        for(int i=0;i<100;i++){
            System.out.println("主线程： " + i);
        }
    }
}

public class ThreadTest15 {
    public static void main(String[] args) {
        //创建一个”未来任务类对象“
        // 第一步：创建一个“未来任务类”对象。
        // 参数非常重要，需要给一个Callable接口实现类对象。
        FutureTask f = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {// call()方法就相当于run方法。只不过这个有返回值
                // 线程执行一个任务，执行之后可能会有一个执行结果
                // 模拟执行
                System.out.println("call method begin!");
                Thread.sleep(1000 * 10);
                System.out.println("call method over!");
                int a = 30;
                int b = 20;
                return a - b;//自动装箱(300结果变成Integer)
            }
        });
        //创建线程对象
        Thread t = new Thread(f);
        //启动线程
        t.start();
        //获取分支线程的名字
        Object name = null;
        try {
            // 这里是main方法，这是在主线程中。
            // 在主线程中，怎么获取t线程的返回结果？
            // get()方法的执行会导致“当前线程阻塞”
            name = f.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(name);
        // main方法这里的程序要想执行必须等待get()方法的结束
        // 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果
        // 另一个线程执行是需要时间的。
        System.out.println("HelloWorld!");
    }
}