多线程的面试题

哥哥真爱粉

已于 2023-04-06 21:32:21 修改

阅读量44

点赞数

文章标签： java jvm 面试

于 2023-04-04 13:45:49 首次发布

本文链接：https://blog.csdn.net/m0_56483785/article/details/129950663

版权

1.什么是多线程：

线程：是程序的执行路径，或者可以说是程序的控制单元

一个进程可能包含一个或者多个线程，当一个进程存在多条执行路径时，就可以将该执行方式称为多线程。

线程的执行方式大致可以分为三种：

就绪（wait）
执行（run）
阻塞（block）
多个线程在运行过程中互相抢夺资源，造成线程在上述的三个状态之间互相转换

2 .名词解释：同步，异步，阻塞，非阻塞，同步阻塞，异步阻塞，异步非阻塞

提示：名词解释

例如：

同步：应用程序要直接参与IO读写的操作。执行一个操作之后，等待结果，然后才继续执行后续的操作。
异步：所有的IO读写交给操作系统去处理，应用程序只需要等待通知。执行一个操作后，可以去执行其他的操作，然后等待通知再回来执行刚才没执行完的操作。
阻塞：当数据没有准备的时候阻塞，往往需要等待缓冲区中的数据准备好过后才处理其他的事情，否則一直等待在那里。进程给CPU传达一个任务之后，一直等待CPU处理完成，然后才执行后面的操作。
非阻塞：当我们的进程访问我们的数据缓冲区的时候，如果数据没有准备好则直接返回，不会等待。如果数据已经准备好，也直接返回 .进程给CPU传达任务后，继续处理后续的操作，隔断时间再来询问之前的操作是否完成。这样的过程其实也叫轮询
同步阻塞：在需要某资源时马上发起请求，并暂停本线程之后的程序，直至获得所需的资源。
同步非阻塞：在需要某资源时马上发起请求，且可以马上得到答复，然后继续执行之后的程序。但如果得到的不是完整的资源，之后将周期性地的请求。
异步阻塞：在需要某资源时不马上发起请求，而安排一个以后的时间再发起请求。当到了那时发出请求时，将暂停本线程之后的程序，直至获得所需的资源。
异步非阻塞：在需要某资源时不马上发起请求，而安排一个以后的时间再发起请求。当到了那时发出请求时，可以马上得到答复，然后继续执行之后的程序。但如果得到的不是完整的资源，之后将周期性地的请求。

3创建线程的三种方法：

提示：

1.继承Thread类，重写父类run()方法 2.实现Runnable接口 3.使用ExecutorService、Callable、Future实现有返回结果的多线程(JDK5.0以后)

例如：

1.继承Thread类，重写父类run()方法

public class Demo {
    //main方法默认是程序的入口，也称为主线程
    public static void main(String[] args) {
        //2、创建MyThread类对象
        MyThread t = new MyThread();
        //3、启动线程
        t.start();
        //t.run(); run就是一个普通方法，并没有开启多线程

        //该线程执行的任务
        for (int i = 1; i <= 100; i++) {
            System.out.println("main线程：" + i);
        }
    }
}

//1、继承Thread，重写run方法（run方法作用：封装该线程执行的任务）
class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println("子线程：" + i);
        }
    }
}

2.实现runnable接口

public class Demo {
    public static void main(String[] args) {
        //2、创建MyRunnable对象
        MyRunnable mr = new MyRunnable();

        //3.创建Thread类的对象，将MyRunnable对象当做参数，启动线程
        Thread t = new Thread(mr);
        t.start();

        for (int i = 1; i <= 100; i++) {
            System.out.println("main线程：" + i);
        }
    }
}

//1、自定义类实现Runnable接口，重写run方法
class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println("子线程：" + i);
        }
    }
}

3.使用ExecutorService、Callable、Future实现有返回结果的多线程(JDK5.0以后)

public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //2.测试类中,将MyCallable类的对象当做参数,传递给FutureTask类的对象,得到线程任务对象
        MyCallable mc1 = new MyCallable(100);
        FutureTask<String> ft1 = new FutureTask(mc1);
        //3.将FutureTask类的对象(线程任务对象)当做参数,传递给Thread对象
        Thread t1 = new Thread(ft1);
        //4.调用Thread对象的start方法启动线程
        t1.start();
        //5.线程执行完毕后,可以通过FutureTask类对象的get方法,获取返回的数据
        System.out.println(ft1.get()); //计算1到100之间的和为:5050

        MyCallable mc2 = new MyCallable(100);
        FutureTask<String> ft2 = new FutureTask(mc2);
        Thread t2 = new Thread(ft2);
        //如果在开启线程之前,就想获取结果,会卡死在这里
        System.out.println(ft2.get()); //get方法是阻塞的
        t2.start();
    }
}

//1.定义MyCallable类实现Callable接口,重写call方法封装这条线程要做的事情,和要返回的数据
class MyCallable implements Callable<String> { //泛型为返回值的类型
    //接收一个整数end
    private int end;

    public MyCallable(int end) {
        this.end = end;
    }

    @Override
    public String call() throws Exception {
        //计算1到指定整数end之间的和
        int sum = 0;
        for (int i = 1; i <= end; i++) {
            sum += i;
        }
        return "计算1到" + end + "之间的和为:" + sum; //返回值类型要匹配
    }
}

4 多线程同步机制：

提示：这里统计学习计划的总量:3

例如：

1. 同步方法
在需要同步的方法的方法签名中加入synchronized关键字。

    //1.实例同步方法：锁对象默认是this
    public synchronized void method() {}

    //2.静态同步方法：锁对象默认是类名.class
    public synchronized static void method() {}

2. 同步代码块
使用synchronized块对需要进行同步的代码段进行同步。

        //注意1：锁对象要唯一，也不能随便选择一把锁，这样会影响其他无关线程
        //synchronized (new Object()){

        //注意2：对于实例方法，建议使用this作为同步锁
        synchronized (this){
                 //访问共享资源的代码
            }
        }

        //注意3：对于静态方法，建议使用类名.class（字节码文件对象）作为同步锁（目前了解）
        public static void method() {
            synchronized (Account.class) {
            //访问共享资源的代码
        }
    }

3.使用lock锁
使用JDK 5中提供的java.util.concurrent.lock包中的Lock对象

    //创建锁对象
    private ReentrantLock lock = new ReentrantLock();
      try {
            //加锁
            lock.lock();
              //访问共享资源的代码块
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放锁
            lock.unlock();
        }