多线程(一)-两种创建线程的方式+实现Callable接口方式

public class MyThread extends Thread{

    @Override
    public void run() {
        //线程执行的业务方法
        System.out.println("子线程执行");
        for (int i = 0;i < 5;i++){
            System.out.println("--- 线程名---："+Thread.currentThread().getName()+"，序号："+i);
        }
    }

    public static void main(String[] args) {
        //主线程
        System.out.println("***主线程执行***");
        System.out.println("***线程名***："+Thread.currentThread().getName());

        //创建一个线程并启动，只能通过主线程创建其他线程
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        //启动线程：start()方法（一旦启动，自动启动子线程，当前线程继续向下执行，不会等子线程）
        thread1.start();

        //启动多线程
        //多线程并发执行：不是正真一样上的并行执行(肉眼感官是并行)，而是通过cpu的调度算法，有序cpu执行极快，所以肉眼看起来是并行的；
        thread2.start();

        //调用run方法，不可以启动线程，就是对象的普通方法调用，等run方法执行结束，主线程才能继续执行
        //thread1.run();
        //thread2.run();

        System.out.println("----主线程执行结束----");

    }
}

***主线程执行***
***线程名***：main
----主线程执行结束----
子线程执行
--- 线程名---：Thread-0，序号：0
--- 线程名---：Thread-0，序号：1
--- 线程名---：Thread-0，序号：2
--- 线程名---：Thread-0，序号：3
--- 线程名---：Thread-0，序号：4
子线程执行
--- 线程名---：Thread-1，序号：0
--- 线程名---：Thread-1，序号：1
--- 线程名---：Thread-1，序号：2
--- 线程名---：Thread-1，序号：3
--- 线程名---：Thread-1，序号：4

***主线程执行***
***线程名***：main
子线程执行
--- 线程名---：main，序号：0
--- 线程名---：main，序号：1
--- 线程名---：main，序号：2
--- 线程名---：main，序号：3
--- 线程名---：main，序号：4
子线程执行
--- 线程名---：main，序号：0
--- 线程名---：main，序号：1
--- 线程名---：main，序号：2
--- 线程名---：main，序号：3
--- 线程名---：main，序号：4
----主线程执行结束----      //必须等子线程完成后才可以继续运行

public class MyRunnable implements Runnable{

    private int num = 5;

    @Override
    public void run() {
        //线程执行的业务方法
        System.out.println("子线程执行");
        for (int i = 0;i < 5 ;i++){
            if(num>0){
                System.out.println("--- 线程名---："+Thread.currentThread().getName()+"，序号："+num--);
            }
        }
    }

    public static void main(String[] args) {
        //主线程
        System.out.println("***主线程执行***");
        System.out.println("***线程名***："+Thread.currentThread().getName());

        //创建一个子线程，并启动
        MyRunnable runnable1 = new MyRunnable();

        //实现Runnable接口方式创建的线程,不能自己启动，只能通过Thread类，将Runnable作为参数传入Thread类的构造方法中，
        // 构造线程对象，才可以启动
        Thread thread1 = new Thread(runnable1);
        thread1.start();
        //创建多线程 (如果传入的Runnable参数一样，可以共享资源)
        Thread thread2 = new Thread(runnable1);
        thread2.start();

        System.out.println("----主线程执行结束----");

    }

}

***主线程执行***
***线程名***：main
----主线程执行结束----
子线程执行
子线程执行
--- 线程名---：Thread-0，序号：5
--- 线程名---：Thread-1，序号：4
--- 线程名---：Thread-0，序号：3
--- 线程名---：Thread-1，序号：2
--- 线程名---：Thread-0，序号：1

//FutureTask<V> 是 RunnableFuture<V> 的实现类
public class FutureTask<V> implements RunnableFuture<V> ;
//RunnableFuture<V> 接口继承了 Runnable, Future<V>          //所以FutureTask最后需要放到Thread参数中，这里跟继承Runnable方法一样；
public interface RunnableFuture<V> extends Runnable, Future<V> ；

public class MyCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        System.out.println("***子线程执行***");
        //执行线程处理方法
        int sun = 0;
        for (int i = 0; i < 5; i++) {
            sun+=i;
        }
        return sun;
    }

    public static void main(String[] args) {
        //主线程执行
        System.out.println("---主线程执行---");

        //创建子线程，不可以自己单独启动，必须借助FutureTask才可以，必须获取子线程执行结果
        MyCallable callable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);

        //启动线程，只能借助Thread类
        Thread thread = new Thread(futureTask);
        thread.start();

        //获取子线程的执行结果(必须要子线程执行结束，才可以获取结果)
        try {
            Integer resultSun = futureTask.get(); //接收返回值
            System.out.println("五以内的数字之和："+resultSun);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("---主线程结束---");

    }
}

---主线程执行---
***子线程执行***
五以内的数字之和：10  //接收到返回值
---主线程结束---