小编inj*_*joy的帖子

我阅读了boost asio http服务器示例代码(参见http://www.boost.org/doc/libs/1_54_0/doc/html/boost_asio/example/cpp11/http/server/connection.cpp)并找到auto self(shared_from_this());变量是已在捕获范围([this, self])中使用.但自变量未在lambda函数中使用.那么这样做有什么好处？

我读了LKD ^1中的一些段落, 我无法理解下面的内容:

从用户空间访问系统调用

通常,C库提供对系统调用的支持.用户应用程序可以从标准头中提取函数原型并与C库链接以使用您的系统调用(或者库例程,而该库例程又使用您的系统调用).但是,如果您刚刚编写了系统调用,那么glibc已经支持它是值得怀疑的!

值得庆幸的是,Linux提供了一组用于包装系统调用访问的宏.它设置寄存器内容并发出陷阱指令.这些宏被命名,其中介于0和6之间.该数字对应于传递给系统调用的参数数量,因为宏需要知道预期的参数数量,从而推入寄存器.例如,考虑系统调用,定义为_syscalln()nopen()

long open(const char *filename, int flags, int mode)

Run Code Online (Sandbox Code Playgroud)

在没有显式库支持的情况下使用此系统调用的syscall宏将是

#define __NR_open 5
_syscall3(long, open, const char *, filename, int, flags, int, mode)

Run Code Online (Sandbox Code Playgroud)

然后,应用程序可以简单地调用open().

对于每个宏,有2 + 2×n个参数.第一个参数对应于系统调用的返回类型.第二个是系统调用的名称.接下来是系统调用顺序的每个参数的类型和名称.的__NR_open定义是在<asm/unistd.h>; 它是系统呼叫号码.的_syscall3宏扩展到与联汇编C函数; 程序集执行上一节中讨论的步骤,将系统调用号和参数推送到正确的寄存器中,并发出软件中断以陷入内核.将此宏放在应用程序中是使用open()系统调用所需的全部内容.

让我们编写宏来使用我们精彩的新foo()系统调用,然后编写一些测试代码来展示我们的努力.

#define __NR_foo 283
__syscall0(long, foo)

int main ()
{
        long stack_size;

        stack_size = foo ();
        printf ("The kernel stack size is %ld\n", stack_size);
        return 0;
}

Run Code Online (Sandbox Code Playgroud)

是什么 …

我有一个程序如下:

int main()
{
    int val = 4;
    auto add = [val](int a)->int{
        val += 2;
        return a+val;
    };
    cout << add(3) << endl;
    cout << val << endl;
    return 0;
}

Xcode中存在编译错误:无法分配给非可变lambda中的副本捕获的变量.

我的问题是:如果我们选择使用副本(使用"="或值名称),是否不能为此值分配新值或更改？

我尝试使用该kubectl get sa default命令，但只能看到一些非常基本的值。在 k8s 中查看与特定服务帐户关联的权限/角色的命令是什么？

可能重复:
pthread_create创建的线程与内核线程相同？

我使用下面的代码来测试pthread_create函数可以创建的最大线程数.

#include <pthread.h>
#include <stdio.h>

static unsigned long long thread_nr = 0;

pthread_mutex_t mutex_;

void* inc_thread_nr(void* arg) {
    (void*)arg;
    pthread_mutex_lock(&mutex_);
    thread_nr ++;
    pthread_mutex_unlock(&mutex_);

    /* printf("thread_nr = %d\n", thread_nr); */

    sleep(300000);
}

int main(int argc, char *argv[])
{
    int err;
    int cnt = 0;

    pthread_t pid[1000000];

    pthread_mutex_init(&mutex_, NULL);

    while (cnt < 1000000) {

        err = pthread_create(&pid[cnt], NULL, (void*)inc_thread_nr, NULL);
        if (err != 0) {
            break;
        }
        cnt++;
    }

    pthread_join(pid[cnt], NULL);

    pthread_mutex_destroy(&mutex_);
    printf("Maximum number of threads per process is = …

例如,我需要生成一个共享库libXXX.so.

1. 生成它的常用方法是什么？只使用-fPIC -shared？

2. 我是否需要创建此库的软链接？我的意思是使用ln -s.

3. 如果我更新共享库,即如何.从libXXX.so.1.2.3到libXXX.so.1.2.4,我的项目如何知道共享库已更新？我是否需要重新编译整个项目？

4. 在Makefile中管理共享库的常用方法是什么？

我完全不明白这些问题.请帮我一个忙 :-)

我读了一些代码如下:

void
mcachefs_file_start_thread()
{
  pthread_attr_t attrs;
  pthread_attr_init(&attrs);
  pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_JOINABLE);
  pthread_create(&mcachefs_file_threadid, &attrs, mcachefs_file_thread, NULL);
}

在这里,设置的用法attrs是PTHREAD_CREATE_JOINABLE什么？此外,它不是由pthead_create？创建的线程的默认属性？

我读了一本手册说(见http://en.cppreference.com/w/cpp/memory/shared_ptr/make_shared):

此外,f(shared_ptr<int>(new int(42)), g())如果g抛出异常,可能导致内存泄漏.如果使用make_shared,则不存在此问题.

为什么会导致内存泄漏？

我是 kafka 的新手，当我阅读 Kafka 文档时，我意识到使用相同密钥提供的消息将被映射到相同的分区以保证顺序。这完全有道理。但是，我想知道如果我们在运行时增加主题分区的数量，具有相同键的新消息是否会像以前一样散列到同一分区（旧分区）？

如果是这样，如果所有消息都提供了键，那么它们都不会映射到新分区怎么办？这对我来说没有意义。

如果不是，那么Kafka如何保证具有相同key的消息的顺序呢？

我正在阅读"Scala中的FP"一书中的练习5.8,问题是:

"稍微概括一下函数常量,返回给定值的无限流."

def constant[A](a: A): Stream[A]

我的解决方案是:

def constant[A](a: A): Stream[A] =
  Stream.cons(a, constant(a))

我指的是标准解决方案,它是:

// This is more efficient than `cons(a, constant(a))` since it's just
// one object referencing itself.
def constant[A](a: A): Stream[A] = {
  lazy val tail: Stream[A] = Cons(() => a, () => tail) 
  tail
}

其中说"效率更高",请看这里.

我能知道它为什么效率更高？Streams中的cons构造函数AFAIK已经将头部和尾部标记为懒惰:

def cons[A](hd: => A, tl: => Stream[A]): Stream[A] = { 
  lazy val head = hd 
  lazy val tail = tl 
  Cons(() => head, () => tail) …