橘子学JDK之JMH-02(BenchmarkModes)

一、案例二代码

这次我们来搞一下官网文档的第二个案例，我删除了一些没用的注释，然后对代码做了一下注释的翻译，可以看一下意思。

package com.levi;import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;import java.util.concurrent.TimeUnit;// 预热注解，修改为只预热一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Warmup(iterations = 1,time = 1)
// 测试执行注解，修改为只执行一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Measurement(iterations = 1,time = 1)
public class JMHSample_02_01_BenchmarkModes {/** Mode.Throughput, as stated in its Javadoc, measures the raw throughput by* continuously calling the benchmark method in a time-bound iteration, and* counting how many times we executed the method.** We are using the special annotation to select the units to measure in,* although you can use the default.** AI直译：Mode.Throughput，如其Javadoc所述，通过在时间限制的迭代中连续调用基准方法，* 并计算我们执行该方法的次数来衡量原始吞吐量。我们正在使用特殊注解来选择要测量的单位，尽管你可以使用默认值。** 我根据我的理解还是说几句人话吧，他的意思是我们之前不是在案例1中输出的是吞吐量的测试指标吗，这里的意思是你可以* 使用@BenchmarkMode这个注解，里面设置参数Mode.Throughput一样可以是通过吞吐量的指标的，或者说你不设置，默认* 本身就是吞吐量，我们第一个案例就是默认的。* 所以我们在第一个方法上看到新出现的两个注解* @BenchmarkMode：设置计算指标* @OutputTimeUnit：计算模式对应的单位*/@Benchmark@BenchmarkMode(Mode.Throughput)@OutputTimeUnit(TimeUnit.SECONDS)public void measureThroughput() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}/** Mode.AverageTime measures the average execution time, and it does it* in the way similar to Mode.Throughput.* 在性能测试或基准测试的背景下，Mode.AverageTime（平均时间模式）测量了给定操作或代码片段的平均执行时间。* 该模式计算了每次调用被测试代码所花费的平均时间。它与Mode.Throughput（吞吐量模式）相似，两种模式都专注于性能测量，* 但它们在优先考虑的性能方面存在差异。以下是Mode.AverageTime和Mode.Throughput之间的简要比较：* 平均时间：该模式计算每个操作或调用的平均执行时间。它提供了关于单个操作平均执行时间的信息。* 吞吐量：另一方面，Mode.Throughput关注的是在给定时间内完成的操作速率。它衡量每单位时间内可以执行多少操作，通常是每秒。* 它提供了系统在高负载下处理大量操作的效率信息。* 虽然两种模式都提供了有关性能的有价值的信息，但它们服务于不同的目的，可能适用于不同类型的性能分析。* Mode.AverageTime适用于了解单个操作的平均延迟或执行时间，而Mode.Throughput更适用于在指定时间范围内最大化完成的操作数量。*** Some might say it is the reciprocal throughput, and it really is.* There are workloads where measuring times is more convenient though.* 有人说，这个指标是吞吐量的倒数，你也可以这么理解，不过有时候你测试的时候，统计时间维度是更加直观的。** 换言之，这个是统计你方法的执行平均时间的，所以看起来比吞吐量更加直观，毕竟耗时是我们普遍关心的第一指标*/@Benchmark@BenchmarkMode(Mode.AverageTime)@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureAvgTime() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}/** Mode.SampleTime samples the execution time. With this mode, we are* still running the method in a time-bound iteration, but instead of* measuring the total time, we measure the time spent in *some* of* the benchmark method calls.** Mode.SampleTime是用于对方法执行时间进行采样的一种模式。在这种模式下，我们仍然在一个有时间限制的迭代中运行方法，* 但不再测量总时间，而是测量一部分基准方法调用所花费的时间。使用Mode.SampleTime模式时，* 基准测试框架会定期中断方法的执行并记录经过的时间。通过只对部分调用进行采样，可以减少与连续时间测量相关的开销，* 同时仍能提供有关方法执行时间分布的有意义数据，而不仅仅关注整体持续时间。这种模式对于识别执行时间的变化非常有用，* 特别是如果方法的某些部分可能具有不同的性能特点或表现出间歇性行为。它使开发人员能够了解方法在不同条件下的性能表现，* 并帮助优化其性能。** This allows us to infer the distributions, percentiles, etc.* JMH also tries to auto-adjust sampling frequency: if the method* is long enough, you will end up capturing all the samples.* 这样可以让我们推断出分布情况、百分位数等。JMH 还会尝试自动调整采样频率：如果方法足够长，你最终会捕获到所有的样本** 这个解释的不明确，我们待会通过现象来看一下具体啥意思。*/@Benchmark@BenchmarkMode(Mode.SampleTime)@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureSamples() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}/** Mode.SingleShotTime measures the single method invocation time. As the Javadoc* suggests, we do only the single benchmark method invocation. The iteration* time is meaningless in this mode: as soon as benchmark method stops, the* iteration is over.** Mode.SingleShotTime测量的是单个方法调用的时间。正如Javadoc所建议的，我们只进行一次基准方法的调用。* 在这种模式下，迭代时间是没有意义的：一旦基准方法停止，迭代就结束了。** This mode is useful to do cold startup tests, when you specifically* do not want to call the benchmark method continuously.* 这种模式在进行冷启动测试时非常有用，当你不想连续调用基准方法时。** 说白了就是只测试一次，就跟你跑main函数一样的，没有预热，就是冷启动的测试。*/@Benchmark@BenchmarkMode(Mode.SingleShotTime)@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureSingleShot() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}/** We can also ask for multiple benchmark modes at once. All the tests* above can be replaced with just a single test like this:** 这个注解还能写数组，指定多种测试指标，一起生效*/@Benchmark@BenchmarkMode({Mode.Throughput, Mode.AverageTime, Mode.SampleTime, Mode.SingleShotTime})@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureMultiple() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}/** Or even...* 如果你懒得写很多模式，你还能直接用Mode.All来表示全部的模式*/@Benchmark@BenchmarkMode(Mode.All)@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureAll() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}public static void main(String[] args) throws RunnerException {Options opt = new OptionsBuilder().include(JMHSample_02_01_BenchmarkModes.class.getSimpleName()).forks(1).build();new Runner(opt).run();}
}

二、@BenchmarkMode

我们先不急着运行程序，我们在看完上面的例子之后可以看到这次出现了一个新的注解，就是
@BenchmarkMode

@Inherited
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface BenchmarkMode {Mode[] value();
}

这个注解我们看到，作用的位置就是方法和类上面，你要是标注在类上，那就这个类所有的方法都按照这个配置生效了。
而且我们注意到他有一个变量，是Mode类型的数组，注意是数组，也就是可以传入多个。我们看一下这个Mode类型是啥。

public enum Mode {Throughput("thrpt", "Throughput, ops/time"),AverageTime("avgt", "Average time, time/op"),SampleTime("sample", "Sampling time"),SingleShotTime("ss", "Single shot invocation time"),All("all", "All benchmark modes");
}

就是个枚举类型，总共五个类型，我们上面的注释其实也标注了这五个类型的各自的作用。

三、 @OutputTimeUnit

与@BenchmarkMode 配套的还有一个注解就是@OutputTimeUnit。

@Inherited
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface OutputTimeUnit {TimeUnit value();
}

他的作用就是你输出指标的时间单位，没别的了。OK，我们在大致有个了解之后，我们开始通过执行程序来看一下结果，加深我们对于注解的理解。

四、执行程序

鉴于我们这里这次一次写了N个方法测试，输出的报告巨长，我们这里就一个一个的测试，这样方便观察。

1、测试吞吐模式：measureThroughput

package com.levi;import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;import java.util.concurrent.TimeUnit;// 预热注解，修改为只预热一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Warmup(iterations = 1,time = 1)
// 测试执行注解，修改为只执行一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Measurement(iterations = 1,time = 1)
public class JMHSample_02_01_BenchmarkModes {/** Mode.Throughput, as stated in its Javadoc, measures the raw throughput by* continuously calling the benchmark method in a time-bound iteration, and* counting how many times we executed the method.** We are using the special annotation to select the units to measure in,* although you can use the default.** AI直译：Mode.Throughput，如其Javadoc所述，通过在时间限制的迭代中连续调用基准方法，* 并计算我们执行该方法的次数来衡量原始吞吐量。我们正在使用特殊注解来选择要测量的单位，尽管你可以使用默认值。** 我根据我的理解还是说几句人话吧，他的意思是我们之前不是在案例1中输出的是吞吐量的测试指标吗，这里的意思是你可以* 使用@BenchmarkMode这个注解，里面设置参数Mode.Throughput一样可以是通过吞吐量的指标的，或者说你不设置，默认* 本身就是吞吐量，我们第一个案例就是默认的。* 所以我们在第一个方法上看到新出现的两个注解* @BenchmarkMode：设置计算指标* @OutputTimeUnit：计算模式对应的单位*/@Benchmark@BenchmarkMode(Mode.Throughput)@OutputTimeUnit(TimeUnit.SECONDS)public void measureThroughput() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}public static void main(String[] args) throws RunnerException {Options opt = new OptionsBuilder().include(JMHSample_02_01_BenchmarkModes.class.getSimpleName()).forks(1).build();new Runner(opt).run();}
}

运行结果为：
Benchmark ：JMHSample_02_01_BenchmarkModes.measureThroughput
Mode ：thrpt
Cnt ： 因为我控制了1次，所以这里没东西
Score ：9.160 这个分数在吞吐这里其实就是你执行的吞吐量，因为我写的@OutputTimeUnit(TimeUnit.SECONDS)单位是秒，所以意思就是一秒能执行9.16次。
Error ：没输出
Units：ops/s
我们看到这个吞吐量其实和我们在第一个案例测试的差不多，其实他就是默认的。你不写就是他。

2、测试平均时间模式：measureAvgTime

package com.levi;import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;import java.util.concurrent.TimeUnit;// 预热注解，修改为只预热一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Warmup(iterations = 1,time = 1)
// 测试执行注解，修改为只执行一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Measurement(iterations = 1,time = 1)
public class JMHSample_02_01_BenchmarkModes {/** Mode.AverageTime measures the average execution time, and it does it* in the way similar to Mode.Throughput.* 在性能测试或基准测试的背景下，Mode.AverageTime（平均时间模式）测量了给定操作或代码片段的平均执行时间。* 该模式计算了每次调用被测试代码所花费的平均时间。它与Mode.Throughput（吞吐量模式）相似，两种模式都专注于性能测量，* 但它们在优先考虑的性能方面存在差异。以下是Mode.AverageTime和Mode.Throughput之间的简要比较：* 平均时间：该模式计算每个操作或调用的平均执行时间。它提供了关于单个操作平均执行时间的信息。* 吞吐量：另一方面，Mode.Throughput关注的是在给定时间内完成的操作速率。它衡量每单位时间内可以执行多少操作，通常是每秒。* 它提供了系统在高负载下处理大量操作的效率信息。* 虽然两种模式都提供了有关性能的有价值的信息，但它们服务于不同的目的，可能适用于不同类型的性能分析。* Mode.AverageTime适用于了解单个操作的平均延迟或执行时间，而Mode.Throughput更适用于在指定时间范围内最大化完成的操作数量。*** Some might say it is the reciprocal throughput, and it really is.* There are workloads where measuring times is more convenient though.* 有人说，这个指标是吞吐量的倒数，你也可以这么理解，不过有时候你测试的时候，统计时间维度是更加直观的。** 换言之，这个是统计你方法的执行平均时间的，所以看起来比吞吐量更加直观，毕竟耗时是我们普遍关心的第一指标*/@Benchmark@BenchmarkMode(Mode.AverageTime)@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureAvgTime() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}public static void main(String[] args) throws RunnerException {Options opt = new OptionsBuilder().include(JMHSample_02_01_BenchmarkModes.class.getSimpleName()).forks(1).build();new Runner(opt).run();}
}

运行结果如下：
Benchmark ：JMHSample_02_01_BenchmarkModes.measureAvgTime
Mode：avgt 平均统计模式
Cnt ：同上
Score：108407.350
Error ：没错误，不输出
Units：us/op 其实你能看出来，他是时间除以执行次数，所以就是吞吐量的倒数，吞吐量的意思是每秒能执行几次，这里就是执行一次需要几秒，不就是平均时间吗。只是我指定的时间单位是@OutputTimeUnit(TimeUnit.MICROSECONDS)微秒，所以这里自然也就是这个单位。
他主打的是一个平均耗时。

3、测试统计时间：measureSamples

package com.levi;import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;import java.util.concurrent.TimeUnit;// 预热注解，修改为只预热一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Warmup(iterations = 1,time = 1)
// 测试执行注解，修改为只执行一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Measurement(iterations = 1,time = 1)
public class JMHSample_02_01_BenchmarkModes {/** Mode.SampleTime samples the execution time. With this mode, we are* still running the method in a time-bound iteration, but instead of* measuring the total time, we measure the time spent in *some* of* the benchmark method calls.** Mode.SampleTime是用于对方法执行时间进行采样的一种模式。在这种模式下，我们仍然在一个有时间限制的迭代中运行方法，* 但不再测量总时间，而是测量一部分基准方法调用所花费的时间。使用Mode.SampleTime模式时，* 基准测试框架会定期中断方法的执行并记录经过的时间。通过只对部分调用进行采样，可以减少与连续时间测量相关的开销，* 同时仍能提供有关方法执行时间分布的有意义数据，而不仅仅关注整体持续时间。这种模式对于识别执行时间的变化非常有用，* 特别是如果方法的某些部分可能具有不同的性能特点或表现出间歇性行为。它使开发人员能够了解方法在不同条件下的性能表现，* 并帮助优化其性能。** This allows us to infer the distributions, percentiles, etc.* JMH also tries to auto-adjust sampling frequency: if the method* is long enough, you will end up capturing all the samples.* 这样可以让我们推断出分布情况、百分位数等。JMH 还会尝试自动调整采样频率：如果方法足够长，你最终会捕获到所有的样本** 这个解释的不明确，我们待会通过现象来看一下具体啥意思。*/@Benchmark@BenchmarkMode(Mode.SampleTime)@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureSamples() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}public static void main(String[] args) throws RunnerException {Options opt = new OptionsBuilder().include(JMHSample_02_01_BenchmarkModes.class.getSimpleName()).forks(1).build();new Runner(opt).run();}
}

在这里插入图片描述
他是以一种分布统计的方式输出的测试指标，单位还是平均时间耗时，等于说百分之99的测试跑一次是109707.264us的耗时，他内部给你做了一个测试，拆分出来测的，测出这么个结果来。
能看出来一个波动，和你实现的代码稳定性，而且他是抽样测试，不会都给你统计，比如我们设置的跑1轮，每轮一秒。可能这一秒跑了一万次，他不会像吞吐和平均那个样都算进去，他是一个抽样，可能抽了前面后面，没取中间。可能压根就是抽了前面。是一个分布统计。

4、测试只跑一次：measureSingleShot

package com.levi;import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;import java.util.concurrent.TimeUnit;// 预热注解，修改为只预热一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Warmup(iterations = 1,time = 1)
// 测试执行注解，修改为只执行一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Measurement(iterations = 1,time = 1)
public class JMHSample_02_01_BenchmarkModes {/** Mode.SingleShotTime measures the single method invocation time. As the Javadoc* suggests, we do only the single benchmark method invocation. The iteration* time is meaningless in this mode: as soon as benchmark method stops, the* iteration is over.** Mode.SingleShotTime测量的是单个方法调用的时间。正如Javadoc所建议的，我们只进行一次基准方法的调用。* 在这种模式下，迭代时间是没有意义的：一旦基准方法停止，迭代就结束了。** This mode is useful to do cold startup tests, when you specifically* do not want to call the benchmark method continuously.* 这种模式在进行冷启动测试时非常有用，当你不想连续调用基准方法时。** 说白了就是只测试一次，就跟你跑main函数一样的，没有预热，就是冷启动的测试。*/@Benchmark@BenchmarkMode(Mode.SingleShotTime)@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureSingleShot() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}public static void main(String[] args) throws RunnerException {Options opt = new OptionsBuilder().include(JMHSample_02_01_BenchmarkModes.class.getSimpleName()).forks(1).build();new Runner(opt).run();}
}

执行结果如下：
在这里插入图片描述
这就是测试冷启动的，没预热，就是直接跑，你也能看到单位是us/op。还是执行一次要多久。还是个平均值，只不过就是没预热直接开跑的。就跑一次。

5、测试多种模式组合：measureMultiple

package com.levi;import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;import java.util.concurrent.TimeUnit;// 预热注解，修改为只预热一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Warmup(iterations = 1,time = 1)
// 测试执行注解，修改为只执行一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Measurement(iterations = 1,time = 1)
public class JMHSample_02_01_BenchmarkModes {/** We can also ask for multiple benchmark modes at once. All the tests* above can be replaced with just a single test like this:** 这个注解还能写数组，指定多种测试指标，一起生效*/@Benchmark@BenchmarkMode({Mode.Throughput, Mode.AverageTime, Mode.SampleTime, Mode.SingleShotTime})@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureMultiple() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}public static void main(String[] args) throws RunnerException {Options opt = new OptionsBuilder().include(JMHSample_02_01_BenchmarkModes.class.getSimpleName()).forks(1).build();new Runner(opt).run();}
}

因为我们前面看了Mode是一个数组，所以可以传入多个模式。结果就是一起统计输出了。
在这里插入图片描述

6、测试全量模式：measureAll

package com.levi;import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;import java.util.concurrent.TimeUnit;// 预热注解，修改为只预热一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Warmup(iterations = 1,time = 1)
// 测试执行注解，修改为只执行一轮，每轮只跑一秒，默认是5,5这里改为1,1
@Measurement(iterations = 1,time = 1)
public class JMHSample_02_01_BenchmarkModes {/** Or even...* 如果你懒得写很多模式，你还能直接用Mode.All来表示全部的模式*/@Benchmark@BenchmarkMode(Mode.All)@OutputTimeUnit(TimeUnit.MICROSECONDS)public void measureAll() throws InterruptedException {TimeUnit.MILLISECONDS.sleep(100);}public static void main(String[] args) throws RunnerException {Options opt = new OptionsBuilder().include(JMHSample_02_01_BenchmarkModes.class.getSimpleName()).forks(1).build();new Runner(opt).run();}
}

自然就是全部的统计都输出了：和上面一样。
在这里插入图片描述
你也可以看他的单位就知道他输出的计算方式了，次数除以时间，那就是平均时间的执行次数，就是吞吐。
时间除以次数，就是统计的某种模式下的平均时间。

五、总结

没啥总结的就是那两个注解，很详细了。

六、参考链接

1、JMH官方文档

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/600902.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Vite+Vue3.0项目使用ant-design-vue ＜a-calendar＞日期组件汉化

Vite+Vue3.0项目使用ant-design-vue ＜a-calendar＞日期组件汉化

antd的弹框、日期等默认为英文，要把英文转为中文请看下文： 1.首先我们要在main.js中引入ant-design组件库并全局挂载： import App from ./App import Antd from ant-design-vue; import ant-design-vue/dist/antd.css;const app createApp(…
阅读更多...
paddle实现手写数字模型（一）

paddle实现手写数字模型（一）

参考文档：paddle官网文档环境：Python 3.12.2 ，pip 24.0 ，paddlepaddle 2.6.0 python -m pip install paddlepaddle2.6.0 -i https://pypi.tuna.tsinghua.edu.cn/simple调试代码如下： LeNet.py import paddle import p…
阅读更多...
1.网络编程-网络协议

1.网络编程-网络协议

目录 网络编程是什么 网络编程三要素 OSI七层网络模型 TCP/IP五层模型 SSL/TLS 是哪层协议 网络编程是什么 网络编程是计算机科学中的一个重要领域，它涉及到编写能够在网络环境中进行通信的程序。网络编程的核心目标是使不同的设备能够通过网络交换信息&#…
阅读更多...
重建大师进行扫码认证了，接下来怎样才能正常使用？（如下图）

重建大师进行扫码认证了，接下来怎样才能正常使用？（如下图）

重建大师软件授权已经有了后，新建工程后设置任务目录和监控目录一致就可以运行了。 重建大师是一款专为超大规模实景三维数据生产而设计的集群并行处理软件，输入倾斜照片，激光点云，POS信息及像控点，输出高精度彩色网格…
阅读更多...
linux创建文件、linux创建文件的几种方式、touch、echo、cat、vi、vim

linux创建文件、linux创建文件的几种方式、touch、echo、cat、vi、vim

文章目录 一、创建文件1.1、touch1.2、echo1.3、cat1.4、vi或vim 一、创建文件 1.1、touch touch命令：用于创建一个新的空文件或者更新已存在文件的访问和修改时间。 （1）如果目标文件不存在，则新建一个文件 touch demo.txt&am…
阅读更多...
基于R语言lavaan结构方程模型（SEM）实践技术应用

基于R语言lavaan结构方程模型（SEM）实践技术应用

原文链接：基于R语言lavaan结构方程模型（SEM）实践技术应用https://mp.weixin.qq.com/s?__bizMzUzNTczMDMxMg&mid2247596681&idx4&sn08753dd4d3e7bc492d750c0f06bba1b2&chksmfa823b6ecdf5b278ca0b94213391b5a222d1776743609cd…
阅读更多...
DFS-0与异或问题，有奖问答，飞机降落

DFS-0与异或问题，有奖问答，飞机降落

代码和解析 #include<bits/stdc.h> using namespace std; int a[5][5]{{1,0,1,0,1}}; //记录图中圆圈内的值&#xff0c;并初始化第1行 int gate[11]; //记录10个逻辑门的一种排列 int ans; //答案 int logic(int x, int y, int op){…
阅读更多...
数仓调优实战：GUC参数调优

数仓调优实战：GUC参数调优

1. 前言 适用版本&#xff1a;【8.1.1及以上】 GaussDB(DWS)性能调优系列专题文章&#xff0c;介绍了数据库性能调优的思路和总体策略。在系统级调优中数据库全局的GUC参数对整体性能的提升至关重要&#xff0c;而在语句级调优中GUC参数可以调整估算模型&#xff0c;选择查询…
阅读更多...
【超重磅牛市信号】减半倒计时12天！首波抛售潮接近尾声，大暴涨将如期而至！

【超重磅牛市信号】减半倒计时12天！首波抛售潮接近尾声，大暴涨将如期而至！

3月&#xff0c;美国CPI环比出现小幅反弹由3.1%升至3.2%&#xff0c;美国制造业指数PMI反弹至50.3%呈现进入扩张期的态势&#xff0c;日本结束长达8年的负利率时代首次加息。这导致美国4月降息概率大幅下降&#xff0c;5月降息概率也跌至50%以下。 尽管如此&#xff0c;全球金融…
阅读更多...
移动医保支付

移动医保支付

传统就医流程中&#xff0c;涉及“三长一短”的难题&#xff0c;因此根据国家政策及互联网的能力支持&#xff0c;用户在微信或者支付宝上激活医保电子凭证之后&#xff0c;无需在医院窗口排队&#xff0c;即可通过微信小程序或者公众号、支付宝小程序缴纳医保挂号或医保门诊费…
阅读更多...
vulnhub----natraj靶机

vulnhub----natraj靶机

文章目录 一.信息收集1.网段探测2.端口扫描3.版本服务探测4.漏扫5.目录扫描 二.漏洞利用1.分析信息2..fuzz工具 三.getshell四.提权六.nmap提权 一.信息收集 1.网段探测 因为使用的是VMware&#xff0c;靶机的IP地址是192.168.9.84 ┌──(root㉿kali)-[~/kali/vulnhub] └─…
阅读更多...
MYSQL快速入门

MYSQL快速入门

理解SQL 语句的执行过程 掌握SQL 语句的基本语法 掌握SQL 语句的增删改查操作 1.SQL 分类 MySQL 是关系型数据库系统&#xff0c;其中存储了大量的数据&#xff0c;通过SQL 管理数据库配置和数据。结构化查询语言&#xff08;SQL&#xff09;&#xff0c;对数据库进行操作的语…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023