面试官:你知道几种获取当前方法名称的方法?

面试官:说说Linux下查看当前登录用户信息的所有方法 点赞关注,不会迷路! 背景 作为系统管理员,你可能经常会(在某个时候)需要查看系统中有哪些用户正在活动。有些时候,你甚至需要知道他(她)们正在做什么。本文总结了4种查看系统用户信息(通过编号(ID))的方法。 正文 1. 使用w命令查看登录用户正在使用的进程信息 w命令用于显示已经登录系统的用户的名称,以及他们正在做的事。该命令所使用的信息来源于/var/run/utmp文件。w命令输出的信息包括: 用户名称 用户的机器名称或tty号 远程主机地址 用户登录系统的时间 空闲... 阅读详情
AI摘要

本文介绍了Java中获取当前正在执行方法体的方法名称的四种方法,包括Thread.currentThread().getStackTrace()、异常对象的getStackTrace()、匿名内部类的getClass().getEnclosingMethod()和Java 9的Stack - Walking API。还分析了Logback日志框架获取方法名的原理,并通过JMH工具对四种方法进行性能测试。

给大家分享一篇关于在 Java 中获取当前正在执行方法体的方法名称的文章,文章中介绍了四种不同的方法。

你看看你能知道几个。

在 Java 中,有四种方法可以获取当前正在执行方法体的方法名称,分别是:

方法一:使用 Thread.currentThread().getStackTrace() 方法

方法二:使用异常对象的 getStackTrace() 方法

方法三:使用匿名内部类的 getClass().getEnclosingMethod() 方法

方法四:Java 9 的 Stack-Walking API

本文将根据以上四种方法来给大家进行具体讲解,不过不知道大家有没有想过,获取当前执行方法体的方法名称有什么用嘞?

它可以用于日志记录、异常处理、测试框架等方面。

例如我们可以在方法的开始和结束时打印出当前方法名和参数,以便追踪程序的执行流程和性能。

方法一

使用 Thread.currentThread().getStackTrace() 方法

这种方法是通过获取当前线程的堆栈跟踪信息,然后从中提取出当前方法名的。

具体的代码如下:

// 获取当前方法名
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
// 打印当前方法名
System.out.println("当前方法名:" + methodName)

这种方法的优点是简单易用,不需要创建额外的对象。

缺点是性能较低,因为 Thread.currentThread().getStackTrace() 方法获取堆栈跟踪信息需要遍历整个调用栈,而且需要保证线程安全性。

方法二

使用异常对象的 getStackTrace()方法

这种方法是通过创建一个新的异常对象,然后从其堆栈跟踪信息中提取出当前方法名和参数的。

具体的代码如下:

// 获取当前方法名
String methodName = new Exception().getStackTrace()[0].getMethodName();
// 打印当前方法名
System.out.println("当前方法名:" + methodName);

这种方法仍然需要获取堆栈跟踪信息,而且需要创建异常对象。

缺点是需要创建额外的对象,而且代码较为复杂,不太直观。

方法三

匿名内部类的 getClass().getEnclosingMethod()方法

这种方法是通过创建一个匿名内部类的对象,然后从其类对象中获取当前方法的方法对象,再从方法对象中获取当前方法名和参数的。

具体的代码如下:

// 获取当前方法名
String methodName = new Object(){}.getClass().getEnclosingMethod().getName();
// 打印当前方法名
System.out.println("当前方法名:" + methodName);

这种方法的优点是不需要获取堆栈跟踪信息,而且不会创建异常对象,因此性能和可读性都较好。

缺点是需要创建额外的对象,而且代码较为复杂,不太直观。

方法四

Java 9 的 Stack-Walking API

Java 9 引入了 Stack-Walking API,以惰性且高效的方式遍历 JVM 堆栈帧。

可以使用这个 API 找到当前正在执行的方法,具体的代码如下:

StackWalker walker = StackWalker.getInstance();
Optional<String> optional = walker.walk(frames -> frames
        .findFirst()
        .map(StackWalker.StackFrame::getMethodName));
System.out.println("当前方法名:" + optional.get());

首先,我们使用 StackWalker.getInstance() 工厂方法获取 StackWalker 实例。

然后我们使用 walk() 方法从上到下遍历栈帧:

  • walk() 方法可以将堆栈帧转化为 Stream流

  • findFirst() 方法从 Stream 流中的获取第一个元素,也就是堆栈的顶部帧,顶部帧就代表当前正在执行的方法

  • map() 方法用于获取顶部帧 StackFrame 的当前方法名称

与以上方法相比,Stack-Walking API 有很多优点:

  • 线程安全

  • 无需创建匿名内部类实例 - new Object().getClass(){}

  • 无需创建异常 - new Throwable()

  • 无需急切地捕获整个堆栈跟踪,这可能成本很高 - Thread.currentThread()

  • StackWalker 是以一种懒惰的方式逐一遍历堆栈。在需要获取当前方法名称时,我们可以只获取顶部帧,而不需要捕获整个堆栈跟踪。

面试题:Logback

Logback 是一个流行的 Java 日志框架,它是 Log4j 的继承者,由 Log4j 的创始人设计。

Logback 有以下特点:

  • 高性能:Logback 比其他日志框架更快,更节省空间,有时甚至大得多。

  • 灵活配置:Logback 支持 XML 和 Groovy 两种配置方式,可以实现动态修改配置,无需重启应用。

  • 丰富功能:Logback 提供了多种输出目标,如控制台、文件、数据库、邮件等,还支持滚动策略、过滤器、异步日志等高级功能。

  • 与 SLF4J 集成:Logback 是 SLF4J 的原生实现,可以与其他基于 SLF4J 的日志框架无缝切换。

不知道大家有没有想过,我们在使用 Logback 日志框架中打印日志时,是如何获取当前执行方法体的方法名称的嘞?

在 Spring 项目中,我们一般是通过 Logback 的 xml 文件 parttern 属性来配置日志格式的。

xml 配置如下:

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <springProperty scope="context" name="appName" source="spring.application.name" defaultValue="dev"/>
    <property name="logPath" value="/home/logs/${appName}"/>
    <property name="pattern"
              value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%X{request_id}] [%thread] [%-5level] %logger{36}:%L %M - %msg%n"/>

    <!-- 控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <!-- encoder 默认配置为PatternLayoutEncoder -->
        <encoder>
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>
    <!-- 记录日志到文件 -->
    <appender name="INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${logPath}/info.log</file>
        <encoder>
            <pattern>${pattern}</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${logPath}/run.%d{yyyy-MM-dd}.log</fileNamePattern>
        </rollingPolicy>
    </appender>
    ...
</configuration>

可以看到我们配置的日志输出格式是

%d{yyyy-MM-dd HH:mm:ss.SSS} [%X{request_id}] [%thread] [%-5level] %logger{36}:%L %M - %msg%n

Logback 在打印日志时,会解析这个日志输出格式,最后将 %M 占位符替换为当前方法名称。

解析日志格式的源码就在 FormattingConverter 类的 write() 方法中,write() 方法中会执行 convert() 方法,这个方法就是执行占位符替换的。

源码截图如下:

图片

如上图根据类名我们可以看到红线框起来的 MethodOfCallerConverter 类就是用来执行 %M 占位符替换逻辑的,源码如下,

public class MethodOfCallerConverter extends ClassicConverter {
    public String convert(ILoggingEvent le) {
        StackTraceElement[] cda = le.getCallerData();
        if (cda != null && cda.length > 0) {
            // 返回当前方法名称
            return cda[0].getMethodName();
        } else {
            return CoreConstants.NA;
        }
    }
}

方法逻辑如下,

  • StackTraceElement[] cda = le.getCallerData() 获取当前堆栈顶部帧

  • cda[0].getMethodName() 根据顶部帧获取当前方法名称。

如上我们只需要看下 le.getCallerData() 方法的堆栈是从哪里获取来的,就能知道答案了。

进入 LoggingEvent 源码类中,我们可以发现堆栈获取逻辑,源码如下:

public class LoggingEvent implements ILoggingEvent {
    public StackTraceElement[] getCallerData() {
        if (callerDataArray == null) {
            // 堆栈初始化
            callerDataArray = CallerData.extract(new Throwable(), fqnOfLoggerClass,
                    loggerContext.getMaxCallerDataDepth(), loggerContext.getFrameworkPackages());
        }
        return callerDataArray;
    }
    ...
}

通过分析源码,我们可以知道,如果当前堆栈为空,进行堆栈信息初始化。

这里就可以看到堆栈信息初始化来自 extract 方法:

CallerData.extract(new Throwable(), fqnOfLoggerClass,loggerContext.getMaxCallerDataDepth(), loggerContext.getFrameworkPackages())

如果堆栈信息不为空,直接返回当前堆栈。这里是为了避免浪费,针对在一个方法中重复获取堆栈信息的情况。

Ok,到这里离胜利就只差一步了。

进一步查看 CallerData.extract(...) 方法,源码如下:

public class CallerData {
    public static StackTraceElement[] extract(Throwable t, String fqnOfInvokingClass, final int maxDepth,
            List<String> frameworkPackageList) {
        if (t == null) {
            return null;
        }

        StackTraceElement[] steArray = t.getStackTrace();
        StackTraceElement[] callerDataArray;
        ...
        callerDataArray = new StackTraceElement[desiredDepth];
        for (int i = 0; i < desiredDepth; i++) {
            callerDataArray[i] = steArray[found + i];
        }
        return callerDataArray;
    }
    ...
}

为了突出源码逻辑的重点,这里我删去了一部分代码,是为了让大家更好的看清楚 Logback 中堆栈信息的初始化,其实用的就是异常对象的 getStackTrace() 方法。

也就是上面源码中 StackTraceElement[] steArray = t.getStackTrace() 方法所体现的。

那么到这里我就可以下一个结论了:Logback 日志框架中打印日志时,就是使用异常对象的 getStackTrace() 方法来获取当前执行方法的方法名称的。

JMH,跑一把

到这里我们介绍了四种方法获取当前执行方法名称,一般情况下大家使用异常对象的 getStackTrace() 方法以及匿名内部类的 getClass().getEnclosingMethod() 方法都是可以的,它们的性能都 OK,代码书写复杂程度都大差不差。

在 Java 9 以后推荐使用 Stack-Walking API,它的功能更为强大,与程序里的堆栈语意也跟为契合,性能 OK,并且还是线程安全的。

那么它们的性能表现到底如何呢?

我们可以通过使用专业基准测试工具 JMH 来对如上四种方案进行测试。

测试环境配置如下:

  • cpu:i7-8759H,6 核 12 线程

  • 内存 16 GB(2667 MHZ)

先简单的科普一下基准测试。

基准测试,也称之为性能测试,是一种用于衡量计算机系统,软件应用或硬件组件性能的测试方法。基准测试旨在通过运行一系列标准化的任务场景来测量系统的性能表现,从而帮助评估系统的各种指标,如响应时间、吞吐量、延迟、资源利用率等。

JMH,即 Java Microbenchmark Harness,是专门用于代码微基准测试的工具套件。何谓 Micro Benchmark 呢?简单的来说就是基于方法层面的基准测试,精度可以达到微秒级。其由 Oracle/openjdk 内部开发 JIT 编译器的大佬们所开发,作为 Java 的方法级性能测试工具可以说是非常合适的。

JMH  可以通过注解和配置参数来控制测试的环境和结果,例如预热次数,迭代次数,线程数,时间单位等。它还可以生成详细的测试报告,包括最小值,平均值,最大值,标准差,置信区间等。

BeachMark:基准测试,主要用来测试一些方法的性能,可以根据不同的参数以不同的单位进行计算(可以使用平均时间作为单位,也可以使用吞吐量作为单位,可以在 BenchmarkMode 值进行调整)。

MIcro Benchmark:简单地说就是在 method 层面上的 benchmark,精度可以精确到微秒级。

OPS:Operation Per Second:每秒操作量,是衡量性能的重要指标,数值的性能越好。类似的有:TPS、QPS。

Throughput:吞吐量。

Warmup:预热,因为 JVM 的 JIT 机制的存储,如果某个函数被调用多次之后,JVM 会尝试将其编译称为机器码从而提高执行速度。为了让结果更加接近真实情况就需要进行预热。

JMH,方案一

使用 Thread.currentThread().getStackTrace() 方法

基准测试参数配置:

Warmup: 3 iterations, 10 s each
Measurement: 5 iterations, 3 s each
Timeout: 10 min per iteration
Threads: 8 threads, will synchronize iterations
Benchmark mode: Throughput

测试代码:

需要说明的是下面的四种测试方法的 JMH 注解配置以及 main 方法都是相同的。所以为了节约篇幅,突出重点,后面三种方案将省去 JMH 注解以及 main 方法配置。

@BenchmarkMode(Mode.Throughput)
@Warmup(iterations = 3)
@Measurement(iterations = 5, time = 3, timeUnit = TimeUnit.SECONDS)
@Threads(8)
@Fork(2)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class MethodNameTest {
    @Benchmark
    @BenchmarkMode({Mode.Throughput})
    public void m1() {
        // 获取当前方法名
        String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(MethodNameTest.class.getSimpleName())
                .build();

        new Runner(opt).run();
    }
}
...
# Run progress: 0.00% complete, ETA 00:06:00
# Fork: 1 of 2
# Warmup Iteration   1: 16.946 ops/ms
# Warmup Iteration   2: 17.086 ops/ms
# Warmup Iteration   3: 17.116 ops/ms
Iteration   1: 17.159 ops/ms
Iteration   2: 17.118 ops/ms
Iteration   3: 17.279 ops/ms
Iteration   4: 17.329 ops/ms
Iteration   5: 17.241 ops/ms

# Run progress: 12.50% complete, ETA 00:05:23
# Fork: 2 of 2
# Warmup Iteration   1: 16.546 ops/ms
# Warmup Iteration   2: 17.340 ops/ms
# Warmup Iteration   3: 17.431 ops/ms
Iteration   1: 17.331 ops/ms
Iteration   2: 17.099 ops/ms
Iteration   3: 17.280 ops/ms
Iteration   4: 17.511 ops/ms
Iteration   5: 17.323 ops/ms


Result "ltd.newbee.mall.MethodNameTest.m1":
  17.267 ±(99.9%) 0.184 ops/ms [Average]
  (min, avg, max) = (17.099, 17.267, 17.511), stdev = 0.122
  CI (99.9%): [17.083, 17.451] (assumes normal distribution)

上面一大堆输出信息,大家直接看重点:在最后 Result "ltd.newbee.mall.MethodNameTest.m1": 这里,平均 ops 是每毫秒 17 次,比较低。

JMH,方案二

使用异常对象的 getStackTrace() 方法

测试代码:

@Benchmark
@BenchmarkMode({Mode.Throughput})
public void m2() {
    // 获取当前方法名
    String methodName = new Throwable().getStackTrace()[0].getMethodName();
}

测试结果:

...
# Run progress: 25.00% complete, ETA 00:04:37
# Fork: 1 of 2
# Warmup Iteration   1: 12.891 ops/ms
# Warmup Iteration   2: 12.873 ops/ms
# Warmup Iteration   3: 13.023 ops/ms
Iteration   1: 25.617 ops/ms
Iteration   2: 25.840 ops/ms
Iteration   3: 25.301 ops/ms
Iteration   4: 24.839 ops/ms
Iteration   5: 25.930 ops/ms

# Run progress: 37.49% complete, ETA 00:03:51
# Fork: 2 of 2
# Warmup Iteration   1: 12.511 ops/ms
# Warmup Iteration   2: 12.329 ops/ms
# Warmup Iteration   3: 13.011 ops/ms
Iteration   1: 23.842 ops/ms
Iteration   2: 24.292 ops/ms
Iteration   3: 25.600 ops/ms
Iteration   4: 25.745 ops/ms
Iteration   5: 25.789 ops/ms


Result "ltd.newbee.mall.MethodNameTest.m2":
  25.280 ±(99.9%) 1.088 ops/ms [Average]
  (min, avg, max) = (23.842, 25.280, 25.930), stdev = 0.720
  CI (99.9%): [24.191, 26.368] (assumes normal distribution)

直接看最后 Result "ltd.newbee.mall.MethodNameTest.m2": 这里,平均 ops 是每毫秒 25 次,也比较低。

JMH,方案三

使用匿名内部类的 getClass().getEnclosingMethod() 方法

测试代码:

@Benchmark
@BenchmarkMode({Mode.Throughput})
public void m1() {
    // 获取当前方法名
    String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
}

测试结果:

...
# Run progress: 49.99% complete, ETA 00:03:04
# Fork: 1 of 2
# Warmup Iteration   1: 10489.110 ops/ms
# Warmup Iteration   2: 9233.590 ops/ms
# Warmup Iteration   3: 10504.615 ops/ms
Iteration   1: 10695.898 ops/ms
Iteration   2: 10570.155 ops/ms
Iteration   3: 11089.810 ops/ms
Iteration   4: 10805.448 ops/ms
Iteration   5: 10027.222 ops/ms

# Run progress: 62.49% complete, ETA 00:02:18
# Fork: 2 of 2
# Warmup Iteration   1: 11322.008 ops/ms
# Warmup Iteration   2: 10025.593 ops/ms
# Warmup Iteration   3: 10808.095 ops/ms
Iteration   1: 10684.594 ops/ms
Iteration   2: 11241.540 ops/ms
Iteration   3: 10742.348 ops/ms
Iteration   4: 9940.437 ops/ms
Iteration   5: 11226.023 ops/ms


Result "ltd.newbee.mall.MethodNameTest.m3":
  10702.347 ±(99.9%) 672.631 ops/ms [Average]
  (min, avg, max) = (9940.437, 10702.347, 11241.540), stdev = 444.904
  CI (99.9%): [10029.716, 11374.979] (assumes normal distribution)

直接看最后 Result "ltd.newbee.mall.MethodNameTest.m3": 这里,平均 ops 是每毫秒 10702 次。

非常夸张,可以看到 ops 对比上面两种方法一下子从几十级别提升到上万级别。

JMH,方案四

Java 9 的 Stack-Walking API

测试代码:

@Benchmark
@BenchmarkMode({Mode.Throughput})
public void m1() {
    // 获取当前方法名
    String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
}

测试结果:

...
# Run progress: 74.99% complete, ETA 00:01:32
# Fork: 1 of 2
# Warmup Iteration   1: 2191.034 ops/ms
# Warmup Iteration   2: 2141.886 ops/ms
# Warmup Iteration   3: 2192.843 ops/ms
Iteration   1: 2262.279 ops/ms
Iteration   2: 2263.193 ops/ms
Iteration   3: 2201.354 ops/ms
Iteration   4: 2282.906 ops/ms
Iteration   5: 2130.322 ops/ms

# Run progress: 87.48% complete, ETA 00:00:46
# Fork: 2 of 2
# Warmup Iteration   1: 2207.800 ops/ms
# Warmup Iteration   2: 2269.887 ops/ms
# Warmup Iteration   3: 2239.005 ops/ms
Iteration   1: 2001.840 ops/ms
Iteration   2: 2047.698 ops/ms
Iteration   3: 2349.138 ops/ms
Iteration   4: 2362.165 ops/ms
Iteration   5: 2305.982 ops/ms


Result "ltd.newbee.mall.MethodNameTest.m4":
  2220.688 ±(99.9%) 186.910 ops/ms [Average]
  (min, avg, max) = (2001.840, 2220.688, 2362.165), stdev = 123.629
  CI (99.9%): [2033.778, 2407.598] (assumes normal distribution)

直接看最后 Result "ltd.newbee.mall.MethodNameTest.m4": 这里,平均 ops 是每毫秒 2220 次。

对比 第一种和第二种方案的 几十 ops 来说性能提升也很客观,但是对比第三种方法的上万级别 ops 还是不足。

四种方案的最终得分对比

Benchmark           Mode  Cnt      Score     Error   Units
MethodNameTest.m1  thrpt   10     17.267 ±   0.184  ops/ms
MethodNameTest.m2  thrpt   10     25.280 ±   1.088  ops/ms
MethodNameTest.m3  thrpt   10  10702.347 ± 672.631  ops/ms
MethodNameTest.m4  thrpt   10   2220.688 ± 186.910  ops/ms
MethodNameTest.m1     ss   10      0.686 ±   0.289   ms/op
MethodNameTest.m2     ss   10      0.339 ±   0.287   ms/op
MethodNameTest.m3     ss   10      0.031 ±   0.011   ms/op
MethodNameTest.m4     ss   10      0.074 ±   0.027   ms/op

根据最后得分可以看出,四种方案中性能最好的方案是基于匿名内部类的 getClass().getEnclosingMethod() 方案,性能第二是的是基于 Java 9 出现的 Stack-Walking API 方案,其他两种性能过于低下了。

如何在 JavaScript 中获取当前方法名 在 JavaScript 中,如果你想要获取当前方法(函数)的名称,可以使用一些技巧和内置的函数来实现。通过这些方法,你可以轻松地获取当前方法的名称并进行相应的操作。是一个指向当前执行的函数的指针,通过它可以访问当前函数的属性和方法,其中。在 JavaScript 中,获取当前方法名的方式有两种:使用。需要注意的是,如果函数是通过变量赋值的方式定义的,那么。现代 JavaScript 中,可以通过函数对象的。这种方法更简洁且符合语言规范,也是推荐使用的方式。方法二:通过函数对象的 name 属性。 阅读详情

相关推荐

Java 获取当前类名和方法名的实现方法

主要介绍了 Java 获取当前类名和方法名的实现方法的相关资料,这里不仅提供了实现方法并比较几种方法的效率,需要的朋友可以参考下

Java获取调用当前方法的类名或方法名(栈堆信息)的4种方式

在java代码中,是可以在运行时通过某种方式获取到当前方法被谁调用了(调用链路)。目前我所知道的有四种方式(通过Thread、Throwable、SecurityManager获取)

星月昭铭的博客 6600

看不懂分子动力学模拟的结果?一文读懂RMSD曲线

随后,将每一帧结构与初始模板进行叠合,计算对应原子的平均偏移量,即RMSD。总之,掌握 RMSD 的解读方法,就等于抓住了评估分子动力学模拟成败与质量的“总开关”。①在模拟初始阶段,RMSD会从0迅速上升,这是蛋白质从静态晶体或模型结构释放到溶液环境中并逐渐适应的正常过程。②经过一段时间后,曲线不再系统性上升或下降,而是围绕一个平均值,小幅度地上下波动,形成一个稳定的“平台”。这种情况下,RMSD 在初始快速上升后,并未进入平台,而是持续甚至加速上升,始终未见收敛。🔍 如何解读不同趋势的RMSD曲线。

weixin_46587777的博客 4904

java获取当前类的类名和方法名

获取当前类的类名

二木成林 1万+

交流电路计算方法:复阻抗和相量法

一,复阻抗 电容电路,电压与电流的大小比值是XC=1/WC,相位上电流比电压超前90度 这样描述很麻烦,在复平面里,相位超前90度,可以用什么数学表示呢? 也就是说,一个相量,乘以j之后,大小没变化,相位变得超前90度了 同样的,大小不变,相位落后90度应该除以j 原来我们说电容电路,给个电压,算电流又要算XC,又要另外说相位超前90度,现在可以简单点 在这个计算式里,1/wc还是原来的容抗大...

theory and practice的博客 3万+

人脸关键点定义汇总

前几天看一份代码临时需要找49个人脸关键点位置定义的图片发现怎么百度都搜不到,最后幸好谷歌可以使用了就用谷歌搜到了。所以在这里汇总一下我所知道的人脸关键点的定义和相关的一点东西,以备不时之需。 68个关键点 最常用的工具是Dlib,网址:http://dlib.net/ dlib的68个特征点检测算法是ERT算法【1】 使用dlib检测68个特征点的python示例见:http://dlib.n...

程序媛 7644

得到当前方法的名字Thread.currentThread().getStackTrace()[1].getMethodName();

一个thread就是一个线程,当你编程使用多线程的时候,用currentthread()这个method来获取当前运行线程,以便对其进行操作。 简单来说就是 Tthread类(线程类) 中的一个方法 Thread.currentThread() 是指获取当前运行的线程对象 例如: Thread.currentThread().getName() 就是获取当前运行的线程的名称

u011159607的博客 5632

Mplus—交叉滞后面板模型(Cross-Lagged Panel Model, CLPM)

本文介绍交叉滞后模型相关知识,以及显变量模型与潜变量模型在Mplus中的语法。

m0_54401011的博客 1万+

面试官:你知道哪几种事务失效的场景?

前言 声明式事务是Spring功能中最爽之一,可是有些时候,我们在使用声明式事务并未生效,这是为什么呢?今天陈某带大家来聊一聊声明事务的几种失效场景。本文将会从以下两个方面来说一下事务为...

码猿技术专栏 1万+

利用VS2019编写安卓APP的步骤和所遇问题的解决办法

遇到了代码错误,这个可以将鼠标箭头置于错误代码处,这样VS2019给你解决办法,给的方法不能解决,并且读了程序都没有问题,那么你应该重启软件,这样还是不能解决,你尝试重新生成解决方案,还是不能解决有可能是运用的代码与当前版本不相符和、过时了,这个时候应当运用相应版本的代码。注:VS2019编写APP的空间不是很稳定,当你写的代码没有问题,但是出现了报错,可能是空间崩溃了,这个时候可以重启软件。点击“+”号,创建密钥存储,输入“别名”、“密码”、以及下面中的任意一项,直至红色框消失后。

youbestcando的博客 7816

【STK】手把手教你利用STK进行导弹和反导仿真01 - STK/MMT模块安装部署

【STK】手把手教你利用STK进行导弹和反导仿真01 - STK/MMT模块安装部署MMT模块与STK的版本是一一对应的,比如我现在手上的版本是MMT9的,那么我使用的STK的版本也必须是9版本的,如果你现在正在使用的是更高版本的STK,比如说10、11.2、11.6、12.2,那么该怎么办呢?这个经本人尝试,目前是可以多个STK版本共存的,我们可以根据自己的需要安装多个版本的STK下面开始讲解具体的安装步骤,

weixin_44184852的博客 2920

【Java】获取当前方法的方法名

有的时候需要知道当前执行的方法的方法名, 方法如下: String method = Thread.currentThread().getStackTrace()[1].getMethodName();

非正常人研究室 3676

MAC-电脑中的user文件夹在哪?

MAC-电脑中的user文件夹在哪?

兴趣是最好的老师 1万+

面试官:你连RESTful都不知道我怎么敢要你?

干货,2019 RESTful最贱实践

dotNet全栈开发 17万+

华为OD机试2025C卷 - 字符串解密 (C++ & Python & JAVA & JS & GO)

华为OD机试 2025C卷 字符串解密,提供Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解

qq_45776114的博客 978

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

面试中可以问面试官的问题

面试中,可以问面试官的问题 1、不要直接说“我没有问题了” 这样回答有2个负面影响: 第一,你居然不想知道详细的、切身利益相关的、在公司网站和媒体无法获知的情况?这可能会让面试官认为你对这个职位的兴趣并不大。 第二,很多公司都非常注重员工的个性和创新能力,回答“没问题”,可能会让面试官认为你是一个“没想法”的人,给你贴上否定的标签。 2、一定不能问很容易在网上搜到答案的问题,如业务,产品 千万不要...

Cheng_MY的博客 1万+

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

你知道面试官喜欢什么样的自我介绍吗?

在准备面试的过程中,不知道小伙们有没有想这样一个问题:作为技术面试官,他希望从你的自我介绍中获取哪些信息呢?毕竟面试时间是有限的,面试官的时间也是有限的。技术背景与技能匹配度:我希望了解你所掌握的技术栈是否与我们团队的需求相吻合。例如,如果你申请的是Java开发工程师的职位,我会想知道你在Java方面的具体经验,包括你熟悉哪些框架(如Spring、mybatis等),以及你是否有处理复杂问题的经验。项目经历和成就。

凡夫编程 2515

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

面试官:for循环你知道几种

背景 J2SE 1.5提供了另一种形式的for循环。借助这种形式的for循环,可以用更简单的方式来遍历数组和Collection等类型的对象。本文介绍使用这种循环的具体方式,说明如何自行定义能被这样遍历的类,并解释和这一机制的一些常见问题。在Java程序中,要“逐一处理”――或者说,“遍历”――某一个数组或Collection中的元素的时候,一般会使用一个for循环来实现(当然,用其它种类的循环也不是不可以,只是不知道是因为for这个词的长度比较短,还是因为for这个词的含义和这种操作比较配,在这种时候f

y_xiao_qi的博客 275

Java通过反射获取方法的参数名 idea的设置

之前阿里面试的时候,面试官问我Java通过反射可以获取到一个方法的形参名称吗? 听到这个问题我是懵逼的,之前只知道通过反射可以获取方法名,形参的类型,但是从来没有注意可不可以获取方法形参的名称。在网上查了一些资料之后,知道在jdk1.7之前获取方法中形参的名称的是打印arg0类型。但是在jdk1.8之后,已经做了改动。可以获取到形参的名称。 注意本文的JDK是基于1.8的。1.8版本以下的博主...

gottawangzi的博客 4599

面试官问我:创建线程有几种方式?我笑了

前言 多线程在面试中基本上已经是必问项了,面试官通常会从简单的问题开始发问,然后再一步一步的挖掘你的知识面。 比如,从线程是什么开始,线程和进程的区别,创建线程有几种方式,线程有几种状态,等等。 接下来自然就会引出线程池,Lock,Synchronized,JUC的各种并发包。然后就会引出 AQS、CAS、JMM、JVM等偏底层原理,一环扣一环。 这一节我们不聊其他的,只说创建线程有几种方式。 是不是感觉非常简单,不就是那个啥啥那几种么。 其实不然,只有我们给面试官解释清楚了,并加上我们自己的理解,才能在面

烟雨星空的博客 1798

Java实习模拟面试之获取指定名称参数的所有值:从HTTP协议到Spring MVC的深度解析

当预期一个参数名可能对应多个值时,必须使用。

吾为热爱计科,致力于知识分享的践行者,此博客是我在这条道路上留下的足迹。 772

面试官:java for循环,你知道几种写法?

这是一道初级题目,但是中级的朋友,甚至高级的朋友也未必能回答上来。 背景 J2SE 1.5提供了另一种形式的for循环。借助这种形式的for循环,可以用更简单的方式来遍历数组和Collection等类型的对象。本文介绍使用这种循环的具体方式,说明如何自行定义能被这样遍历的类,并解释和这一机制的一些常见问题。在Java程序中,要“逐一处理”――或者说,“遍历”――某一个数组或Collection中的元素的时候,一般会使用一个for循环来实现(当然,用其它种类的循环也不是不可以,只是不知道是因为fo...

m0_60461003的博客 365

反射获取类_面试官:你来说说反射如何获取私有对象的属性和方法

最近,@Python大星 的朋友小鹿参加了一场#Java#面试。有一道题是这样的 >>>【面试官问:你来说说反射如何获取私有对象的属性和方法?】问题的答案我们文章中揭晓,先看下反射的基础知识,无论你是学动态代理,Spring 的 AOP 都离不开反射的知识。反射最开始接触反射这个概念,是在初中上物理--光的反射原理,是不是格外的熟悉亲切。光的反射1、那什么是Java 的反射??对...

weixin_30061949的博客 250

如何判别公司靠不靠谱?看面试官就行了!

以为进了家有前途的公司,结果入职了才发现管理混乱,工作任务分配不均; 入职前信心满满,下决心要和同事、领导相处融洽,结果发现团队抱团严重,喜欢勾心斗角,一点也无法和谐相处,工作都很难推进; 希望进新公司学习新东西,进一步锻炼、提升自己的业务能力,结果发现入职即巅峰,除了工作的熟练度外,自己的能力竟然比其他员工都要强……   经常看到不少人有以上类似的吐槽,入职后才发现受了骗,进了个渣公司,满心期待终成空。难道这样的情况真不能在入职前就发现端倪吗?面试的时候就不会露出...

438
上一篇: Quarkus 是 Spring Boot 的替代品吗?
下一篇: 微软深夜连甩三大炸弹!Bing Chat更名Copilot,自研芯片问世,还加入GPTs功能
IT界那些事儿
博客等级 码龄6年 2万+粉丝 22原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值