京东二面:线程池中的线程抛出了异常,该如何处理?大部分人都会答错!

京东数据开发笔试复盘:SQL、数仓与大数据框架全解析 数据仓库是企业数据流转的中枢,而SQL则是数据开发工程师最核心的生产力工具。从基础的表关联、聚合统计,到窗口函数、连续问题处理,再到分布式计算框架Hive的原理与适用场景,每一个环节都直接决定了数据任务的准确性、性能与可维护性。在实际的离线批处理和实时数仓场景中,掌握这些技术不仅能提升个人产出效率,更是应对大厂笔试和工程实践的基石。本文以京东校招数据开发真题为切入点,系统拆解高频考点,包括SQL易错点、数仓维度建模、拉链表设计、数据倾斜治理以及海量数据TopK解法,帮助读者建立从理论到实战的完整认知框架,真 阅读详情

👉 这是一个或许对你有用的社群

🐱 一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料: 

c30b32ea95e05df56dd140fb5bd5ea3c.gif

👉这是一个或许对你有用的开源项目

国产 Star 破 10w+ 的开源项目,前端包括管理后台 + 微信小程序,后端支持单体和微服务架构。

功能涵盖 RBAC 权限、SaaS 多租户、数据权限、商城、支付、工作流、大屏报表、微信公众号、CRM 等等功能:

  • Boot 仓库:https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • Cloud 仓库:https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程:https://doc.iocoder.cn

【国内首批】支持 JDK 21 + SpringBoot 3.2.2、JDK 8 + Spring Boot 2.7.18 双版本 

来源:blog.youkuaiyun.com/qq_45076180
/article/details/114552567

2769164062b82e819536eccd9b603956.jpeg


1. 模拟线程池抛异常

在实际开发中,我们常常会用到线程池,但任务一旦提交到线程池之后,如果发生异常之后,怎么处理? 怎么获取到异常信息?在了解这个问题之前,可以先看一下 线程池的源码解析,从链接中我们知道了线程池的提交方式:submit和execute的区别,接下来分别使用他们执行带有异常的任务!看结果是怎么样的!

我们先用伪代码模拟一下线程池抛异常的场景:

public class ThreadPoolException {
    public static void main(String[] args) {

        //创建一个线程池
        ExecutorService executorService= Executors.newFixedThreadPool(1);

        //当线程池抛出异常后 submit无提示,其他线程继续执行
        executorService.submit(new task());

        //当线程池抛出异常后 execute抛出异常,其他线程继续执行新任务
        executorService.execute(new task());
    }
}

//任务类
class task implements  Runnable{

    @Override
    public void run() {
        System.out.println("进入了task方法!!!");
        int i=1/0;

    }
}

运行结果:

383bdf3e4de49e21bc6d38e4d0e3d0eb.png

可以看到:submit不打印异常信息,而execute则会打印异常信息!,submit的方式不打印异常信息,显然在生产中,是不可行的,因为我们无法保证线程中的任务永不异常,而如果使用submit的方式出现了异常,直接如上写法,我们将无法获取到异常信息,做出对应的判断和处理,所以下一步需要知道如何获取线程池抛出的异常!

submit()想要获取异常信息就必须使用get()方法!!

//当线程池抛出异常后 submit无提示,其他线程继续执行
Future<?> submit = executorService.submit(new task());
submit.get();

submit打印异常信息如下:

dac6adc7b851bc3c3543a88f42c0efdc.png

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

2. 如何获取和处理异常

方案一:使用 try -catch
public class ThreadPoolException {
    public static void main(String[] args) {
        
        //创建一个线程池
        ExecutorService executorService = Executors.newFixedThreadPool(1);

        //当线程池抛出异常后 submit无提示,其他线程继续执行
        executorService.submit(new task());

        //当线程池抛出异常后 execute抛出异常,其他线程继续执行新任务
        executorService.execute(new task());
    }
}
// 任务类
class task implements Runnable {
    @Override
    public void run() {
        try {
            System.out.println("进入了task方法!!!");
            int i = 1 / 0;
        } catch (Exception e) {
            System.out.println("使用了try -catch 捕获异常" + e);
        }
    }
}

打印结果:

2a7eab38b4586b236bb4ac269d0f5a16.png

可以看到 submit 和 execute都清晰易懂的捕获到了异常,可以知道我们的任务出现了问题,而不是消失的无影无踪。

方案二:使用Thread.setDefaultUncaughtExceptionHandler方法捕获异常

方案一中,每一个任务都要加一个try-catch 实在是太麻烦了,而且代码也不好看,那么这样想的话,可以用Thread.setDefaultUncaughtExceptionHandler方法捕获异常

a21856d576ba2a47605903d16e15ec73.png

UncaughtExceptionHandler 是Thread类一个内部类,也是一个函数式接口。

内部的uncaughtException是一个处理线程内发生的异常的方法,参数为线程对象t和异常对象e。

cc6ba16056734fbef6b5b53b039b1dc8.png

应用在线程池中如下所示:重写它的线程工厂方法,在线程工厂创建线程的时候,都赋予UncaughtExceptionHandler处理器对象。

public class ThreadPoolException {
    public static void main(String[] args) throws InterruptedException {


        //1.实现一个自己的线程池工厂
        ThreadFactory factory = (Runnable r) -> {
            //创建一个线程
            Thread t = new Thread(r);
            //给创建的线程设置UncaughtExceptionHandler对象 里面实现异常的默认逻辑
            t.setDefaultUncaughtExceptionHandler((Thread thread1, Throwable e) -> {
                System.out.println("线程工厂设置的exceptionHandler" + e.getMessage());
            });
            return t;
        };

        //2.创建一个自己定义的线程池,使用自己定义的线程工厂
        ExecutorService executorService = new ThreadPoolExecutor(
                1,
                1,
                0,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue(10),
                factory);

        // submit无提示
        executorService.submit(new task());

        Thread.sleep(1000);
        System.out.println("==================为检验打印结果,1秒后执行execute方法");

        // execute 方法被线程工厂factory 的UncaughtExceptionHandler捕捉到异常
        executorService.execute(new task());


    }


}

class task implements Runnable {
    @Override
    public void run() {
        System.out.println("进入了task方法!!!");
        int i = 1 / 0;
    }
}

打印结果如下:

3d1d907b4f1a31b37f38846c6f51de94.png

根据打印结果我们看到,execute方法被线程工厂factory中设置的 UncaughtExceptionHandler捕捉到异常,而submit方法却没有任何反应!说明UncaughtExceptionHandler在submit中并没有被调用。这是为什么呢?

在日常使用中,我们知道,execute和submit最大的区别就是execute没有返回值,submit有返回值。submit返回的是一个future ,可以通过这个future取到线程执行的结果或者异常信息。

Future<?> submit = executorService.submit(new task());
//打印异常结果
  System.out.println(submit.get());
598ba90c156bceb421c5ad40ed4fab87.png

从结果看出:submit并不是丢失了异常,使用future.get()还是有异常打印的!!那为什么线程工厂factory 的UncaughtExceptionHandler没有打印异常呢?猜测是submit方法内部已经捕获了异常, 只是没有打印出来,也因为异常已经被捕获,因此jvm也就不会去调用Thread的UncaughtExceptionHandler去处理异常。

接下来,验证猜想:

首先看一下submit和execute的源码:

execute方法的源码在这博客中写的很详细,点击查看execute源码,在此就不再啰嗦了

https://blog.youkuaiyun.com/qq_45076180/article/details/108316340

submit源码在底层还是调用的execute方法,只不过多一层Future封装,并返回了这个Future,这也解释了为什么submit会有返回值

//submit()方法
 public <T> Future<T> submit(Callable<T> task) {
     if (task == null) throw new NullPointerException();
     
     //execute内部执行这个对象内部的逻辑,然后将结果或者异常 set到这个ftask里面
     RunnableFuture<T> ftask = newTaskFor(task); 
     // 执行execute方法
     execute(ftask); 
     //返回这个ftask
     return ftask;
 }

可以看到submit也是调用的execute,在execute方法中,我们的任务被提交到了addWorker(command, true) ,然后为每一个任务创建一个Worker去处理这个线程,这个Worker也是一个线程,执行任务时调用的就是Worker的run方法!run方法内部又调用了runworker方法!如下所示:

public void run() {
        runWorker(this);
 }
     
final void runWorker(Worker w) {
     Thread wt = Thread.currentThread();
     Runnable task = w.firstTask;
     w.firstTask = null;
     w.unlock(); // allow interrupts
     boolean completedAbruptly = true;
     try {
      //这里就是线程可以重用的原因,循环+条件判断,不断从队列中取任务        
      //还有一个问题就是非核心线程的超时删除是怎么解决的
      //主要就是getTask方法()见下文③
         while (task != null || (task = getTask()) != null) {
             w.lock();
             if ((runStateAtLeast(ctl.get(), STOP) ||
                  (Thread.interrupted() &&
                   runStateAtLeast(ctl.get(), STOP))) &&
                 !wt.isInterrupted())
                 wt.interrupt();
             try {
                 beforeExecute(wt, task);
                 Throwable thrown = null;
                 try {
                  //执行线程
                     task.run();
                     //异常处理
                 } catch (RuntimeException x) {
                     thrown = x; throw x;
                 } catch (Error x) {
                     thrown = x; throw x;
                 } catch (Throwable x) {
                     thrown = x; throw new Error(x);
                 } finally {
                  //execute的方式可以重写此方法处理异常
                     afterExecute(task, thrown);
                 }
             } finally {
                 task = null;
                 w.completedTasks++;
                 w.unlock();
             }
         }
         //出现异常时completedAbruptly不会被修改为false
         completedAbruptly = false;
     } finally {
      //如果如果completedAbruptly值为true,则出现异常,则添加新的Worker处理后边的线程
         processWorkerExit(w, completedAbruptly);
     }
 }

核心就在 task.run(); 这个方法里面了, 期间如果发生异常会被抛出。

  • 如果用execute提交的任务,会被封装成了一个runable任务,然后进去 再被封装成一个worker,最后在worker的run方法里面调用runWoker方法, runWoker方法里面执行任务任务,如果任务出现异常,用try-catch捕获异常往外面抛,我们在最外层使用try-catch捕获到了 runWoker方法中抛出的异常。因此我们在execute中看到了我们的任务的异常信息。

  • 那么为什么submit没有异常信息呢? 因为submit是将任务封装成了一个futureTask ,然后这个futureTask被封装成worker,在woker的run方法里面,最终调用的是futureTask的run方法, 猜测里面是直接吞掉了异常,并没有抛出异常,因此在worker的runWorker方法里面无法捕获到异常。

下面来看一下futureTask的run方法,果不其然,在try-catch中吞掉了异常,将异常放到了 setException(ex);里面

public void run() {
     if (state != NEW ||
         !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                      null, Thread.currentThread()))
         return;
     try {
         Callable<V> c = callable;
         if (c != null && state == NEW) {
             V result;
             boolean ran;
             try {
                 result = c.call();
                 ran = true;
             } catch (Throwable ex) {
                 result = null;
                 ran = false;
                 //在此方法中设置了异常信息
                 setException(ex);
             }
             if (ran)
                 set(result);
         }
         //省略下文
 。。。。。。
setException(ex)`方法如下:将异常对象赋予`outcome
protected void setException(Throwable t) {
       if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        //将异常对象赋予outcome,记住这个outcome,
           outcome = t;
           UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
           finishCompletion();
       }
   }

将异常对象赋予outcome有什么用呢?这个outcome是什么呢?当我们使用submit返回Future对象,并使用Future.get()时, 会调用内部的report方法!

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    //注意这个方法
    return report(s);
}

reoport里面实际上返回的是outcome ,刚好之前的异常就set到了这个outcome里面

private V report(int s) throws ExecutionException {
 //设置`outcome`
    Object x = outcome;
    if (s == NORMAL)
     //返回`outcome`
        return (V)x;
    if (s >= CANCELLED)
        throw new CancellationException();
    throw new ExecutionException((Throwable)x);
}

因此,在用submit提交的时候,runable对象被封装成了future ,future 里面的 run方法在处理异常时, try-catch了所有的异常,通过setException(ex);方法设置到了变量outcome里面, 可以通过future.get获取到outcome。

所以在submit提交的时候,里面发生了异常, 是不会有任何抛出信息的。而通过future.get()可以获取到submit抛出的异常!在submit里面,除了从返回结果里面取到异常之外, 没有其他方法。因此,在不需要返回结果的情况下,最好用execute ,这样就算没有写try-catch,疏漏了异常捕捉,也不至于丢掉异常信息。

方案三:重写afterExecute进行异常处理

通过上述源码分析,在excute的方法里面,可以通过重写afterExecute进行异常处理,但是注意! 这个也只适用于excute提交(submit的方式比较麻烦,下面说),因为submit的task.run里面把异常吞了,根本不会跑出来异常,因此也不会有异常进入到afterExecute里面。

在runWorker里面,调用task.run之后,会调用线程池的 afterExecute(task, thrown) 方法

final void runWorker(Worker w) {
//当前线程
        Thread wt = Thread.currentThread();
        //我们的提交的任务
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                    //直接就调用了task的run方法 
                        task.run(); //如果是futuretask的run,里面是吞掉了异常,不会有异常抛出,
                       // 因此Throwable thrown = null;  也不会进入到catch里面
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                    //调用线程池的afterExecute方法 传入了task和异常
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

重写afterExecute处理execute提交的异常

public class ThreadPoolException3 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {


        //1.创建一个自己定义的线程池
        ExecutorService executorService = new ThreadPoolExecutor(
                2,
                3,
                0,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue(10)
        ) {
            //重写afterExecute方法
            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                System.out.println("afterExecute里面获取到异常信息,处理异常" + t.getMessage());
            }
        };
        
        //当线程池抛出异常后 execute
        executorService.execute(new task());
    }
}

class task3 implements Runnable {
    @Override
    public void run() {
        System.out.println("进入了task方法!!!");
        int i = 1 / 0;
    }
}

执行结果:我们可以在afterExecute方法内部对异常进行处理

14faec9a953cc0a5eceab3856e7fe62f.png

如果要用这个afterExecute处理submit提交的异常, 要额外处理。判断Throwable是否是FutureTask,如果是代表是submit提交的异常,代码如下:

public class ThreadPoolException3 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {


        //1.创建一个自己定义的线程池
        ExecutorService executorService = new ThreadPoolExecutor(
                2,
                3,
                0,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue(10)
        ) {
            //重写afterExecute方法
            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                //这个是excute提交的时候
                if (t != null) {
                    System.out.println("afterExecute里面获取到excute提交的异常信息,处理异常" + t.getMessage());
                }
                //如果r的实际类型是FutureTask 那么是submit提交的,所以可以在里面get到异常
                if (r instanceof FutureTask) {
                    try {
                        Future<?> future = (Future<?>) r;
                        //get获取异常
                        future.get();

                    } catch (Exception e) {
                        System.out.println("afterExecute里面获取到submit提交的异常信息,处理异常" + e);
                    }
                }
            }
        };
        //当线程池抛出异常后 execute
        executorService.execute(new task());
        
        //当线程池抛出异常后 submit
        executorService.submit(new task());
    }
}

class task3 implements Runnable {
    @Override
    public void run() {
        System.out.println("进入了task方法!!!");
        int i = 1 / 0;
    }
}

处理结果如下:

1b09c5d4d41f40d1e4547ff7336d99fb.png

可以看到使用重写afterExecute这种方式,既可以处理execute抛出的异常,也可以处理submit抛出的异常


欢迎加入我的知识星球,全面提升技术能力。

👉 加入方式,“长按”或“扫描”下方二维码噢:

ae7556fa0d596e835dbf1356f27f6476.png

星球的内容包括:项目实战、面试招聘、源码解析、学习路线。

62ea012c54f7cd43a038a58870fb2a69.png

10aa091467d0c47e4d70a7bfc19c58c2.png5c26b27ede76a67078c3f0a5ca5a3a11.pngd0e1ce42c79640ed2f59ed7ff8eca540.pngc4fd778d7223c17344f3e55afc3e83d3.png

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
frontend-design skills 立即下载

相关推荐

政府科技管理者在推动区域科技成果转化过程中,如何解决成果供需匹配效率低的问题?.docx

政府科技管理者在推动区域科技成果转化过程中,如何解决成果供需匹配效率低的问题?

从3s到25ms!看看人家的接口优化技巧,确实很优雅!!

上一篇:京东二面:线程池中的线程抛出了异常,该如何处理?大部分人都会答错!大家好,最近看到京东云的一位大佬分享的接口优化方案,感觉挺不错的,拿来即用。建议收藏一波或者整理到自己的笔记本中,随时查阅!下面是正文。一、背景针对老项目,去年做了许多降本增效的事情,其中发现最多的就是接口耗时过长的问题,就集中搞了一次接口性能优化。本文将给小伙伴们分享一下接口优化的通用方案。二、接口优化方案总结1.批处理批...

Java和Android架构 94

用于计算系统状态的卡尔曼最优增益和最小均方误差(MMSE)估计研究(Matlab代码实现)

内容概要:本文围绕用于计算系统状态的卡尔曼最优增益和最小均方误差(MMSE)估计展开研究,深入探讨了卡尔曼滤波在动态系统状态估计中的核心作用。文章系统阐述了卡尔曼滤波的数学基础,包括状态空间模型的建立、先验与后验状态估计、协方差矩阵的递推更新,以及最优增益矩阵的推导过程,确保在高斯白噪声环境下实现对系统状态的最小均方误差估计。结合Matlab代码实现,完整展示了算法从理论建模到仿真实验的全流程,涵盖系统建模、噪声设置、滤波迭代、状态更新与误差分析等环节,并通过仿真实验验证了算法在噪声干扰下对系统真实状态的高精度跟踪能力。该研究为控制工程、导航系统、信号处理及自动化领域中的状态估计问题提供了坚实的理论依据与高效的数值实现方案。; 适合人群:具备一定控制理论、概率统计基础和Matlab编程能力,从事自动化、电子信息、航空航天、机器人、导航定位等相关领域的科研人员、工程技术人员及高校研究生。; 使用场景及目标:①掌握卡尔曼滤波的基本原理及其在状态估计中的数学推导过程;②学习如何利用Matlab实现卡尔曼滤波算法并进行系统仿真与性能评估;③应用于目标跟踪、传感器融合、惯性导航、故障诊断、时间序列预测等实际工程中的动态状态估计问题。; 阅读建议:建议读者结合文中提供的Matlab代码进行动手实践,通过调整系统模型参数、过程噪声与观测噪声强度,观察滤波效果的变化,深入理解卡尔曼增益的自适应调节机制与MMSE估计的收敛特性。同时可进一步拓展学习扩展卡尔曼滤波(EKF)、无迹卡尔曼滤波(UKF)等非线性滤波方法,以应对更复杂的非线性系统状态估计挑战。

公司新来了个架构师:我的代码不需要做注释,所谓的注释,都是给垃圾代码用的!...

往期热门文章:1、微服务的血与泪,从拆分到合并2、SpringBoot 插件化开发模式,强烈推荐!3、京东二面:线程池中的线程抛出了异常,该如何处理?大部分人都会答错!4、利用 Function 接口告别冗余(屎山)代码5、搭建静态网站竟然有这么多方案,而且还如此简单部门新来了个架构师,BAT背景,住在三环,开宝马上班,有车位。小伙话不多,但一旦说话斩钉截铁,带着无法撼动的自信。原因就是,有他着数...

Java后端技术 179

高校技术转移办公室人员如何提升成果转化服务效率?.docx

科易网基于行业知识库+行业大数据+科技资源要素+AI模型,以AI,赋能技术转移、成果转化、技术经理人培训、知识产权管理、区域产业分析与布局、地方科技招商、创新创业大赛等场景,推出科技创新领域的AI工具、场景化服务和数智化解决方案,推动科技创新与产业创新智能化发展。

国央企创新负责人如何利用平台实现技术需求的精准挖掘与匹配?.docx

科易网基于行业知识库+行业大数据+科技资源要素+AI模型,以AI,赋能技术转移、成果转化、技术经理人培训、知识产权管理、区域产业分析与布局、地方科技招商、创新创业大赛等场景,推出科技创新领域的AI工具、场景化服务和数智化解决方案,推动科技创新与产业创新智能化发展。

程序员缺乏经验的 7 种表现!

往期热门文章:1、公司新来了个架构师:我的代码不需要做注释,所谓的注释,都是给垃圾代码用的!2、微服务的血与泪,从拆分到合并3、SpringBoot 插件化开发模式,强烈推荐!4、京东二面:线程池中的线程抛出了异常,该如何处理?大部分人都会答错!5、利用 Function 接口告别冗余(屎山)代码知道这些表现,才能在自己的程序员职业生涯中犯相同的错误。软件行业的工作经验和你从事这个行业的工作年限直...

Java后端技术 176

从ADRV9002到ADRV9003:手把手教你移植FPGA驱动,避开那些官方没说的坑

本文详细介绍了从ADRV9002到ADRV9003的FPGA驱动移植实战指南,重点解析了两者在硬件架构上的关键差异,如通道配置和DPD功能的移除。通过提供完整的移植步骤、调试技巧和性能优化建议,帮助工程师避开官方文档未提及的常见陷阱,实现高效驱动开发。

weixin_28738397的博客 177

SpringBoot 插件化开发模式,强烈推荐!

往期热门文章:1、京东二面:线程池中的线程抛出了异常,该如何处理?大部分人都会答错!2、利用 Function 接口告别冗余(屎山)代码3、搭建静态网站竟然有这么多方案,而且还如此简单4、公司新来一个同事,写了一个责任链模式,bug 无数...5、什么样的老程序员,写出这么低级的 bug!5、大厂也在用的分布式链路追踪:TraceIdFilter + MDC + Skywalking来源:http...

Java后端技术 178

Halcon工业相机开发全流程:从SDK配置到实时图像采集(C++版)

本文详细介绍了使用C++进行Halcon工业相机开发的完整流程,从SDK配置到实时图像采集的实现。涵盖环境搭建、设备初始化、回调机制、参数控制等关键环节,并提供异常处理和实战案例,帮助开发者快速掌握工业视觉系统的开发技巧。

weixin_33728268的博客 515

以太网MII、RMII、GMII、RGMII(三)

RMII接口收发的数据位宽为2bit,因此管脚数目大为减少,在高密端口PHY中应用较多,但是由于其是MAC和PHY共用一个参考时钟,接口之间的距离不能太远;一般的GMII接口都有两个发送参考时钟:TX_CLK和GTX_CLK,两者的方向是不一样的,前者有PHY提供(同MII),后者由MAC或外部参考时钟源提供,绝大多数GMII接口都是兼容MII接口的,在用作MII模式时,使用TX_CLK和8根数据线中的4根。MII接口中的接收时钟和发送时钟是分开的,而且都是由PHY芯片提供给MAC芯片的。

qq_42357877的博客 2338

京东2019校招数据开发笔试题拆解:SQL、数仓与算法核心考点

数据开发岗位的笔试考察,向来不是单纯刷题就能应对的,它需要候选人具备扎实的大数据基础功底与工程化思维。从SQL窗口函数应用到数据仓库分层设计,从Hive调优到数据倾斜场景的定位与解决,这些高频考点共同勾勒出企业真实的数据处理能力要求。尤其在电商海量数据背景下,熟练运用窗口函数完成连续登录统计、TopN查询、行列转换,理解ODS到ADS的逐层加工链路,并能在算法题中展现清晰的逻辑与代码规范,是获得大厂青睐的关键。本文从这些基础概念出发,系统拆解了京东2019校招数据开发工程师笔试题的考察逻辑与答题策略,帮助你

weixin_33843947的博客 546

基于STM32F103C8T6的智能蓝牙手环系统设计与实现

摘要:本文设计并实现了一款基于STM32F103C8T6单片机的智能蓝牙手环系统。该系统集成了ADXL345加速度计、DS18B20温度传感器、plusesennor心率模块和BT06蓝牙模块,实现了心率(±2bpm)、体温(±0.5℃)、步数(±3%)等健康数据的实时监测与显示。通过OLED屏提供人机交互界面,支持蓝牙APP远程控制,具备自动步数清零、异常提醒等功能。测试表明系统各项功能均达到设计要求,响应时间0.1-0.5秒,心率检测准确率98%,体温检测准确率99%,功耗50mA(工作)/10mA(待

3254968421的博客 208

程序员如何设计logo,如何找Icon和插画(绝对干货)

往期热门文章:1、程序员缺乏经验的 7 种表现!2、公司新来了个架构师:我的代码不需要做注释,所谓的注释,都是给垃圾代码用的!3、微服务的血与泪,从拆分到合并4、SpringBoot 插件化开发模式,强烈推荐!5、京东二面:线程池中的线程抛出了异常,该如何处理?大部分人都会答错!今天给大家带来点儿干货,真真儿的干货。作为一个程序员,不管你是平时要自己做博客网站、写文章,还是独立开发一些产品,基本上...

Java后端技术 309

「深度学习之优化算法」笔记(二)优化算法的分类

但是由于生物的局限性,人们所创造出的算法也会有局限性:我们所熟知的生物都生存在三维空间,在这些环境中,影响生物生存的条件比较有限,反应到算法中就是这些算法在解决较低维度的问题时效果很好,当遇到超高维(维度>500)问题时,结果可能不容乐观,没做过实验,我也不敢乱说。当然,他们的目的不是在最佳狩猎位置集合,他们的目的是在过去的途中看是否能发现更加好的狩猎位置,去往已经到过的狩猎地点再次狩猎是没有意义的,因为每个位置获取食物的难易程度是固定的。如果他们的策略是“不跟随最优解”,那么他们的策略是什么呢?

quanzhan_King的博客 1375

Microsemi Libero系列教程(四)——PLL的使用

文章目录PLL是什么Libero中PLL的使用官方文档 系列教程:Microsemi Libero系列教程 PLL是什么 PLL(Phase Locked Loop): 为锁相回路或锁相环,用来统一整合时钟信号,使高频器件正常工作,如内存的存取资料等。PLL用于振荡器中的反馈技术。 许多电子设备要正常工作,通常需要外部的输入信号与内部的振荡信号同步。一般的晶振由于工艺与成本原因,做不到很高的频率...

whik1194的博客 7217

微服务的血与泪,从拆分到合并

往期热门文章:1、SpringBoot 插件化开发模式,强烈推荐!2、京东二面:线程池中的线程抛出了异常,该如何处理?大部分人都会答错!3、利用 Function 接口告别冗余(屎山)代码4、搭建静态网站竟然有这么多方案,而且还如此简单5、公司新来一个同事,写了一个责任链模式,bug 无数...来源:juejin.cn/post/7442153919055364136背景微服务这几年越来越火,大家...

Java后端技术 160

【Halcon-2D测量】add_metrology_object_rectangle2_measure 函数功能(用于向2D计量模型中添加旋转矩形(rectangle2类型)计量对象)

HALCON算子add_metrology_object_rectangle2_measure解析摘要 该算子是HALCON 2D计量模块的核心算子,用于添加旋转矩形计量对象并配置测量参数。主要功能包括:定义旋转矩形几何轮廓(中心坐标、主轴角度、长短半长);生成垂直于矩形边界的测量区域;设置边缘提取预处理参数(高斯平滑、振幅阈值)。关键注意事项:MeasureLength1必须小于矩形长短半长;角度参数Phi需使用弧度单位;多线程需同步模型句柄。该算子适用于方形螺母、PCB板边框等矩形零件的精密测量,需与a

weixin_45590420的博客 1226
上一篇: 微服务架构拆分的 7 大黄金法则
下一篇: 2025,Java开发已经炸了吗?
公众号-芋道源码
博客等级 码龄10年 1640粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值