JAVA基础—创建线程的3种方式

线程的生命周期（五种状态）

线程的五种状态

创建线程的三种方式对比

对比	继承Thread	实现Runnable	实现线程池 Callable
优点	编程简单，执行效率高	面向接口编程，执行效率高	容器管理线程，允许返回值与异常
缺点	单继承，无法对线程组有效控制	无法对线程组有效控制，没有返回值、异常	执行效率相对较低，编程麻烦
使用场景	不推荐使用	简单的多线程程序	企业级应用，推荐使用

1. 创建多线程-继承Thread

public class Match1 {
    public static void main(String[] args) {
        //创建一个新的线程
        Runner1 lx = new Runner1();
        //设置线程名称
        lx.setName("刘翔");

        Runner1 mr = new Runner1();
        mr.setName("鸣人");

        Runner1 lf = new Runner1();
        lf.setName("路飞");

        //启动线程
        lx.start();
        mr.start();
        lf.start();
    }
}

class Runner1 extends Thread {
    //继承线程的 run()方法
    @Override
    public void run() {
        Integer speed = new Random().nextInt(100);
        for (int i = 1; i <= 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.getName() + "已前进" + (i * speed) + "米(" + speed +"米/秒)");
        }
    }
}

运行结果

...

鸣人已前进2376米(24米/秒)
刘翔已前进2574米(26米/秒)
路飞已前进2376米(24米/秒)
鸣人已前进2400米(24米/秒)
刘翔已前进2600米(26米/秒)
路飞已前进2400米(24米/秒)

2. 创建多线程-实现Runnable接口

public class Match2 {
    public static void main(String[] args) {
        Runner2 lx = new Runner2();
        Thread thread1 = new Thread(lx);
        thread1.setName("刘翔");

        Thread mr = new Thread(new Runner2());
        mr.setName("鸣人");

        Thread lf = new Thread(new Runner2());
        lf.setName("路飞");

        thread1.start();
        mr.start();
        lf.start();
    }
}

class Runner2 implements Runnable{

    @Override
    public void run() {
        Integer speed = new Random().nextInt(100);
        for (int i = 1; i <= 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "已前进" + (i * speed) + "米(" + speed +"米/秒)");
        }
    }
}

运行结果

...
鸣人已前进4257米(43米/秒)
刘翔已前进2970米(30米/秒)
路飞已前进5346米(54米/秒)
刘翔已前进3000米(30米/秒)
鸣人已前进4300米(43米/秒)
路飞已前进5400米(54米/秒)

3. 创建多线程-实现Callable接口

public class Match3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建一个线程，里面定义了3个“空线程”。 Executors调度器，对线程进行管理
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        //实例化Callable对象
        Runner3 liuxiang = new Runner3();
        liuxiang.setName("刘翔");
        Runner3 mr = new Runner3();
        mr.setName("鸣人");
        Runner3 lf = new Runner3();
        lf.setName("路飞");

        //将这个对象扔到线程池中，线程池自动分配一个线程池来运行liuxiang这个对象的call方法
        //Future用于接收线程内部call方法的返回值
        Future<Integer> result1 = executorService.submit(liuxiang);
        Future<Integer> result2 = executorService.submit(mr);
        Future<Integer> result3 = executorService.submit(lf);

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //关闭线程池释放所有资源
        executorService.shutdown();

        System.out.println("刘翔累计跑了" + result1.get() + "米");
        System.out.println("鸣人累计跑了" + result2.get() + "米");
        System.out.println("路飞累计跑了" + result3.get() + "米");
    }
}

class Runner3 implements Callable<Integer> {
    //concurrent包没有getName 所以在类里自定义name
    private String name;

    public void setName(String name){
        this.name = name;
    }

    //实现Callable接口可以允许我们的线程返回值或抛出异常
    @Override
    public Integer call() throws Exception {
        Integer speed = new Random().nextInt(100);
        Integer distince = 0; //总共奔跑的距离
        for (int i = 1; i <= 100; i++) {
            Thread.sleep(10);
            distince = i * speed;
            //打印已跑多少米
            System.out.println(this.name + "已前进" + distince + "米("+speed+"米/秒)");
        }
        return distince;
    }
}

运行结果

...
刘翔累计跑了2300米
鸣人累计跑了2900米
路飞累计跑了4100米