xperious's questions

文章中有一段代码

int c;
if ((c = cmpxchg (val, 0, 1)) != 0) {
    //something
}
// cmpxchg(var, old, new): The content of the variable var will be replaced with 
// new if the current value is old. Regardless, the current value of var before the   
// operation is returned.

std 中没有这样的 CAS 指令实现...

我试图模拟这段代码：

std::uint32_t с = 0;
if ((с = std::atomic_compare_exchange_strong(&val, &c, 1) ? 0 : 1) != 0) {
    //something
}

这有多正确？

编辑：待回答

std::uint32_t с = 0;
if (!std::atomic_compare_exchange_strong(&val, &c, 1)) {
    //something
}

我的这段代码有语法错误：

from typing import List, Dict, Any, Optional, Union    

class Message:
    def __init__(self):
        self.a: Dict[str, Any] = {}
        self.b: List[Dict[str, Any]] = []
        self.c: List[Dict[str, Any]] = []
              ^
SyntaxError: invalid syntax

我知道这是python版本。帮我转换成python3.5的有效版本

你好，有必要学习如何通过gdb调试多线程应用程序......假设有这样一个应用程序有几个线程：

int main() {
     static int i =0;
     std::thread([](){ while(true) { ++i; std::this_thread::sleep_for( std::chrono::milliseconds(700)); std::cout << "hello\n";}}).detach();
     std::thread([](){ while(true) { std::this_thread::sleep_for(std::chrono::milliseconds(600)); std::cout << "my\n";}}).detach();
     std::thread([](){ while(true) { std::this_thread::sleep_for(std::chrono::milliseconds(900)); std::cout << "world\n";}}).detach();
     std::thread([](){ while(true) { std::this_thread::sleep_for(std::chrono::milliseconds(700)); std::cout << "ro\n";}}).join();
}

连接 gdb -p number_of_pid 进程：

Type "apropos word" to search for commands related to "word".
Attaching to process 9208
[New LWP 9209]
[New LWP 9210]
[New LWP 9211]
[New LWP 9212]
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib64/libthread_db.so.1".
0x00007f1bae990acd in pthread_join () from /lib64/libpthread.so.0

并且应用程序停止...告诉我如何在调试器中查看变量 i 的值，如果我们一附加 gdb，那么一切都停止，如果我们接下来执行，那么假设某行中的 br，然后n，然后一切顺利 和以前一样，变量 i 的值（通过打印）无法显示...

有一个功能

int foo(int num) {
if(num)
    return 1;
else
    return 3;
}

我理解没有优化的输出：

foo(int):
  pushq %rbp
  movq %rsp, %rbp
  movl %edi, -4(%rbp)
  cmpl $0, -4(%rbp)
  je .L2
  movl $1, %eax
  jmp .L3
.L2:
  movl $3, %eax
.L3:
  popq %rbp
  ret

但目前还不清楚 O2 发生了什么：

foo(int):
  cmpl $1, %edi
  sbbl %eax, %eax
  andl $2, %eax
  addl $1, %eax
  ret

为什么要使用 SubBtract 和 Borrow ......此外，如果你用 return 2 替换 return 3 的返回值，那么总的来说，奇怪的是一切都解决了

 foo(int):
  xorl %eax, %eax
  testl %edi, %edi
  sete %al
  addl $1, %eax
  ret

澄清一点优化的地方......否则我无法以任何方式输入一些东西

动态链接 .so 库。我找不到如何使用构建此库的 .cpp 文件的功能。

您好，我正在阅读 Robert Love 的《系统编程》，他写了关于 fsync()、O_SYNC，但不清楚这些函数的用途...

1. 哪里需要这些函数调用？如果总是需要它，那么默认情况下会设置同步。从书中引用。

   开销会大幅增加，因此只有在别无选择时才应使用同步 I/O。

2. 一个硬盘驱动器可以处理多少个并发 I/O 操作？嗯，即 我想在 1000 个线程中并行读取或写入磁盘上的不同文件，是否有任何意义，或者一切都会变慢（这意味着不是因为上下文切换，而是因为磁盘本身的某种原因）？

你好，假设在几个程序线程（线程）中，我们调用 read 函数......它在一个线程中结束，比如说，errno = EAGAIN，在另一个线程中，errno = EBADF ... 是 errno 变量线程安全的，还是在每个线程中都是她的？

对如何在 C 中实现一段时间后异步调用的计时器感兴趣。在这里，假设设置了一个 javascript 计时器：

setTimeout(func, 1000);

或在 boost::asio:

boost::asio::deadline_timer t(io, boost::posix_time::seconds(5));
t.async_wait(&print);

对如何在 C 中实现相同的内容感兴趣。那些。我们设置一个计时器，做一些有用的工作，然后在一段时间后触发一个信号，或者我们以其他方式异步通知。做延迟只是愚蠢的，这是不对的，而是在一段时间后调用它，直到那一刻才暂停工作。至少原理本身，使用什么，eventfd信号或其他东西。

这不是我第一次听说C#或Java 中的堆分配速度比C++中的快。我不知道为什么会这样：堆分配意味着在内存中寻找空闲页面。这怎么能加速，谣言是真的吗？

你好，有必要使用正则表达式从 scgi 请求中撕掉所有标头及其值...请求：

CONTENT_LENGTH\027\0SCGI\01\0REQUEST_METHOD\0POST\0REQUEST_URI\0/deepthought\0,What is the answer to life?

整个问题都在终端零......我只是没有尝试过：“（\ 0 [a-zA-Z_ /] + \ 0）”，一般来说，它甚至找不到数字“（ \\d+)"

代码本身：

auto f = QString("CONTENT_LENGTH\027\0SCGI\01\0REQUEST_METHOD\0POST\0REQUEST_URI\0/deepthought\0,What is the answer to life?");
QRegExp rx("(/\x00/\\d+)");    // сюда много чего перепробовал
int pos1{0}; QStringList list1;
while ((pos1 = rx.indexIn(f, pos1)) != -1) {
    list1 << rx.cap(1);
    pos1 += rx.matchedLength();
}
std::cout << list1.join(",").toStdString() << std::endl;

Abyx同志，灵机一动，还是不知道怎么把header的值拉出来 （比如27），之后：

f = QString::fromLocal8Bit("CONTENT_LENGTH\027\0SCGI\01\0REQUEST_METHOD\0POST\0REQUEST_URI\0/deepthought\0,What is the answer to life?"
          , 96);
QRegExp rx("(\\x00*[a-zA-Z_/]+)");

以下是输出：

  CONTENT_LENGTH,SCGI,REQUEST_METHOD,POST,REQUEST_URI,/deepthought,What,is,the,answer,to,life

我用了QThreadPool，我做setMaxThreadCount(10)了，没有错误，一切正常，只是线程池中还有4个线程（机器上的核心数），我完全不明白为什么。谁遇到过这个问题，你是如何解决这个问题的？

您好，MySQL DBMS中有两张表：

1. 用户

   +----+-------+----------+
   | id | login | password |
   +----+-------+----------+
   |  1 | o1    | 123      |
   +----+-------+----------+
   

2. 会议

   +-------+--------+---------+---------------------+---------------------+
   | token | active | user_id | create_time         | update_time         |
   +-------+--------+---------+---------------------+---------------------+
   | first |      1 |       1 | 2017-07-06 12:31:00 | 2017-07-06 12:31:00 |
   +-------+--------+---------+---------------------+---------------------+
   

您需要执行以下操作：如果user有一行登录名是 o1，则将条目添加到session.

我做了这样的事情，但没有用：

if((select count(*) from user where login = 'o1')>0, 
    insert into session values ('first', 1, now(), now()), 
    select NULL from user);

我想弄清楚什么样的轻量级流，结果，我脑子里的一团糟变得更浓了……我在这里读了 W. Richard Stevens 和 Steven A. Rago 的书“UNIX. Professional Programming”，那里是一块：

pthread_t ntid;
void
printids(const char *s)
{
    pid_t pid;
    pthread_t tid;
    pid = getpid();
    tid = pthread_self();
    printf("%s pid %u tid %u (0x%x)\n", s, (unsigned int)pid,
       (unsigned int)tid, (unsigned int)tid);
}
void* thr_fn(void *arg)
{
printids("новый поток: ");
return((void *)0);
}
int
main(void)
{
    int err;
    err = pthread_create(&ntid, NULL, thr_fn, NULL);
    if (err != 0)
        err_quit("невозможно создать поток: %s\n", strerror(err));
    printids("главный поток:");
    sleep(1);
    exit(0);
}

这linux导致了以下结果：

$ ./a.out
новый поток:   pid 6628 tid 1026 (0x402)
главный поток: pid 6626 tid 1024 (0x400)

那些。对于每个线程都是process id不同的，因为当使用该类型pthread_create的系统调用clone()时，这也是一种过程...... 线程有共同的地址空间，但有自己的栈，进程有不同的地址空间。

谷歌搜索非常令人困惑：它在某个地方说posix threads在 Linux 中它们只在内核空间中工作，在用户空间中的某个地方，在两者中的某个地方。我认为在 there 和 there 中都只执行进程。

因此问题：

• linux 中的本机线程是在用户空间还是内核空间中运行？

• Linux 中是否有本机线程？它是轻量级进程吗？

你好，假设我有一个客户端套接字...建立连接，接收数据/发送...但是是否可以连接到另一个地址，并且，就好像什么都没发生一样，开始与完全不同的主机进行交换？我知道 SO_REUSEADDR 参数不会影响这个

你好，我对 QTimer 的几个问题很感兴趣。据我了解，它不在文档中：

1）假设有一个代码：

{
    QTimer::singleShot(5000, this, [this](){ std::cout<<"hello world\n"; });
    /*...какие-то долгие вычисления...*/
}

计时器何时启动：在调用 singleShot 的行中立即启动，还是在退出范围后（即经过长时间计算后）？

2) 启动后 5 秒后，是否将回调添加到事件处理程序队列？那些。如果已经有 1 个正在运行的回调，队列中有 2 个在它后面，那么我们来自计时器的回调将已经是 4，或者在第一个回调被调用之后立即，即 超越下一个 2？

你好，我决定在 c 套接字上写一个小包装器，告诉我为什么 sigpipe 在写函数中崩溃？

套接字.hpp

#ifndef SOCKET_HPP
#define SOCKET_HPP


#include <iostream>
#include <vector>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <strings.h>

enum class socket_type {
    client,
    server,
};


class ISocket {
public:
    ISocket() = default;
    virtual ~ISocket() = default;

    virtual void connect() = 0;
    virtual void close() = 0;

    virtual void receive(char* buff, std::size_t len) = 0;
    virtual void receive(std::vector<char>& buff, std::size_t len) = 0;
    virtual void send(char* buff, std::size_t len) = 0;
    virtual void send(std::vector<char> &buff, std::size_t len) = 0;

protected:
    virtual void bind() = 0;
    virtual void accept() = 0;
    virtual void listen() = 0;

    virtual int getdescriptor() = 0;
};

class serv_socket : public ISocket {
public:
    // у серверного сокета должен быть порт
    serv_socket(int port);
    ~serv_socket() = default;

    virtual void connect() final;
    virtual void close() final;

    virtual void receive(char *buff, std::size_t len) final;
    virtual void receive(std::vector<char> &buff, std::size_t len) final;
    virtual void send(char *buff, std::size_t len) final;
    virtual void send(std::vector<char> &buff, std::size_t len) final;

protected:
    virtual void bind() final;
    virtual void accept() final;
    virtual void listen() final;

    virtual int getdescriptor() final;

private:
    //дескриптор сокета который прослушиваем
    int descriptor;
    // дескриптор сокета к которому accept-имся
    int newdescriptor;
    // адрес сокета который прослушиваем
    struct sockaddr_in addr;
    // адрес сокета к которому accept-имся
    struct sockaddr cli_addr;
    //
    socklen_t clilen;
    // тип сокета
    socket_type type;
};

class client_socket : public ISocket {
public:
    client_socket(char * const address, int port);
    ~client_socket() = default;

    virtual void connect() final;
    virtual void close() final;

    virtual void receive(char* buff, std::size_t len) final;
    virtual void receive(std::vector<char> &buff, std::size_t len) final;
    virtual void send(char *buff, std::size_t len) final;
    virtual void send(std::vector<char> &buff, std::size_t len) final;


protected:
    virtual void bind() final;
    virtual void accept() final;
    virtual void listen() final;

    virtual int getdescriptor() final;

private:
    //дескриптор сокета
    int descriptor;
    //характеристики сокета
    struct sockaddr_in serv_addr;
    // хост
    struct hostent *server;
    // тип сокета
    socket_type type;
};

#endif // SOCKET_HPP

套接字.cpp：

#include <socket.hpp>
#include <vector>
#include <netdb.h>

serv_socket::serv_socket(int port)
    : ISocket(),
      descriptor(0),
      newdescriptor(0),
      type(socket_type::server)
{
    descriptor = ::socket(AF_INET, SOCK_STREAM, 0);
    bzero((char *) &addr, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(port);
}

void serv_socket::bind() {
    if(::bind(descriptor,
              (struct sockaddr *) &addr,
              sizeof(addr)) < 0
    )
        log_("ERROR in bind socket");
}

void serv_socket::listen()
{
    ::listen(descriptor, 5);
}

void serv_socket::accept()
{
    clilen = sizeof(cli_addr);
    newdescriptor = ::accept(descriptor,
                     (struct sockaddr *) &cli_addr,
                     &clilen);
}

void serv_socket::close() {
    ::close(newdescriptor);
    ::close(descriptor);
}

void serv_socket::receive(std::vector<char>& buff, std::size_t len) {
    int n = ::read(newdescriptor, buff.data(), len);
    if(n < 0)
        log_("ERROR reading from socket");
}

void serv_socket::receive(char *buff, std::size_t len) {
    int n = ::read(newdescriptor, buff, len);
    if(n < 0)
        log_("ERROR reading from socket");
}

void serv_socket::send(std::vector<char>& buff, std::size_t len) {
    int n = ::write(newdescriptor, buff.data(), len);
}

void serv_socket::send(char *buff, std::size_t len) {
    int n = ::write(newdescriptor, buff, len);
}

void serv_socket::connect()
{
    bind();
    listen();
    accept();
}

int serv_socket::getdescriptor() {
    return descriptor;
}

// ------------------клиентский сокет

client_socket::client_socket(char* const address, int port)
    : ISocket(),
      descriptor(0),
      type(socket_type::client)
{
    // создаем сокет
    descriptor = socket(AF_INET, SOCK_STREAM, 0);
    // устанавливаем адрес сервера
    server = gethostbyname(address);
    if(server == nullptr)
        log_("ERROR");
    //
    bzero((char *) &serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    bcopy((char *)server->h_addr,
         (char *)&serv_addr.sin_addr.s_addr,
         server->h_length);
    serv_addr.sin_port = htons(port);
}

void client_socket::connect() {
    if (::connect(descriptor,
                  (struct sockaddr *)&serv_addr,
                  sizeof(serv_addr)) < 0
        )
            log_("ERROR connecting");
}

void client_socket::close() {
    ::close(descriptor);
}

void client_socket::receive(std::vector<char> &buff, std::size_t len) 
{
    int n = ::read(descriptor, buff.data(), len);
    if(n < 0)
        log_("ERROR reading from socket");
}

void client_socket::receive(char* buff, std::size_t len) {
    int n = ::read(descriptor, buff, len);
    if(n < 0)
        log_("ERROR reading from socket");
}

void client_socket::send(std::vector<char>& buff, std::size_t len) {
    int n = ::write(descriptor, buff.data(), len);
}

void client_socket::send(char* buff, std::size_t len) {
    int stop = 0;
    int n = ::write(descriptor, buff, len);     <<---------------вот тут вылетает sigpipe
}

void client_socket::bind() {

}

void client_socket::accept() {

}

void client_socket::listen() {

}

int client_socket::getdescriptor() {
    return descriptor;
}

主.cpp：

int main(int argc, char** argv) {

    client_socket cs("127.0.0.1", 80);
    cs.connect();
    cs.send("hello", 6);
    cs.close();
    return 0;
}

一个关于原子操作的问题...
让我们以增量为例，执行以下操作：

1)грузим в регистр значение переменной
2)инкрементируем
3)выгружаем из регистра в память

如果我们从不同的线程开始这样做，那么我们可以读取旧值，这是可以理解的......

然而，来自不同线程的原子类型有什么魔力可以让这一切无误地完成呢？原子类型是什么意思？它是特定类型的属性还是可以保证任何类型？
嗯，代码：

#include <iostream>
#include <atomic>
#include <thread>
#include <chrono>
int main()
{
using namespace std::chrono_literals;
//std::atomic<long long> i{1};
//std::atomic<long long> ii{2};
long long i = 1;
long long ii = 2;

std::thread t1([&](){ i++; i--; ii++; });
std::thread t2([&](){ i++; i--; ii++; });
std::thread t3([&](){ i++; i--; ii++; });
std::thread t4([&](){ i++; i--; ii++; });

t1.join();
t2.join();
t3.join();
t4.join();

std::this_thread::sleep_for(100ms);

std::cout<<i<<" "<<ii;
}

为什么对于原子类型，对于非原子类型，它总是输出 1 6 ...它不应该是那样的

你好，试图理解qt中异步的本质...他们说qt是异步编程。假设这是代码：

void requests() {
     websocket->sendTextMessage(text1);

     websocket->sendTextMessage(text2);
}

我们发送一个请求，一个响应来了，它被排队，然后我们发送第二个请求，它的答案也排队等待第一个响应，然后在 onTextMessageReceived 槽中我们一个一个地处理响应......尽管事实第二条消息可能会更早收到响应，因此会更早地处理它。我不明白为什么这是一种异步方法？没有任何并行处理，我们仅在退出 requests() 函数时才进入 onTextMessageReceived() 槽，即 事实上，在 requests() 函数结束后同步...

你好，我不明白从操作系统的角度来看什么是任务......他们到处都写到基于任务的并行性从池中获取“任务”......但是“任务”是什么意思？这是一个有自己的堆栈的本机线程......我是否正确理解任务是“没有自己的堆栈的线程”，即 光流？如果是这样，它是如何在操作系统方面实现的？我假设 async/await 以某种方式使用轻量级线程的概念是否正确？

你好，帮忙用qt解析这个json：

{
"data": [{
    "services": {
        "414": {
            "23": {
                "3": {
                    "user_id": null,
                    "state": "WAITING"
                }
            },
            "2": {
                "23": {
                    "user_id": null,
                    "state": "WAITING"
                }
            }
        }
    }
}]
}

数字是随机生成的……我知道有一个 QJsonObject，但我想不出什么。如果数字是固定的（它们可以用作键），那没问题，否则我无法停止