JS 同步 function 来处理异步活动

Question

我有一个 function write2Bytes 附加到缓冲区。 如果已满，则必须写入电报。 如果我将 write2Bytes 设置为异步 function，则调用者可以等待并且它可以工作。 但由于 write2Bytes 主要是同步的，它只写入 memory，buf 但不写入套接字。 所以让它异步只会导致创建/删除不需要的承诺。 使用以下同步实现，无法确保对 write2Bytes 的第二次调用是否在不使用异步和调用方等待的情况下完成第一次调用。

请建议是否有更好的方法来设计这个 API write2Bytes ..谢谢...

以下是示例

var buf = Buffer.alloc(1024);
var offset = 0;

function write2Bytes(val) {
    if (buf.length - offset + 1 > 2) { // buf is full 
        // write buf data to socket
        socket.write(buf, (err) => {
            if (err) {
               console.log("failure");
            }   
            console.log("success");
        }); 
    }
    buf[offset++] = val 
    buf[offset++] = val + 1;
}

write2Bytes(4);
write2Bytes(4);

上面是我正在编写的代码，无法使其同步并仍然保持性能。

Answer 1

您可以使用 async await 使 socket.write function 像同步操作一样工作。

async write2Bytes(val) {

if (buf.length - offset + 1 > 2) { // buf is full 
   // write buf data to socket
        try{
           await socket.write(buf)
        }catch(e){
           consol.log(e);
        }
}

 buf[offset++] = val 
 buf[offset++] = val + 1;

}

有关更多信息，请查看此链接

Answer 2

我不知道你的套接字到底做了什么，但因为我假设它消耗了整个缓冲区，所以我将 go 与 2 个缓冲区串联。 这样你就可以“溢出”第一个缓冲区而不会丢失数据。

这也意味着，由于您可以写入超过缓冲区大小，因此无需在写入前检查是否有足够的空间（在合理的程度上） ，而只需写入一些数据，只是偶尔检查缓冲区是否已满并且需要被冲入插座。

亲 - 这使消耗 API 变得简单，因为它不必提前计划（太多）； 就像在每个写入步骤之前检查是否有足够的空间（如果没有，等待套接字，...）。

contra - 更高的 memory 消耗，或者您通过套接字发送一个 go 的更小的块大小。

// keep the buffer size at a power of 2, 
// then the math stays trivial and fast.
const BUFFER_SIZE = 1024, 
  SHIFT = Math.log2(BUFFER_SIZE), 
  MASK = BUFFER_SIZE - 1;
console.assert(BUFFER_SIZE & MASK === 0, "BUFFER_SIZE needs to be a power of 2");

const buffers = [ Buffer.alloc(BUFFER_SIZE), Buffer.alloc(BUFFER_SIZE) ];
let offset = 0;

const empty = () => !offset;
const isFull = () => offset > MASK;

async function flushBuffer() {
  const buf = buffers.shift();

  // fill the buffer with zeroes untill the end ...
  // if (offset < BUFFER_SIZE) {
  //   buf.fill(0, offset);
  // }

  offset = Math.max(0, offset - BUFFER_SIZE);

  // that's up to you to make this async
  await socket.write(buf);

  // ... or empty the buffer before reuse
  // buffer.fill(0);

  // reuse the buffer
  buffers.push(buf);
}

function writeByte(val) {
  // automagically writes into the second buffer when the offset >= BUFFER_SIZE
  buffers[offset >> SHIFT][MASK & offset++] = val;
}

function write2Bytes(val) {
  // just guessing
  writeByte(val & 0xFF);
  writeByte(val >> 8 & 0xFF);
}

然后你可以做类似的事情

write2Bytes(1);
write2Bytes(2);
// write some more ...

// every now and then
if (isFull()) {
  await flushBuffer();
}
// and write some more ...



// and at the end
if (!empty()) {
  // flush the rest of the data
  await flushBuffer();
}

或者喜欢循环

while (youHaveData) {
  while (!isFull()) {
    write2Bytes(1);
    write2Bytes(2);
    // write some more ...
  }

  await flushBuffer();
}

if (!empty()) {
  await flushBuffer();
}

你知道我要去哪里吗？