线程的常考面试题总结

最新推荐文章于 2025-03-15 23:34:01 发布

Double丶11

最新推荐文章于 2025-03-15 23:34:01 发布

阅读量289

点赞数

文章标签： java 面试开发语言

本文链接：https://blog.youkuaiyun.com/qq_58417838/article/details/132064190

版权

一、线程的概念，线程与进程的区别是什么？

线程：是进程的一个实体，是CPU调度和分派的基本单位，是比进程更小的可以独立运行的基本单位。

进程：（运行中的程序称之为进程）。具有一定的独立功能的程序关于某个数据集合的一次运行活动，是操作系统进行资源分配和调度的一个独立单位。

两者的区别：

1、进程是系统分配资源的单位，线程是 CPU 的调度单位

2、一个程序，至少包含一个进程

3、一个进程至少包含一个线程。线程是不能独立运行的，必须依附在进程中

4、进程之间是不能共享数据段地址，但是同一个进程下的线程是可以共享的

二、线程创建的方式有哪些？

1、通过继承Thread类并重写run方法创建线程，实现简单但不可以继承其他的类。

2、实现Runnable接口并重写run方法，避免了单继承局限性，编程更加灵活，实现解耦。

3、实现Callable接口并重写call方法，创建线程，可以获取线程执行结果的返回值，并且可以抛出异常。

4、使用线程池创建线程

实现代码如下

package com.qf.thread;

import java.util.concurrent.*;

public class ThreadTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.通过继承Thread类，重写run方法来创建线程
        for (int i = 0; i < 5; i++) {
            ThreadCreate1 create1 = new ThreadCreate1();
            create1.start();//开启线程
        }
        //当JAVA程序运行后，程序至少会创建一个主线程（自动），
        //主线程的线程执行体不是由run()方法确定的，而是由main()方法确定的；
        System.out.println(Thread.currentThread().getName()+"------------------------");

        //2.通过实现Runnable接口并重写run方法
        //注意1：启动线程调用start方法，并非run方法(相当于new对象调方法)
        //注意2：一个线程不能多次调用start方法,但是线程类可以创建多次并启动
        for (int i = 0; i < 5; i++) {
            new Thread(new ThreadCreate2()).start();
        }
        System.out.println(Thread.currentThread().getName()+"------------------------");

        //3.通过实现Callable接口并重写call方法
        //使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值；
        for (int i = 0; i < 5; i++) {
            FutureTask futureTask = new FutureTask(new ThreadCreate3());
            new Thread(futureTask).start();
        }
        //调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。
        //System.out.println(futureTask.get());
        System.out.println(Thread.currentThread().getName()+"------------------------");
        //4.通过创建线程池来创建线程，数量设为5个
        ExecutorService executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "----->线程4创建了");
                }
            });
        }
        //关闭资源
        executor.shutdownNow();
        System.out.println(Thread.currentThread().getName()+"------------------------");
    }
}

//1.通过继承Thread类，重写run方法来创建线程
class ThreadCreate1 extends Thread {
    //无需调用Thread.currentThread()方法,直接this调用getName()方法即可
    @Override
    public void run() {
        System.out.println(this.getName() + "----->线程1创建了");
    }
}

//2.通过实现Runnable接口并重写run方法
class ThreadCreate2 implements Runnable {

    @Override
    public void run() {
        //要访问当前线程，必须调用Thread.currentThread()方法。
        System.out.println(Thread.currentThread().getName() + "---->线程2创建了");
    }
}

//3.通过实现Callable接口并重写call方法
class ThreadCreate3 implements Callable {
    //    1、call()方法可以有返回值；
//    2、call()方法可以声明抛出异常；
    @Override
    public Object call() throws Exception {
        //要访问当前线程，必须调用Thread.currentThread()方法。
        System.out.println(Thread.currentThread().getName() + "----->线程3创建了");
        return null;
    }
}

运行结果如下

通过上述代码得出结果，线程的执行是抢占式的，当JAVA程序运行后，程序至少会创建一个主线程（自动），主线程的线程执行体不是由run()方法确定的，而是由main()方法确定的；

三、线程池有哪几种？线程池的核心参数有哪些？

在Java中，常见的线程池实现有以下几种：

FixedThreadPool：固定大小的线程池。
CachedThreadPool：可以根据需要动态调整大小的线程池。
SingleThreadExecutor：单线程的线程池。
ScheduledThreadPool：用于执行延迟任务或定期任务的线程池。
WorkStealingPool：基于工作窃取算法的线程池。

这些线程池都在java.util.concurrent包中提供。都是通过Executors工具类来创建的，还可以手动使用ThreadPoolExecutor类来自定义线程池的参数和行为。

线程池的核心参数包括：

corePoolSize：线程池的核心线程数量，即线程池中最小的线程数。线程池会始终保持这些线程存活，即使它们处于空闲状态。
maximumPoolSize：线程池的最大线程数量。如果队列已满且当前线程数小于最大线程数，线程池会创建新的线程来执行任务。
keepAliveTime：线程空闲超过这个时间后，多余的线程会被终止并从线程池中移除。
unit：keepAliveTime的时间单位。
workQueue：存放等待执行任务的队列。
threadFactory：用于创建线程的工厂类。
handler：当线程池和队列都满了，无法执行新的任务时，用于处理被拒绝的任务。

四、什么是线程的串行，并行，并发？

线程的串行、并行和并发是指线程的执行方式。

串行：指线程按照顺序依次执行，一个线程执行完毕后才能执行下一个线程。线程的串行执行是指多个线程按照一定的顺序依次执行，每个线程都要等待上一个线程执行完毕后才能执行。

并行：指多个线程同时执行，每个线程都有自己的执行流程，互不干扰。线程的并行执行是指多个线程在同一时间段内同时执行，每个线程都有自己的执行流程，能够并行执行任务。

并发：指多个线程交替执行，每个线程都有自己的执行流程，但是线程之间会相互切换执行。线程的并发执行是指多个线程在同一时间段内交替执行，每个线程都有自己的执行流程，通过线程切换来实现并发执行任务。

总结：

串行是指线程按照顺序依次执行，一个线程执行完毕后才能执行下一个线程。
并行是指多个线程同时执行，每个线程都有自己的执行流程，互不干扰。
并发是指多个线程交替执行，每个线程都有自己的执行流程，但是线程之间会相互切换执行。

五、在项目中是怎么使用多线程的？

对于商城在线系统

并发库存管理：在商品库存管理中，多个用户可能同时购买同一件商品，使用多线程可以并发地更新商品库存，避免库存不一致的问题。
并发订单处理：在订单处理中，多个用户可能同时下单，使用多线程可以并发地处理订单，提高订单处理效率和用户体验。

对于这种高并发的场景，我使用了redission分布式锁来解决了商品超卖问题。

六、如何解决多线程的线程安全问题？

使用synchronized关键字：通过在共享资源的访问方法或代码块上添加synchronized关键字，确保同一时间只有一个线程可以访问该资源。synchronized关键字可以修饰方法、代码块或静态方法。
使用ReentrantLock类：ReentrantLock是Java提供的可重入锁，可以使用lock()方法获取锁，使用unlock()方法释放锁。通过在关键代码块中获取和释放锁，确保同一时间只有一个线程可以访问共享资源。
使用volatile关键字：volatile关键字可以保证共享变量的可见性，即当一个线程修改了共享变量的值，其他线程能够立即看到最新的值。但是volatile关键字并不能保证原子性，如果需要保证原子性，可以结合使用volatile和Atomic类。
使用Atomic类：Java提供了一系列的原子类，如AtomicInteger、AtomicLong等，这些类提供了一些原子操作，可以保证对共享变量的操作是原子的，避免了数据竞争的问题。
使用并发容器：Java提供了一些线程安全的容器类，如ConcurrentHashMap、CopyOnWriteArrayList等，这些容器类在内部实现上采用了一些并发控制机制，可以在多线程环境下安全地进行操作。

七、Java线程中常用的方法有哪些，作用是什么？

Java中的线程类（Thread）提供了一些常用的方法，用于控制线程的执行和状态。以下是一些常用的线程方法及其作用：

start()：启动线程。调用start()方法后，线程会进入就绪状态，等待CPU调度执行。
run()：线程的执行体。需要重写该方法，在该方法中定义线程要执行的任务。
sleep(long millis)：使当前线程暂停执行一段时间。参数millis表示暂停的时间，单位是毫秒。
interrupt()：中断线程。调用该方法会设置线程的中断标志为true，但不会立即停止线程的执行。
isInterrupted()：判断线程是否被中断。返回一个boolean值，表示线程的中断状态。
join()：等待线程终止。调用该方法会使当前线程进入等待状态，直到被等待的线程执行完毕。
yield()：线程礼让。调用该方法会使当前线程暂停执行，让出CPU资源给其他线程。
setPriority(int priority)：设置线程的优先级。参数priority表示线程的优先级，范围是1~10，其中1为最低优先级，10为最高优先级。
getName()：获取线程的名称。
isAlive()：判断线程是否存活。返回一个boolean值，表示线程是否处于活动状态。
notify()：唤醒等待中的线程。调用该方法会从等待队列中选择一个线程，并唤醒它。
notifyAll()：唤醒所有等待中的线程。调用该方法会唤醒所有在等待队列中的线程。
wait()：使线程进入等待状态。调用该方法会使线程释放锁，并进入等待队列，直到被唤醒。

八、wait()和sleep()方法的作用和区别？

在Java中，wait()和sleep()都是用于线程的控制和调度。

wait()的作用和使用方式：
- wait()方法是Object类中的方法，用于将当前线程置于等待状态，直到其他线程调用notify()或notifyAll()方法来唤醒等待的线程。
- wait()方法必须在synchronized块或方法中调用，因为它要求当前线程释放锁，然后进入等待状态。
- wait()方法会释放当前线程占有的锁，允许其他线程进入临界区。
- 被wait()方法挂起的线程可以被其他线程通过notify()或notifyAll()方法唤醒。
sleep()的作用和使用方式：
- sleep()方法是Thread类中的静态方法，用于使当前线程暂停执行一段时间。
- sleep()方法不会释放锁，即使当前线程在synchronized块或方法中调用sleep()，其他线程也无法进入临界区。
- sleep()方法的参数是毫秒数，表示线程暂停的时间。
- sleep()方法会抛出InterruptedException异常，可以通过捕获异常来处理中断情况。

区别：

wait()是Object类的方法，而sleep()是Thread类的静态方法。
wait()必须在synchronized块或方法中调用，而sleep()可以在任何地方调用。
wait()会释放锁，允许其他线程进入临界区，而sleep()不会释放锁。
wait()需要通过notify()或notifyAll()方法来唤醒等待的线程，而sleep()会自动唤醒。
wait()会抛出InterruptedException异常，而sleep()不会。

总结来说：

wait()和sleep()都可以暂停线程的执行，但wait()更适合在多线程间进行协作和通信，而sleep()更适合在需要暂停一段时间后再继续执行的情况下使用。

九、线程中的join()的礼让和打断是怎样实现的？

在Java中，join()方法用于让一个线程等待另一个线程执行完毕。它的实现主要依赖于Object类中的wait()和notifyAll()方法。

当一个线程调用另一个线程的join()方法时，它会进入等待状态，直到被等待的线程执行完毕或被中断。具体实现如下：

当线程A调用线程B的join()方法时，线程A会进入等待状态，并将等待标记设置为true。
线程B执行完毕后，会调用notifyAll()方法来唤醒所有等待的线程。
线程A被唤醒后，会重新检查等待标记，如果等待标记为false，说明线程B已经执行完毕，线程A会继续执行；如果等待标记为true，说明线程B还未执行完毕，线程A会继续等待。
如果线程A被中断，则会抛出InterruptedException异常，线程A会终止等待状态。

需要注意的是，join()方法的实现依赖于线程的状态和等待标记的判断，因此在使用join()方法时需要注意以下几点：

join()方法只能在当前线程对其他线程调用的join()方法上调用，不能对自己调用。
join()方法会释放当前线程占有的锁，允许其他线程进入临界区。
join()方法会抛出InterruptedException异常，需要进行异常处理。

通过join()方法，可以实现线程的礼让和打断，即一个线程可以等待另一个线程执行完毕后再继续执行，或者在等待过程中被中断。这样可以有效地控制线程的执行顺序和协调线程间的操作。

十、synchronized锁和lock锁的区别？

synchronized锁和Lock锁是Java中用于实现线程同步的两种机制，它们有以下几点区别：

使用方式：synchronized是Java中的关键字，可以直接用于方法或代码块中，而Lock是一个接口，需要通过实例化具体的Lock实现类来使用。
锁的获取与释放：synchronized锁是隐式获取和释放的，当线程进入synchronized代码块或方法时，会自动获取锁，当线程退出该代码块或方法时，会自动释放锁。而Lock锁需要显式地调用lock()方法获取锁，调用unlock()方法释放锁。
锁的可重入性：synchronized锁是可重入的，即同一个线程可以多次获取同一个锁，而不会造成死锁。而Lock锁也是可重入的，但需要注意在使用时要正确地调用lock()和unlock()方法。
锁的灵活性：synchronized锁是非公平锁，即线程获取锁的顺序是不确定的。而Lock锁可以通过构造函数指定是公平锁还是非公平锁。
锁的条件等待：Lock锁提供了Condition接口，可以通过它实现线程的条件等待和唤醒，而synchronized锁只能使用Object类的wait()、notify()和notifyAll()方法。
性能：Lock锁相对于synchronized锁来说，具有更好的性能。在高并发的情况下，Lock锁的性能更好，但在低并发的情况下，synchronized锁的性能可能更好。