동일한 Unix 소켓에 동시에 읽기/쓰기가 가능합니까?

두 개 이상의 프로세스가 동시에 동일한 프로세스를 읽고 쓸 수 있습니까 unix socket?

몇 가지 테스트를 해봤습니다.

sock_test.sh다음은 50개의 클라이언트를 생성하고 각각 5K 메시지를 동시에 작성하는 내 것입니다 .

#! /bin/bash --

SOC='/tmp/tst.socket'

test_fn() {
  soc=$1
  txt=$2
  for x in {1..5000}; do
    echo "${txt}" | socat - UNIX-CONNECT:"${soc}"
  done
}

for x in {01..50}; do
  test_fn "${SOC}" "Test_${x}" &
done

그런 다음 하나를 만들고 unix socket해당 파일에 대한 모든 트래픽을 캡처합니다 sock_test.txt.

# netcat -klU /tmp/tst.socket | tee ./sock_test.txt

마지막으로 테스트 스크립트( )를 실행 sock_test.sh하고 화면에 표시되는 워커 50개를 모두 모니터링합니다. 마지막으로 모든 메시지가 목적지에 도달했는지 확인합니다.

# ./sock_test.sh
# sort ./sock_test.txt | uniq -c

놀랍게도 50명의 작업자 모두가 오류 없이 5K 메시지를 모두 성공적으로 보냈습니다.

결론을 내려야 할 것 같은데, unix sockets동시에 써도 괜찮을까요?

내 동시성 수준이 너무 낮아 충돌을 볼 수 없나요?

내 테스트 방법에 문제가 있나요? 그렇다면 어떻게 제대로 테스트할 수 있을까요?

편집하다

이 질문에 대한 훌륭한 답변에 따라 더 친숙한 사람들을 위해 python여기에 내 테스트 베드가 있습니다.

#! /usr/bin/python3 -u
# coding: utf-8

import socket
from concurrent import futures


pow_of_two = ['B','KB','MB','GB','TB']
bytes_dict = {x: 1024**pow_of_two.index(x) for x in pow_of_two}
SOC = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
SOC.connect('/tmp/tst.socket')


def write_buffer(
    char: 'default is a' = 'a',
    sock: 'default is /tmp/tst.socket' = SOC,
    step: 'default is 8KB' = 8 * bytes_dict['KB'],
    last: 'default is 2MB' = 2 * bytes_dict['MB']):

    print('## Dumping to the socket: {0}'.format(sock))
    while True:
        in_memory = bytearray([ord(char) for x in range(step)])
        msg = 'Dumping {0} bytes of {1}'
        print(msg.format(step, char))
        sock.sendall(bytes(str(step), 'utf8') + in_memory)
        step += step
        if last % step >= last:
            break


def workers(concurrency=5):
    chars = concurrency * ['a', 'b', 'c', 'd']
    with futures.ThreadPoolExecutor() as executor:
        for c in chars:
            executor.submit(write_buffer, c)


def parser(chars, file='./sock_test.txt'):
    with open(file=file, mode='rt', buffering=8192) as f:
        digits = set(str(d) for d in range(0, 10))
        def is_digit(d):
            return d in digits
        def printer(char, size, found, junk):
            msg = 'Checking {}, Expected {:8s}, Found {:8s}, Junk {:8s}, Does Match: {}'
            print(msg.format(char, size, str(found), str(junk), size == str(found)))
        char, size, found, junk = '', '', 0, 0
        prev = None
        for x in f.read():
            if is_digit(x):
                if not is_digit(prev) and prev is not None:
                    printer(char, size, found, junk)
                    size = x
                else:
                    size += x
            else:
                if is_digit(prev):
                    char, found, junk = x, 1, 0
                else:
                    if x==char:
                        found += 1
                    else:
                        junk += 1
            prev = x
        else:
            printer(char, size, found, junk)


if __name__ == "__main__":
    workers()
    parser(['a', 'b', 'c', 'd'])

그러면 출력에서 ​​다음과 같은 줄을 볼 수 있습니다.

Checking b, Expected 131072  , Found 131072  , Junk 0       , Does Match: True
Checking d, Expected 262144  , Found 262144  , Junk 0       , Does Match: True
Checking b, Expected 524288  , Found 219258  , Junk 0       , Does Match: False
Checking d, Expected 524288  , Found 219258  , Junk 0       , Does Match: False
Checking c, Expected 8192    , Found 8192    , Junk 0       , Does Match: True
Checking c, Expected 16384   , Found 16384   , Junk 0       , Does Match: True
Checking c, Expected 32768   , Found 32768   , Junk 610060  , Does Match: True
Checking c, Expected 524288  , Found 524288  , Junk 0       , Does Match: True
Checking b, Expected 262144  , Found 262144  , Junk 0       , Does Match: True

b어떤 경우에는 페이로드( , d)가 불완전하지만 누락된 조각( c)이 나중에 수신되는 것을 볼 수 있습니다 . 간단한 수학이 이를 증명합니다.

# Expected
b + d = 524288 + 524288 = 1048576
# Found b,d + extra fragment on the other check on c
b + d + c = 219258 + 219258 + 610060 = 1048576

따라서 동시 쓰기 unix sockets는좋아요안좋다.