Java 使用PipedOutputStream和PipedInputStream的多线程编写器和单线程读取器_Java_Multithreading

Java 使用PipedOutputStream和PipedInputStream的多线程编写器和单线程读取器

java multithreading

Java 使用PipedOutputStream和PipedInputStream的多线程编写器和单线程读取器,java,multithreading,Java,Multithreading,我有一个多写线程和单读线程模型。 ThreadMultipleDateReceiver类设计用于从多个线程读取数据 public class ThreadMultipleDateReceiver extends Thread { private static final int MAX_CLIENT_THREADS = 4; private byte[] incomingBytes; private volatile boolean isRunning; private vol

我有一个多写线程和单读线程模型。

ThreadMultipleDateReceiver

类设计用于从多个线程读取数据

public class ThreadMultipleDateReceiver extends Thread {

  private static final int MAX_CLIENT_THREADS = 4;
  private byte[] incomingBytes;
  private volatile boolean isRunning;
  private volatile List<ThreadStreamDateWriter> lThrdDate;

  private static PipedInputStream pipedInputStream;

  public ThreadMultipleDateReceiver() {
    lThrdDate = Collections.synchronizedList(new ArrayList<>(MAX_CLIENT_THREADS));
    pipedInputStream = new PipedInputStream();
    System.out.println("ThreadMultipleDateReceiver Created");
  }

  @Override public void run() {
    isRunning = true;
    while (isRunning) {
      if (!lThrdDate.isEmpty()) {
        System.out.println("ThreadMultipleDateReceiver has:" + lThrdDate.size());
        for (int i = lThrdDate.size(); i > 0; i--) {
          if (lThrdDate.get(i - 1).getState() == Thread.State.TERMINATED) {
            lThrdDate.remove(i - 1);
          } else {
            System.out.println("I ThreadMultipleDateReceiver have:" + lThrdDate.get(i - 1).getNameDateWriter());
          }
        }
        incomingBytes = new byte[1024];
        try {
          String str = "";
          int iRd;
          System.out.println("ThreadMultipleDateReceiver waiting:" + str);
          while ((iRd = pipedInputStream.read(incomingBytes)) != -1) {
            if (iRd > 0) {
              str += new String(incomingBytes);
            }
          }
          System.out.println("ThreadMultipleDateReceiver Received:\n\t:" + str);
        } catch (IOException e) { }
      } else {
        System.out.println("ThreadMultipleDateReceiver Empty");
      }
    }
    emptyDateWriters();
  }

  public void addDateWriter(ThreadStreamDateWriter threadDateWriter) {
    if (lThrdDate.size() < MAX_CLIENT_THREADS) {
      lThrdDate.add(threadDateWriter);
    }
  }

  private void emptyDateWriters() {
    if (!lThrdDate.isEmpty()) {
      for (int i = lThrdDate.size(); i > 0; i--) {
        ThreadStreamDateWriter threadDateWriter = lThrdDate.get(i - 1);
        threadDateWriter.stopThread();
        lThrdDate.remove(i - 1);
      }
    }
  }

  public PipedInputStream getPipedInputStream() {
    return pipedInputStream;
  }

  public void stopThread() {
    isRunning = false;
  }

}

如何启动（我正在使用Netbeans）

输出

    run:
ThreadMultipleDateReceiver Created
ThreadMultipleDateReceiver Empty
ThreadMultipleDateReceiver Empty
ThreadMultipleDateReceiver Empty
.....
ThreadMultipleDateReceiver Empty
ThreadMultipleDateReceiver Empty
ThreadMultipleDateReceiver Empty
ThreadMultipleDateReceiver has:1
I ThreadMultipleDateReceiver have:-0-
ThreadMultipleDateReceiver waiting:
ThreadStreamDateWriter -> write to pipedOutputStream:-0- -> 20170608-090003
ThreadStreamDateWriter -> write to pipedOutputStream:-1- -> 20170608-090003
BUILD SUCCESSFUL (total time: 1 minute 3 seconds)

ThreadMultipledTereReceiver被阻止，并且未打印：

ThreadMultipleDateReceiver Received:
    -1- -> 20170608-090003

或

如何解决此问题？

管道输出流看起来是静态的，因此每次构造ThreadStreamDateWriter时，您都会使用管道输出流的旧值

尝试将其作为实例变量并将其传递到构造函数中。所以你只有一个

编辑1：我制作了管道实例变量并添加了一些打印输出。现在似乎运行时间更长（见下文）：

编辑2：第二个pipedOutputStream.connect（snk）；他在扔东西。一次只能连接一个对象

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.List;
public class So44438086 {
    public static class ThreadMultipleDateReceiver extends Thread {
        private static final int MAX_CLIENT_THREADS=4;
        private byte[] incomingBytes;
        private volatile boolean isRunning;
        private volatile List<ThreadStreamDateWriter> lThrdDate;
        private /*static*/ PipedInputStream pipedInputStream;
        public ThreadMultipleDateReceiver() {
            lThrdDate=Collections.synchronizedList(new ArrayList<>(MAX_CLIENT_THREADS));
            pipedInputStream=new PipedInputStream();
            System.out.println("ctor setting pipedInputStream to: "+pipedInputStream);
            System.out.println("ThreadMultipleDateReceiver Created");
        }
        @Override public void run() {
            isRunning=true;
            while(isRunning) {
                if(!lThrdDate.isEmpty()) {
                    System.out.println("ThreadMultipleDateReceiver has:"+lThrdDate.size());
                    for(int i=lThrdDate.size();i>0;i--) {
                        if(lThrdDate.get(i-1).getState()==Thread.State.TERMINATED) {
                            lThrdDate.remove(i-1);
                        } else {
                            System.out.println("I ThreadMultipleDateReceiver have:"+lThrdDate.get(i-1).getNameDateWriter());
                        }
                    }
                    incomingBytes=new byte[1024];
                    try {
                        String str="";
                        int iRd;
                        System.out.println("ThreadMultipleDateReceiver waiting:"+str);
                        System.out.println("reading: "+pipedInputStream);
                        while((iRd=pipedInputStream.read(incomingBytes))!=-1) {
                            if(iRd>0) {
                                str+=new String(incomingBytes);
                            }
                        }
                        System.out.println("ThreadMultipleDateReceiver Received:\n\t:"+str);
                    } catch(IOException e) {}
                } else {
                    System.out.println("ThreadMultipleDateReceiver Empty");
                }
            }
            emptyDateWriters();
        }
        public void addDateWriter(ThreadStreamDateWriter threadDateWriter) {
            if(lThrdDate.size()<MAX_CLIENT_THREADS) {
                lThrdDate.add(threadDateWriter);
            }
        }
        private void emptyDateWriters() {
            if(!lThrdDate.isEmpty()) {
                for(int i=lThrdDate.size();i>0;i--) {
                    ThreadStreamDateWriter threadDateWriter=lThrdDate.get(i-1);
                    threadDateWriter.stopThread();
                    lThrdDate.remove(i-1);
                }
            }
        }
        public PipedInputStream getPipedInputStream() {
            return pipedInputStream;
        }
        public void stopThread() {
            isRunning=false;
        }
    }
    public static class ThreadStreamDateWriter extends Thread {
        String Self;
        private byte[] outgoingBytes;
        private volatile boolean isRunning;
        private /*static*/ PipedOutputStream pipedOutputStream;
        ThreadStreamDateWriter(String name,PipedInputStream snk) {
            Self=name;
            pipedOutputStream=new PipedOutputStream();
            System.out.println("ctor setting pipedOutputStream to: "+pipedOutputStream);
            try {
                pipedOutputStream.connect(snk);
                System.out.println(pipedOutputStream+" connectd to: "+snk);
            } catch(IOException e) {}
        }
        @Override public void run() {
            isRunning=true;
            while(isRunning) {
                try {
                    outgoingBytes=getInfo().getBytes();
                    System.out.println("ThreadStreamDateWriter -> write to pipedOutputStream:"+new String(outgoingBytes));
                    System.out.println("writing to: "+pipedOutputStream);
                    pipedOutputStream.write(outgoingBytes);
                    System.out.println("ThreadStreamDateWriter -> wrote:"+new String(outgoingBytes));
                    try {
                        Thread.sleep(4000);
                    } catch(InterruptedException ex) {}
                } catch(IOException|NegativeArraySizeException|IndexOutOfBoundsException e) {
                    isRunning=false;
                }
            }
        }
        String getInfo() {
            String sDtTm=new SimpleDateFormat("yyyyMMdd-hhmmss").format(Calendar.getInstance().getTime());
            return Self+" -> "+sDtTm;
        }
        public void stopThread() {
            isRunning=false;
        }
        public String getNameDateWriter() {
            return Self;
        }
    }
    private void foo() {
        if(thrdMDateReceiver==null) {
            thrdMDateReceiver=new ThreadMultipleDateReceiver();
            thrdMDateReceiver.start();
        }
        if(thrdSDateWriter0==null) {
            thrdSDateWriter0=new ThreadStreamDateWriter("-0-",thrdMDateReceiver.getPipedInputStream());
            thrdSDateWriter0.start();
            thrdMDateReceiver.addDateWriter(thrdSDateWriter0);
        }
        if(thrdSDateWriter1==null) {
            thrdSDateWriter1=new ThreadStreamDateWriter("-1-",thrdMDateReceiver.getPipedInputStream());
            thrdSDateWriter1.start();
            thrdMDateReceiver.addDateWriter(thrdSDateWriter1);
        }
    }
    void run() throws InterruptedException {
        System.out.println(("running"));
        foo();
        System.out.println(("sleeping"));
        Thread.sleep(10000);
        System.out.println(("stopping"));
        if(thrdMDateReceiver!=null) {
            thrdMDateReceiver.stopThread();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        new So44438086().run();
    }
    ThreadMultipleDateReceiver thrdMDateReceiver=null;
    ThreadStreamDateWriter thrdSDateWriter0=null;
    ThreadStreamDateWriter thrdSDateWriter1=null;
}

import java.io.IOException；
导入java.io.PipedInputStream；
导入java.io.PipedOutputStream；
导入java.text.simpleDataFormat；
导入java.util.ArrayList；
导入java.util.Calendar；
导入java.util.Collections；
导入java.util.List；
公共类So44438086{
公共静态类ThreadMultipleDataReceiver扩展线程{
私有静态final int MAX_CLIENT_线程=4；
专用字节[]incomingBytes；
私有易失性布尔运算正在运行；
私有易失性列表日期；
private/*static*/PipedInputStream PipedInputStream；
public-ThreadMultipleDateReceiver（）{
lThrdDate=Collections.synchronizedList（新的ArrayList（MAX_CLIENT_THREADS））；
pipedInputStream=新的pipedInputStream（）；
System.out.println（“将pipedInputStream设置为：“+pipedInputStream的ctor”）；
System.out.println（“创建了ThreadMultipledTereReceiver”）；
}
@重写公共无效运行（）{
isRunning=true；
同时（正在运行）{
如果（！lThrdDate.isEmpty（））{
System.out.println（“ThreadMultipledTereReceiver有：“+lThrdDate.size（）”）；
对于（int i=lThrdDate.size（）；i>0；i--）{
if（lThrdDate.get（i-1）.getState（）==Thread.State.TERMINATED）{
删除（i-1）；
}否则{
System.out.println（“I ThreadMultipleDateReceiver have:”+lThrdDate.get（I-1.getNameDateWriter（））；
}
}
incomingBytes=新字节[1024]；
试一试{
字符串str=“”；
国际税务局；
System.out.println（“ThreadMultipleDateReceiver waiting:+str”）；
System.out.println（“读取：“+pipedInputStream”）；
而（（iRd=pipedInputStream.read（incomingBytes））！=-1）{
如果（iRd>0）{
str+=新字符串（incomingBytes）；
}
}
System.out.println（“接收到的ThreadMultipledTereReceiver:\n\t:+str”）；
}捕获（IOE）{}
}否则{
System.out.println（“threadmultipledTereceiver-Empty”）；
}
}
清空DateWriters（）；
}
公共无效addDateWriter（ThreadStreamDateWriter threadDateWriter）{
if（lThrdDate.size（）0；i--）{
ThreadStreamDateWriter-threadDateWriter=lThrdDate.get（i-1）；
threadDateWriter.stopThread（）；
删除（i-1）；
}
}
}
公共PipedInputStream getPipedInputStream（）{
返回管道输入流；
}
公共void stopThread（）{
isRunning=false；
}
}
公共静态类ThreadStreamDateWriter扩展线程{
弦自身；
专用字节[]输出字节；
私有易失性布尔运算正在运行；
private/*static*/PipedOutputStream PipedOutputStream；
ThreadStreamDateWriter（字符串名称，PipedInputStream snk）{
Self=名称；
pipedOutputStream=新的pipedOutputStream（）；
System.out.println（“将PipeDoutpStream设置为：“+PipeDoutpStream”）；
试一试{
pipedOutputStream.connect（snk）；
System.out.println（管道输出流+”连接到：“+snk”）；
}捕获（IOE）{}
}
@重写公共无效运行（）{
isRunning=true；
同时（正在运行）{
试一试{
outgoingBytes=getInfo（）.getBytes（）；
System.out.println（“ThreadStreamDateWriter->写入pipedOutputStream:”+新字符串（outgoingBytes））；
System.out.println（“写入：“+pipedOutputStream”）；
pipedOutputStream.write（输出字节）；
println（“ThreadStreamDateWriter->writed:”+新字符串（outgoingBytes））；
试一试{
睡眠（4000）；
}catch（InterruptedException ex）{}
}捕获（IOException | NegativeArraySizeException | IndexOutOfBoundsException e）{
isRunning=false；
}
}
}
字符串getInfo（）{
字符串sDtTm=新的SimpleDataFormat（“yyyyMMdd hhmmss”）.format（Calendar.getInstance（）.getTime（））；
返回Self+“->”+sDtTm；
}
公共void stopThread（）{
isRunning=false；
}
公共字符串getNameDateWriter（）{
回归自我；
}
}
私人文件{
if（thrdMDateReceiver==null）{
thrdMDateReceiver=新的ThreadMultipleDateReceiver（）；
thrdMDateReceiver.start（）；
}
if（thrdSDateWriter0==null）{
thrdSDateWriter0=新的ThreadStreamDateWriter
ThreadMultipleDateReceiver Received:
    -1- -> 20170608-090003

ThreadMultipleDateReceiver Received:
    -0- -> 20170608-090003

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.List;
public class So44438086 {
    public static class ThreadMultipleDateReceiver extends Thread {
        private static final int MAX_CLIENT_THREADS=4;
        private byte[] incomingBytes;
        private volatile boolean isRunning;
        private volatile List<ThreadStreamDateWriter> lThrdDate;
        private /*static*/ PipedInputStream pipedInputStream;
        public ThreadMultipleDateReceiver() {
            lThrdDate=Collections.synchronizedList(new ArrayList<>(MAX_CLIENT_THREADS));
            pipedInputStream=new PipedInputStream();
            System.out.println("ctor setting pipedInputStream to: "+pipedInputStream);
            System.out.println("ThreadMultipleDateReceiver Created");
        }
        @Override public void run() {
            isRunning=true;
            while(isRunning) {
                if(!lThrdDate.isEmpty()) {
                    System.out.println("ThreadMultipleDateReceiver has:"+lThrdDate.size());
                    for(int i=lThrdDate.size();i>0;i--) {
                        if(lThrdDate.get(i-1).getState()==Thread.State.TERMINATED) {
                            lThrdDate.remove(i-1);
                        } else {
                            System.out.println("I ThreadMultipleDateReceiver have:"+lThrdDate.get(i-1).getNameDateWriter());
                        }
                    }
                    incomingBytes=new byte[1024];
                    try {
                        String str="";
                        int iRd;
                        System.out.println("ThreadMultipleDateReceiver waiting:"+str);
                        System.out.println("reading: "+pipedInputStream);
                        while((iRd=pipedInputStream.read(incomingBytes))!=-1) {
                            if(iRd>0) {
                                str+=new String(incomingBytes);
                            }
                        }
                        System.out.println("ThreadMultipleDateReceiver Received:\n\t:"+str);
                    } catch(IOException e) {}
                } else {
                    System.out.println("ThreadMultipleDateReceiver Empty");
                }
            }
            emptyDateWriters();
        }
        public void addDateWriter(ThreadStreamDateWriter threadDateWriter) {
            if(lThrdDate.size()<MAX_CLIENT_THREADS) {
                lThrdDate.add(threadDateWriter);
            }
        }
        private void emptyDateWriters() {
            if(!lThrdDate.isEmpty()) {
                for(int i=lThrdDate.size();i>0;i--) {
                    ThreadStreamDateWriter threadDateWriter=lThrdDate.get(i-1);
                    threadDateWriter.stopThread();
                    lThrdDate.remove(i-1);
                }
            }
        }
        public PipedInputStream getPipedInputStream() {
            return pipedInputStream;
        }
        public void stopThread() {
            isRunning=false;
        }
    }
    public static class ThreadStreamDateWriter extends Thread {
        String Self;
        private byte[] outgoingBytes;
        private volatile boolean isRunning;
        private /*static*/ PipedOutputStream pipedOutputStream;
        ThreadStreamDateWriter(String name,PipedInputStream snk) {
            Self=name;
            pipedOutputStream=new PipedOutputStream();
            System.out.println("ctor setting pipedOutputStream to: "+pipedOutputStream);
            try {
                pipedOutputStream.connect(snk);
                System.out.println(pipedOutputStream+" connectd to: "+snk);
            } catch(IOException e) {}
        }
        @Override public void run() {
            isRunning=true;
            while(isRunning) {
                try {
                    outgoingBytes=getInfo().getBytes();
                    System.out.println("ThreadStreamDateWriter -> write to pipedOutputStream:"+new String(outgoingBytes));
                    System.out.println("writing to: "+pipedOutputStream);
                    pipedOutputStream.write(outgoingBytes);
                    System.out.println("ThreadStreamDateWriter -> wrote:"+new String(outgoingBytes));
                    try {
                        Thread.sleep(4000);
                    } catch(InterruptedException ex) {}
                } catch(IOException|NegativeArraySizeException|IndexOutOfBoundsException e) {
                    isRunning=false;
                }
            }
        }
        String getInfo() {
            String sDtTm=new SimpleDateFormat("yyyyMMdd-hhmmss").format(Calendar.getInstance().getTime());
            return Self+" -> "+sDtTm;
        }
        public void stopThread() {
            isRunning=false;
        }
        public String getNameDateWriter() {
            return Self;
        }
    }
    private void foo() {
        if(thrdMDateReceiver==null) {
            thrdMDateReceiver=new ThreadMultipleDateReceiver();
            thrdMDateReceiver.start();
        }
        if(thrdSDateWriter0==null) {
            thrdSDateWriter0=new ThreadStreamDateWriter("-0-",thrdMDateReceiver.getPipedInputStream());
            thrdSDateWriter0.start();
            thrdMDateReceiver.addDateWriter(thrdSDateWriter0);
        }
        if(thrdSDateWriter1==null) {
            thrdSDateWriter1=new ThreadStreamDateWriter("-1-",thrdMDateReceiver.getPipedInputStream());
            thrdSDateWriter1.start();
            thrdMDateReceiver.addDateWriter(thrdSDateWriter1);
        }
    }
    void run() throws InterruptedException {
        System.out.println(("running"));
        foo();
        System.out.println(("sleeping"));
        Thread.sleep(10000);
        System.out.println(("stopping"));
        if(thrdMDateReceiver!=null) {
            thrdMDateReceiver.stopThread();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        new So44438086().run();
    }
    ThreadMultipleDateReceiver thrdMDateReceiver=null;
    ThreadStreamDateWriter thrdSDateWriter0=null;
    ThreadStreamDateWriter thrdSDateWriter1=null;
}

public class ThreadMultipleDateReceiver extends Thread {

    private static final int MAX_CLIENT_THREADS = 4;
    private byte[] incomingBytes;
    private volatile boolean isRunning;
    private volatile List<ThreadStreamDateWriter> lThrdDate;

    private PipedInputStream pipedInputStream;
    private PipedOutputStream pipedOutputStream;

    public ThreadMultipleDateReceiver() {
        lThrdDate = Collections.synchronizedList(new ArrayList<>(MAX_CLIENT_THREADS));
        pipedInputStream = new PipedInputStream();
        pipedOutputStream = new PipedOutputStream();
        pipedInputStream.connect(pipedOutputStream);
        System.out.println("ThreadMultipleDateReceiver Created");
    }

    @Override public void run() {
        isRunning = true;
        while (isRunning) {
            if (!lThrdDate.isEmpty()) {
                System.out.println("ThreadMultipleDateReceiver has:" + lThrdDate.size());
                for (int i = lThrdDate.size(); i > 0; i--) {
                    if (lThrdDate.get(i - 1).getState() == Thread.State.TERMINATED) {
                        lThrdDate.remove(i - 1);
                    } else {
                        System.out.println("ThreadMultipleDateReceiver have:" + lThrdDate.get(i - 1).getNameDateWriter());
                    }
                }
                incomingBytes = new byte[1024];
                try {
                    String str = "";
                    int iRd;
                    System.out.println("ThreadMultipleDateReceiver waiting:" + str);
                    while ((iRd = pipedInputStream.read(incomingBytes)) != -1) {
                        String r = new String(Arrays.copyOf(incomingBytes, iRd));
//                        if (iRd > 0) {
//                            str += r;
//                        }
                        System.out.println("ThreadMultipleDateReceiver Received:\t" + r);
                    }
//                    System.out.println("ThreadMultipleDateReceiver Received:\n\t:" + str);
                } catch (IOException e) { }
            } else {
                System.out.println("ThreadMultipleDateReceiver Empty");
            }
        }
        emptyDateWriters();
    }

public void addDateWriter(ThreadStreamDateWriter threadDateWriter) {
    if (lThrdDate.size() < MAX_CLIENT_THREADS) {
        lThrdDate.add(threadDateWriter);
    }
}

    private void emptyDateWriters() {
        if (!lThrdDate.isEmpty()) {
            for (int i = lThrdDate.size(); i > 0; i--) {
                ThreadStreamDateWriter threadDateWriter = lThrdDate.get(i - 1);
                threadDateWriter.stopThread();
                lThrdDate.remove(i - 1);
            }
        }
    }

    public PipedOutputStream getPipedOutputStream() {
        return pipedOutputStream;
    }

    public void stopThread() {
        isRunning = false;
    }

}

public class ThreadStreamDateWriter extends Thread {
    String Self;
    private byte[] outgoingBytes;
    private volatile boolean isRunning;
    private final PipedOutputStream pipedOutputStream;


    ThreadStreamDateWriter(String name, PipedOutputStream src) {
        Self = name;
        pipedOutputStream = src;
    }

    @Override public void run() {
        isRunning = true;
        while (isRunning) {
            try {
                outgoingBytes = getInfo().getBytes();
                System.out.println("ThreadStreamDateWriter -> write to pipedOutputStream:" + new String(outgoingBytes));
                pipedOutputStream.write(outgoingBytes);
                System.out.println("ThreadStreamDateWriter -> wrote:" + new String(outgoingBytes));
                try { Thread.sleep(4000); } catch (InterruptedException ex) { }
            } catch (IOException | NegativeArraySizeException | IndexOutOfBoundsException e) {
                isRunning = false;
            }
        }
    }

    String getInfo() {
      String sDtTm = new SimpleDateFormat("yyyyMMdd-hhmmss").format(Calendar.getInstance().getTime());
      return Self + " -> " + sDtTm;
    }

    public void stopThread() {
        isRunning = false;
    }

    public String getNameDateWriter() {
        return Self;
    }
}

  ThreadMultipleDateReceiver thrdMDateReceiver = null;
  ThreadStreamDateWriter thrdSDateWriter0 = null;
  ThreadStreamDateWriter thrdSDateWriter1 = null;
  private void jtbDateExchangerActionPerformed(java.awt.event.ActionEvent evt) {  
    if (jtbDateExchanger.isSelected()) {
      if (thrdMDateReceiver == null) {
        thrdMDateReceiver = new ThreadMultipleDateReceiver();
        thrdMDateReceiver.start();
      }
      if (thrdSDateWriter0 == null) {
        thrdSDateWriter0 = new ThreadStreamDateWriter("-0-", thrdMDateReceiver.getPipedOutputStream());
        thrdSDateWriter0.start();
        thrdMDateReceiver.addDateWriter(thrdSDateWriter0);
      }
      if (thrdSDateWriter1 == null) {
        thrdSDateWriter1 = new ThreadStreamDateWriter("-1-", thrdMDateReceiver.getPipedOutputStream());
        thrdSDateWriter1.start();
        thrdMDateReceiver.addDateWriter(thrdSDateWriter1);
      }
    } else {
      if (thrdMDateReceiver != null) {
        thrdMDateReceiver.stopThread();
      }
    }
  }