Đầu ra thay thế quá trình là ra khỏi thứ tự

Các

echo one; echo two > >(cat); echo three; 

lệnh cho đầu ra bất ngờ.

Tôi đọc điều này: Làm thế nào thay thế quá trình được thực hiện trong bash? và nhiều bài viết khác về thay thế quy trình trên internet, nhưng không hiểu tại sao nó lại hoạt động theo cách này.

Sản lượng dự kiến:

one
two
three

Sản lượng thực:

prompt$ echo one; echo two > >(cat); echo three;
one
three
prompt$ two

Ngoài ra, hai lệnh này phải tương đương với quan điểm của tôi, nhưng chúng không:

##### first command - the pipe is used.
prompt$ seq 1 5 | cat
1
2
3
4
5
##### second command - the process substitution and redirection are used.
prompt$ seq 1 5 > >(cat)
prompt$ 1
2
3
4
5

Tại sao tôi nghĩ, họ nên giống nhau? Bởi vì, cả hai kết nối seqđầu ra với catđầu vào thông qua đường ống ẩn danh - Wikipedia, Quá trình thay thế .

Câu hỏi: Tại sao nó hành xử theo cách này? Lỗi của tôi ở đâu? Câu trả lời toàn diện là mong muốn (với lời giải thích về cách bashthực hiện dưới mui xe).

Có, bashgiống như trong ksh(tính năng đến từ đâu), các quy trình bên trong quy trình thay thế không được chờ đợi (trước khi chạy lệnh tiếp theo trong tập lệnh).

đối với một <(...), điều đó thường tốt như trong:

cmd1 <(cmd2)

Shell sẽ chờ đợi cmd1và cmd1thường sẽ chờ đợi cho cmd2đến khi nó đọc cho đến khi hết tập tin trên đường ống được thay thế, và việc kết thúc tập tin đó thường xảy ra khi cmd2chết. Đó là lý do cùng nhiều vỏ (không bash) không bận tâm chờ đợi cmd2trong cmd2 | cmd1.

Đối cmd1 >(cmd2)Tuy nhiên,, đó là thường không phải như vậy, vì nó là nhiều cmd2mà thường chờ cmd1có như vậy sẽ thường thoát sau đó.

Điều đó đã được sửa trong zshđó chờ cmd2ở đó (nhưng không phải nếu bạn viết nó dưới dạng cmd1 > >(cmd2)và cmd1không được dựng sẵn, {cmd1} > >(cmd2)thay vào đó hãy sử dụng như tài liệu ).

kshkhông chờ đợi theo mặc định, nhưng cho phép bạn chờ nó với waitnội trang (nó cũng làm cho pid có sẵn $!, mặc dù điều đó không giúp ích gì nếu bạn làm vậy cmd1 >(cmd2) >(cmd3))

rc(với cmd1 >{cmd2}cú pháp), giống như kshngoại trừ bạn có thể nhận được các pids của tất cả các quy trình nền với $apids.

es(cũng với cmd1 >{cmd2}) chờ đợi cmd2như trong zshvà cũng chờ cmd2trong <{cmd2}quá trình chuyển hướng.

bashkhông làm cho pid của cmd2(hoặc chính xác hơn là lớp con như nó chạy cmd2trong một tiến trình con của lớp con đó mặc dù đó là lệnh cuối cùng ở đó) có sẵn $!, nhưng không cho phép bạn chờ đợi.

Nếu bạn phải sử dụng bash, bạn có thể giải quyết vấn đề bằng cách sử dụng lệnh sẽ chờ cả hai lệnh với:

{ { cmd1 >(cmd2); } 3>&1 >&4 4>&- | cat; } 4>&1

Điều đó làm cho cả hai cmd1và cmd2có fd 3 của họ mở ra một đường ống. catsẽ chờ kết thúc tập tin ở đầu kia, vì vậy thường sẽ chỉ thoát khi cả hai cmd1và cmd2đã chết. Và shell sẽ chờ catlệnh đó . Bạn có thể thấy rằng như một mạng lưới để bắt đầu chấm dứt tất cả các quy trình nền (bạn có thể sử dụng nó cho những thứ khác bắt đầu trong nền như với &, coprocs hoặc thậm chí các lệnh mà nền đó cung cấp, chúng không đóng tất cả các mô tả tệp của chúng như daemon thường làm ).

Lưu ý rằng nhờ quy trình chia nhỏ bị lãng phí đã đề cập ở trên, nó hoạt động ngay cả khi cmd2đóng fd 3 của nó (các lệnh thường không làm điều đó, nhưng một số thích sudohoặc sshlàm). Các phiên bản trong tương lai bashcuối cùng có thể thực hiện tối ưu hóa như trong các shell khác. Sau đó, bạn cần một cái gì đó như:

{ { cmd1 >(sudo cmd2; exit); } 3>&1 >&4 4>&- | cat; } 4>&1

Để đảm bảo vẫn còn một quá trình shell bổ sung với fd 3 mở đó đang chờ sudolệnh đó .

Lưu ý rằng catsẽ không đọc bất cứ điều gì (vì các quy trình không viết trên fd 3 của họ). Nó chỉ ở đó để đồng bộ hóa. Nó sẽ thực hiện chỉ một read()cuộc gọi hệ thống sẽ trở lại mà không có gì ở cuối.

Bạn thực sự có thể tránh chạy catbằng cách sử dụng thay thế lệnh để thực hiện đồng bộ hóa đường ống:

{ unused=$( { cmd1 >(cmd2); } 3>&1 >&4 4>&-); } 4>&1

Lần này, nó là cái vỏ thay vì catđọc từ ống có đầu kia mở trên fd 3 cmd1và cmd2. Chúng tôi đang sử dụng một phép gán biến để trạng thái thoát cmd1có sẵn trong $?.

Hoặc bạn có thể thực hiện thay thế quy trình bằng tay, và sau đó bạn thậm chí có thể sử dụng hệ thống của mình shvì điều đó sẽ trở thành cú pháp shell tiêu chuẩn:

{ cmd1 /dev/fd/3 3>&1 >&4 4>&- | cmd2 4>&-; } 4>&1

mặc dù lưu ý như đã lưu ý trước đó rằng không phải tất cả các shtriển khai sẽ đợi cmd1sau khi cmd2kết thúc (mặc dù điều đó tốt hơn so với cách khác). Thời gian đó, $?chứa trạng thái thoát của cmd2; mặc dù bashvà zshlàm cho cmd1trạng thái thoát có sẵn trong ${PIPESTATUS[0]}và $pipestatus[1]tương ứng (xem thêm pipefailtùy chọn trong một số shell để $?có thể báo cáo sự cố của các thành phần đường ống khác với lần cuối)

Lưu ý rằng yashcó vấn đề tương tự với tính năng chuyển hướng quy trình của nó . cmd1 >(cmd2)sẽ được viết cmd1 /dev/fd/3 3>(cmd2)ở đó. Nhưng cmd2không được chờ đợi và bạn cũng không thể sử dụng waitđể chờ đợi và pid của nó cũng không có sẵn trong $!biến. Bạn sẽ sử dụng cùng một công việc xung quanh như cho bash.

Bạn có thể chuyển lệnh thứ hai sang lệnh khác cat, lệnh này sẽ đợi cho đến khi đường ống đầu vào của nó đóng lại. Ví dụ:

prompt$ echo one; echo two > >(cat) | cat; echo three;
one
two
three
prompt$

Ngắn gọn và đơn giản.

==========

Đơn giản như nó có vẻ, rất nhiều điều đang diễn ra đằng sau hậu trường. Bạn có thể bỏ qua phần còn lại của câu trả lời nếu bạn không quan tâm đến cách thức hoạt động của nó.

Khi bạn có echo two > >(cat); echo three, >(cat)bị chặn bởi lớp vỏ tương tác và chạy độc lập với echo two. Do đó, echo twokết thúc, và sau đó echo threeđược thực hiện, nhưng trước khi >(cat)kết thúc. Khi bashnhận được dữ liệu từ >(cat)khi nó không mong đợi (một vài mili giây sau), nó sẽ mang đến cho bạn tình huống giống như nhắc nhở khi bạn phải nhấn dòng mới để quay lại thiết bị đầu cuối (Giống như khi người dùng khác sửa mesgbạn).

Tuy nhiên, được đưa ra echo two > >(cat) | cat; echo three, hai subshells được sinh ra (theo tài liệu của |biểu tượng).

Một subshell tên A là cho echo two > >(cat), và một subshell tên B là cho cat. A được tự động kết nối với B (Thiết bị xuất chuẩn của A là stdin của B). Sau đó, echo twovà >(cat)bắt đầu thực hiện. >(cat)Thiết bị xuất chuẩn của A được đặt thành thiết bị xuất chuẩn của A, bằng với stdin của B. Sau khi echo twokết thúc, A thoát ra, đóng lại thiết bị xuất chuẩn của nó. Tuy nhiên, >(cat)vẫn đang giữ tài liệu tham khảo cho stdin của B. catStdin của người thứ hai đang giữ stdin của B, và điều đó catsẽ không thoát cho đến khi thấy EOF. Một EOF chỉ được đưa ra khi không ai mở tệp ở chế độ ghi nữa, do đó >(cat), thiết bị xuất chuẩn sẽ chặn thứ hai cat. B vẫn chờ ngày thứ hai cat. Kể từ khi echo twothoát ra, >(cat)cuối cùng nhận được EOF, vì vậy>(cat)tuôn ra bộ đệm của nó và thoát ra. Không ai giữ catstdin của B / giây nữa, vì vậy người thứ hai catđọc EOF (B hoàn toàn không đọc stdin của nó, điều đó không quan tâm). EOF này làm cho cái thứ hai cattuôn ra bộ đệm của nó, đóng thiết bị xuất chuẩn của nó và thoát ra, rồi B ​​thoát ra vì catthoát ra và B đang đợi cat.

Một cảnh báo của điều này là bash cũng sinh ra một subshell cho >(cat)! Bởi vì điều này, bạn sẽ thấy rằng

echo two > >(sleep 5) | cat; echo three

vẫn sẽ đợi 5 giây trước khi thực hiện echo three, mặc dù sleep 5không giữ stdin của B. Điều này là do một mạng con ẩn C được sinh ra >(sleep 5)đang chờ đợi sleepvà C đang giữ stdin của B. Bạn có thể thấy như thế nào

echo two > >(exec sleep 5) | cat; echo three

Tuy nhiên, sẽ không chờ đợi, vì sleepkhông giữ stdin của B, và không có con ma nào C giữ stdin của B (người thực thi sẽ buộc ngủ để thay thế C, trái ngược với việc cưỡng bức và khiến C chờ đợi sleep). Bất kể cảnh báo này,

echo two > >(exec cat) | cat; echo three

vẫn sẽ thực hiện đúng các chức năng theo thứ tự, như được mô tả trước đây.