Java面试总结（六）

进程和线程的区别

根本区别： 进程时操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位。

资源开销： 每个进程都有自己独立的代码和数据空间（程序上下文），进程之间的切换开销比较大；线程可以看作轻量级进程，同类的线程共享进程的堆和方法区（JDK1.7及之前实现为永久代，JDK1.8及之后实现为元空间）资源，但是每个线程都有自己的程序计数器、Java虚拟机栈和本地方法栈，线程之间的切换开销比较小。

包含关系： 如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。

内存分配： 同一进程的线程共享本进程的地址空间和资源，而进程之间的地址空间和资源是相互独立的。

影响关系： 一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉，所以多进程要比多线程健壮。

执行过程： 每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发执行。

总结： 线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。线程执行开销小，但不利于资源的管理和保护；而进程正相反。

创建线程的三种方式

使用继承Thread类的方式创建多线程

Thread类是Java提供的线程顶级类，继承Thread类可快速定义线程。

使用多线程实现龟兔赛跑

public class TortoiseThread extends Thread{

    @Override
    public void run() {
        while (true) {
            System.out.println("乌龟领先了，加油.....，" +
                    "当前线程的名称：" + this.getName() +
                    ",当前线程的优先级别：" + this.getPriority());
        }
    }

    public static void main(String[] args) {


        TortoiseThread tortoiseThread = new TortoiseThread();
        tortoiseThread.setName("乌龟线程");
        tortoiseThread.start();

        Thread.currentThread().setName("兔子线程");
        while(true){
            System.out.println("兔子领先了，add oil....，当前线程名称："
                    +Thread.currentThread().getName()+",当前线程的优先级别："
                    +Thread.currentThread().getPriority());
        }
    }
}

运行结果截取（这里只截取了部分结果，应该是无限循环的）

乌龟领先了，加油.....，当前线程的名称：乌龟线程,当前线程的优先级别：5
乌龟领先了，加油.....，当前线程的名称：乌龟线程,当前线程的优先级别：5
兔子领先了，add oil....，当前线程名称：兔子线程,当前线程的优先级别：5
兔子领先了，add oil....，当前线程名称：兔子线程,当前线程的优先级别：5

使用实现Runnable接口的方式创建多线程

使用多线程实现龟兔赛跑

public class TortoiseRunnable implements Runnable{
    @Override
    public void run() {
        while (true) {
            System.out.println("乌龟领先了，加油.....，" +
                    "当前线程的名称：" + Thread.currentThread().getName() +
                    ",当前线程的优先级别：" + Thread.currentThread().getPriority());
        }
    }

    public static void main(String[] args) {

        Thread thread = new Thread(new TortoiseRunnable());
        thread.setName("乌龟线程");
        thread.start();

        Thread.currentThread().setName("兔子线程");
        while(true){
            System.out.println("兔子领先了，add oil....，当前线程名称："
                    +Thread.currentThread().getName()+",当前线程的优先级别："
                    +Thread.currentThread().getPriority());
        }
    }
}

运行结果截取（这里只截取了部分结果，应该是无限循环的）

乌龟领先了，加油.....，当前线程的名称：乌龟线程,当前线程的优先级别：5
乌龟领先了，加油.....，当前线程的名称：乌龟线程,当前线程的优先级别：5
兔子领先了，add oil....，当前线程名称：兔子线程,当前线程的优先级别：5
兔子领先了，add oil....，当前线程名称：兔子线程,当前线程的优先级别：5

使用实现Callable接口的方式创建多线程

使用多线程实现龟兔赛跑

public class TortoiseCallable implements Callable {
    @Override
    public Object call() throws Exception {
        while (true) {
            System.out.println("乌龟领先了，加油.....，" +
                    "当前线程的名称：" + Thread.currentThread().getName() +
                    ",当前线程的优先级别：" + Thread.currentThread().getPriority());
        }
    }

    public static void main(String[] args) {

        TortoiseCallable tortoiseCallable = new TortoiseCallable();

        FutureTask futureTask = new FutureTask(tortoiseCallable);

        Thread thread = new Thread(futureTask);
        thread.setName("乌龟线程");
        thread.start();

        Thread.currentThread().setName("兔子线程");
        while(true){
            System.out.println("兔子领先了，add oil....，当前线程名称："
                    +Thread.currentThread().getName()+",当前线程的优先级别："
                    +Thread.currentThread().getPriority());
        }

    }
}

运行结果截取（这里只截取了部分结果，应该是无限循环的）

乌龟领先了，加油.....，当前线程的名称：乌龟线程,当前线程的优先级别：5
乌龟领先了，加油.....，当前线程的名称：乌龟线程,当前线程的优先级别：5
兔子领先了，add oil....，当前线程名称：兔子线程,当前线程的优先级别：5
兔子领先了，add oil....，当前线程名称：兔子线程,当前线程的优先级别：5

创建三种线程的方式对比

使用实现Runnable、Callable接口的方式创建多线程。

优势：
Java的设计是单继承的设计，如果使用继承Thread的方式实现多线程，则不能继承其他的类，而如果使用实现Runnable接口或Callable接口的方式实现多线程，还可以继承其他类。
采用接口能够更好的实现数据共享。线程的启动需要Thread类的start方法，如果采用继承的方式每次新建一个线程时，每个新建线程的数据都会单独的存在线程内存中，这样每个线程会单独的操作自己线程的数据，不能更好的实现线程之间的数据共享。
劣势：
编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。

使用继承Thread类的方式创建多线程

优势：
编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。
劣势：
线程类已经继承了Thread类，所以不能再继承其他的类。

Runnable和Callable的区别

与Runnable相比，Callable功能更强大些

Callable规定（重写）的方法是call()，Runnable规定（重写）的方法是run()。
Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
call方法可以抛出异常，run方法不可以。
Callable是支持泛型的
运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

Runnable接口源码

@FunctionalInterface
public interface Runnable {

    public abstract void run();
}

Callable接口源码

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result //可以有返回值
     * @throws Exception if unable to compute a result  //可以抛出异常
     */
    V call() throws Exception;
}

Callable接口使用案例

/*
创建线程的方式三：实现Callable接口。-----JDK1.5新增
 */
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public  Object call() throws Exception{
        int sum=0;
        for (int i=1;i<=100;i++){
            sum+=i;
        }
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //3.创建Callable接口实现类的对象
        NumThread numThread=new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造中，创建FutureTask的对象
        FutureTask futureTask=new FutureTask(numThread);
        //5.将FutureTask的对象组排位哦参数传递到thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();
      
        //6.获取Callable中call方法的返回值
        //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
        Object sum = futureTask.get();
        System.out.println("总和为："+sum);
    }
}

线程的状态

NEW：初始状态，线程刚刚被创建出来，还没有调用 start() 方法；
RUNABLE：运行中状态，调用了 start() 方法，Java 线程将操作系统中的就绪/可运行（READY）状态和运行（RUNNING）状态统称为 RUNABLE 状态；
BLOCK：阻塞状态，线程阻塞于锁，需要等待锁的释放；
WAITING：等待状态，进入等待状态表示需要等待其他线程做出一些特定的状态（通知或中断）；
TIMED_WAITING：超时等待状态，可以在指定时间后自行返回，而不是像WAITING状态一样一直等待；
TEMENATED：终止状态，表示当前线程已经执行完毕。

在这里插入图片描述

由上图可以看出：线程创建之后它将处于 NEW（初始）状态，调用 start() 方法后开始运行，线程这时候处于 READY（就绪/可运行）状态。可运行状态的线程获得了 CPU 时间片（timeslice）后就处于 RUNNING（运行）状态。
在操作系统层面，线程有 READY 和 RUNNING 状态；而在 JVM 层面，只能看到 RUNNABLE 状态，所以 Java 系统一般将这两个状态统称为 RUNNABLE（运行中）状态。
为什么 JVM 没有区分这两种状态呢？
java 现在的时分（time-sharing）多任务（multi-task）操作系统架构通常都是用所谓的“时间分片（time quantum or time slice）”方式进行抢占式（preemptive）轮转调度（round-robin 式）。这个时间分片通常是很小的，一个线程一次最多只能在 CPU 上运行比如 10-20ms 的时间（此时处于 running 状态），也即大概只有 0.01 秒这一量级，时间片用后就要被切换下来放入调度队列的末尾等待再次调度。（也即回到 ready 状态）。线程切换的如此之快，区分这两种状态就没什么意义了。
当线程执行 wait()方法之后，线程进入 WAITING（等待）状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态。
TIMED_WAITING(超时等待) 状态相当于在等待状态的基础上增加了超时限制，比如通过 sleep（long millis）方法或 wait（long millis）方法可以将线程置于 TIMED_WAITING 状态。当超时时间结束后，线程将会返回到 RUNNABLE 状态。
当线程进入 synchronized 方法/块或者调用 wait 后，（被 notify）想要重新进入 synchronized 方法/块时，但是锁被其它线程占有，这个时候线程就会进入 BLOCKED（阻塞）状态。
线程在执行完了 run()方法之后将会进入到 TERMINATED（终止）状态。