1.线程间的通信
通过管道实现线程间的通信：字节流
通信关单实现线程间的通信：字符流
等待通知之交叉备份
java的各种流中有一种叫管道流（pipeStream),用于在不同的线程之间直接传送数据，一个线程发送数据到输出管道，另一个线程从从输入管道中读取数据，通过使用管道实现不同线程间的通信
提供四个类来实现通信：
PipeInputStram PipeOutputStram
PipedReader PipedWriter
用管道流的时候记得有一个流的连接操作
2.通过管道实现线程间的通信：字节流
负责写数据的类：
package com.wx.threadlearn3;
import java.io.IOException;
import java.io.PipedOutputStream;
public class WriteData {
public void writeData(PipedOutputStream outputStream)
{
try{
String data="123456789987654321";
outputStream.write(data.getBytes());
outputStream.close();
}catch (IOException e)
{
e.printStackTrace();
}
}
}
负责读数据的类：
package com.wx.threadlearn3;
import java.io.PipedInputStream;
public class ReadData {
public void readData(PipedInputStream pipedInputStream)
{
try{
byte[] buffer=new byte[10];
int length=pipedInputStream.read(buffer);
while(length!=-1)
{
String s = new String(buffer, 0, length);
System.out.println(s);
}
pipedInputStream.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
写数据的线程：
package com.wx.threadlearn3;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
public class WriteThread implements Runnable {
private WriteData writeData;
private PipedOutputStream outputStream;
public WriteThread(WriteData writeData,PipedOutputStream pipedOutputStream)
{
this.writeData=writeData;
this.outputStream=pipedOutputStream;
}
@Override
public void run() {
writeData.writeData(outputStream);
}
}
读数据的线程：
package com.wx.threadlearn3;
import java.io.PipedInputStream;
public class ReadThread implements Runnable {
private ReadData readData;
private PipedInputStream pipedInputStream;
public ReadThread(ReadData readData,PipedInputStream pipedInputStream)
{
this.pipedInputStream=pipedInputStream;
this.readData=readData;
}
@Override
public void run() {
readData.readData(pipedInputStream);
}
}
测试：
package com.wx.threadlearn3;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
public class Test {
public static void main(String[] args)
{
try {
WriteData writeData = new WriteData();
ReadData readData=new ReadData();
PipedInputStream pipedInputStream = new PipedInputStream();
PipedOutputStream pipedOutputStrea=new PipedOutputStream();
pipedOutputStrea.connect(pipedInputStream);
WriteThread writeThread=new WriteThread(writeData,pipedOutputStrea);
ReadThread readThread = new ReadThread(readData,pipedInputStream);
Thread thread1=new Thread(readThread);
thread1.start();
Thread.sleep(2000);
Thread thread=new Thread(writeThread);
thread.start();
}catch (Exception e)
{
e.printStackTrace();
}
}
}
3.通信关单实现线程间的通信：字符流
package com.wx.threadlearn4;
import java.io.IOException;
import java.io.PipedOutputStream;
import java.io.PipedWriter;
public class WriteData {
public void writeData(PipedWriter pipedWriter)
{
try{
for(int i=0;i<300;i++)
{
pipedWriter.write((i+""));
}
pipedWriter.close();
}catch (IOException e)
{
e.printStackTrace();
}
}
}
package com.wx.threadlearn4;
import java.io.PipedInputStream;
import java.io.PipedReader;
public class ReadData {
public void readData(PipedReader pipedReader)
{
try{
char[] buffer=new char[10];
int length=pipedReader.read(buffer);
while(length!=-1)
{
String s = new String(buffer, 0, length);
System.out.print(s+"空额");
pipedReader.read(buffer);
}
pipedReader.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
package com.wx.threadlearn4;
import java.io.PipedWriter;
public class WriteThread implements Runnable {
private WriteData writeData;
private PipedWriter pipedWriter;
public WriteThread(WriteData writeData,PipedWriter pipedWriter)
{
this.writeData=writeData;
this.pipedWriter=pipedWriter;
}
@Override
public void run() {
writeData.writeData(pipedWriter);
}
}
package com.wx.threadlearn4;
import java.io.PipedInputStream;
import java.io.PipedReader;
public class ReadThread implements Runnable {
private ReadData readData;
private PipedReader pipedReader;
public ReadThread(ReadData readData, PipedReader pipedReader)
{
this.pipedReader=pipedReader;
this.readData=readData;
}
@Override
public void run() {
readData.readData(pipedReader);
}
}
package com.wx.threadlearn4;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.PipedReader;
import java.io.PipedWriter;
public class Test {
public static void main(String[] args)
{
try {
WriteData writeData = new WriteData();
ReadData readData=new ReadData();
PipedReader pipedReader=new PipedReader();
PipedWriter pipedWriter=new PipedWriter();
pipedReader.connect(pipedWriter);
WriteThread writeThread=new WriteThread(writeData,pipedWriter);
ReadThread readThread = new ReadThread(readData,pipedReader);
Thread thread1=new Thread(readThread);
thread1.start();
Thread.sleep(2000);
Thread thread=new Thread(writeThread);
thread.start();
}catch (Exception e)
{
e.printStackTrace();
}
}
}
4.等待通知之交叉备份：
创建20个线程，10个线程叫数据备份到A数据库，10个线程将数据备份到B数据库并且他们是交替进行的。
package com.wx.threadlearn5;
public class DBTools {
volatile private boolean flag=true;
synchronized public void backA()
{
try{
while(flag==true)
{
System.out.println("backA处于的wait前面");
wait();
System.out.println("backA的wait后面");
}
System.out.println("数据库A备份完成");
flag=true;
notifyAll();
System.out.println("唤醒B");
}catch (Exception e)
{
e.printStackTrace();
}
}
synchronized public void backB()
{
try{
while(flag==false)
{
System.out.println("backB处于的wait前面");
wait();
System.out.println("backB的wait后面");
}
System.out.println("数据库B备份完成");
flag=false;
notifyAll();
System.out.println("唤醒A");
}catch (Exception e)
{
e.printStackTrace();
}
}
}
package com.wx.threadlearn5;
public class ThreadA extends Thread {
private DBTools dbTools;
public ThreadA(DBTools dbTools)
{
this.dbTools=dbTools;
}
@Override
public void run() {
super.run();
/*
线程A备份数据库
*/
dbTools.backA();
}
}
package com.wx.threadlearn5;
public class ThreadB extends Thread {
private DBTools dbTools;
public ThreadB(DBTools dbTools)
{
this.dbTools=dbTools;
}
@Override
public void run() {
super.run();
/*
线程B备份数据库
*/
dbTools.backB();
}
}
package com.wx.threadlearn5;
public class Test1 {
public static void main(String[] args)
{
DBTools dbTools = new DBTools();
for (int i=0;i<20;i++)
{
ThreadA threadA = new ThreadA(dbTools);
ThreadB threadB=new ThreadB(dbTools);
threadA.start();
threadB.start();
}
}
}
