Java多线程面试题(面试官常问)

进程和线程

进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是从一个进程从创建、运行到消亡的过程。在java中，当我们启动main函数时其实就是启动了一个jvm的进程，而mian函数所在的线程就是这个进程中的一个线程，称为主线程。

线程是比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程都有自己的程序计数器、虚拟机和本地方法栈，所以系统在产生一个线程，或在各个线程之间切换工作是，负担要比进程小很多，所以线程也称轻量级进程。

并发和并行

• 并发：同一时间段内，多个任务都在执行（单位时间内不一定同时执行）
• 并行：单位时间内，多个任务同时执行。

上下文切换

多线程编程中一般线程的个数都大于cpu核心的个数，而一个cpu核心在任意时刻内只能被一个线程使用，为了让这些线程都能得到有效执行，cpu采取的策略时为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程属于一次上下文切换。

换句话说，当前任务在执行完cpu时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换会这个任务时，可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。

sleep()和wait()

• 最主要的区别是sleep()方法没有释放锁，而wait()方法释放了锁。
• 两者都可以暂停线程的执行。
• wait()通常用于线程间交互/通信，sleep()通常用于暂停执行。
• wait()方法被调用后，线程不会自动苏醒（除非超时），需要别的线程调用同一个对象上的notify()或notifyall()方法。而sleep()方法执行完后，线程会自动苏醒。

 start()和run()

为什么调用start()方法时会执行run()方法，为什么不能直接调用run()方法？

当我们new一个thread时，线程进入了新建状态，调用start()方法，会启动一个线程并使线程进入就绪状态，等分到时间片后就可以开始运行了。
start()会执行线程的相应准备工作，然后自动执行run()方法的内容，这是真正的多线程工作。
而直接执行run()方法会把run方法当作一个main线程下的普通方法去执行，并不是在某个线程中执行它，所以这不是多线程工作。

synchronized关键字

synchronized关键字是解决多个线程之间访问资源的同步性，可以保证被它修饰的方法或代码块在任意时刻只能有一个线程执行。

synchronized主要的三种使用方式：

1.修饰实例方法

作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁。

2.修饰静态方法

给当前类加锁，会作用于类的所有对象实例，因为静态成员是类成员，不属于任何一个实例对象，所以线程a调用一个实例对象的非静态synchronized方法，而线程b调用该实例对象所属类的静态synchronized方法时是允许的，不会冲突互斥。因为访问静态synchronized方法占用的是当前类的锁，而访问非静态synchronized方法占用的是当前实例对象锁。

3.修饰代码块

指定加锁对象，进入同步代码库前要获得给定对象的锁。

synchronized和reentrantlock：

1.两者都是可重入锁
即自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁时还是可以获取的。

2.前者依赖jvm而后者依赖api
synchronized是依赖于jvm实现的，reentrantlock是依赖于jdk层面实现的。

3.reentrantlock比synchronized功能多
reentrantlock增加了一些高级功能，主要说有三点：①等待可中断②可实现公平锁③可实现选择性通知。

volatile关键字

当前java内存模型下，线程可以把变量保存到本地内存（如寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还在继续使用它在寄存器中变量值的拷贝，造成数据的不一致。

volatile关键字就是解决这个问题，指示jvm这个变量不稳定，每次使用它都要到主存中进行读取。除此之外还有一个重要的作用是防重排。

并发执行的三个重要特性：

1.原子性

要么所有的操作都得到执行并且不会收到任何因素干扰而中断，要么所有的操作都不执行。可使用synchronized来保证代码原子性。

2.可见性
当对一个共享变量进行了修改后，那么另外的线程都是立即可以看到修改后的最新值。volatile可以保证可见性。

3.有序性
代码在执行过程中的先后顺序，java在编译器以及运行期间的优化，代码的执行顺序未必就是编写代码时候的顺序，即指令重排。volatile可以禁止指令重排优化。

threadlocal

通常情况下，我们创建的变量时可以被任何一个线程访问并修改的。如果要实现每一个线程都有自己的专属本地变量该如何解决？这就需要threadlocal类了。

threadlocal类主要解决的就是让每个线程绑定自己的值，可以将threadlocal类比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。

当创建一个threadlocal变量后，访问这个变量的每个线程都会有这个变量的本地副本，这也是threadlocal名称的由来。可以使用get()和set()方法来获取默认值或将其值更改为当前线程所存副本的值，从而避免了线程安全问题。

实际上，threadlocal类有一个静态内部类threadlocalmap，可以把threadlocalmap看作是threadlocal类定制的hashmap，最终的变量是放在了当前线程的threadlocalmap中，而不是threadlocal类上，可以看作threadlocal类是threadlocalmap的封装，传递了值。

如果再同一个线程中声明了两个thradlocal对象的话，会使用thread内部仅有的那个threadlocalmap存放数据的，theadlocalmap的key就是threadlocal对象，value就是threadlocal对象调用set方法设置的值。

threadlocalmap使用的key为threadlocal的弱引用，而value是强引用。所以threadlocal没有被外部强引用的情况下，在垃圾回收的时候，key 会被清理掉，而value不会被
清理掉。这样一来，threadlocalmap中就会出现key为null的entry。假如我们不做任何措施的话，value永远无法被gc回收，这个时候就可能会产生内存泄露。threadlocalmap实现中已经考虑了这种情况，在调用set()、get()、remove()方法的时会清理掉key为null 的记录。使用完threadlocal方法后最好手动调用remove()方法。

（插播反爬信息 ）博主csdn地址：

线程池

池化技术大家应该很熟悉，线程池、数据库连接池、http连接池等等都是对这思想的应用。池化技术的思想主要是为了减少每次获取资源的消耗，提高对资源的利用率。
使用线程池，可以降低资源消耗、提高响应速度、提高线程的可管理性。

runnable和callable

runnable接口不会返回结果或抛出检查异常，但callable接口可以。
工具类excutors可以实现runnable对对象和callable对象之间的相互转换。

@functionalinterface
public interface runnable{
 //没有返回值也无法抛出异常
 public abstract void run();
}

@functionalinterface
public interface callable<v>{
 //@return 计算得出结果
 //@throws 如果无法计算结果，则抛出异常
}

execute()和submit()

1. execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否。
2. submit()方法用于提交需要返回值的任务。线程池会返回一个future类型对象，通过这个对象可以判断任务是否执行成功。

 创建线程池

1. 通过构造器threadpoolexecutor实现（下面介绍）。
2. 通过工具类executors实现（不推荐）

threadpoolexecutor: .

• fixedthreadpool：该访法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。
• singlethreadexecutor：方法返回- 个只有一一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。
• cachedthreadpool：该方法返回一个可 根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。

threadpoolexecutor

• threadpoolexecutor构造函数重要参数分析：
• corepoolsize：核⼼线程数线程数定义了最⼩可以同时运⾏的线程数量。
• maximumpoolsize：当队列中存放的任务达到队列容量的时候，当前可以同时运⾏的线程数量变为最⼤线程数。
• workqueue：当新任务来的时候会先判断当前运⾏的线程数量是否达到核⼼线程数，如果达到的话，新任务就会被存放在队列中。
• keepalivetime：当线程池中的线程数量⼤于 corepoolsize 的时候，如果这时没有新的任务提交，核⼼线程外的线程不会⽴即销毁，⽽是会等待，直到等待的时间超过了keepalivetime 才会被回收销毁；
• unit：keepalivetime 参数的时间单位。
• threadfactory：executor 创建新线程的时候会⽤到。
• handler：饱和策略

①threadpoolexecutor.abortpolicy：抛出 rejectedexecutionexception 来拒绝新任务的处理。
②threadpoolexecutor.callerrunspolicy：调⽤执⾏⾃⼰的线程运⾏任务。会降低对于新任务提交速度，影响程序的整体性能，另外会增加队列容量。
③threadpoolexecutor.discardpolicy：不处理新任务，直接丢弃掉。
④threadpoolexecutor.discardoldestpolicy：此策略将丢弃最早的未处理的任务请求。

demo

模拟了 10 个任务，我们配置的核⼼线程数为 5 、等待队列容量为 100 ，所以每次只能存在5个任务同时执⾏，剩下的5个任务会被放到等待队列中去。当前的 5 个任务之⾏完成后，才会之⾏剩下的 5 个任务。

public class myrunnable implements runnable {
 private string command;
 public myrunnable(string s) {
  this.command = s;
 }
 @override
 public void run() {
  system.out.println(thread.currentthread().getname() + "开始时间：" + new date());
    processcommand();
  system.out.println(thread.currentthread().getname() + "结束时间：" + new date());
 }
 private void processcommand() {
  try {
   thread.sleep(3000); //设花费3秒执行任务
  } catch (interruptedexception e) {
   e.printstacktrace();
  }
 }
 @override
 public string tostring() {
  return this.command;
 }
}

public class demo {
 private static final int core_pool_size = 5;//核⼼线程数为 5
 private static final int max_pool_size = 10;//最⼤线程数 10
 private static final int queue_capacity = 100;//容量100
 private static final long keep_alive_time = 1l;//等待时间为 1l
 public static void main(string[] args) {
  //通过threadpoolexecutor构造函数⾃定义参数创建
  threadpoolexecutor executor = new threadpoolexecutor(
    core_pool_size,
    max_pool_size,
    keep_alive_time,
    timeunit.seconds,
    new arrayblockingqueue<>(queue_capacity),
    new threadpoolexecutor.callerrunspolicy());//饱和策略
  for (int i = 0; i < 10; i++) {
   //创建workerthread对象（workerthread类实现了runnable接⼝）
   runnable worker = new myrunnable("" + i);
   executor.execute(worker);//执⾏runnable
  }
  executor.shutdown();//终⽌线程池
  while (!executor.isterminated()) {
  }
  system.out.println("结束");
 }
}
/*运行结果如下：
pool-1-thread-3开始时间：mon mar 29 22:46:02 cst 2021
pool-1-thread-2开始时间：mon mar 29 22:46:02 cst 2021
pool-1-thread-4开始时间：mon mar 29 22:46:02 cst 2021
pool-1-thread-5开始时间：mon mar 29 22:46:02 cst 2021
pool-1-thread-1开始时间：mon mar 29 22:46:02 cst 2021
pool-1-thread-2结束时间：mon mar 29 22:46:07 cst 2021
pool-1-thread-2开始时间：mon mar 29 22:46:07 cst 2021
pool-1-thread-3结束时间：mon mar 29 22:46:07 cst 2021
pool-1-thread-3开始时间：mon mar 29 22:46:07 cst 2021
pool-1-thread-4结束时间：mon mar 29 22:46:07 cst 2021
pool-1-thread-4开始时间：mon mar 29 22:46:07 cst 2021
pool-1-thread-5结束时间：mon mar 29 22:46:07 cst 2021
pool-1-thread-5开始时间：mon mar 29 22:46:07 cst 2021
pool-1-thread-1结束时间：mon mar 29 22:46:07 cst 2021
pool-1-thread-1开始时间：mon mar 29 22:46:07 cst 2021
pool-1-thread-2结束时间：mon mar 29 22:46:12 cst 2021
pool-1-thread-3结束时间：mon mar 29 22:46:12 cst 2021
pool-1-thread-4结束时间：mon mar 29 22:46:12 cst 2021
pool-1-thread-5结束时间：mon mar 29 22:46:12 cst 2021
pool-1-thread-1结束时间：mon mar 29 22:46:12 cst 2021
结束
*/

到此这篇关于java多线程面试题(面试官常问)的文章就介绍到这了,更多相关java多线程面试题内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！