programming php

Luồng trong PHP là gì?

Để làm cho EventLoop dễ sử dụng hơn, thành phần này giới thiệu khái niệm mạnh mẽ về "luồng". Luồng cho phép bạn xử lý hiệu quả lượng dữ liệu khổng lồ [chẳng hạn như tải xuống tệp nhiều Gigabyte] thành các phần nhỏ mà không phải lưu trữ mọi thứ trong bộ nhớ cùng một lúc. Chúng rất giống với các luồng được tìm thấy trong chính PHP, nhưng có giao diện phù hợp hơn cho I/O không đồng bộ, không chặn

Mục lục

Sử dụng luồng

ReactPHP sử dụng khái niệm "luồng" trong toàn bộ hệ sinh thái của nó để cung cấp khả năng trừu tượng hóa cấp cao nhất quán để xử lý các luồng có nội dung và kích thước dữ liệu tùy ý. Mặc dù bản thân luồng là một khái niệm khá thấp, nhưng nó có thể được sử dụng như một sự trừu tượng hóa mạnh mẽ để xây dựng các thành phần và giao thức cấp cao hơn ở trên cùng

Nếu bạn chưa quen với khái niệm này, bạn nên nghĩ chúng giống như một đường ống nước. Bạn có thể tiêu thụ nước từ một nguồn hoặc bạn có thể sản xuất nước và chuyển tiếp [đường ống] nước đến bất kỳ điểm đến nào [bồn rửa]

Tương tự, các luồng có thể là

có thể đọc được [chẳng hạn như đầu vào thiết bị đầu cuối

assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];

8] hoặc

có thể ghi [chẳng hạn như đầu ra của thiết bị đầu cuối

assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];

9] hoặc

song công [cả có thể đọc và ghi, chẳng hạn như kết nối TCP/IP]

Theo đó, gói này xác định ba giao diện sau

ReadableStreamGiao diện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

0 chịu trách nhiệm cung cấp giao diện cho luồng chỉ đọc và phía có thể đọc được của luồng song công

Bên cạnh việc xác định một vài phương thức, giao diện này cũng triển khai

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

1 cho phép bạn phản ứng với một số sự kiện nhất định

Các hàm gọi lại sự kiện PHẢI là một

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

2 hợp lệ tuân theo các định nghĩa tham số nghiêm ngặt và PHẢI chấp nhận các tham số sự kiện chính xác như được ghi lại. Các chức năng gọi lại sự kiện KHÔNG ĐƯỢC ném một

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

3. Giá trị trả về của các hàm gọi lại sự kiện sẽ bị bỏ qua và không có tác dụng, vì vậy, vì lý do hiệu suất, bạn không nên trả về bất kỳ cấu trúc dữ liệu thừa nào

Mọi triển khai của giao diện này PHẢI tuân theo các ngữ nghĩa sự kiện này để được coi là luồng hoạt động tốt

Lưu ý rằng việc triển khai cấp cao hơn của giao diện này có thể chọn xác định các sự kiện bổ sung với ngữ nghĩa chuyên dụng không được xác định như một phần của đặc tả luồng cấp thấp này. Sự phù hợp với các ngữ nghĩa sự kiện này nằm ngoài phạm vi của giao diện này, vì vậy bạn cũng có thể phải tham khảo tài liệu về cách triển khai cấp cao hơn như vậy

sự kiện dữ liệu

Sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

4 sẽ được phát ra bất cứ khi nào một số dữ liệu được đọc/nhận từ luồng nguồn này. Sự kiện nhận được một đối số hỗn hợp duy nhất cho dữ liệu đến

$stream->on['data', function [$data] {
    echo $data;
}];

Sự kiện này CÓ THỂ được phát ra nhiều lần, có thể là 0 lần nếu luồng này hoàn toàn không gửi bất kỳ dữ liệu nào. Nó KHÔNG NÊN được phát ra sau một sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5 hoặc

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

Đối số

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

7 đã cho có thể thuộc loại hỗn hợp, nhưng nó thường được khuyến nghị NÊN là giá trị

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

8 hoặc CÓ THỂ sử dụng loại cho phép biểu diễn dưới dạng

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

8 để tương thích tối đa

Nhiều luồng phổ biến [chẳng hạn như kết nối TCP/IP hoặc luồng dựa trên tệp] sẽ phát ra dữ liệu tải trọng thô [nhị phân] được nhận qua dây dưới dạng các khối gồm _______8 giá trị

Do tính chất dựa trên luồng của điều này, người gửi có thể gửi bất kỳ số lượng khối nào với các kích thước khác nhau. Không có gì đảm bảo rằng các khối này sẽ được nhận với cùng một khung chính xác mà người gửi dự định gửi. Nói cách khác, nhiều giao thức cấp thấp hơn [chẳng hạn như TCP/IP] truyền dữ liệu theo khối có thể ở bất kỳ đâu giữa các giá trị một byte đến vài chục kilobyte. Bạn có thể muốn áp dụng giao thức cấp cao hơn cho các khối dữ liệu cấp thấp này để đạt được khung thông báo phù hợp

kết thúc sự kiện

Sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5 sẽ được phát sau khi luồng nguồn đã đến cuối luồng thành công [EOF]

$stream->on['end', function [] {
    echo 'END';
}];

Sự kiện này NÊN được phát một lần hoặc không bao giờ, tùy thuộc vào việc có phát hiện kết thúc thành công hay không. Nó KHÔNG NÊN được phát ra sau sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5 hoặc

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6 trước đó. Nó KHÔNG ĐƯỢC phát ra nếu luồng đóng do kết thúc không thành công, chẳng hạn như sau sự kiện

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

4 trước đó

Sau khi luồng kết thúc, nó PHẢI chuyển sang chế độ không thể đọc được, xem thêm

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

Sự kiện này sẽ chỉ được phát ra nếu kết thúc thành công, không phải nếu luồng bị gián đoạn do lỗi không thể khôi phục hoặc bị đóng rõ ràng. Không phải tất cả các luồng đều biết khái niệm "kết thúc thành công" này. Thay vào đó, nhiều trường hợp sử dụng liên quan đến việc phát hiện thời điểm luồng đóng [chấm dứt], trong trường hợp này, bạn nên sử dụng sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6. Sau khi luồng phát ra một sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5, nó thường NÊN được theo sau bởi một sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

Nhiều luồng phổ biến [chẳng hạn như kết nối TCP/IP hoặc luồng dựa trên tệp] sẽ phát ra sự kiện này nếu phía từ xa đóng kết nối hoặc xử lý tệp được đọc thành công cho đến khi kết thúc [EOF]

Lưu ý rằng không nên nhầm lẫn sự kiện này với phương thức

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

9. Sự kiện này xác định việc đọc kết thúc thành công từ luồng nguồn, trong khi phương thức

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

9 xác định việc ghi kết thúc thành công vào luồng đích

sự kiện lỗi

Sự kiện

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

4 sẽ được phát ra sau khi xảy ra lỗi nghiêm trọng, thường là khi cố gắng đọc từ luồng này. Sự kiện nhận được một đối số

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

3 duy nhất cho trường hợp lỗi

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

Sự kiện này NÊN được phát ra sau khi luồng phát hiện lỗi nghiêm trọng, chẳng hạn như lỗi truyền nghiêm trọng hoặc sau sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

4 không mong muốn hoặc sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5 sớm. Nó KHÔNG NÊN được phát ra sau một sự kiện

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5 hoặc

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6 trước đó. Nó KHÔNG ĐƯỢC phát ra nếu đây không phải là tình trạng lỗi nghiêm trọng, chẳng hạn như sự cố mạng tạm thời không làm mất bất kỳ dữ liệu nào

Sau lỗi luồng, nó PHẢI đóng luồng và do đó NÊN được theo sau bởi một sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6 và sau đó chuyển sang chế độ không thể đọc được, xem thêm

$connection->pipe[$connection];

9 và

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

Nhiều luồng phổ biến [chẳng hạn như kết nối TCP/IP hoặc luồng dựa trên tệp] chỉ xử lý việc truyền dữ liệu và không đưa ra giả định về ranh giới dữ liệu [chẳng hạn như các sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

4 không mong muốn hoặc các sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5 sớm]. Nói cách khác, nhiều giao thức cấp thấp hơn [chẳng hạn như TCP/IP] có thể chọn chỉ phát ra điều này cho lỗi truyền nghiêm trọng một lần và sau đó sẽ đóng [chấm dứt] luồng để phản hồi

Nếu luồng này là một

$source->pipe[$decodeGzip]->pipe[$filterBadWords]->pipe[$dest];

3, bạn cũng nên chú ý cách phần có thể ghi của luồng cũng thực hiện một sự kiện

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

4. Nói cách khác, một lỗi có thể xảy ra trong khi đọc hoặc ghi luồng sẽ dẫn đến cùng một quá trình xử lý lỗi

đóng sự kiện

Sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6 sẽ được phát ra sau khi luồng đóng [chấm dứt]

$stream->on['close', function [] {
    echo 'CLOSED';
}];

Sự kiện này NÊN được phát một lần hoặc không bao giờ, tùy thuộc vào việc luồng có bao giờ kết thúc hay không. Nó KHÔNG NÊN được phát ra sau sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6 trước đó

Sau khi đóng luồng, nó PHẢI chuyển sang chế độ không thể đọc được, xem thêm

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

Không giống như sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5, sự kiện này NÊN được phát ra bất cứ khi nào luồng đóng lại, bất kể điều này xảy ra hoàn toàn do lỗi không thể khôi phục hay rõ ràng khi một trong hai bên đóng luồng. Nếu bạn chỉ muốn phát hiện một kết thúc thành công, bạn nên sử dụng sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5 để thay thế

Nhiều luồng phổ biến [chẳng hạn như kết nối TCP/IP hoặc luồng dựa trên tệp] có thể sẽ chọn phát ra sự kiện này sau khi đọc sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5 thành công hoặc sau sự kiện truyền tải nghiêm trọng

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

Nếu luồng này là một

$source->pipe[$decodeGzip]->pipe[$filterBadWords]->pipe[$dest];

3, bạn cũng nên chú ý cách phần có thể ghi của luồng cũng thực hiện một sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6. Nói cách khác, sau khi nhận được sự kiện này, luồng PHẢI chuyển sang chế độ không thể ghi VÀ không thể đọc được, xem thêm

$source->pipe[$dest, array['end' => false]];

4. Lưu ý rằng không nên nhầm lẫn sự kiện này với sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

isReadable[]

Phương pháp

$source->pipe[$dest, array['end' => false]];

6 có thể được sử dụng để kiểm tra xem luồng này có ở trạng thái có thể đọc được không [chưa đóng]

Phương pháp này có thể được sử dụng để kiểm tra xem luồng vẫn chấp nhận các sự kiện dữ liệu đến hay luồng đã kết thúc hoặc đã đóng. Khi luồng không thể đọc được, thì không có sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

4 hoặc

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5 nào NÊN được phát ra nữa

assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];

Luồng được mở thành công luôn PHẢI bắt đầu ở chế độ có thể đọc được

Khi luồng kết thúc hoặc đóng, nó PHẢI chuyển sang chế độ không thể đọc được. Điều này có thể xảy ra bất cứ lúc nào, rõ ràng thông qua

$connection->pipe[$connection];

9 hoặc hoàn toàn do đóng từ xa hoặc lỗi đường truyền không thể khôi phục. Khi một luồng đã chuyển sang chế độ không thể đọc được, nó KHÔNG ĐƯỢC chuyển trở lại chế độ có thể đọc được

Nếu luồng này là

$source->pipe[$decodeGzip]->pipe[$filterBadWords]->pipe[$dest];

3, bạn cũng nên chú ý cách phần có thể ghi của luồng cũng triển khai phương thức

$source->pipe[$dest, array['end' => false]];

4. Trừ khi đây là luồng song công nửa mở, chúng thường NÊN có cùng giá trị trả về

tạm ngừng[]

Phương pháp

$stream->on['end', function [] {
    echo 'END';
}];

02 có thể được sử dụng để tạm dừng đọc các sự kiện dữ liệu đến

Xóa bộ mô tả tệp nguồn dữ liệu khỏi vòng lặp sự kiện. Điều này cho phép bạn điều tiết dữ liệu đến

Trừ khi có ghi chú khác, luồng được mở thành công KHÔNG NÊN bắt đầu ở trạng thái tạm dừng

Sau khi luồng bị tạm dừng, các sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

4 hoặc

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5 KHÔNG NÊN được phát ra nữa

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

Phương pháp này chỉ mang tính chất tư vấn, mặc dù nhìn chung không được khuyến nghị, luồng CÓ THỂ tiếp tục phát ra các sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

Bạn có thể tiếp tục xử lý các sự kiện bằng cách gọi lại

$stream->on['end', function [] {
    echo 'END';
}];

Lưu ý rằng cả hai phương pháp có thể được gọi bất kỳ số lần nào, cụ thể là gọi

$stream->on['end', function [] {
    echo 'END';
}];

07 nhiều hơn một lần KHÔNG NÊN có bất kỳ ảnh hưởng nào

Xem thêm

$stream->on['end', function [] {
    echo 'END';
}];

bản tóm tắt[]

Phương pháp

$stream->on['end', function [] {
    echo 'END';
}];

09 có thể được sử dụng để tiếp tục đọc các sự kiện dữ liệu đến

Đính kèm lại nguồn dữ liệu sau một

$stream->on['end', function [] {
    echo 'END';
}];

07 trước đó

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

Lưu ý rằng cả hai phương pháp có thể được gọi bất kỳ số lần nào, cụ thể là gọi

$stream->on['end', function [] {
    echo 'END';
}];

06 mà không có trước _

$stream->on['end', function [] {
    echo 'END';
}];

07 KHÔNG NÊN có bất kỳ tác dụng nào

Xem thêm

$stream->on['end', function [] {
    echo 'END';
}];

đường ống[]

Phương pháp

$stream->on['end', function [] {
    echo 'END';
}];

14 có thể được sử dụng để chuyển tất cả dữ liệu từ nguồn có thể đọc này sang đích có thể ghi đã cho

Tự động gửi tất cả dữ liệu đến đến đích. Tự động điều chỉnh nguồn dựa trên những gì đích có thể xử lý

Tương tự, bạn cũng có thể đưa một thể hiện triển khai

$source->pipe[$decodeGzip]->pipe[$filterBadWords]->pipe[$dest];

3 vào chính nó để ghi lại tất cả dữ liệu nhận được. Đây có thể là một tính năng hữu ích cho dịch vụ tiếng vang TCP/IP

$connection->pipe[$connection];

Phương thức này trả về nguyên trạng luồng đích, có thể được sử dụng để thiết lập chuỗi luồng theo đường ống

$source->pipe[$decodeGzip]->pipe[$filterBadWords]->pipe[$dest];

Theo mặc định, điều này sẽ gọi

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

9 trên luồng đích sau khi luồng nguồn phát ra sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5. Điều này có thể bị vô hiệu hóa như thế này

$source->pipe[$dest, array['end' => false]];

Lưu ý rằng điều này chỉ áp dụng cho sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5. Nếu một sự kiện

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

4 hoặc

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6 rõ ràng xảy ra trên luồng nguồn, bạn sẽ phải đóng luồng đích theo cách thủ công

$stream->on['end', function [] {
    echo 'END';
}];

Nếu luồng nguồn không thể đọc được [trạng thái đóng], thì đây là NO-OP

$stream->on['end', function [] {
    echo 'END';
}];

Nếu luồng đích không thể ghi [trạng thái đóng], thì điều này sẽ chỉ đơn giản là điều tiết [tạm dừng] luồng nguồn

$stream->on['end', function [] {
    echo 'END';
}];

Tương tự, nếu luồng đích bị đóng trong khi đường ống vẫn đang hoạt động, luồng đó cũng sẽ điều tiết [tạm dừng] luồng nguồn

$stream->on['end', function [] {
    echo 'END';
}];

Khi đường ống được thiết lập thành công, luồng đích PHẢI phát ra một sự kiện

$stream->on['end', function [] {
    echo 'END';
}];

21 với luồng nguồn này là một đối số sự kiện

Thoát[]

Phương pháp

$stream->on['end', function [] {
    echo 'END';
}];

22 có thể được sử dụng để đóng luồng [mạnh mẽ]

Phương pháp này có thể được sử dụng để [bắt buộc] đóng luồng

Khi luồng đã đóng, luồng NÊN phát ra sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6. Lưu ý rằng sự kiện này KHÔNG NÊN được phát ra nhiều lần, đặc biệt nếu phương thức này được gọi nhiều lần

Sau khi gọi phương thức này, luồng PHẢI chuyển sang chế độ không đọc được, xem thêm

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

5. Điều này có nghĩa là không có sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

4 hoặc

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5 nào NÊN được phát ra

$stream->on['end', function [] {
    echo 'END';
}];

Nếu luồng này là một

$source->pipe[$decodeGzip]->pipe[$filterBadWords]->pipe[$dest];

3, bạn cũng nên chú ý cách phần có thể ghi của luồng cũng triển khai phương thức

$connection->pipe[$connection];

9. Nói cách khác, sau khi gọi phương thức này, luồng PHẢI chuyển sang chế độ không thể ghi VÀ không thể đọc, xem thêm

$source->pipe[$dest, array['end' => false]];

4. Lưu ý rằng không nên nhầm lẫn phương pháp này với phương pháp

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

WritableStreamGiao Diện

$stream->on['end', function [] {
    echo 'END';
}];

31 chịu trách nhiệm cung cấp giao diện cho luồng chỉ ghi và phía có thể ghi của luồng song công

Bên cạnh việc xác định một vài phương thức, giao diện này cũng triển khai

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

1 cho phép bạn phản ứng với một số sự kiện nhất định

Các hàm gọi lại sự kiện PHẢI là một

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

Mọi triển khai của giao diện này PHẢI tuân theo các ngữ nghĩa sự kiện này để được coi là luồng hoạt động tốt

Lưu ý rằng việc triển khai cấp cao hơn của giao diện này có thể chọn xác định các sự kiện bổ sung với ngữ nghĩa chuyên dụng không được xác định như một phần của đặc tả luồng cấp thấp này. Sự phù hợp với các ngữ nghĩa sự kiện này nằm ngoài phạm vi của giao diện này, vì vậy bạn cũng có thể phải tham khảo tài liệu về cách triển khai cấp cao hơn như vậy

cống sự kiện

Sự kiện

$stream->on['end', function [] {
    echo 'END';
}];

35 sẽ được phát ra bất cứ khi nào bộ đệm ghi trước đó đầy và hiện sẵn sàng chấp nhận thêm dữ liệu

$stream->on['end', function [] {
    echo 'END';
}];

Sự kiện này NÊN được phát ra một lần mỗi khi bộ đệm đầy trước đó và hiện đã sẵn sàng để nhận thêm dữ liệu. Nói cách khác, sự kiện này CÓ THỂ được phát ra nhiều lần, có thể là 0 lần nếu bộ đệm không bao giờ đầy ngay từ đầu. Sự kiện này KHÔNG NÊN được phát ra nếu bộ đệm chưa đầy trước đó

Sự kiện này chủ yếu được sử dụng trong nội bộ, xem thêm

$stream->on['end', function [] {
    echo 'END';
}];

36 để biết thêm chi tiết

sự kiện đường ống

Sự kiện

$stream->on['end', function [] {
    echo 'END';
}];

21 sẽ được phát ra bất cứ khi nào một luồng có thể đọc được là

$stream->on['end', function [] {
    echo 'END';
}];

38d vào luồng này. Sự kiện nhận được một đối số

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

0 duy nhất cho luồng nguồn

$stream->on['end', function [] {
    echo 'END';
}];

Sự kiện này PHẢI được phát một lần cho mỗi luồng có thể đọc được dẫn thành công vào luồng đích này. Nói cách khác, sự kiện này CÓ THỂ được phát ra nhiều lần, có thể là 0 lần nếu không có luồng nào được đưa vào luồng này. Sự kiện này KHÔNG ĐƯỢC phát ra nếu nguồn không thể đọc được [đã đóng] hoặc đích này không thể ghi [đã đóng]

Sự kiện này chủ yếu được sử dụng trong nội bộ, xem thêm

$stream->on['end', function [] {
    echo 'END';
}];

38 để biết thêm chi tiết

sự kiện lỗi

Sự kiện

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

4 sẽ được phát ra sau khi xảy ra lỗi nghiêm trọng, thường là khi cố ghi vào luồng này. Sự kiện nhận được một đối số

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

3 duy nhất cho trường hợp lỗi

$stream->on['end', function [] {
    echo 'END';
}];

Sự kiện này NÊN được phát ra sau khi luồng phát hiện lỗi nghiêm trọng, chẳng hạn như lỗi truyền dẫn nghiêm trọng. Nó KHÔNG NÊN được phát ra sau một sự kiện

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

4 hoặc

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

Sau lỗi luồng, nó PHẢI đóng luồng và do đó NÊN được theo sau bởi một sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6 và sau đó chuyển sang chế độ không thể ghi, xem thêm

$connection->pipe[$connection];

9 và

$source->pipe[$dest, array['end' => false]];

Nhiều luồng phổ biến [chẳng hạn như kết nối TCP/IP hoặc luồng dựa trên tệp] chỉ xử lý việc truyền dữ liệu và có thể chọn chỉ phát ra điều này cho lỗi truyền dẫn nghiêm trọng một lần và sau đó sẽ đóng [chấm dứt] luồng để phản hồi

Nếu luồng này là một

$source->pipe[$decodeGzip]->pipe[$filterBadWords]->pipe[$dest];

3, bạn cũng nên chú ý cách phần có thể đọc được của luồng cũng triển khai một sự kiện

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

4. Nói cách khác, một lỗi có thể xảy ra trong khi đọc hoặc ghi luồng sẽ dẫn đến cùng một quá trình xử lý lỗi

đóng sự kiện

Sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6 sẽ được phát ra sau khi luồng đóng [chấm dứt]

$stream->on['close', function [] {
    echo 'CLOSED';
}];

Sự kiện này NÊN được phát một lần hoặc không bao giờ, tùy thuộc vào việc luồng có bao giờ kết thúc hay không. Nó KHÔNG NÊN được phát ra sau sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6 trước đó

Sau khi đóng luồng, nó PHẢI chuyển sang chế độ không thể ghi, xem thêm

$source->pipe[$dest, array['end' => false]];

Sự kiện này NÊN được phát ra bất cứ khi nào luồng đóng lại, bất kể điều này xảy ra hoàn toàn do lỗi không thể khôi phục hay rõ ràng khi một trong hai bên đóng luồng

Nhiều luồng phổ biến [chẳng hạn như kết nối TCP/IP hoặc luồng dựa trên tệp] có thể sẽ chọn phát ra sự kiện này sau khi xóa bộ đệm từ phương thức

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

9, sau khi nhận được sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5 thành công hoặc sau sự kiện truyền dẫn nghiêm trọng

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

Nếu luồng này là

$source->pipe[$decodeGzip]->pipe[$filterBadWords]->pipe[$dest];

3, bạn cũng nên chú ý cách phần có thể đọc được của luồng cũng triển khai sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6. Nói cách khác, sau khi nhận được sự kiện này, luồng PHẢI chuyển sang chế độ không thể ghi VÀ không thể đọc, xem thêm

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

5. Lưu ý rằng không nên nhầm lẫn sự kiện này với sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

isWritable[]

Phương pháp

$stream->on['end', function [] {
    echo 'END';
}];

60 có thể được sử dụng để kiểm tra xem luồng này có ở trạng thái có thể ghi hay không [chưa đóng]

Phương pháp này có thể được sử dụng để kiểm tra xem luồng có còn chấp nhận ghi bất kỳ dữ liệu nào hay luồng đã kết thúc hoặc đã đóng. Ghi bất kỳ dữ liệu nào vào luồng không thể ghi là KHÔNG OP

$stream->on['end', function [] {
    echo 'END';
}];

Luồng được mở thành công luôn PHẢI bắt đầu ở chế độ có thể ghi

Khi luồng kết thúc hoặc đóng, nó PHẢI chuyển sang chế độ không thể ghi. Điều này có thể xảy ra bất cứ lúc nào, rõ ràng thông qua

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

9 hoặc

$connection->pipe[$connection];

9 hoặc hoàn toàn do đóng từ xa hoặc lỗi đường truyền không thể khôi phục. Khi một luồng đã chuyển sang chế độ không thể ghi, nó KHÔNG ĐƯỢC chuyển trở lại chế độ có thể ghi

Nếu luồng này là

$source->pipe[$decodeGzip]->pipe[$filterBadWords]->pipe[$dest];

3, bạn cũng nên chú ý cách phần có thể đọc được của luồng cũng triển khai phương thức

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

5. Trừ khi đây là luồng song công nửa mở, chúng thường NÊN có cùng giá trị trả về

viết[]

Phương thức

$stream->on['end', function [] {
    echo 'END';
}];

65 có thể được sử dụng để ghi một số dữ liệu vào luồng

Việc ghi thành công PHẢI được xác nhận bằng boolean

$stream->on['end', function [] {
    echo 'END';
}];

66, có nghĩa là dữ liệu được ghi [xóa] ngay lập tức hoặc được lưu vào bộ đệm và được lên lịch cho lần ghi trong tương lai. Lưu ý rằng giao diện này không cung cấp cho bạn quyền kiểm soát đối với việc xóa dữ liệu được lưu vào bộ đệm một cách rõ ràng, vì việc tìm thời điểm thích hợp cho việc này nằm ngoài phạm vi của giao diện này và tùy thuộc vào việc triển khai giao diện này

Nhiều luồng phổ biến [chẳng hạn như kết nối TCP/IP hoặc luồng dựa trên tệp] có thể chọn đệm tất cả dữ liệu đã cho và lên lịch xóa trong tương lai bằng cách sử dụng EventLoop cơ bản để kiểm tra xem tài nguyên có thực sự có thể ghi được không

Nếu một luồng không thể xử lý việc ghi [hoặc xóa] dữ liệu, thì nó NÊN phát ra một sự kiện

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

4 và CÓ THỂ

$connection->pipe[$connection];

9 luồng nếu nó không thể phục hồi từ lỗi này

Nếu bộ đệm bên trong đầy sau khi thêm

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

7, thì

$stream->on['end', function [] {
    echo 'END';
}];

36 NÊN trả về

$stream->on['end', function [] {
    echo 'END';
}];

71, cho biết rằng người gọi nên ngừng gửi dữ liệu cho đến khi bộ đệm cạn kiệt. Luồng NÊN gửi một sự kiện

$stream->on['end', function [] {
    echo 'END';
}];

35 sau khi bộ đệm sẵn sàng chấp nhận thêm dữ liệu

Tương tự, nếu luồng không thể ghi [đã ở trạng thái đóng] thì nó KHÔNG ĐƯỢC xử lý

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

7 đã cho và NÊN trả về

$stream->on['end', function [] {
    echo 'END';
}];

71, cho biết rằng người gọi nên ngừng gửi dữ liệu

Đối số

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

7 đã cho CÓ THỂ thuộc loại hỗn hợp, nhưng nó thường được khuyến nghị NÊN là giá trị

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

8 hoặc CÓ THỂ sử dụng loại cho phép biểu diễn dưới dạng

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

8 để tương thích tối đa

Nhiều luồng phổ biến [chẳng hạn như kết nối TCP/IP hoặc luồng dựa trên tệp] sẽ chỉ chấp nhận dữ liệu tải trọng thô [nhị phân] được truyền qua dây dưới dạng các khối gồm các giá trị

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

kết thúc[]

Phương pháp

$stream->on['end', function [] {
    echo 'END';
}];

79 có thể được sử dụng để kết thúc luồng thành công [sau khi tùy chọn gửi một số dữ liệu cuối cùng]

Phương pháp này có thể được sử dụng để kết thúc luồng thành công, tôi. e. đóng luồng sau khi gửi tất cả dữ liệu hiện đang được lưu vào bộ đệm

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

Nếu hiện không có dữ liệu nào được lưu vào bộ đệm và không có dữ liệu nào cần xóa, thì phương pháp này CÓ THỂ

$connection->pipe[$connection];

9 luồng ngay lập tức

Nếu vẫn còn dữ liệu trong bộ đệm cần được xóa trước, thì phương pháp này NÊN cố gắng ghi dữ liệu này ra và chỉ sau đó

$connection->pipe[$connection];

9 luồng. Khi luồng đã đóng, luồng NÊN phát ra sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

Lưu ý rằng giao diện này không cung cấp cho bạn quyền kiểm soát đối với việc xóa dữ liệu được lưu vào bộ đệm một cách rõ ràng, vì việc tìm thời điểm thích hợp cho việc này nằm ngoài phạm vi của giao diện này và tùy thuộc vào việc triển khai giao diện này

Bạn có thể tùy ý chuyển một số dữ liệu cuối cùng được ghi vào luồng trước khi kết thúc luồng. Nếu một giá trị không phải _______15_______83 được đưa ra là

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

7, thì phương thức này sẽ hoạt động giống như gọi

$stream->on['end', function [] {
    echo 'END';
}];

85 trước khi kết thúc mà không có dữ liệu

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

Sau khi gọi phương thức này, luồng PHẢI chuyển sang chế độ không thể ghi, xem thêm

$source->pipe[$dest, array['end' => false]];

4. Điều này có nghĩa là không thể ghi thêm nữa, vì vậy mọi lệnh gọi bổ sung

$stream->on['end', function [] {
    echo 'END';
}];

36 hoặc

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

9 đều không có hiệu lực

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

Nếu luồng này là

$source->pipe[$decodeGzip]->pipe[$filterBadWords]->pipe[$dest];

3, việc gọi phương thức này cũng NÊN kết thúc phần có thể đọc được của nó, trừ khi luồng hỗ trợ chế độ nửa mở. Nói cách khác, sau khi gọi phương thức này, các luồng này NÊN chuyển sang chế độ không thể ghi VÀ không thể đọc được, xem thêm

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

5. Điều này ngụ ý rằng trong trường hợp này, luồng KHÔNG NÊN phát ra bất kỳ sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

4 hoặc

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

5 nào nữa. Các luồng CÓ THỂ chọn sử dụng logic của phương thức

$stream->on['end', function [] {
    echo 'END';
}];

07 cho việc này, nhưng có thể phải đặc biệt cẩn thận để đảm bảo một cuộc gọi tiếp theo tới phương thức

$stream->on['end', function [] {
    echo 'END';
}];

06 KHÔNG NÊN tiếp tục phát ra các sự kiện có thể đọc được

Lưu ý rằng không nên nhầm lẫn phương thức này với phương thức

$connection->pipe[$connection];

Thoát[]

Phương pháp

$stream->on['end', function [] {
    echo 'END';
}];

22 có thể được sử dụng để đóng luồng [mạnh mẽ]

Phương pháp này có thể được sử dụng để buộc đóng luồng, tôi. e. đóng luồng mà không cần đợi bất kỳ dữ liệu đệm nào được xóa. Nếu vẫn còn dữ liệu trong bộ đệm, dữ liệu này NÊN bị loại bỏ

Khi luồng đã đóng, luồng NÊN phát ra sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6. Lưu ý rằng sự kiện này KHÔNG NÊN được phát ra nhiều lần, đặc biệt nếu phương thức này được gọi nhiều lần

Sau khi gọi phương thức này, luồng PHẢI chuyển sang chế độ không thể ghi, xem thêm

$source->pipe[$dest, array['end' => false]];

4. Điều này có nghĩa là không thể ghi thêm nữa, vì vậy mọi lệnh gọi bổ sung

$stream->on['end', function [] {
    echo 'END';
}];

36 hoặc

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

9 đều không có hiệu lực

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

Lưu ý rằng không nên nhầm lẫn phương pháp này với phương pháp

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

9. Không giống như phương pháp

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

9, phương pháp này không quan tâm đến bất kỳ bộ đệm hiện có nào và chỉ loại bỏ mọi nội dung bộ đệm. Tương tự như vậy, phương thức này cũng có thể được gọi sau khi gọi

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

9 trên một luồng để dừng chờ luồng xóa dữ liệu cuối cùng của nó

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

Nếu luồng này là

$source->pipe[$decodeGzip]->pipe[$filterBadWords]->pipe[$dest];

3, bạn cũng nên chú ý cách phần có thể đọc được của luồng cũng triển khai phương thức

$connection->pipe[$connection];

9. Nói cách khác, sau khi gọi phương thức này, luồng PHẢI chuyển sang chế độ không thể ghi VÀ không thể đọc được, xem thêm

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

DuplexStreamGiao Diện

$source->pipe[$decodeGzip]->pipe[$filterBadWords]->pipe[$dest];

3 chịu trách nhiệm cung cấp giao diện cho các luồng song công [cả có thể đọc và ghi]

Nó được xây dựng dựa trên các giao diện hiện có cho các luồng có thể đọc và ghi được, đồng thời tuân theo chính xác cùng một phương thức và ngữ nghĩa sự kiện. Nếu bạn chưa quen với khái niệm này, trước tiên bạn nên xem xét

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

0 và

$stream->on['end', function [] {
    echo 'END';
}];

Bên cạnh việc xác định một vài phương thức, giao diện này cũng triển khai

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

1 cho phép bạn phản ứng với các sự kiện tương tự được xác định trên

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

11 và

$stream->on['end', function [] {
    echo 'END';
}];

Các hàm gọi lại sự kiện PHẢI là một

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

Mọi triển khai của giao diện này PHẢI tuân theo các ngữ nghĩa sự kiện này để được coi là luồng hoạt động tốt

Lưu ý rằng việc triển khai cấp cao hơn của giao diện này có thể chọn xác định các sự kiện bổ sung với ngữ nghĩa chuyên dụng không được xác định như một phần của đặc tả luồng cấp thấp này. Sự phù hợp với các ngữ nghĩa sự kiện này nằm ngoài phạm vi của giao diện này, vì vậy bạn cũng có thể phải tham khảo tài liệu về cách triển khai cấp cao hơn như vậy

Xem thêm và để biết thêm chi tiết

Tạo luồng

ReactPHP sử dụng khái niệm "luồng" trong toàn bộ hệ sinh thái của nó, do đó nhiều người tiêu dùng cấp cao hơn của gói này chỉ xử lý. Điều này ngụ ý rằng các phiên bản luồng thường được tạo trong một số thành phần cấp cao hơn và nhiều người tiêu dùng thực sự không bao giờ phải xử lý việc tạo phiên bản luồng

Sử dụng Reac/socket nếu bạn muốn chấp nhận các luồng kết nối TCP/IP văn bản gốc gửi đến hoặc thiết lập các luồng kết nối ổ cắm TLS an toàn
Sử dụng Reac/http nếu bạn muốn nhận luồng nội dung yêu cầu HTTP đến
Sử dụng phản ứng/quy trình con nếu bạn muốn giao tiếp với các quy trình con thông qua các quy trình xử lý như STDIN, STDOUT, STDERR, v.v.
Sử dụng hệ thống tệp/phản ứng thử nghiệm nếu bạn muốn đọc từ/ghi vào hệ thống tệp
Xem thêm chương cuối để biết

Tuy nhiên, nếu bạn đang viết một thành phần cấp thấp hơn hoặc muốn tạo một thể hiện luồng từ tài nguyên luồng, thì chương sau là dành cho bạn

Lưu ý rằng các ví dụ sau đây chỉ sử dụng
$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];
17 và
$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];
18 cho mục đích minh họa. Các chức năng này KHÔNG NÊN được sử dụng trong một chương trình thực sự không đồng bộ vì mỗi cuộc gọi có thể mất vài giây để hoàn thành và nếu không thì sẽ chặn EventLoop. Ngoài ra, lệnh gọi
$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];
17 sẽ trả về một tệp xử lý trên một số nền tảng có thể được hỗ trợ hoặc không bởi tất cả các triển khai EventLoop. Thay vào đó, bạn có thể muốn sử dụng các thư viện cấp cao hơn được liệt kê ở trên

ReadableResourceStream

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

20 là một triển khai cụ thể cho tài nguyên luồng của PHP

Điều này có thể được sử dụng để đại diện cho tài nguyên chỉ đọc như luồng tệp được mở ở chế độ có thể đọc được hoặc luồng chẳng hạn như

assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

Xem thêm để biết thêm chi tiết

Tham số đầu tiên được cung cấp cho hàm tạo PHẢI là tài nguyên luồng hợp lệ được mở ở chế độ đọc [e. g. Chế độ

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

25]. Nếu không, nó sẽ ném một

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

Xem thêm tài nguyên luồng đọc và ghi nếu không

Trong nội bộ, lớp này cố gắng bật chế độ không chặn trên tài nguyên luồng, chế độ này có thể không được hỗ trợ cho tất cả các tài nguyên luồng. Đáng chú ý nhất, điều này không được hỗ trợ bởi các đường ống trên Windows [STDIN, v.v. ]. Nếu điều này không thành công, nó sẽ ném một

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

Khi hàm tạo được gọi với tài nguyên luồng hợp lệ, lớp này sẽ xử lý tài nguyên luồng bên dưới. Bạn chỉ NÊN sử dụng API công khai của nó và KHÔNG NÊN can thiệp thủ công vào tài nguyên luồng bên dưới

Lớp này nhận một tham số

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

29 tùy chọn có thể được sử dụng để truyền thể hiện vòng lặp sự kiện để sử dụng cho đối tượng này. Bạn có thể sử dụng giá trị

$stream->on['end', function [] {
    echo 'END';
}];

83 ở đây để sử dụng. Giá trị này KHÔNG NÊN được cung cấp trừ khi bạn chắc chắn muốn sử dụng rõ ràng một phiên bản vòng lặp sự kiện đã cho

Lớp này nhận một tham số

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

31 tùy chọn kiểm soát kích thước bộ đệm tối đa theo byte để đọc cùng một lúc từ luồng. Bạn có thể sử dụng giá trị

$stream->on['end', function [] {
    echo 'END';
}];

83 tại đây để áp dụng giá trị mặc định của nó. Giá trị này KHÔNG NÊN thay đổi trừ khi bạn biết mình đang làm gì. Đây có thể là một số dương, có nghĩa là tối đa X byte sẽ được đọc cùng một lúc từ tài nguyên luồng bên dưới. Lưu ý rằng số byte đọc thực tế có thể thấp hơn nếu tài nguyên luồng hiện có ít hơn X byte. Đây có thể là

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

33 có nghĩa là "đọc mọi thứ có sẵn" từ tài nguyên luồng bên dưới. Điều này sẽ đọc cho đến khi tài nguyên luồng không thể đọc được nữa [tôi. e. bộ đệm bên dưới đã hết], lưu ý rằng điều này không nhất thiết có nghĩa là nó đã đạt đến EOF

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

Cảnh báo lỗi PHP. Nếu quy trình PHP đã được bắt đầu một cách rõ ràng mà không có luồng
assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];
8, thì việc cố gắng đọc từ
assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];
8 có thể trả về dữ liệu từ một tài nguyên luồng khác. Điều này không xảy ra nếu bạn bắt đầu điều này với một luồng trống như
$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];
36 thay vì
$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];
37. Xem #81 để biết thêm chi tiết

Nhật ký thay đổi. kể từ v1. 2. 0 tham số
$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];
38 có thể được bỏ qua [hoặc bỏ qua với giá trị
$stream->on['end', function [] {
    echo 'END';
}];
83] để sử dụng

Nguồn tài nguyên có thể ghi

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

40 là một triển khai cụ thể cho tài nguyên luồng của PHP

Điều này có thể được sử dụng để đại diện cho tài nguyên chỉ ghi như luồng tệp được mở ở chế độ có thể ghi hoặc luồng chẳng hạn như

assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];

9 hoặc

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

Xem thêm để biết thêm chi tiết

Tham số đầu tiên được cung cấp cho hàm tạo PHẢI là tài nguyên luồng hợp lệ được mở để ghi. Nếu không, nó sẽ ném một

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

$stream->on['close', function [] {
    echo 'CLOSED';
}];

Xem thêm tài nguyên luồng đọc và ghi nếu không

Trong nội bộ, lớp này cố gắng bật chế độ không chặn trên tài nguyên luồng, chế độ này có thể không được hỗ trợ cho tất cả các tài nguyên luồng. Đáng chú ý nhất, điều này không được hỗ trợ bởi các đường ống trên Windows [STDOUT, STDERR, v.v. ]. Nếu điều này không thành công, nó sẽ ném một

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

$stream->on['close', function [] {
    echo 'CLOSED';
}];

Bất kỳ cuộc gọi

$stream->on['end', function [] {
    echo 'END';
}];

36 nào đến lớp này sẽ không được thực hiện ngay lập tức mà sẽ được thực hiện không đồng bộ, sau khi EventLoop báo cáo tài nguyên luồng đã sẵn sàng chấp nhận dữ liệu. Đối với điều này, nó sử dụng chuỗi bộ đệm trong bộ nhớ để thu thập tất cả các lần ghi chưa xử lý. Bộ đệm này có giới hạn mềm được áp dụng để xác định lượng dữ liệu mà nó sẵn sàng chấp nhận trước khi người gọi NÊN ngừng gửi thêm dữ liệu

Lớp này nhận một tham số

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

29 tùy chọn có thể được sử dụng để truyền thể hiện vòng lặp sự kiện để sử dụng cho đối tượng này. Bạn có thể sử dụng giá trị

$stream->on['end', function [] {
    echo 'END';
}];

83 ở đây để sử dụng. Giá trị này KHÔNG NÊN được cung cấp trừ khi bạn chắc chắn muốn sử dụng rõ ràng một phiên bản vòng lặp sự kiện đã cho

Lớp này có một tham số tùy chọn

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

51 kiểm soát kích thước bộ đệm tối đa này theo byte. Bạn có thể sử dụng giá trị

$stream->on['end', function [] {
    echo 'END';
}];

83 tại đây để áp dụng giá trị mặc định của nó. Giá trị này KHÔNG NÊN thay đổi trừ khi bạn biết mình đang làm gì

$stream->on['close', function [] {
    echo 'CLOSED';
}];

Lớp này nhận một tham số

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

53 tùy chọn kiểm soát kích thước bộ đệm tối đa này tính bằng byte để ghi ngay lập tức vào luồng. Bạn có thể sử dụng giá trị

$stream->on['end', function [] {
    echo 'END';
}];

83 tại đây để áp dụng giá trị mặc định của nó. Giá trị này KHÔNG NÊN thay đổi trừ khi bạn biết mình đang làm gì. Đây có thể là một số dương, nghĩa là tối đa X byte sẽ được ghi cùng lúc vào tài nguyên luồng bên dưới. Lưu ý rằng số byte thực tế được ghi có thể thấp hơn nếu tài nguyên luồng hiện có ít hơn X byte. Đây có thể là

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

33 có nghĩa là "ghi mọi thứ có sẵn" vào tài nguyên luồng bên dưới

$stream->on['close', function [] {
    echo 'CLOSED';
}];

Xem thêm để biết thêm chi tiết

Nhật ký thay đổi. kể từ v1. 2. 0 tham số
$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];
38 có thể được bỏ qua [hoặc bỏ qua với giá trị
$stream->on['end', function [] {
    echo 'END';
}];
83] để sử dụng

DuplexResourceStream

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

27 là một triển khai cụ thể cho tài nguyên luồng của PHP

Điều này có thể được sử dụng để biểu thị tài nguyên đọc và ghi như luồng tệp được mở ở chế độ đọc và ghi hoặc luồng chẳng hạn như kết nối TCP/IP

$stream->on['close', function [] {
    echo 'CLOSED';
}];

Xem thêm để biết thêm chi tiết

Tham số đầu tiên được cung cấp cho hàm tạo PHẢI là tài nguyên luồng hợp lệ được mở để đọc và ghi. Nếu không, nó sẽ ném một

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

$stream->on['close', function [] {
    echo 'CLOSED';
}];

Xem thêm tài nguyên luồng chỉ đọc và chỉ ghi

Trong nội bộ, lớp này cố gắng bật chế độ không chặn trên tài nguyên luồng, chế độ này có thể không được hỗ trợ cho tất cả các tài nguyên luồng. Đáng chú ý nhất, điều này không được hỗ trợ bởi các đường ống trên Windows [STDOUT, STDERR, v.v. ]. Nếu điều này không thành công, nó sẽ ném một

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

$stream->on['close', function [] {
    echo 'CLOSED';
}];

Lớp này nhận một tham số

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

29 tùy chọn có thể được sử dụng để truyền thể hiện vòng lặp sự kiện để sử dụng cho đối tượng này. Bạn có thể sử dụng giá trị

$stream->on['end', function [] {
    echo 'END';
}];

83 ở đây để sử dụng. Giá trị này KHÔNG NÊN được cung cấp trừ khi bạn chắc chắn muốn sử dụng rõ ràng một phiên bản vòng lặp sự kiện đã cho

Lớp này nhận một tham số

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

31 tùy chọn kiểm soát kích thước bộ đệm tối đa theo byte để đọc cùng một lúc từ luồng. Bạn có thể sử dụng giá trị

$stream->on['end', function [] {
    echo 'END';
}];

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

$stream->on['close', function [] {
    echo 'CLOSED';
}];

Bất kỳ cuộc gọi

$stream->on['end', function [] {
    echo 'END';
}];

Lớp này có một tham số

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

72 tùy chọn khác kiểm soát hành vi ghi này của luồng này. Bạn có thể sử dụng giá trị

$stream->on['end', function [] {
    echo 'END';
}];

83 tại đây để áp dụng giá trị mặc định của nó. Giá trị này KHÔNG NÊN thay đổi trừ khi bạn biết mình đang làm gì

Nếu bạn muốn thay đổi giới hạn mềm của bộ đệm ghi, bạn có thể chuyển một phiên bản như thế này

$stream->on['close', function [] {
    echo 'CLOSED';
}];

Xem thêm để biết thêm chi tiết

Nhật ký thay đổi. kể từ v1. 2. 0 tham số
$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];
38 có thể được bỏ qua [hoặc bỏ qua với giá trị
$stream->on['end', function [] {
    echo 'END';
}];
83] để sử dụng

QuaStream

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

78 thực hiện và sẽ đơn giản chuyển bất kỳ dữ liệu nào bạn ghi vào nó đến phần cuối có thể đọc được của nó

$stream->on['close', function [] {
    echo 'CLOSED';
}];

Tương tự như vậy, sẽ kết thúc luồng và phát ra một và sau đó là luồng. Sẽ đóng luồng và phát ra một. Theo đó, this is cũng có thể được sử dụng trong ngữ cảnh như thế này

assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];

Tùy chọn, hàm tạo của nó chấp nhận bất kỳ chức năng có thể gọi nào, sau đó sẽ được sử dụng để lọc bất kỳ dữ liệu nào được ghi vào nó. Hàm này nhận một đối số dữ liệu duy nhất khi được chuyển đến phía có thể ghi và phải trả về dữ liệu vì nó sẽ được chuyển đến phần có thể đọc được của nó

assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];

Lưu ý rằng lớp này không đưa ra giả định về bất kỳ loại dữ liệu nào. Điều này có thể được sử dụng để chuyển đổi dữ liệu, chẳng hạn như để chuyển đổi bất kỳ dữ liệu có cấu trúc nào thành luồng JSON [NDJSON] được phân tách bằng dòng mới như thế này

assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];

Chức năng gọi lại được phép ném một

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

3. Trong trường hợp này, luồng sẽ phát ra sự kiện

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

4 và sau đó luồng

assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];

CompositeStream

$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];

89 triển khai và có thể được sử dụng để tạo một luồng song công từ hai luồng riêng lẻ triển khai và tương ứng

Điều này hữu ích đối với một số API có thể yêu cầu một phiên bản duy nhất hoặc đơn giản vì làm việc với một phiên bản luồng đơn như thế này thường thuận tiện hơn

assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];

Đây là một luồng hoạt động tốt chuyển tiếp tất cả các sự kiện phát trực tiếp từ các luồng bên dưới và chuyển tiếp tất cả lệnh gọi luồng đến các luồng bên dưới

Nếu bạn _______15_______36 tới luồng song công, nó sẽ chỉ ____15_______36 tới phía có thể ghi và trả về trạng thái của nó

Nếu bạn

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

9 luồng song công, nó sẽ

$stream->pause[];

Loop::addTimer[1.0, function [] use [$stream] {
    $stream->resume[];
}];

9 bên có thể ghi và sẽ

$stream->on['end', function [] {
    echo 'END';
}];

07 bên có thể đọc

Nếu bạn

$connection->pipe[$connection];

9 luồng song công, cả hai luồng đầu vào sẽ bị đóng. Nếu một trong hai luồng đầu vào phát ra sự kiện

$stream->pause[];

$stream->on['data', assertShouldNeverCalled[]];
$stream->on['end', assertShouldNeverCalled[]];

6, thì luồng song công cũng sẽ đóng. Nếu một trong hai luồng đầu vào đã bị đóng trong khi xây dựng luồng song công, nó sẽ

$connection->pipe[$connection];

9 phía bên kia và trả về một luồng đã đóng

Cách sử dụng

Ví dụ sau có thể được sử dụng để chuyển nội dung của tệp nguồn sang tệp đích mà không cần phải đọc toàn bộ tệp vào bộ nhớ

assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];

Lưu ý rằng ví dụ này chỉ sử dụng
$server->on['error', function [Exception $e] {
    echo 'Error: ' . $e->getMessage[] . PHP_EOL;
}];
17 cho mục đích minh họa. Điều này không nên được sử dụng trong một chương trình thực sự không đồng bộ vì hệ thống tệp vốn đã bị chặn và mỗi cuộc gọi có thể mất vài giây. Xem thêm các ví dụ phức tạp hơn

Cài đặt

Cách khuyến nghị để cài đặt thư viện này là thông qua Composer. Bạn mới sử dụng Trình soạn nhạc?

Dự án này theo SemVer. Điều này sẽ cài đặt phiên bản được hỗ trợ mới nhất

assert[$stream->isReadable[] === false];

$stream->on['data', assertNeverCalled[]];
$stream->on['end', assertNeverCalled[]];

Xem thêm CHANGELOG để biết chi tiết về nâng cấp phiên bản

Dự án này nhằm mục đích chạy trên bất kỳ nền tảng nào và do đó không yêu cầu bất kỳ phần mở rộng PHP nào và hỗ trợ chạy trên PHP 5 kế thừa. 3 đến PHP 8+ và HHVM hiện tại. Rất nên sử dụng PHP 7+ cho dự án này do những cải tiến hiệu suất lớn của nó

bài kiểm tra

Để chạy bộ thử nghiệm, trước tiên bạn cần sao chép repo này, sau đó cài đặt tất cả các phụ thuộc thông qua Trình soạn thảo

Để chạy bộ thử nghiệm, hãy vào thư mục gốc của dự án và chạy

Bộ thử nghiệm cũng chứa một số thử nghiệm tích hợp chức năng dựa trên kết nối internet ổn định. Nếu bạn không muốn chạy chúng, bạn có thể bỏ qua chúng như thế này

một dòng giải thích là gì?

Dòng suối là khối nước chảy trên bề mặt Trái đất . Dòng từ thường được sử dụng thay thế cho dòng sông, mặc dù các dòng sông thường mô tả các dòng lớn hơn. Suối mang lại nhiều lợi ích cho con người.

Làm cách nào để tạo luồng trong PHP?

$stream = fopen['php. //temp', 'r']; Luồng kết quả [ $stream ] khi đó là một tài nguyên kiểu "stream", được tạo từ URL php. //nhiệt độ.

Luồng đầu vào trong PHP là gì?

php. // đầu vào là luồng chỉ đọc cho phép bạn đọc dữ liệu thô từ phần thân yêu cầu .

Trình bao bọc luồng PHP là gì?

Giới thiệu ¶ . Ví dụ: trình bao bọc http biết cách dịch URL thành HTTP/1. 0 yêu cầu tệp trên máy chủ từ xa. additional code which tells the stream how to handle specific protocols/encodings. For example, the http wrapper knows how to translate a URL into an HTTP/1.0 request for a file on a remote server.

Sử dụng luồng

ReadableStreamGiao diện

sự kiện dữ liệu

kết thúc sự kiện

sự kiện lỗi

đóng sự kiện

isReadable[]

tạm ngừng[]

bản tóm tắt[]

đường ống[]

Thoát[]

WritableStreamGiao Diện

cống sự kiện

sự kiện đường ống

sự kiện lỗi

đóng sự kiện

isWritable[]

viết[]

kết thúc[]

Thoát[]

DuplexStreamGiao Diện

Tạo luồng

ReadableResourceStream

Nguồn tài nguyên có thể ghi

DuplexResourceStream

QuaStream

CompositeStream

Cách sử dụng

Cài đặt

bài kiểm tra

một dòng giải thích là gì?

Làm cách nào để tạo luồng trong PHP?

Luồng đầu vào trong PHP là gì?

Trình bao bọc luồng PHP là gì?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề