多线程学习笔记4-线程间的通信(2)

多线程通信(2)
字节流中的管道流(pipeStream)是一种特殊的流,用于在不同线程之间直接传输数据
一个线程发送数据到输出管道,另一个线程从输入管道读取数据
JDK提供了四个类来使线程进行通信
1.PipedInputStream和PipedOutputStream
2.PipedReader和PipeWriter
例子:
一个用于写入流的类:
public class WriterData {
public void writeMethod(PipedOutputStream out){
try{
System.out.print("writer :");
for(int i = 0;i< 300;i++){
String outData = ""+i+1;
out.write(outData.getBytes());
System.out.print(outData);
}
System.out.println();
out.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
一个用于读取流的类:
public class ReadData {
public void readMethod(PipedInputStream input){
try{
System.out.print("read :");
byte[] bytes = new byte[20];
int length = input.read(bytes);
while(length != -1){
String newData = new String(bytes,0,length);
System.out.print(newData);
length = input.read(bytes);
}
System.out.println();
input.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
写入线程:
public class ThreadWrite extends Thread{
private WriterData write;
private PipedOutputStream out;
public ThreadWrite(WriterData write,PipedOutputStream out){
this.write = write;
this.out = out;
}
public void run(){
write.writeMethod(out);
}
}
读取线程:
public class ThreadRead extends Thread{
private ReadData read;
private PipedInputStream input;
public ThreadRead(ReadData read,PipedInputStream input){
this.read = read;
this.input = input;
}
public void run(){
read.readMethod(input);
}
public static void main(String[] args) {
try{
WriterData writeData = new WriterData();
ReadData readData = new ReadData();
PipedInputStream inputStream = new PipedInputStream();
PipedOutputStream outputStream = new PipedOutputStream();
inputStream.connect(outputStream);
ThreadRead threadread = new ThreadRead(readData,inputStream);
threadread.start();
Thread.sleep(2000);
ThreadWrite threadwrite = new ThreadWrite(writeData,outputStream);
threadwrite.start();
}catch(IOException e){
e.printStackTrace();
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
利用变量控制线程的顺序
用于操作a和b的类
public class DBTools {
volatile private boolean preIsA = false;
synchronized public void backupA(){
try{
while(preIsA == true){
wait();
}
for(int i = 0;i < 5;i++){
System.out.println("*********");
}
preIsA = true;
notifyAll();
}catch(InterruptedException e){
e.printStackTrace();
}
}
synchronized public void backupB(){
try{
while(preIsA == false){
wait();
}
for(int i = 0;i < 5;i++){
System.out.println(".........");
}
preIsA = false;
notifyAll();
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
线程a:
public class BackupA extends Thread{
private DBTools dbtools;
public BackupA(DBTools dbtools){
this.dbtools = dbtools;
}
public void run(){
dbtools.backupA();
}
}
线程b:
public class BackupB extends Thread{
private DBTools dbtools;
public BackupB(DBTools dbtools){
this.dbtools = dbtools;
}
public void run(){
dbtools.backupB();
}
public static void main(String[] args) {
DBTools dbtools = new DBTools();
for(int i = 0;i< 20;i++){
BackupB out = new BackupB(dbtools);
out.start();
BackupA in = new BackupA(dbtools);
in.start();
}
}
}

输出结果: