小编Par*_*olu的帖子

我知道-XmsJVM进程的标志是允许JVM进程使用特定数量的内存来初始化其进程.而对于Java应用程序的性能,通常建议设置为两个相同的价值观-Xms和-Xmx启动应用程序时,喜欢-Xms2048M -Xmx2048M.

我很好奇-Xms和-Xmx标志是否意味着JVM进程预留了特定的内存量以防止同一台机器中的其他进程使用它.

这是正确的吗？

我需要在批处理程序中获得理想数量的线程,该程序在支持并行模式的批处理框架中运行,如Spring Batch中的并行步骤.

据我所知,执行程序步骤的线程太多并不好,可能会对程序的性能产生负面影响.一些因素可能会导致性能下降(上下文切换,使用共享资源时的竞争条件(锁定,同步......)......(还有其他因素吗？)).

当然,获得理想线程数的最佳方法是让我有实际的程序测试来调整程序的线程数.但在我的情况下,进行实际测试并不容易,因为测试需要很多东西(人员,测试计划,测试数据等等),这对我来说现在很难准备.所以,在进行实际测试之前,我想知道如何尽可能地获得我的程序中可猜测的理想线程数.我应该考虑什么来获得我的程序的理想线程数(步数)？CPU核心数？我的程序运行的机器上的进程数？数据库连接数？在这样的情况下,是否存在诸如公式之类的理性方式？

据我所知，方法的局部变量位于执行线程的堆栈帧中，局部变量的引用类型仅具有对象的引用，而不具有对象本身。JVM中的所有对象都位于堆空间中。

我想知道正在执行的方法中局部变量引用的对象在方法执行结束之前永远不会被垃圾收集。（不使用 java.lang.ref.WeakReference 和 SoftReference。）

它们被垃圾收集了吗？或者从来没有？编译器对这类东西有优化吗？

（如果它们从未被垃圾回收，这意味着在执行需要很长时间的大方法时可能需要将 null 分配给不再使用的变量。）

我通过阅读 Rust 应用程序的代码来学习 Rust，并且经常很难找到结构的特征方法实现。

例如，我有以下代码：

fn peek_u8(src: &mut Cursor<&[u8]>) -> Result<u8, Error> {
    if !src.has_remaining() {
        return Err(Error::Incomplete);
    }

    Ok(src.chunk()[0])
}

我想知道Cursor的'has_remaining'和'chunk'方法的定义和起源在哪里。经过一些互联网研究，我发现它源自 'bytes::Buf' 特征。但是，我找不到“块”。

每次遇到这种情况，我都很难找到 struct 中如何有方法（哪个 Trait 实现了这些方法？）。有时它的时间成本非常高。

有什么建议可以给我吗？

我已经搜索了使用@TestConfiguration与@Configuration相比的真正含义，并且我在@TestConfiguration的官方评论中看到了一个声明。

...与常规@Configuration类不同，@TestConfiguration的使用不会阻止@SpringBootConfiguration的自动检测。

该声明的含义是，使用 @Configuration 可以防止自动检测 @SpringBootConfiguration，但 @TestConfiguration 不会。

我对“预防”这个词感到困惑。@Configuration的使用会影响@SpringBootConfiguration吗？

我写了以下内容来测试闭包：

fn main() {
    let captured_val = "a captured value".to_string();
    let closure_parameter = "a parameter value".to_string();

    let mut ct = ClosureTest {
        cls: |closure_parameter| &captured_val,
    };
    println!("{}", (ct.cls)(&closure_parameter));
}

struct ClosureTest<T>
where
    T: FnMut(&str) -> &str,
{
    cls: T,
}

我收到以下编译错误：

fn main() {
    let captured_val = "a captured value".to_string();
    let closure_parameter = "a parameter value".to_string();

    let mut ct = ClosureTest {
        cls: |closure_parameter| &captured_val,
    };
    println!("{}", (ct.cls)(&closure_parameter));
}

struct ClosureTest<T>
where
    T: FnMut(&str) -> &str,
{
    cls: T,
} …

有时，我在尝试运行 Kafka 代理时会出现以下错误：

ERROR Fatal error during KafkaServer startup. Prepare to shutdown (kafka.server.KafkaServer)
kafka.common.InconsistentClusterIdException: The Cluster ID m1Ze6AjGRwqarkcxJscgyQ doesn't match stored clusterId Some(1TGYcbFuRXa4Lqojs4B9Hw) in meta.properties. The broker is trying to join the wrong cluster. Configured zookeeper.connect may be wrong.
        at kafka.server.KafkaServer.startup(KafkaServer.scala:220)
        at kafka.server.KafkaServerStartable.startup(KafkaServerStartable.scala:44)
        at kafka.Kafka$.main(Kafka.scala:84)
        at kafka.Kafka.main(Kafka.scala)
[2020-01-04 15:58:43,303] INFO shutting down (kafka.server.KafkaServer)

我知道错误消息的含义，并且可以通过删除 Kafka 日志目录中的 meta.properties 来解决。

我现在想知道这种情况何时发生，以防止这种情况发生。为什么/何时 Zookeeper 查找的集群 ID 有时会发生变化？

我正在尝试实现一个链接列表以用于学习目的。std::cell::RefCell 和 stc::rc::{Rc, Weak} 主要用于将数据存储到列表实例中。现在我正在实现fn pop，它使用并返回列表中第一个位置的值，但我不知道如何使用 Rc 和 RefCell 包装的值。

这是我的代码：

use std::cell::RefCell;
use std::rc::{Rc, Weak};

#[derive(Debug)]
pub struct DbNode<T> {
    data: T,
    next: Option<Rc<RefCell<DbNode<T>>>>,
    prev: Option<Weak<RefCell<DbNode<T>>>>,
}

#[derive(Debug)]
pub struct DbList<T> {
    first: Option<Rc<RefCell<DbNode<T>>>>,
    last: Option<Weak<RefCell<DbNode<T>>>>,
}

pub fn push_front(&mut self, data: T) {
    match self.first.take() {
        Some(e) => {
            let new_front = Rc::new(RefCell::new(DbNode {
                data,
                next: Some(e.clone()),
                prev: None,
            }));
            let mut me = e.borrow_mut();
            me.prev = Some(Rc::downgrade(&new_front));
            self.first = Some(new_front);
        },
        None => {
            let …

java 类在每个 JVM 中仅在首次加载时初始化一次。而且我认为多个线程可以尝试同时加载同一个类。JVM 如何处理这种争用？有没有什么机制可以防止这种情况发生，比如锁？