小编Sri*_*nth的帖子

我有一个进程名称,我kill()要向该进程发送一个信号,但我需要调用它的PID kill().我只想用:

popen("pidof process_name");

作为最后一件事.有没有其他方法可以找到进程'PID？我能想到的一种方法是向该进程发送套接字请求并询问其PID.

另一种方式对于我正在编写的简单代码来说有点过于复杂:要做pidof命令的源代码实际正在做的事情(它使用函数调用find_pid_by_name()但是它做了很多事情).

如果没有简单的解决方案,我就这样做:

system("pkill <process_name>");

并检查其返回码.但是,在所有Linux机器上都可以获得pkill吗？

我输入的密码(比如Gmail登录表单)如何安全地传输到Web服务器？

• 浏览器或任何客户端应用程序做什么？
• Web服务器做什么？

当我这样做:

find . -name "pattern" | grep "another-pattern"

是过程,find并且grep,催生了一起？我的猜测是肯定的.如果是这样,那么这是如何工作的？:

yes | command_that_prompts_for_confirmations

如果yes不断向stdout发送'y'并在command_that_prompts_for_confirmations读取stdin时读取'y',那么如何yes知道何时终止？因为如果我yes单独运行而不将其输出传递给其他命令,它就永远不会结束.

但是如果管道命令不能同时产生所有进程,那么如何yes知道要输出多少？这对我来说是22.有人能解释一下这个管道在*NIX中是如何工作的吗？

编辑:我终于弄清楚问题是什么.一些文件具有非常高的复制因子集,我将我的集群减少到2个节点.一旦我减少了对这些文件的复制因子,退役就会很快成功结束.

我在dfs.hosts.exclude和mapred.hosts.exclude文件中添加了要退役的节点,并执行了以下命令:

bin/hadoop dfsadmin -refreshNodes.

在NameNode用户界面中,我看到了这个节点Decommissioning Nodes,但它花了太长时间,而且我没有太多关于该节点退役的数据.

解析节点总是需要很长时间,还是我应该看一些地方？我不确定究竟发生了什么.

我在这个节点上看不到任何损坏的块:

$ ./hadoop/bin/hadoop fsck -blocks /
 Total size:    157254687 B
 Total dirs:    201
 Total files:   189 (Files currently being written: 6)
 Total blocks (validated):      140 (avg. block size 1123247 B) (Total open file blocks (not validated): 1)
 Minimally replicated blocks:   140 (100.0 %)
 Over-replicated blocks:        6 (4.285714 %)
 Under-replicated blocks:       12 (8.571428 %)
 Mis-replicated blocks:         0 (0.0 %)
 Default replication factor:    2
 Average block replication: …

我刚刚开始阅读一本定义Graphs的算法书,如下所示:

图形 - 表示任意对象对之间的关​​系.图1.8(b)将道路网络建模为图形,其中顶点是城市,边缘是连接城市对的道路.无论何时寻求"网络","电路","网络"或"关系",图形都可能是有问题的对象.

图1.8(b)是这样的:

让我困惑的是以下几行:

......顶点是城市,边缘是连接城市的道路......

我正在阅读有关仿制药中未知类型和原始类型的内容,我想到了这个问题.换句话说,是......

Set<?> s = new HashSet<String>();

和

Set s = new HashSet<String>();

......一个一样？

我试了一下,他们似乎都完成了同样的事情,但我想知道他们是否与编译器有任何不同.

这是我面临的问题的简短代码版本：

public static void main(String[] args) {
    CompletableFuture.supplyAsync(() -> {
                /*
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException ignored) {}
                */
                //System.out.println("supplyAsync: " + Thread.currentThread().getName());
                return 1;
            })
            .thenApply(i -> {
                System.out.println("apply: " + Thread.currentThread().getName());
                return i + 1;
            })
            .thenAccept((i) -> {
                System.out.println("accept: " + Thread.currentThread().getName());
                System.out.println("result: " + i);
            }).join();
}

这是我得到的输出：

apply: main
accept: main
result: 2

看到main那里我很惊讶！Thread.sleep()我预计当我取消注释该调用或什至取消注释单个语句时会发生类似的情况sysout：

supplyAsync: ForkJoinPool.commonPool-worker-1
apply: ForkJoinPool.commonPool-worker-1
accept: ForkJoinPool.commonPool-worker-1
result: 2

我理解thenApplyAsync()将确保它不会在main线程上运行，但我想避免将供应商从运行的线程返回的数据传递supplyAsync …

我们在里面使用的字符串文字是自动变量吗？或者它们是否已在堆中分配,我们必须手动释放？

我的情况类似于下面显示的代码,其中我将字符串文字分配给类的私有字段(在代码中标记为ONE),并在稍后的程序中检索它并使用它(标记为TWO).我是否将堆栈中的变量分配给ONE中的字段？代码是否可以引用悬空指针,在这种情况下,因为程序足够小,所以可以工作？

我编译并运行它,它运行正常,但我在我的实际程序中遇到了一个奇怪的崩溃,我将字符串文字分配给类的字段,我怀疑上面提到的情况.

#include <iostream>

using namespace std;

class MemoryLeak
{
private:
    char *s;
public:
    MemoryLeak() {}

    void store()
    {
        s = "Storing a string"; // ONE
    }

    char *retrieve()
    {
        return s;
    }
};

int main()
{
    MemoryLeak *obj = new MemoryLeak();
    obj->store();
    cout << obj->retrieve() << endl; // TWO
    delete obj;
    return 0;
}

我应该将变量"s"声明为char数组而不是指针吗？我打算使用std :: string,但我对此很好奇.

任何指针或帮助,一如既往,非常感谢:)谢谢.

我不能在我的项目中使用shared_ptr,没有提升:(

所以,我的课程大致类似于下面的课程:

class MyClass
{
private:
  std::auto_ptr<MyOtherClass> obj;
};

现在,我想在std :: vector中存储上面类的实例.安全吗？我在这里读到 std :: auto_ptr与STL容器一起使用是错误的.这适用于我的情况吗？

我启用了 /health 端点，但我只是不希望它在同一台机器上列出 Consul 监控的所有服务。

这是我的 application.properties：

# Enable just the health endpoint.
endpoints.health.enabled=true

# Disable all default endpoints and Spring Cloud endpoints.
endpoints.enabled=false
endpoints.consul.enabled=false
endpoints.pause.enabled=false
endpoints.resume.enabled=false
endpoints.refresh.enabled=false
endpoints.restart.enabled=false
endpoints.shutdown.enabled=false
endpoints.env.enabled=false

management.health.db.enabled=false
management.health.diskspace.enabled=false
management.health.defaults.enabled=false

...这就是 /health 当前发出的信息：

$ curl -o- http://localhost:8080/health | python -m json.tool
{
    "consul": {
        "advertiseAddress": "10.10.10.10", 
        "bindAddress": "10.10.10.10", 
        "clientAddress": "127.0.0.1", 
        "datacenter": "DC", 
        "domain": "consul.", 
        "nodeName": "mynode", 
        "services": {
            "myservice1": [
                "tag1"
            ], 
            "myservice2": [
                "tag1", 
                "tag2"
            ]
        }, 
        "status": "UP"
    }, 
    "description": "Spring Cloud Consul Discovery …

下面,我没有宣称my_ints是指针.我不知道将分配内存的位置.请教我这里!

#include <iostream>
#include <vector>

class FieldStorage
{
private:
    std::vector<int> my_ints;

public:
    FieldStorage()
    {
        my_ints.push_back(1);
        my_ints.push_back(2);
    }

    void displayAll()
    {
        for (int i = 0; i < my_ints.size(); i++)
        {
            std::cout << my_ints[i] << std::endl;
        }
    }
};

在这里,我将该字段声明my_ints为指针:

#include <iostream>
#include <vector>

class FieldStorage
{
private:
    std::vector<int> *my_ints;

public:
    FieldStorage()
    {
        my_ints = new std::vector<int>();
        my_ints->push_back(1);
        my_ints->push_back(2);
    }

    void displayAll()
    {
        for (int i = 0; i < my_ints->size(); i++)
        {
            std::cout << …

我还在学习C++; 我正在尝试多态性如何工作,并在调用虚方法时遇到分段错误.

(注意:我没有将析构函数标记为虚拟,我只是试着看看会发生什么.)这是代码:

#include <iostream>

using namespace std;

class Base
{
protected:
  char *name;

public:
  Base(char *name)
  {
    cout << name << ": Base class cons" << endl;
  }

  ~Base()
  {
    cout << name << ": Base class des" << endl;
  }

  virtual void disp();
};

void Base::disp()
{
  cout << name << ": Base disp()" << endl;
}

class Child : public Base
{
public:
  Child(char *name):
    Base(name)
  {
    cout << name << ": Child class cons" << endl; …

我正在尝试以一种直观的方式将我听到的P,NP,NP-Complete和NP-Hard包裹起来,以便我不必记住他们的定义.

在下图中(左手方案,P!= NP),NP-Complete和NP-Hard之间存在重叠区域.这是否意味着一些问题既是NP-Complete又是NP-Hard？根据这个特殊的答案,我发现这是矛盾的:NP,NP-Complete和NP-Hard之间有什么区别？.

上面链接中的表说NP-Complete问题在多项式时间内是可验证的,而NP-Hard问题则不是.那怎么会有重叠呢？