java面试题-并发基础

喜欢ヅ旅行 2023-09-27 14:41 28阅读 0赞

## 1.多线程的出现是要解决什么问题的? 本质什么? ##

1.  提高程序性能：单线程程序只能按照固定的顺序依次执行每个任务，无法同时处理多个任务。多线程技术可以在同一时间内执行多个任务，从而提高程序的运行效率和响应速度。

1.  提高程序的并发性：单线程程序在处理多个任务时，需要等待某个任务完成后才能进行下一个任务，导致程序无法同时处理多个请求。多线程技术可以同时处理多个请求，提高程序的并发性。

1.  充分利用多核CPU：现代计算机大多都具备多核CPU，但是单线程程序只能利用其中的一个核心，无法充分利用CPU的性能。多线程技术可以同时使用多个CPU核心，充分利用计算机的性能。

1.  程序设计的灵活性：多线程技术可以将程序拆分成多个独立的任务，每个任务可以独立进行设计和测试，从而提高程序的灵活性和可维护性。

多线程的本质是通过将程序拆分成多个线程并行执行，实现程序的并发执行，从而提高程序的效率和性能。同时，多线程也带来了一些问题，如线程安全性、死锁、竞争条件等，需要仔细考虑和处理。

## 2.Java是怎么解决并发问题的? ##

Java提供了多种机制来解决并发问题，包括锁、原子变量、线程池、并发集合等等。其中最常用的机制包括synchronized关键字、volatile关键字、以及并发集合类如ConcurrentHashMap、ConcurrentLinkedQueue等。

1.  synchronized关键字

synchronized关键字可以保证同一时刻只有一个线程可以访问被synchronized修饰的代码块或方法，从而避免多个线程同时访问同一个共享资源，导致数据不一致或者线程安全问题。synchronized关键字可以用于方法、代码块、静态方法等。

1.  volatile关键字

volatile关键字可以确保在多线程环境下变量的可见性和有序性，从而避免了由于指令重排等原因导致的线程安全问题。使用volatile关键字修饰的变量在每次被访问时，都会从内存中读取最新的值，而不是从缓存中读取，保证了变量的可见性。

1.  原子变量

Java提供了原子变量类如AtomicInteger、AtomicLong等，这些类提供了一些线程安全的操作，如自增、自减、比较并交换等操作。使用原子变量可以避免多线程同时修改同一个变量导致的线程安全问题。

1.  线程池

线程池是一种重用线程的机制，可以减少线程创建和销毁的开销。Java提供了Executor框架来支持线程池的使用。通过使用线程池，可以减少线程的创建和销毁次数，从而提高了程序的执行效率。

1.  并发集合类

Java提供了一系列的并发集合类，如ConcurrentHashMap、ConcurrentLinkedQueue等，这些集合类可以在多线程环境下保证线程安全，从而避免了使用传统的集合类时可能出现的线程安全问题。

1.  JMM

Java内存模型（Java Memory Model，简称JMM）是Java用来描述多线程访问共享内存时，内存可见性、指令重排、原子性等特性的规范。Java通过JMM来保证多线程之间的可见性、有序性和原子性，从而避免了线程安全问题。

综上所述，Java通过提供锁、原子变量、线程池、并发集合等机制以及JMM规范来解决并发问题，从而保证了多线程环境下程序的正确性和安全性。

## 3.线程安全有哪些实现思路? ##

线程安全的实现思路主要有以下几种：

1.  互斥同步

互斥同步是通过锁来保证多个线程之间的互斥访问，从而避免多个线程同时访问共享资源导致的数据不一致或者线程安全问题。常见的互斥同步机制包括synchronized关键字、Lock接口等。

1.  非阻塞同步

非阻塞同步是一种无需线程阻塞等待的同步方式，通过CAS操作等原子性操作来保证线程之间的互斥访问，从而避免了线程阻塞等待的开销。Java中的Atomic类就是基于非阻塞同步的机制。

1.  读写同步

读写同步是一种针对读写操作进行区分的同步方式，通过读写锁来实现多个线程之间的并发读取、独占写入，从而提高程序的执行效率。Java中的ReentrantReadWriteLock就是一个典型的读写锁。

1.  信号量

信号量是一种多线程同步机制，通过信号量来控制同时访问共享资源的线程数，从而实现线程之间的同步。Java中的Semaphore类就是一种基于信号量的同步机制。

1.  ThreadLocal

ThreadLocal是一种线程本地变量，它可以为每个线程提供独立的变量副本，从而避免多个线程之间共享变量导致的线程安全问题。ThreadLocal的实现原理是为每个线程维护一个独立的变量副本，从而保证线程之间互不干扰。

1.  并发容器

Java提供了一些并发容器类，如ConcurrentHashMap、ConcurrentLinkedQueue等，这些容器类可以在多线程环境下保证线程安全，从而避免了使用传统的容器类时可能出现的线程安全问题。

综上所述，实现线程安全的方式有很多种，可以根据具体的应用场景来选择最合适的实现方式。

## 4.如何理解并发和并行的区别? ##

并发是指一个处理器同时处理多个任务。

![c8f52bf009ca33e42c393bf629e991a5.jpeg][]

并行是指多个处理器或者是多核的处理器同时处理多个不同的任务。

![1cdca6f3f7ffdb4ccfec2615ab94d9b9.jpeg][]

## 5.线程有哪几种状态? 分别说明从一种状态到另一种状态转变有哪些方式? ##

![27043b1d759ab08c72e163d174c9d0de.png][]

1.  新建（New）：当一个线程对象被创建但还没有开始运行时，它的状态就是新建状态。

1.  就绪（Runnable）：当一个线程处于就绪状态时，表示它已经准备好了，等待系统的调度程序分配CPU时间片段，以便开始执行它的run()方法。

1.  运行（Running）：当一个线程正在执行run()方法时，它的状态就是运行状态。

1.  阻塞（Blocked）：当一个线程因为某些原因暂时停止执行，以等待系统资源或者等待某个条件得到满足，此时它的状态就是阻塞状态。

1.  等待（Waiting）：当一个线程因为某些条件没有得到满足而处于等待状态时，它的状态就是等待状态。在等待状态下，线程不会占用CPU资源，直到其它线程调用notify()或notifyAll()方法来唤醒它。

1.  计时等待（Timed Waiting）：当一个线程处于计时等待状态时，它会等待一定的时间，或者等待某个条件被满足，直到时间到期或者条件被满足时才会被唤醒。

1.  终止（Terminated）：当一个线程的run()方法执行完毕，或者因为出现了异常而结束时，它的状态就是终止状态。

一个线程在不同状态之间转换的方式有以下几种：

1.  新建状态转变为就绪状态：通过调用start()方法来启动线程，使它进入就绪状态。

1.  就绪状态转变为运行状态：当系统调度程序把CPU时间片段分配给了线程，使它开始执行run()方法时，线程就从就绪状态转变为运行状态。

1.  运行状态转变为就绪状态：当一个线程的run()方法执行完毕或者调用了wait()方法，使它暂时停止执行时，它就从运行状态转变为就绪状态。

1.  运行状态转变为阻塞状态：当一个线程因为某些原因而暂停执行，如等待某个条件得到满足时，它就从运行状态转变为阻塞状态。

1.  阻塞状态转变为就绪状态：当等待的条件得到满足或者等待时间到期时，线程就从阻塞状态转变为就绪状态。

1.  运行状态、就绪状态、阻塞状态、等待状态转变为终止状态：当一个线程的run()方法执行完毕，或者因为出现了异常而结束时，它的状态就会转变为终止状态。

## 6.通常线程有哪几种使用方式? ##

1.  基于继承Thread类：通过继承Thread类，重写其run()方法来创建线程，并调用start()方法启动线程。例如：

public class MyThread extends Thread {
        @Override
        public void run() {
            // 线程执行的代码
        }
    }
    
    MyThread thread = new MyThread();
    thread.start();

1.  实现Runnable接口：通过实现Runnable接口，并将其实例作为Thread的构造函数参数来创建线程。例如：

public class MyRunnable implements Runnable {
        @Override
        public void run() {
            // 线程执行的代码
        }
    }
    
    Thread thread = new Thread(new MyRunnable());
    thread.start();

1.  实现Callable接口：与实现Runnable接口类似，但是Callable接口的call()方法可以返回执行结果，并且可以抛出异常。例如：

public class MyCallable implements Callable<String> {
        @Override
        public String call() throws Exception {
            // 线程执行的代码
            return "result";
        }
    }
    
    FutureTask<String> task = new FutureTask<>(new MyCallable());
    Thread thread = new Thread(task);
    thread.start();

1.  使用线程池：通过线程池可以有效地管理线程的生命周期，避免频繁地创建和销毁线程。例如：

ExecutorService executor = Executors.newFixedThreadPool(5);
    executor.submit(new MyRunnable());
    executor.submit(new MyCallable());
    executor.shutdown();

## 7.线程的中断方式有哪些? ##

线程的中断方式主要有以下三种：

1.  通过调用interrupt()方法：这种方式是最常见的中断线程的方式。调用线程的interrupt()方法会将线程的中断状态设置为true，但并不会中断线程的执行。在线程的执行代码中，需要不断地检查线程的中断状态，如果中断状态为true，则可以结束线程的执行。

1.  通过检查isInterrupted()方法：可以在线程的执行代码中使用isInterrupted()方法来检查线程的中断状态，如果中断状态为true，则可以结束线程的执行。与interrupt()方法不同，调用isInterrupted()方法不会改变线程的中断状态。

1.  通过使用stop()方法：stop()方法可以立即结束线程的执行，但是这种方式已经被废弃，不建议使用。在使用stop()方法时，线程可能会被中断在执行过程中的任意位置，导致数据不一致和资源泄露等问题。

需要注意的是，使用interrupt()方法和isInterrupted()方法时，需要在线程的执行代码中不断地检查线程的中断状态，以便及时地结束线程的执行。同时，在使用这两种方式中断线程时，需要注意处理InterruptedException异常，以便正确地维护线程的中断状态。

## 8.线程之间有哪些协作方式? ##

1.  wait()和notify()/notifyAll()方法：可以使用wait()方法让一个线程等待，直到其他线程调用notify()或notifyAll()方法唤醒它。以下是一个简单的例子：

public class WaitNotifyExample {
        public static void main(String[] args) {
            Object lock = new Object();
            Thread t1 = new Thread(() -> {
                synchronized (lock) {
                    try {
                        System.out.println("Thread 1 waiting");
                        lock.wait();
                        System.out.println("Thread 1 notified");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            Thread t2 = new Thread(() -> {
                synchronized (lock) {
                    System.out.println("Thread 2 notifying");
                    lock.notify();
                }
            });
    
            t1.start();
            t2.start();
        }
    }

在上面的例子中，t1线程调用了lock的wait()方法，导致它被阻塞，直到t2线程调用了lock的notify()方法。在t2线程调用notify()方法之后，t1线程就会被唤醒，继续执行。

1.  join()方法：可以使用join()方法让一个线程等待另一个线程执行完成，再继续执行。以下是一个简单的例子：

public class JoinExample {
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(() -> {
                try {
                    Thread.sleep(1000);
                    System.out.println("Thread 1 finished");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
    
            Thread t2 = new Thread(() -> {
                try {
                    Thread.sleep(2000);
                    System.out.println("Thread 2 finished");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
    
            t1.start();
            t2.start();
    
            t1.join();
            t2.join();
    
            System.out.println("All threads finished");
        }
    }

在上面的例子中，主线程启动了t1和t2两个线程，然后调用了它们的join()方法，等待它们执行完成。当t1和t2两个线程都执行完成后，主线程才会继续执行。

[c8f52bf009ca33e42c393bf629e991a5.jpeg]: https://img-blog.csdnimg.cn/img_convert/c8f52bf009ca33e42c393bf629e991a5.jpeg
[1cdca6f3f7ffdb4ccfec2615ab94d9b9.jpeg]: https://img-blog.csdnimg.cn/img_convert/1cdca6f3f7ffdb4ccfec2615ab94d9b9.jpeg
[27043b1d759ab08c72e163d174c9d0de.png]: https://img-blog.csdnimg.cn/img_convert/27043b1d759ab08c72e163d174c9d0de.png