Lớp PipedWriter
(Class PipedWriter)
Lớp PipedWriter trong Java cung cấp một cơ chế để truyền dữ liệu giữa các luồng (threads) thông qua một ống (pipe). Nó hoạt động phối hợp với lớp PipedReader, cho phép một luồng ghi dữ liệu vào ống, trong khi một luồng khác đọc dữ liệu từ ống đó.
Đặc điểm của lớp PipedWriter
↳ Là một luồng xuất (output stream) cho các ký tự.
↳ Được sử dụng để truyền dữ liệu giữa các luồng (threads) trong cùng một chương trình.
↳ Phải được kết nối với một PipedReader trước khi sử dụng.
Khai báo lớp PipedWriter trong Java
Để sử dụng lớp PipedWriter, bạn cần import gói java.io bạn cần thêm câu lệnh import vào đầu file Java của mình. Gói này cung cấp các lớp và giao diện để thực hiện các hoạt động nhập xuất (I/O) trong Java.
Cú pháp câu lệnh import:
Cú pháp
import java.io.PipedWriter;
Cú pháp khai báo lớp PipedWriter:
Cú pháp
public class PipedWriter
extends Writer
Dưới đây là giải thích chi tiết về cú pháp khai báo này:
↳ public class PipedWriter: Đây là khai báo một lớp công khai (public) tên là PipedWriter. Lớp này có thể được truy cập từ bất kỳ đâu trong dự án Java, miễn là nó được import hoặc ở cùng gói.
↳ extends Writer: Lớp PipedWriter kế thừa từ lớp Writer. Điều này có nghĩa là PipedWriter kế thừa các phương thức từ lớp Writer, như write(), flush(), và close(), nhưng cũng bổ sung các tính năng đặc biệt để làm việc với các ống (pipes).
Các Constructor của lớp PipedWriter
Lớp PipedWriter cung cấp hai constructor để tạo đối tượng và thiết lập kết nối với một PipedReader:
↳ PipedWriter(): Tạo một PipedWriter chưa được kết nối với bất kỳ PipedReader nào. Bạn phải sử dụng phương thức connect() để kết nối nó sau đó.
↳ PipedWriter(PipedReader snk): Tạo một PipedWriter và kết nối nó ngay lập tức với PipedReader được truyền vào.
Các phương thức của lớp PipedWriter
Lớp PipedWriter cung cấp các phương thức để viết dữ liệu ký tự vào một ống dẫn (pipe). Dưới đây là danh sách tất cả các phương thức của lớp PipedWriter trong Java:
↳ void close(): Đóng luồng và giải phóng tài nguyên hệ thống liên quan.
↳ void connect(PipedReader snk): Kết nối PipedWriter với PipedReader được chỉ định.
↳ void flush(): Buộc ghi dữ liệu đệm ra luồng đích.
↳ void write(char[] cbuf, int off, int len): Ghi một phần của một mảng ký tự vào ống dẫn.
↳ void write(int c): Ghi một ký tự vào ống dẫn.
Lưu ý:
↳ PipedWriter phải được kết nối với một PipedReader trước khi sử dụng.
↳ Việc ghi dữ liệu vào PipedWriter sẽ tự động được truyền đến PipedReader được kết nối.
Ví dụ 1 về lớp PipedReader và lớp PipedWriter
Trong ví dụ này, chúng ta sẽ tạo hai luồng: một luồng sẽ ghi dữ liệu vào PipedWriter, và một luồng khác sẽ đọc dữ liệu từ PipedReader. Dữ liệu sẽ được truyền qua ống (pipe) giữa hai luồng.
Ví dụ: Example.java
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
public class Example {
public static void main(String[] args) {
// Tạo đối tượng PipedReader và PipedWriter
PipedWriter pipedWriter = new PipedWriter();
PipedReader pipedReader = new PipedReader();
try {
// Kết nối PipedReader với PipedWriter
pipedReader.connect(pipedWriter);
// Tạo luồng để ghi dữ liệu vào PipedWriter
Thread writerThread = new Thread(() -> {
try {
for (char c = 'A'; c <= 'Z'; c++) {
pipedWriter.write(c);
Thread.sleep(100); // Đợi 100ms
}
pipedWriter.close(); // Đóng pipedWriter khi hoàn tất
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
});
// Tạo luồng để đọc dữ liệu từ PipedReader
Thread readerThread = new Thread(() -> {
try {
int data;
while ((data = pipedReader.read()) != -1) {
System.out.print((char) data);
}
pipedReader.close(); // Đóng pipedReader khi hoàn tất
} catch (IOException e) {
e.printStackTrace();
}
});
// Bắt đầu các luồng
writerThread.start();
readerThread.start();
// Đợi cho đến khi các luồng hoàn tất
writerThread.join();
readerThread.join();
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}
Kết quả của chương trình là:
Khi bạn chạy chương trình, bạn sẽ thấy các ký tự từ 'A' đến 'Z' được in ra màn hình, thể hiện rằng dữ liệu đã được truyền từ luồng ghi sang luồng đọc thông qua ống.
Ví dụ 2 về lớp PipedReader và lớp PipedWriter
Chương trình này minh họa cách sử dụng PipedReader và PipedWriter để thực hiện giao tiếp giữa các luồng trong Java, cho phép một luồng viết dữ liệu và một luồng khác đọc dữ liệu qua một ống.
Dưới đây là một ví dụ đơn giản về cách sử dụng PipedWriter cùng với PipedReader để truyền dữ liệu giữa hai luồng (threads) trong Java:
Ví dụ: Example.java
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
public class Example {
public static void main(String[] args) {
try {
// Tạo PipedReader và PipedWriter
PipedReader pipedReader = new PipedReader();
PipedWriter pipedWriter = new PipedWriter(pipedReader);
// Tạo một thread để ghi dữ liệu
Thread writerThread = new Thread(() -> {
try {
pipedWriter.write("Hello, world!");
pipedWriter.close(); // Đóng luồng sau khi ghi xong
} catch (IOException e) {
e.printStackTrace();
}
});
// Tạo một thread để đọc dữ liệu
Thread readerThread = new Thread(() -> {
try {
int data;
while ((data = pipedReader.read()) != -1) {
System.out.print((char) data);
}
pipedReader.close(); // Đóng luồng sau khi đọc xong
} catch (IOException e) {
e.printStackTrace();
}
});
// Bắt đầu cả hai thread
writerThread.start();
readerThread.start();
// Chờ cho cả hai thread kết thúc
writerThread.join();
readerThread.join();
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}
Kết quả của chương trình là:
Khi chạy chương trình này, bạn sẽ thấy chuỗi "Hello, world!" được in ra màn hình. Đây là dữ liệu đã được ghi từ writerThread vào PipedWriter và sau đó được đọc bởi readerThread từ PipedReader. Ví dụ này minh họa cách PipedWriter và PipedReader có thể được sử dụng để truyền dữ liệu giữa hai luồng trong Java. PipedWriter ghi dữ liệu vào một ống, trong khi PipedReader đọc dữ liệu từ cùng ống đó.