2025年java多线程并发面试题及答案

2025年java多线程并发面试题及答案本文借鉴了近年相关经典试题创作而成，力求帮助考生深入理解测试题型，掌握答题技巧，提升应试能力。一、选择题1.关于Java线程的生命周期，下列说法正确的是？A.新建状态B.运行状态C.阻塞状态D.以上都是2.在Java中，创建线程的两种方式是？A.继承Thread类B.实现Runnable接口C.使用线程池D.A和B3.以下哪个方法可以用来停止一个正在运行的线程？A.stop()B.interrupt()C.terminate()D.quit()4.在Java中，哪个关键字用于表示线程同步？A.synchronizedB.volatileC.finalD.transient5.以下哪个类是Java中用于处理并发的工具？A.ThreadB.RunnableC.CallableD.ExecutorService6.在多线程环境中，以下哪个方法是线程安全的？A.ArrayListB.HashMapC.VectorD.HashTable7.以下哪个方法可以用于设置线程的优先级？A.setPriority()B.setDaemon()C.setThreadGroup()D.setPriority()和setDaemon()8.以下哪个类是Java中用于实现线程通信的工具？A.wait()B.notify()C.notifyAll()D.A、B和C9.在Java中，以下哪个关键字用于表示线程的守护线程？A.daemonB.backgroundC.asyncD.thread10.以下哪个方法可以用于获取当前线程的名称？A.getName()B.getThreadName()C.getThread()D.getCurrentThreadName()二、填空题1.在Java中，线程的优先级范围是______到______。2.在Java中，使用______关键字可以表示线程的同步。3.在Java中，使用______方法可以用于设置线程的优先级。4.在Java中，使用______方法可以用于停止一个正在运行的线程。5.在Java中，使用______方法可以用于唤醒一个阻塞的线程。6.在Java中，使用______方法可以用于等待一个线程。7.在Java中，使用______关键字可以表示线程的守护线程。8.在Java中，使用______类可以用于实现线程通信。9.在Java中，使用______类可以用于创建线程池。10.在Java中，使用______关键字可以表示线程的不可变对象。三、简答题1.简述Java线程的生命周期及其各个状态。2.简述Java中创建线程的两种方式及其优缺点。3.简述Java中线程同步的两种方式及其区别。4.简述Java中线程通信的两种方式及其应用场景。5.简述Java中线程池的工作原理及其优点。四、编程题1.编写一个简单的Java程序，创建三个线程，分别打印数字1到10，每个数字之间暂停1秒。2.编写一个Java程序，实现一个线程安全的计数器。3.编写一个Java程序，使用线程池执行五个任务，每个任务打印当前时间。4.编写一个Java程序，使用生产者消费者模式实现线程通信。5.编写一个Java程序，使用锁机制实现线程同步。五、综合题1.编写一个Java程序，模拟一个银行账户的转账操作，使用多线程实现，并保证转账操作的安全性。2.编写一个Java程序，使用线程池处理多个任务，并实现任务的优先级排序。3.编写一个Java程序，使用线程池和定时任务，实现每天定时执行的任务调度。4.编写一个Java程序，使用线程池和并发集合，实现一个线程安全的日志系统。5.编写一个Java程序，使用线程池和并发集合，实现一个高并发的计数器系统。答案及解析一、选择题1.D.以上都是-Java线程的生命周期包括新建状态、运行状态、阻塞状态等。2.D.A和B-创建线程的两种方式是继承Thread类和实现Runnable接口。3.B.interrupt()-interrupt()方法可以用来停止一个正在运行的线程。4.A.synchronized-synchronized关键字用于表示线程同步。5.D.ExecutorService-ExecutorService是Java中用于处理并发的工具。6.D.HashTable-HashTable是线程安全的集合类。7.A.setPriority()-setPriority()方法可以用于设置线程的优先级。8.D.A、B和C-wait()、notify()和notifyAll()方法用于线程通信。9.A.daemon-daemon关键字用于表示线程的守护线程。10.A.getName()-getName()方法可以用于获取当前线程的名称。二、填空题1.在Java中，线程的优先级范围是1到10。2.在Java中，使用synchronized关键字可以表示线程的同步。3.在Java中，使用setPriority()方法可以用于设置线程的优先级。4.在Java中，使用interrupt()方法可以用于停止一个正在运行的线程。5.在Java中，使用notify()或notifyAll()方法可以用于唤醒一个阻塞的线程。6.在Java中，使用wait()方法可以用于等待一个线程。7.在Java中，使用daemon关键字可以表示线程的守护线程。8.在Java中，使用Lock类可以用于实现线程通信。9.在Java中，使用ExecutorService类可以用于创建线程池。10.在Java中，使用final关键字可以表示线程的不可变对象。三、简答题1.Java线程的生命周期及其各个状态-新建状态：线程被创建但尚未启动。-运行状态：线程正在执行。-阻塞状态：线程因等待某些资源或条件而暂停执行。-终止状态：线程执行完毕。2.Java中创建线程的两种方式及其优缺点-继承Thread类：简单直接，但无法继承其他类。-实现Runnable接口：可以继承其他类，更灵活，但需要实现run()方法。3.Java中线程同步的两种方式及其区别-同步方法：使用synchronized关键字修饰方法，作用于方法。-同步块：使用synchronized关键字修饰代码块，作用于代码块。4.Java中线程通信的两种方式及其应用场景-wait()和notify()：用于线程间的协作，适用于生产者消费者模式。-Lock和Condition：更灵活的线程通信工具，适用于复杂的并发场景。5.Java中线程池的工作原理及其优点-线程池管理一组线程，重用线程，减少创建和销毁线程的开销。-优点：提高系统性能，减少资源消耗，提高响应速度。四、编程题1.创建三个线程，分别打印数字1到10，每个数字之间暂停1秒```javaclassPrintNumbersextendsThread{privateintstart;privateintend;publicPrintNumbers(intstart,intend){this.start=start;this.end=end;}@Overridepublicvoidrun(){for(inti=start;i<=end;i++){System.out.println(Thread.currentThread().getName()+":"+i);try{Thread.sleep(1000);}catch(InterruptedExceptione){e.printStackTrace();}}}}publicclassMain{publicstaticvoidmain(String[]args){PrintNumberst1=newPrintNumbers(1,10);PrintNumberst2=newPrintNumbers(1,10);PrintNumberst3=newPrintNumbers(1,10);t1.setName("Thread-1");t2.setName("Thread-2");t3.setName("Thread-3");t1.start();t2.start();t3.start();}}```2.实现一个线程安全的计数器```javaclassSafeCounter{privateintcount=0;privatefinalObjectlock=newObject();publicvoidincrement(){synchronized(lock){count++;}}publicintgetCount(){synchronized(lock){returncount;}}}publicclassMain{publicstaticvoidmain(String[]args){SafeCountercounter=newSafeCounter();for(inti=0;i<10;i++){newThread(()->{counter.increment();}).start();}System.out.println("Finalcount:"+counter.getCount());}}```3.使用线程池执行五个任务，每个任务打印当前时间```javaimportjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;importjava.util.concurrent.TimeUnit;publicclassThreadPoolExample{publicstaticvoidmain(String[]args){ExecutorServiceexecutor=Executors.newFixedThreadPool(5);for(inti=0;i<5;i++){inttaskId=i;executor.submit(()->{System.out.println("Task"+taskId+"executedat"+System.currentTimeMillis());});}executor.shutdown();try{executor.awaitTermination(1,TimeUnit.MINUTES);}catch(InterruptedExceptione){e.printStackTrace();}}}```4.使用生产者消费者模式实现线程通信```javaimportjava.util.LinkedList;importjava.util.Queue;classProducerimplementsRunnable{privateQueue<Integer>queue;privateintcapacity;publicProducer(Queue<Integer>queue,intcapacity){this.queue=queue;this.capacity=capacity;}@Overridepublicvoidrun(){inti=0;while(true){synchronized(queue){while(queue.size()==capacity){try{queue.wait();}catch(InterruptedExceptione){e.printStackTrace();}}queue.add(i++);System.out.println("Produced:"+i);queue.notifyAll();}try{Thread.sleep(1000);}catch(InterruptedExceptione){e.printStackTrace();}}}}classConsumerimplementsRunnable{privateQueue<Integer>queue;publicConsumer(Queue<Integer>queue){this.queue=queue;}@Overridepublicvoidrun(){while(true){synchronized(queue){while(queue.isEmpty()){try{queue.wait();}catch(InterruptedExceptione){e.printStackTrace();}}intnum=queue.poll();System.out.println("Consumed:"+num);queue.notifyAll();}try{Thread.sleep(1000);}catch(InterruptedExceptione){e.printStackTrace();}}}}publicclassMain{publicstaticvoidmain(String[]args){Queue<Integer>queue=newLinkedList<>();intcapacity=5;Threadproducer=newThread(newProducer(queue,capacity));Threadconsumer=newThread(newConsumer(queue));producer.start();consumer.start();}}```5.使用锁机制实现线程同步```javaimportjava.util.concurrent.locks.Lock;importjava.util.concurrent.locks.ReentrantLock;classSharedResource{privatefinalLocklock=newReentrantLock();publicvoidperformAction(){lock.lock();try{System.out.println("Performingaction");//SimulatesomeworkThread.sleep(1000);}catch(InterruptedExceptione){e.printStackTrace();}finally{lock.unlock();}}}publicclassMain{publicstaticvoidmain(String[]args){SharedResourceresource=newSharedResource();for(inti=0;i<5;i++){newThread(()->{resource.performAction();}).start();}}}```五、综合题1.模拟一个银行账户的转账操作，使用多线程实现，并保证转账操作的安全性```javaclassBankAccount{privatedoublebalance;privatefinalLocklock=newReentrantLock();publicBankAccount(doubleinitialBalance){this.balance=initialBalance;}publicvoidtransfer(BankAccounttarget,doubleamount){lock.lock();try{if(this.balance>=amount){this.balance-=amount;target.balance+=amount;System.out.println("Transferred"+amount+"from"+this+"to"+target);}else{System.out.println("Insufficientbalancein"+this);}}finally{lock.unlock();}}@OverridepublicStringtoString(){return"BankAccount{"+"balance="+balance+'}';}}publicclassMain{publicstaticvoidmain(String[]args){BankAccountaccount1=newBankAccount(1000);BankAccountaccount2=newBankAccount(500);Threadt1=newThread(()->{account1.transfer(account2,200);});Threadt2=newThread(()->{account2.transfer(account1,100);});t1.start();t2.start();try{t1.join();t2.join();}catch(InterruptedExceptione){e.printStackTrace();}}}```2.使用线程池处理多个任务，并实现任务的优先级排序```javaimportjava.util.concurrent.PriorityBlockingQueue;importjava.util.concurrent.ThreadPoolExecutor;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.atomic.AtomicInteger;classTaskimplementsRunnable,Comparable<Task>{privatestaticfinalAtomicIntegertaskCount=newAtomicInteger(0);privatefinalinttaskId;privatefinalintpriority;publicTask(intpriority){this.taskId=taskCount.incrementAndGet();this.priority=priority;}@Overridepublicvoidrun(){System.out.println("ExecutingTask"+taskId+"withpriority"+priority);try{Thread.sleep(1000);}catch(InterruptedExceptione){e.printStackTrace();}}@OverridepublicintcompareTo(Taskother){returnIpare(other.priority,this.priority);}}publicclassMain{publicstaticvoidmain(String[]args){PriorityBlockingQueue<Runnable>queue=newPriorityBlockingQueue<>();ThreadPoolExecutorexecutor=newThreadPoolExecutor(3,5,0L,TimeUnit.MILLISECONDS,queue);executor.execute(newTask(5));executor.execute(newTask(1));executor.execute(newTask(3));executor.execute(newTask(4));executor.execute(newTask(2));executor.shutdown();try{executor.awaitTermination(1,TimeUnit.MINUTES);}catch(InterruptedExceptione){e.printStackTrace();}}}```3.使用线程池和定时任务，实现每天定时执行的任务调度```javaimportjava.util.concurrent.Executors;importjava.util.concurrent.ScheduledExecutorService;importjava.util.concurrent.TimeUnit;publicclassScheduledTaskExample{publicstaticvoidmain(String[]args){ScheduledExecutorServicescheduler=Executors.newScheduledThreadPool(1);Runnabletask=()->{System.out.println("Taskexecutedat"+System.currentTimeMillis());};scheduler.scheduleAtFixedRate(task,0,1,TimeUnit.SECONDS);}}```4.使用线程池和并发集合，实现一个线程安全的日志系统```javaimportjava.util.concurrent.ConcurrentLinkedQueue;importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;classLogger{privatefinalConcurrentLinkedQueue<String>logQueue=newConcurrentLinkedQueue<>();publicvoidlog(Stringmessage){logQueue.add(message);}publicvoidprintLogs(){logQueue.forEach(System.out::println);}}publicclassMain{publicstaticvoidmain(String[]args){Loggerlogger=newLogger();ExecutorServiceexecutor=Executors.newFixedThreadPool(5);for(inti=0;i<10;i++){intfinalI=i;executor.submit(()->{logge