Java线程基础（二）——线程的创建

线程的实现

java实现的三种方法：

1. 继承Thread类
2. 实现Runnable接口
3. 实现Callable接口

继承Thread类

1） 定义类继承Thread类

2） 重写run方法

3） 创建线程对象，调用start方法

/**
 * 自定义线程
 */
public class MyThread extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---->"+i);
        }
    }

    public static void main(String[] args) {
        //创建线程对象
        MyThread thread1 = new MyThread();
        //启动线程
        thread1.start();
        //主线程执行
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---->"+i);
        }
    }
}

面试问题

1） 执行run和start有什么区别？
调用run是在主线程中同步执行的，调用start后才会启动新线程去执行
2） 调用两次start会怎么样？
会抛出异常IllegalThreadStateException，线程是一次性的，不允许执行两次
3） 多线程的执行是什么顺序？
上下文切换
多线程的执行是抢占式的，线程会去抢占CPU，抢到后执行自己的指令，执行过程中CPU可能被其它线程抢占，其它线程执行
上下文切换回原来线程时，如何执行从哪里开始执行？
每个线程有自己的程序计数器，保存当前线程执行的行数，切换回来后继续执行下面的行代码

实现Runnable接口

1） 定义类实现Runnable接口

2） 实现run方法

3） 创建Thread对象，传入Runnable对象，调用start

/**
 * 自定线程 Runnable方式
 */
public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }

    public static void main(String[] args) {
        //创建Runnable对象 创建Thread对象
        Thread thread1 = new Thread(new MyRunnable());
        //启动线程
        thread1.start();
        //匿名内部类
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName()+"--->"+i);
                }
            }
        });
        thread2.start();
        //lambda表达式
        Thread thread3 = new Thread(()->{
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName()+"--->"+i);
            }
        });
        thread3.start();
    }
}

面试问题

1） 继承Thread类和实现Runnable两种方式的区别

1. Java是单继承的，继承Thread类就不能继承其它类，实现接口没有此限制
2. 继承Thread不强制要求重写run，实现Runnable强制要求重写
3. Runnable可以使用Lambda表达式，语法简介

​

​ 推荐使用Runnable方式

​

实现Callable接口

前面两种方式都实现的run方法没有返回值，如果需要进行运算后返回值，就需要使用Callable接口

1） 实现Callable接口的call方法

2） 创建FutureTask对象传入Callable实现对象

3） 创建Thread线程传入FutureTask对象

4） 启动线程

5） 通过FutureTask的get方法获得返回值

/**
 * 带返回值的线程对象
 */
public class MyCallable implements Callable<Long> {

    @Override
    public Long call() throws Exception {
        long sum = 0;
        for(int i = 0;i < 10000000;i++){
            sum += i;
        }
        return sum;
    }

    public static void main(String[] args) {
        //创建FutureTask对象，传入Callable对象
        FutureTask<Long> futureTask = new FutureTask<>(new MyCallable());
        //创建Thread对象
        Thread thread = new Thread(futureTask);
        //启动线程
        thread.start();
        //获得返回值
        try {
            Long value = futureTask.get();
            System.out.println("运算结果是：" + value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

线程的生命周期

线程的生命周期（状态）分为：

1. 新建
2. 就绪/准备
3. 运行
4. 阻塞
5. 死亡

如下图所示：