多线程笔试题目专题

于 2025-01-15 21:00:00 发布
阅读量266 收藏 4
点赞数 5
CC 4.0 BY-SA版权
分类专栏： LeetCode 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/HcJsJqJSSM/article/details/145162248

一、基于阻塞队列实现生产者和消费者循环生产消费。

1、解题思路基于自定义线程+ArrayBlockQuery实现

  1.1 生产者

package com.boot.skywalk.util.queue;

import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable{
    private BlockingQueue<Menu> blockingQueue;

    public Producer(BlockingQueue blockingQueue){
        this.blockingQueue=blockingQueue;
    }

    @Override
    public void run() {
        for(int i=1;i<=100;i++){
            Menu menu = new Menu(i + "code");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            try {
                blockingQueue.put(menu);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("生产商品:"+menu.getMessage());
        }
        // 作为退出标记
        Menu exit = new Menu("exit");
        try {
            blockingQueue.put(exit);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

  1.2 消费者

package com.boot.skywalk.util.queue;

import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable{
    private BlockingQueue<Menu> blockingQueue;

    public Consumer(BlockingQueue blockingQueue){
        this.blockingQueue=blockingQueue;
    }
    @Override
    public void run() {
        Menu menu;
        try {
            while(!(menu=blockingQueue.take()).getMessage().equals("exit")){
                 Thread.sleep(100);
                System.out.println("消费商品:"+menu.getMessage());
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

  1.3 测试代码

package com.boot.skywalk.util.queue;

public class Menu {
    private String message;

    public Menu(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}
package com.boot.skywalk.util.queue;

import java.util.concurrent.ArrayBlockingQueue;

public class Client {
    public static void main(String[] args) throws InterruptedException {
        ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(10);
        Producer producer = new Producer(blockingQueue);
        Consumer consumer = new Consumer(blockingQueue);
        System.out.println("消费开始");
        Thread produceThread = new Thread(producer);
        Thread consumerThread = new Thread(consumer);
        produceThread.start();
        consumerThread.start();
        produceThread.join();
        consumerThread.join();
        System.out.println("消费结束");
    }
}

 运行结果

二、多个线程顺序执行

1、解题思路基于CountDownLatch的countDown和await实现.
package com.boot.skywalk.thread;

import com.boot.skywalk.exception.GlobalException;
import lombok.extern.slf4j.Slf4j;

import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * 线程工具类封装,ThreadUtil
 */
@Slf4j
public final class ThreadUtil {
    /**
     * Number of milliseconds in a standard second.
     */
    public static final long MILLIS_PER_SECOND = 1000;
    /**
     * Number of milliseconds in a standard minute.
     */
    public static final long MILLIS_PER_MINUTE = 60 * MILLIS_PER_SECOND;
    /**
     * Number of milliseconds in a standard hour.
     */
    public static final long MILLIS_PER_HOUR = 60 * MILLIS_PER_MINUTE;
    /**
     * Number of milliseconds in a standard day.
     */
    public static final long MILLIS_PER_DAY = 24 * MILLIS_PER_HOUR;
    /**
     * 校验时间单位
     *
     * @param duration duration
     * @param unit unit
     */
    public static void checkDurationLength(long duration, TimeUnit unit){
        long durationSeconds = TimeUnit.MILLISECONDS.convert(duration, unit);
        if(durationSeconds<0||durationSeconds>MILLIS_PER_DAY){
            log.error("illegal duration time,duration={},unit={}",duration,unit);
            throw new GlobalException("duration time is illegal");
        }
    }

    /**
     * 毫秒级中断线程
     *
     * @param millSeconds
     */
    public static void pauseThreadMillSeconds(long millSeconds){
        pauseThread(millSeconds, TimeUnit.MILLISECONDS);
    }

    /**
     * 秒级中断线程
     *
     * @param seconds
     */
    public static void pauseThreadSeconds(long seconds){
        pauseThread(seconds, TimeUnit.SECONDS);
    }

    /**
     * 中断线程
     *
     * @param duration duration
     * @param unit unit
     */
    public static void pauseThread(long duration,TimeUnit unit){
        if(Objects.isNull(unit)){
            log.error("TimeUnit is null");
            throw new GlobalException("TimeUnit is null");
        }
        checkDurationLength(duration, unit);
        try {
            unit.sleep(duration);
        } catch (InterruptedException e) {
            log.error("pause thread fail,duration={},unit={}",duration,unit,e);
        }
    }

    // 使用
    public static void main(String[] args) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

    private static CountDownLatch countDownLatch1 = new CountDownLatch(1);

    private static CountDownLatch countDownLatch2 = new CountDownLatch(1);

    private static CountDownLatch countDownLatch3 = new CountDownLatch(1);

   // 基于CountDownLatch实现 
   public static void test4(){
        // Thread1
        final Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread1 Run");
                countDownLatch1.countDown();
            }
        });
        // Thread2
        final Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    countDownLatch1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread2 Run");
                countDownLatch2.countDown();
            }
        });
        // Thread3
        final Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    countDownLatch2.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread3 Run");
                countDownLatch3.countDown();
            }
        });
        // Thread4
        final Thread thread4 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    countDownLatch3.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread4 Run");

            }
        });
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }

运行如下：

2、基于线程join实现.
public static void test1(){
        // Thread1
        final Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread1 Run");
            }
        });
        final Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    thread1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread2 Run");
            }
        });
        final Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    thread2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread3 Run");
            }
        });
        final Thread thread4 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    thread3.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread4 Run");
            }
        });
        // 线程执行
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
3、多个子线程交替start()+join()
    public static void test2() throws InterruptedException {
        // Thread1
        final Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread1 Run");
            }
        });
        // Thread2
        final Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread2 Run");
            }
        });
        // Thread3
        final Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread3 Run");
            }
        });
        // Thread4
        final Thread thread4 = new Thread(new Runnable() {
            @Override
            public void run() {
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread4 Run");
            }
        });
        thread1.start();
        thread1.join();
        thread2.start();
        thread2.join();
        thread3.start();
        thread3.join();
        thread4.start();
        thread4.join();
    }
4、单个线程依次提交
    public static void test3(){
        // Thread1
        final Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread1 Run");
            }
        });
        // Thread2
        final Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread2 Run");
            }
        });
        // Thread3
        final Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread3 Run");
            }
        });
        // Thread4
        final Thread thread4 = new Thread(new Runnable() {
            @Override
            public void run() {
                ThreadUtil.pauseThreadSeconds(1);
                System.out.println("Thread4 Run");
            }
        });
        singleThreadEventExecutor.execute(thread1);
        singleThreadEventExecutor.execute(thread2);
        singleThreadEventExecutor.execute(thread3);
        singleThreadEventExecutor.execute(thread4);
        singleThreadEventExecutor.shutdown();
    }

三、多个线程交替打印

1、synchionized+volatile+对象锁+等待通知机制。
        private int times;
        private volatile int state;
        private static final Object LOCK = new Object();

        public SynchionizedTest(int times) {
            this.times = times;
        }

        public static void main(String[] args) {
            SynchionizedTest printABC = new SynchionizedTest(20);
            new Thread(printABC::printA).start();
            new Thread(printABC::printB).start();
            new Thread(printABC::printC).start();
        }
        public void printA() {
            try {
                print("A", 0);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public void printB() {
            try {
                print("B", 1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public void printC() {
            try {
                print("C", 2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        private void print(String name, int targetState) throws InterruptedException {
            for (int i = 0; i < times; i++) {
                synchronized (LOCK) {
                    while (state % 3 != targetState) {
                        LOCK.wait();
                    }
                    state++;
                    ThreadUtil.pauseThreadSeconds(1);
                    System.out.println(name);
                    LOCK.notifyAll();
                }
            }
        }
    }

四、多个线程等待某一个线程的信号，同时开始执行

    // 在这段代码中，首先打印出了运动员有 5 秒的准备时间，然后新建了一个 CountDownLatch，其倒数值只有 1；接着，同样是一个 5 线程的线程池，并且用 for 循环的方式往里提交 5 个任务，而这 5 个任务在一开始时就让它调用 await() 方法开始等待。
    public static void countLatch (){
        System.out.println("运动员有5秒的准备时间");
        CountDownLatch countDownLatch = new CountDownLatch(1);
        ExecutorService service = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            final int no = i + 1;
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println(no + "号运动员准备完毕，等待裁判员的发令枪");
                    try {
                        countDownLatch.await();
                        System.out.println(no + "号运动员开始跑步了");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            service.submit(runnable);
        }
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("5秒准备时间已过，发令枪响，比赛开始！");
        countDownLatch.countDown();
        service.shutdown();
    }

五、一个线程等待多个线程完成各自工作后再进行工作

private static void extractedLatch() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(5);
        ExecutorService service = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            final int no = i + 1;
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println(no + "号运动员完成了比赛。");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        latch.countDown();
                    }
                }
            };
            service.submit(runnable);
        }
        System.out.println("等待5个运动员都跑完.....");
        latch.await();
        service.shutdown();
        System.out.println("所有人都跑完了，比赛结束。");
    }

 运行截图.

关于多线程的笔试面试题
ljthdu的专栏
07-29 934
关于多线程方面的笔试面试题
并发编程44题（含答案）
weixin_42034166的博客
11-21 3533
1、并发编程三要素？ 1）原子性 原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。 2）可见性 可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线程可以立即看到修改的结果。 实现可见性的方法： synchronized或者Lock：保证同一个时刻只有一个线程获取锁执行代码，锁释放之前把最新的值刷新到主内存，实现可见...
java多线程笔试题_JAVA多线程笔试题
weixin_42339883的博客
02-15 330
import java.util.;import java.util.concurrent.;public class Main {public static void main(String[] args) {List<String> allPaymentList=Arrays.asList("余额","红包","余额宝","银行卡");long start=System.nanoT...
Java多线程笔试题
thewebcode
12-04 294
60、java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？ 答：有两种实现方法，分别是继承Thread类与实现Runnable接口 用synchronized关键字修饰同步方法 反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难...
多线程笔试面试题汇总-答案
qq_41786318的博客
08-15 760
二．选择题 第一题（百度笔试题）： 以下多线程对int型变量x的操作，哪几个不需要进行同步：  A. x=y;      B. x++;    C. ++x;    D. x=1; 答案：ABC A：在X86上它包含两个操作：读取y至寄存器，再把该值写入x。读y的值这个操作本身是原子的，把值写入x也是原子的，但是两者合起来不是原子操作，因为它不是不可再分的操作，所以需要进行同步 B、C：...
多线程测试题(附答案)
L00teacher的博客
06-11 4834
**多线程** 一、判断题(T为正确,F为错误),每题1分 1.如果线程死亡，它便不能运行。（ T ） 2.在Java中，高优先级的可运行线程会抢占低优先级线程。（ T ） 3.线程可以用yield方法使低优先级的线程运行。（ F ） yield方法：暂停线程，暂停当前正在执行的线程对象。yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。 yield()只能使同优先级或更高优先级的线程有执行的机会。 4.程序开发者必须创建一...
多线程面试59题（含答案）
weixin_68009402的博客
05-18 388
对方释放锁，此时若无外力干预，这些线程则一直处理阻塞的假死状态，形成死锁。虽然重排序优化了性能，但也是会遵守一些规则的，并不能随便乱排序，一种分法，堆是所有线程共享的一块区域，而栈是线程隔离的，每个线程互不共享。假的多线程，同一时间处理器只会处理一段逻辑，只不过线程之间切换得比较快，线程可以防止这个问题，多条线程同时运行，哪怕一条线程的代码执行读取数据阻。地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程。法进行等待的线程等待目标线程运行结束而唤醒，一旦通过相关事件唤醒线程，线。
Java笔试题多线程部分简答
weixin_33716941的博客
04-14 284
1.谈谈你对多线程的理解一个类继承了Thread类之后，那么此类就具备了多线程的操作功能。线程的三点必要因素：class MyThread extends Thread{ //第一、要继承Thread private String name; public MyThread(String name) { this.name = name; ...
多线程经典面试题和答案
11-15
常见的多线程经典面试题和答案，包含了面试中常见了多线程问题。
最全多线程经典面试题和答案
一个有情怀的程序猿博客
05-19 711
Java实现线程有哪几种方式？ 1、继承Thread类实现多线程2、实现Runnable接口方式实现多线程3、使用ExecutorService、Callable、Future实现有返回结果的多线程 多线程同步有哪几种方法？ Synchronized关键字，Lock锁实现，分布式锁等。 Runnable和Thread用哪个好？ Java不支持类的多重继承，但允许你实现多个接口。所以如果你要继承其他类，也为了减少类之间的耦合性，Run...
java多线程
dhwu43996的博客
01-07 117
详细见，Java并发编程的艺术/P101 在java中，每个对象的监视器都有两个池，锁(monitor)池和等待池 wait() ,notifyAll(),notify() 三个方法都是Object类中的方法. 锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入...
学透并发编程——LeetCode多线程协作经典题
Hopefully Sky的博客
11-09 1890
LeetCode上专门的多线程题目版块，本文通过解决几道leetCode上的多线程协作交替打印的编程题，来加深对并发编程的理解，并训练一下并发编程思想。
经典笔试题-线程篇
逍遥云恋
02-10 521
线程部分：（共10 题：基础7 道，中等难度3 道） 81、sleep() 和wait() 有什么区别? 【基础】 答：sleep 是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep 不会释放对象锁。wait 是Object 类的方法，对此对象调用wait 方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只...
史上最强多线程面试47题(含答案)，建议收藏
jjc4261的博客
09-08 5760
线程池就是提前创建若干个线程，如果有任务需要处理，线程池里的线程就会处理任务，处理完之后线程并不会被销毁，而是等待下一个任务。由于创建和销毁线程都是消耗系统资源的，所以当你想要频繁的创建和销毁线程的时候就可以考虑使用线程池来提升系统的性能。java 提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池。CAS是compare and swap的缩写，即我们所说的比较交换。cas是一种基于锁的操作，而且是乐观锁。在java中锁分为乐观锁和悲观锁。
【多线程与高并发】这可能是最全的多线程面试题了
牧小农
04-28 9538
1. 如何预防死锁？ 首先需要将死锁发生的是个必要条件讲出来: 互斥条件 同一时间只能有一个线程获取资源。 不可剥夺条件 一个线程已经占有的资源，在释放之前不会被其它线程抢占 请求和保持条件 线程等待过程中不会释放已占有的资源 循环等待条件 多个线程互相等待对方释放资源 死锁预防，那么就是需要破坏这四个必要条件： 由于资源互斥是资源使用的固有特性，无法改变，我们不讨论 破坏不可剥夺条件 一个进程不能获得所需要的全部资源时便处于等待状态，等待期间他占有的资源将被隐式的释放重新加入到系统的资源列表中
第一篇 多线程笔试面试题汇总（转）
weixin_34313182的博客
06-12 122
一．概念性问答题 第一题：线程的基本概念、线程的基本状态及状态之间的关系？  线程：一个线程是进程的一个顺序执行流。同类的多个线程共享一块内存空间和一组系统资源，线程本身有一个供程序执行时的堆栈。线程在切换时负荷小，因此，线程也被称为轻负荷进程。一个进程中可以包含多个线程。 并发原理 多个线程或进程”同时”运行只是我们感官上的一种表现。事实上进程和线程是并发运行的，OS的线程调度机制将时间划分为很...
JAVA笔试题之集合数和多线程
程序员救不了第四宇宙的博客
11-14 1988
一. 阐述下对于常用的集合数的理解。 答案通过百度百科整理而来，不保证百分百正确。 简述： 集合类是Java数据结构的实现。Java的集合类是java.util包中的重要内容，它允许以各种方式将元素分组，并定义了各种使这些元素更容易操作的方法。 集合类是用来存放某类对象的。集合类有一个共同特点，就是它们只容纳对象（实际上是对象名，即指向地址的指针）。这一点和数组不同，数组可以容纳对象和简单...
掌握这些多线程笔试题，还不轻松应对面试官
最新发布
关关的博客
12-24 413
多线程的常见面试手撕题
40道Java多线程面试真题及答案
a6636656的博客
05-17 249
这篇文章主要是对多线程的问题进行总结的，因此罗列了40个多线程的问题。 这些多线程的问题，有些来源于各大网站、有些来源于自己的思考。可能有些问题网上有、可能有些问题对应的答案也有、也可能有些各位网友也都看过，但是本文写作的重心就是所有的问题都会按照自己的理解回答一遍，不会去看网上的答案，因此可能有些问题讲的不对，能指正的希望大家不吝指教。 除此之外我还整理了一份大厂高频面试真题，共1000余题，希望对准备春招的同学有所帮助 1、多线程有什么用？ 一个可能在很多人看来很扯淡的一个问...
C++多线程与网络数据库笔试题集锦
标签指出了这些题目的主题是C++编程相关的笔试题目，因此，题目内容将聚焦于C++的语言特性、标准模板库（STL）的应用、面向对象编程原则以及C++在特定领域（如多线程、网络、数据库）的编程实践。 ### 文件内容...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大道之简

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值