小编Kid*_*nbo的帖子

我有一段代码，可以在两个线程中更改一个计数器。它不是线程安全的，因为我没有在代码中放置任何原子变量或锁。如果代码仅运行一次，它会给出正确的结果，但是我想运行几次，因此将代码放入for循环中。问题是只有前两个循环会生成我期望的结果。对于其余的循环，结果始终为0，这似乎是线程安全的。Java虚拟机中是否有任何内部运算符导致这种情况？

我尝试过更改循环数，而第一个或第二个总是我期望的，但是无论有多少个循环，其他的都是0。

计数器：

private static class Counter {
    private int count;

    public void increase() {
        count++;
    }

    public void decrease() {
        count--;
    }

    public int getCount() {
        return count;
    }
}

人：

// This is just a thread to increase and decrease the counter for many times.
private static class Person extends Thread {
    private Counter c;

    public Person(Counter c) {
        this.c = c;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100000; i++) { …

我在 CPPCon 上看过一个演讲，back to basic: class layout链接是这个。在 54:20，他说两次删除 nullptr 是未定义的行为。据我所知，C++ 标准保证删除 nullptr 没有任何作用，但为什么删除 nullptr 两次是未定义的行为？

之前有人告诉我，不需要检查析构函数中的 ptr 是否为空，因为删除空指针是有效的。但是如果两次删除一个空指针是未定义的，这是否意味着我仍然需要检查它是否为 nullptr 以防止发生双重删除？

这是作者从他的视频中的转录：

[...] 忽略标准，然后又遇到了问题。我看到的一个常见示例是可以删除空指针，这很好，但是如果不将值重置为某个有效指针值，就不能删除它两次。如果我删除相同的指针两次，如果它不是空的，你可能会得到一个段错误，如果它是空的，它通常只是碰巧工作，但不能保证工作，实际上在 1980 年代有一个编译器在那里它不会工作，因为当您删除指针时，删除的指针中会覆盖一个新值。因此，再次遵循标准。

我在返回 a 中的值的引用时遇到了一些麻烦，HashMap<String,String>该值由 Arc 和 Mutex 包装以在线程之间共享。代码是这样的：

use std::sync::{Arc,Mutex};
use std::collections::HashMap;

struct Hey{
    a:Arc<Mutex<HashMap<String, String>>>
}


impl Hey {
    fn get(&self,key:&String)->&String{
        self.a.lock().unwrap().get(key).unwrap()
    }
}

如上所示，代码由于returns a value referencing data owned by the current function. 我知道lock()返回 MutexGuard 这是一个局部变量。但是我怎样才能实现这种方法来获取对 HashMap 中的值的引用。如果我不能，Rust 禁止这样做的动机是什么？

当我第一次学习如何检查课程中的特定签名时,我被教导使用std::void_t并编写如下代码:

template<typename T, typename =void>
class HAS:public false_type{};

template<typename T>
class HAS<T,void_t<decltype(declval<T>().print())>>:public true_type{};

这段代码将检查一个类是否有名为" print()" 的方法.它运作良好.

但当我试图删除它时std::void_t,它仍然有效.

代码如下所示:

template<typename T, typename = void>
class HAS:public false_type{};

template<typename T>
class HAS<T,decltype(declval<T>().print())>:public true_type{};

所以我很困惑,如果需要" std::void_t"来检查一个类是否有一个具有特定签名的方法？或者那只是巧合？

Rust 在编译时提供借用检查。但如果使用Rcand RefCell，检查将在运行时推迟，并且当程序违反规则时将引发恐慌。像这样：

use std::rc::Rc;
use std::cell::RefCell;

fn func1(reference: Rc<RefCell<String>>){
    let mut a = reference.borrow_mut();
    *a = String::from("func1");
    func2(reference.clone());
}

fn func2(reference: Rc<RefCell<String>>){
    let mut a = reference.borrow_mut();
    *a = String::from("func2");
    func3(reference.clone());
}

fn func3(reference: Rc<RefCell<String>>){
    let mut a = reference.borrow_mut();
    *a = String::from("func3");
}


fn main() {
    let a = Rc::new(RefCell::new(String::from("hello")));
    func1(a.clone());
}

这段代码仍然将错误（也许不是错误）留给运行时并陷入恐慌。那么我应该尽可能避免使用Rcand吗？RefCell这段代码算安全代码吗？

我曾经用Visual Studio编写代码,这很容易添加一个类.最近,我转而使用Qt Creator编写纯C++项目,添加类总是有问题.代码如下:

#include <iostream>
#include "hello.h"

using namespace std;

int main()
{
    Hello H;
    H.say();
    cout << "Hello World!" << endl;
    return 0;
}

我创建了一个名为Hello的类并将其包含在main.cpp中,但是当我编译它时,会发生一些错误.

那么如何使用QT创建者添加一个类？提前致谢!

我编写了一个小程序来生成唯一 ID。并打印出时间成本。这是代码：

public class JavaSF_OLD {

    static int randomNumberShiftBits = 12;
    static int randomNumberMask = (1 << randomNumberShiftBits) - 1;
    static int machineNumberShiftBits = 5;
    static int machineNumberMask = (1 << machineNumberShiftBits) - 1;
    static int dataCenterNumberShiftBits = 5;
    static int dataCenterNumberMask = (1 << dataCenterNumberShiftBits) - 1;
    static int dateTimeShiftBits = 41;
    static long dateTimeMask = (1L << dateTimeShiftBits)-1;

    static int snowFlakeId = 0;
    static long lastTimeStamp = 0;
    static int DataCenterID = 1;
    static int MachineID = 1; …

我的同事告诉我，代码修改 2 的功能将针对位操作进行优化，并且比修改其他数字更快。我检查了装配体，证明了他的选择。但我用 Golang 编写了一个基准代码并使用 Go 版本 1.17 运行它。似乎并没有太大的区别。为什么会发生这种事？他是对的吗？

这是 Golang 代码：

package main

import (
    "fmt"
    "time"
)

const loop = 10000000000

func Mod1024() int {
    sum := 0
    for i := 0; i < loop; i++ {
        sum += i % 1024
    }
    return sum
}

func Mod1023() int {
    sum := 0
    for i := 0; i < loop; i++ {
        sum += i % 1023
    }
    return sum
}

func main() {
    start := time.Now()
    Mod1023() …