Java基础面试题（IO和多线程专题）

Java基础面试题

一、IO和多线程专题

1.介绍下进程和线程的关系

进程：一个独立的正在执行的程序

线程：一个进程的最基本的执行单位，执行路径

多进程：在操作系统中，同时运行多个程序

多进程的好处：可以充分利用CPU，提高CPU的使用率

多线程：在同一个进程(应用程序)中同时执行多个线程

多线程的好处：提高进程的执行使用率，提高了CPU的使用率

注意：

1. 在同一个时间点一个CPU中只可能有一个线程在执行
2. 多线程不能提高效率、反而会降低效率，但是可以提高CPU的使用率
3. 一个进程如果有多条执行路径，则称为多线程程序
4. Java虚拟机的启动至少开启了两条线程，主线程和垃圾回收线程
5. 一个线程可以理解为进程的子任务

2.说说Java中实现多线程的几种方法

Thread对象就是一个线程

创建线程的常用三种方式：

1. 继承Thread类
2. 实现Runnable接口
3. 实现Callable接口（JDK1.5>=）
4. 线程池方式创建

  通过继承Thread类或者实现Runnable接口、Callable接口都可以实现多线程，不过实现Runnable
接口与实现Callable接口的方式基本相同，只是Callable接口里定义的方法返回值，可以声明抛出异
常而已。因此将实现Runnable接口和实现Callable接口归为一种方式。这种方式与继承Thread方式
之间的主要差别如下。

继承Thread类

实现的步骤：

1. 创建Thread类的子类
2. 重写run方法
3. 创建线程对象
4. 启动线程

案例代码

package com.bobo.thread;

public class ThreadDemo02 {
   

    /**
     * 线程的第一种实现方式
     *     通过创建Thread类的子类来实现
     * @param args
     */
    public static void main(String[] args) {
   
        System.out.println("main方法执行了1...");
        // Java中的线程 本质上就是一个Thread对象
        Thread t1 = new ThreadTest01();
        // 启动一个新的线程
        t1.start();
        for(int i = 0 ; i< 100 ; i++){
   
            System.out.println("main方法的循环..."+i);
        }
        System.out.println("main方法执行结束了3...");
    }
}

/**
 * 第一个自定义的线程类
 *    继承Thread父类
 *    重写run方法
 */
class ThreadTest01 extends Thread{
   

    @Override
    public void run() {
   
        System.out.println("我们的第一个线程执行了2....");
        for(int i = 0 ; i < 10 ; i ++){
   
            System.out.println("子线程："+i);
        }
    }
}

注意点：

1. 启动线程是使用start方法而不是run方法
2. 线程不能启动多次，如果要创建多个线程，那么就需要创建多个Thread对象

实现Runnable接口

  在第一种实现方式中，我们是将线程的创建和线程执行的业务都封装在了Thread对象中，我们可以通过Runable接口来实现线程程序代码和数据有效的分离。

Thread(Runnable target)
// 分配一个新的 Thread对象。

实现的步骤：

1. 创建Runable的实现类
2. 重写run方法
3. 创建Runable实例对象(通过实现类来实现)
4. 创建Thread对象，并把第三部的Runable实现作为Thread构造方法的参数
5. 启动线程

package com.bobo.runable;

public class RunableDemo01 {
   

    /**
     * 线程的第二种方式
     *     本质是创建Thread对象的时候传递了一个Runable接口实现
     * @param args
     */
    public static void main(String[] args) {
   
        System.out.println("main执行了...");
        // 创建一个新的线程  Thread对象
        Runnable r1 = new RunableTest();
        Thread t1 = new Thread(r1);
        // 启动线程
        t1.start();
        System.out.println("main结束了...");
    }
}

/**
 * 线程的第二种创建方式
 *   创建一个Runable接口的实现类
 */
class RunableTest implements Runnable{
   

    @Override
    public void run() {
   
        System.out.println("子线程执行了...");
    }
}

实现Runable接口的好处：

1. 可以避免Java单继承带来的局限性
2. 适合多个相同的程序代码处理同一个资源的情况，把线程同程序的代码和数据有效的分离，较好的体现了面向对象的设计思想

Callable的方式

  前面我们介绍的两种创建线程的方式都是重写run方法，而且run方法是没有返回结果的，也就是main方法是不知道开启的线程什么时候开始执行，什么时候结束执行，也获取不到对应的返回结果。而且run方法也不能把可能产生的异常抛出。在JDK1.5之后推出了通过实现Callable接口的方式来创建新的线程，这种方式可以获取对应的返回结果

package com.bobo.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class CallableDemo01 {
   

    /**
     * 创建线程的第三种实现方式：
     *    Callable方式
     */
    public static void main(String[] args) throws  Exception {
   
        // 创建一个Callable实例
        Callable<Integer> callable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(callable)