2025年多线程中级面试题及答案

2025年多线程中级面试题及答案本文借鉴了近年相关经典试题创作而成，力求帮助考生深入理解测试题型，掌握答题技巧，提升应试能力。---2025年多线程中级面试题及答案一、选择题1.以下哪个选项是线程安全的？-A.`HashMap`-B.`ArrayList`-C.`StringBuilder`-D.`LinkedList`答案：C解析：-`HashMap`不是线程安全的，需要使用`ConcurrentHashMap`。-`ArrayList`不是线程安全的，需要使用`CopyOnWriteArrayList`。-`StringBuilder`是线程安全的，因为其内部有同步机制。-`LinkedList`不是线程安全的，需要使用`CopyOnWriteArrayList`或其他线程安全实现。2.在Java中，哪个方法用于让当前线程休眠指定时间？-A.`wait()`-B.`sleep()`-C.`yield()`-D.`suspend()`答案：B解析：-`wait()`是在`Object`类中定义的，用于线程等待，需要与`notify()`或`notifyAll()`配合使用。-`sleep()`是在`Thread`类中定义的，用于让当前线程休眠。-`yield()`是让出当前线程的执行权，但不一定会休眠。-`suspend()`已废弃，不推荐使用。3.以下哪个锁是可重入锁？-A.`ReentrantLock`-B.`synchronized`关键字-C.`Semaphore`-D.`CyclicBarrier`答案：A、B解析：-`ReentrantLock`是可重入锁，一个线程可以多次获取同一个锁。-`synchronized`关键字也是可重入锁。-`Semaphore`不是可重入锁。-`CyclicBarrier`不是锁，而是用于线程同步的工具。4.以下哪个方法用于释放锁？-A.`unlock()`-B.`release()`-C.`notify()`-D.`notifyAll()`答案：A、B解析：-`ReentrantLock`使用`unlock()`方法释放锁。-`Semaphore`使用`release()`方法释放许可。-`notify()`和`notifyAll()`用于唤醒等待的线程，不是释放锁。5.以下哪个选项可能导致死锁？-A.`ReentrantLock`使用不当-B.多个线程同时获取多个锁-C.线程优先级设置不当-D.使用`synchronized`关键字答案：A、B解析：-`ReentrantLock`如果顺序不当，可能导致死锁。-多个线程同时获取多个锁，且顺序不一致，可能导致死锁。-线程优先级设置不当可能导致性能问题，但不一定导致死锁。-`synchronized`使用不当也可能导致死锁，但通常通过顺序一致性避免。---二、简答题1.简述线程和进程的区别。答案：-进程：是系统资源分配的基本单位，拥有独立的内存空间，多个进程之间内存是隔离的。-线程：是CPU调度的基本单位，属于进程的一部分，共享进程的内存空间。-资源占用：进程占用资源更多，线程占用资源较少。-切换开销：线程切换开销比进程切换开销小。-通信方式：进程间通信需要通过IPC（进程间通信）机制，线程间通信可以直接读写共享内存。2.解释什么是线程池，以及它的优点。答案：-线程池：是一种管理线程的容器，可以预先创建多个线程并复用，避免频繁创建和销毁线程的开销。-优点：-减少创建和销毁线程的开销：预先创建线程池，避免频繁创建和销毁。-提高系统性能：通过复用线程，减少等待时间。-控制系统资源：限制线程数量，避免资源耗尽。-提高响应速度：任务提交后立即返回，无需等待线程创建。3.简述`synchronized`关键字的用法和原理。答案：-用法：-修饰方法：`synchronizedvoidmethod(){...}`-修饰代码块：`synchronized(this){...}`-原理：-对象锁：`synchronized`使用对象头中的MarkWord和Monitor实现锁。-锁升级：无锁->偏向锁->轻量级锁->重量级锁。-线程阻塞：获取不到锁的线程会被阻塞，等待锁释放。4.解释`volatile`关键字的用途和原理。答案：-用途：-可见性：保证变量在多个线程间的可见性。-禁止指令重排：保证指令的执行顺序。-原理：-内存屏障：`volatile`会在读写操作前后插入内存屏障，防止指令重排。-读操作：读取主内存的值。-写操作：写入主内存的值，并通知其他线程更新缓存。5.简述`ReentrantLock`和`synchronized`的区别。答案：-实现方式：-`synchronized`是JVM实现的锁，基于对象头和Monitor。-`ReentrantLock`是JDK实现的锁，基于AQS（抽象锁队列）。-功能：-`synchronized`不能中断锁等待，不能超时获取锁。-`ReentrantLock`支持中断、超时获取锁、可重入、可公平/非公平锁。-性能：-`synchronized`通常比`ReentrantLock`性能高，因为JVM对其进行了优化。-`ReentrantLock`提供更多功能，但可能存在额外的开销。---三、编程题1.编写一个线程安全的计数器。答案：```javaimportjava.util.concurrent.atomic.AtomicInteger;publicclassSafeCounter{privateAtomicIntegercount=newAtomicInteger(0);publicvoidincrement(){count.incrementAndGet();}publicintgetCount(){returncount.get();}publicstaticvoidmain(String[]args)throwsInterruptedException{SafeCountercounter=newSafeCounter();intthreadCount=1000;Thread[]threads=newThread[threadCount];for(inti=0;i<threadCount;i++){threads[i]=newThread(()->{counter.increment();});threads[i].start();}for(inti=0;i<threadCount;i++){threads[i].join();}System.out.println("Finalcount:"+counter.getCount());}}```2.编写一个生产者-消费者问题，使用`wait()`和`notify()`解决。答案：```javaimportjava.util.LinkedList;importjava.util.Queue;publicclassProducerConsumer{privateQueue<Integer>queue=newLinkedList<>();privatefinalintcapacity=10;publicsynchronizedvoidproduce(intitem)throwsInterruptedException{while(queue.size()==capacity){wait();}queue.add(item);System.out.println("Produced:"+item);notify();}publicsynchronizedintconsume()throwsInterruptedException{while(queue.isEmpty()){wait();}intitem=queue.poll();System.out.println("Consumed:"+item);notify();returnitem;}publicstaticvoidmain(String[]args){ProducerConsumerpc=newProducerConsumer();Threadproducer=newThread(()->{try{for(inti=0;i<20;i++){duce(i);Thread.sleep(100);}}catch(InterruptedExceptione){e.printStackTrace();}});Threadconsumer=newThread(()->{try{for(inti=0;i<20;i++){pc.consume();Thread.sleep(100);}}catch(InterruptedExceptione){e.printStackTrace();}});producer.start();consumer.start();}}```3.编写一个线程安全的`HashMap`实现。答案：```javaimportjava.util.concurrent.ConcurrentHashMap;publicclassSafeHashMap<K,V>{privateConcurrentHashMap<K,V>map=newConcurrentHashMap<>();publicvoidput(Kkey,Vvalue){map.put(key,value);}publicVget(Kkey){returnmap.get(key);}publicVremove(Kkey){returnmap.remove(key);}publicstaticvoidmain(String[]args){SafeHashMap<String,Integer>smap=newSafeHashMap<>();smap.put("one",1);smap.put("two",2);System.out.println(smap.get("one"));smap.remove("one");System.out.println(smap.get("one"));}}```4.编写一个使用`ReentrantLock`的线程安全计数器。答案：```javaimportjava.util.concurrent.locks.Lock;importjava.util.concurrent.locks.ReentrantLock;publicclassSafeCounterWithLock{privateintcount=0;privateLocklock=newReentrantLock();publicvoidincrement(){lock.lock();try{count++;}finally{lock.unlock();}}publicintgetCount(){lock.lock();try{returncount;}finally{lock.unlock();}}publicstaticvoidmain(String[]args)throwsInterruptedException{SafeCounterWithLockcounter=newSafeCounterWithLock();intthreadCount=1000;Thread[]threads=newThread[threadCount];for(inti=0;i<threadCount;i++){threads[i]=newThread(()->{counter.increment();});threads[i].start();}for(inti=0;i<threadCount;i++){threads[i].join();}System.out.println("Finalcount:"+counter.getCount());}}```5.编写一个使用`CyclicBarrier`的线程同步问题。答案：```javaimportjava.util.concurrent.CyclicBarrier;publicclassCyclicBarrierExample{privateCyclicBarrierbarrier=newCyclicBarrier(5,()->{System.out.println("Allthreadshavereachedthebarrier!");});publicvoidrunTask(){try{System.out.println(Thread.currentThread().getName()+"iswaitingatthebarrier.");barrier.await();System.out.println(Thread.currentThread().getName()+"hascrossedthebarrier.");}catch(Exceptione){e.printStackTrace();}}publicstaticvoidmain(String[]args){CyclicBarrierExampleexample=newCyclicBarrierExample();Thread[]threads=newThread[5];for(inti=0;i<5;i++){threads[i]=newThread(()->example.runTask());threads[i].start();}}}```---四、设计题1.设计一个高并发的计数器，要求支持高并发访问。答案：可以使用`AtomicInteger`或`AtomicLong`，它们基于CAS机制实现，支持高并发访问。```javaimportjava.util.concurrent.atomic.AtomicLong;publicclassHighConcurrentCounter{privateAtomicLongcount=newAtomicLong(0);publicvoidincrement(){count.incrementAndGet();}publiclonggetCount(){returncount.get();}publicstaticvoidmain(String[]args)throwsInterruptedException{HighConcurrentCountercounter=newHighConcurrentCounter();intthreadCount=100000;Thread[]threads=newThread[threadCount];for(inti=0;i<threadCount;i++){threads[i]=newThread(()->{counter.increment();});threads[i].start();}for(inti=0;i<threadCount;i++){threads[i].join();}System.out.println("Finalcount:"+counter.getCount());}}```2.设计一个线程安全的任务调度器，支持定时任务和延迟任务。答案：可以使用`ScheduledExecutorService`，它支持定时任务和延迟任务，并且是线程安全的。```javaimportjava.util.concurrent.Executors;importjava.util.concurrent.ScheduledExecutorService;importjava.util.concurrent.TimeUnit;publicclassSafeTaskScheduler{privateScheduledExecutorServicescheduler=Executors.newScheduledThreadPool(5);publicvoidscheduleTask(Runnabletask,longdelay,TimeUnitunit){scheduler.schedule(task,delay,unit);}publicvoidscheduleAtFixedRate(Runnabletask,longinitialDelay,longperiod,TimeUnitunit){scheduler.scheduleAtFixedRate(task,initialDelay,period,unit);}publicvoidshutdown(){scheduler.shutdown();}publicstaticvoidmain(String[]args){SafeTaskSchedulerscheduler=newSafeTaskScheduler();//延迟任务scheduler.scheduleTask(()->{System.out.println("Delayedtaskexecutedat"+System.currentTimeMillis());},5,TimeUnit.SECONDS);//定时任务scheduler.scheduleAtFixedRate(()->{System.out.println("Periodictaskexecutedat"+System.currentTimeMillis());},1,1,TimeUnit.SECONDS);try{Thread.sleep(10000);}catch(InterruptedExceptione){e.printStackTrace();}scheduler.shutdown();}}```3.设计一个线程安全的缓存系统，支持过期和最大容量限制。答案：可以使用`ConcurrentHashMap`和`LinkedHashMap`实现一个简单的线程安全缓存系统。```javaimportjava.util.concurrent.ConcurrentHashMap;importjava.util.concurrent.LinkedBlockingQueue;publicclassSafeCache<K,V>{privateConcurrentHashMap<K,V>cache=newConcurrentHashMap<>();privateLinkedBlockingQueue<K>queue=newLinkedBlockingQueue<>();privatefinalintcapacity;publicSafeCache(intcapacity){this.capacity=capacity;}publicvoidput(Kkey,Vvalue,longexpiryTime){cache.put(key,value);queue.add(key);if(queue.size()>capacity){KoldestKey=queue.poll();cache.remove(oldestKey);}}publicVget(Kkey){returncache.get(key);}publicstaticvoidmain(String[]args){SafeCache<String,String>cache=newSafeCache<>(10);cache.put("one","1",10000);cache.put("two","2",10000);cache.put("three","3",10000);System.out.println(cache.get("one"));System.out.println(cache.get("two"));System.out.println(cache.get("three"));try{Thread.sleep(10000);}catch(InterruptedExceptione){e.printStackTrace();}System.out.println(cache.get("one"));//null,becauseofexpiry}}```---五、性能优化题1.如何优化多线程环境下的锁竞争问题？答案：-使用细粒度锁：将大锁拆分成多个小锁，减少锁竞争。-使用不可变对象：不可变对象不需要锁，因为它们的状态不可变。-使用`volatile`关键字：保证变量的可见性，避免不必要的锁。-使用`CopyOnWriteArrayList`：适用于读多写少的场景。-使用`ReentrantLock`的公平锁：减少线程等待时间。-使用`Atomic`类：基于CAS机制，避免锁开销。2.如何优化多线程环境下的内存可见性问题？答案：-使用`volatile`关键字：保证变量的可见性。-使用`synchronized`关键字：保证变量的可见性和原子性。-使用`final`关键字：保证初始化安全发布。-使用`java.util.concurrent`包中的类：如`AtomicInteger`，保证内存可见性。-使用`MemoryBarrier`或`Fence`：防止指令重排。---答案和解析一、选择题1.C-解析：`StringBuilder`是线程安全的，因为其内部有同步机制。其他选项都不是线程安全的。2.B-解析：`sleep()`是在`Thread`类中定义的，用于让当前线程休眠。3.A、B-解析：`ReentrantLock`和`synchronized`关键字都是可重入锁。4.A、B-解析：`ReentrantLock`使用`unlock()`方法释放锁，`Semaphore`使用`release()`方法释放许可。5.A、B-解析：`ReentrantLock`使用不当和多个线程同时获取多个锁可能导致死锁。二、简答题1.线程和进程的区别：-进程是系统资源分配的基本单位，拥有独立的内存空间；线程是CPU调度的基本单位，共享进程的内存空间。进程切换开销大，线程切换开销小。2.线程池的优点：-减少创建和销毁线程的开销，提高系