Esempio n. 1
1
 public void actionPerformed(ActionEvent ae) {
   // 响应用户点击
   if (ae.getActionCommand().equals("new_game")) {
     // 如果选择 “开始新游戏” 则跳转到游戏开始
     ae_panel = new GamePanel(false);
     Thread ae_thread = new Thread(ae_panel);
     ae_thread.start();
     // 先删除旧面板 -- 开始界面
     this.remove(start_panel);
     this.add(ae_panel);
     this.addKeyListener(ae_panel);
     this.setVisible(true); // 如果没有这句点击后不会出现新的游戏面板
   } else if (ae.getActionCommand().equals("qs_game")) {
     // 退出时保存游戏进度
     Recorder.set_enemies(ae_panel.enemies);
     Recorder.save_game_data();
     // 0 表示正常退出
     System.exit(0);
   } else if (ae.getActionCommand().equals("restart_old_game")) {
     // 恢复游戏数据 -- 如果曾经保存
     Recorder.recovery_position();
     ae_panel = new GamePanel(true);
     Thread ae_thread = new Thread(ae_panel);
     ae_thread.start();
     // 先删除旧面板 -- 开始界面
     this.remove(start_panel);
     this.add(ae_panel);
     this.addKeyListener(ae_panel);
     this.setVisible(true);
   } else if (ae.getActionCommand().equals("save_now")) {
     Recorder.set_enemies(ae_panel.enemies);
     Recorder.recovery_position();
   }
 }
  public static void main(String[] args) {
    Thread prodThread = new Thread(new Producer(), "Producer");
    Thread consThread = new Thread(new Consumer(), "Consumer");

    prodThread.start();
    consThread.start();
  }
  public void testEarlySet() throws InterruptedException {
    final BlockingCell<String> cell = new BlockingCell<String>();
    final AtomicReference<String> holder = new AtomicReference<String>();

    Thread getterThread =
        new Thread(
            new Runnable() {
              public void run() {
                try {
                  Thread.sleep(300);
                  holder.set(cell.get());
                } catch (InterruptedException ie) {
                  // no special handling required
                }
              }
            });
    Thread setterThread =
        new Thread(
            new Runnable() {
              public void run() {
                cell.set("hello");
              }
            });

    getterThread.start();
    setterThread.start();

    getterThread.join();
    setterThread.join();

    assertEquals("hello", holder.get());
  }
Esempio n. 4
1
  public static void main(String[] args) throws InterruptedException {
    final Runner runner = new Runner();

    Thread thread1 =
        new Thread(
            () -> {
              try {
                runner.firstThread();
              } catch (InterruptedException e) {
              }
            });

    Thread thread2 =
        new Thread(
            () -> {
              try {
                runner.secondThread();
              } catch (InterruptedException e) {
              }
            });

    thread1.start();
    thread2.start();

    thread1.join();
    thread2.join();

    runner.printCount();
  }
Esempio n. 5
1
  @Test
  public void testRunThreads() throws InterruptedException {
    int numThreads = 2;
    CountDownLatch latch = new CountDownLatch(numThreads);

    UpdateTask task1 =
        new UpdateTask(dao, 1L, latch) {
          @Override
          Item editItem(Item item) {
            item.setProperty2("p2=task1");
            return dao.setProperty2(item);
          }
        };
    UpdateTask task2 =
        new UpdateTask(dao, 1L, latch) {
          @Override
          Item editItem(Item item) {
            item.setProperty1("p1=task2");
            return dao.setProperty1(item);
          }
        };

    Thread t1 = new Thread(task1);
    Thread t2 = new Thread(task2);

    t1.start();
    t2.start();

    t1.join();
    t2.join();

    System.out.println(task1.result);
    System.out.println(task2.result);
  }
Esempio n. 6
1
  // --------------------------------actionConnect------------------------------
  private void actionConnect() {
    if (oParty == null) {
      JOptionPane.showMessageDialog(frame, "Make a party before trying to connect.");
      return;
    }

    String[] oResults = (String[]) DialogManager.show(DialogManager.CONNECT, frame);

    if (oResults[DialogManager.RETURN_IP].equals("cancel")) return;

    lblStatus3.setText("Connecting...");
    try {
      oConn.connect(
          oResults[DialogManager.RETURN_IP], Integer.parseInt(oResults[DialogManager.RETURN_PORT]));
    } catch (UnknownHostException e) {
      JOptionPane.showMessageDialog(
          frame,
          "The IP of the host cannot be determined.",
          "Unknown Host Exception",
          JOptionPane.ERROR_MESSAGE);
      frame.repaint();
      return;
    } catch (IOException e) {
      JOptionPane.showMessageDialog(
          frame, e.getMessage(), "Input/Output Exception", JOptionPane.ERROR_MESSAGE);
      frame.repaint();
      return;
    }
    echo("Connected to opponent!");

    tConn = new Thread(oConn, "conn");
    tConn.start();
    tMain = new Thread(this, "main");
    tMain.start();
  }
 /**
  * Executes the test.
  *
  * @since 1.00
  */
 private static void execute() {
   try {
     Thread.sleep(2000);
   } catch (InterruptedException e) {
     e.printStackTrace();
   }
   ThreadedTest listener = new ThreadedTest();
   r1 = new Runnable1(listener, 0 /*8 * MILLI_SEC*/);
   Thread t1 = new Thread(r1);
   r2 = new Runnable2(listener, 0 /*19 * MILLI_SEC*/);
   Thread t2 = new Thread(r2);
   r3 = new Runnable3(listener, 0 /*25 * MILLI_SEC*/);
   Thread t3 = new Thread(r3);
   TestEnvironment.notice("Starting runnable 1");
   t1.start();
   TestEnvironment.notice("Starting runnable 2");
   t2.start();
   TestEnvironment.notice("Starting runnable 3");
   t3.start();
   while (finished < 3 || t1.isAlive() || t2.isAlive() || t3.isAlive()) {
     try {
       Thread.sleep(1000);
     } catch (InterruptedException e) {
     }
   }
 }
  /**
   * size:2 scenario: pop,pop,push,push,push,push,pop,pop
   *
   * @throws InterruptedException
   */
  public void test() throws InterruptedException {
    BlockingQueue blockingQueue = new BlockingQueueImpl(2);

    QueueThreadPop queueThreadPop = new QueueThreadPop(blockingQueue, 2);
    Thread threadPop = new Thread(queueThreadPop);
    threadPop.start();

    Integer expected = new Integer(1);
    Integer expected2 = new Integer(2);
    Integer expected3 = new Integer(3);
    Integer expected4 = new Integer(4);
    List<Object> expectedList = new ArrayList<Object>();
    expectedList.add(expected);
    expectedList.add(expected2);

    List<Object> values = new ArrayList<Object>();
    values.add(expected);
    values.add(expected2);
    values.add(expected3);
    values.add(expected4);

    QueueThreadPush queueThread = new QueueThreadPush(blockingQueue, values);
    Thread thread = new Thread(queueThread);
    thread.start();
    thread.join();

    List<Object> result = queueThreadPop.getValues();
    assertEquals(expectedList.size(), result.size());
    for (int i = 0; i < result.size(); i++) {
      assertEquals(expectedList.get(i), result.get(i));
    }
    assertEquals(expected3, blockingQueue.pop());
    assertEquals(expected4, blockingQueue.pop());
  }
  public static void main(String[] args) {
    Thread thread =
        new Thread(
            new Runnable() {

              @Override
              public void run() {
                try {
                  Thread.sleep(5 * 1000);
                } catch (InterruptedException e) {
                  e.printStackTrace();
                }
              }
            },
            "rookiefly");

    /*		try {
    	Thread.sleep(1 * 60 * 1000);
    } catch (InterruptedException e) {
    	e.printStackTrace();
    }*/
    thread.start();
    try {
      thread.join();
      thread.start();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    BufferedInputStream bufferedInputStream = new BufferedInputStream(System.in);
    try {
      bufferedInputStream.read();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
Esempio n. 10
0
  public void main() {
    System.out.println("Starting ...");
    long start = System.currentTimeMillis();
    Thread t1 =
        new Thread(
            new Runnable() {
              public void run() {
                process();
              }
            });

    Thread t2 =
        new Thread(
            new Runnable() {
              public void run() {
                process();
              }
            });

    t1.start();
    t2.start();

    try {
      t1.join();
      t2.join();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    long end = System.currentTimeMillis();

    System.out.println("Time taken: " + (end - start));
    System.out.println("List1: " + list1.size() + "; List2: " + list2.size());
  }
Esempio n. 11
0
  @Override
  public boolean onContextItemSelected(MenuItem item) {

    // 擷取是哪個位置的Item被select
    AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();
    final int ItemPosition = info.position;

    switch (item.getItemId()) {
      case 0:
        CheckChangeNumberState CCNS = new CheckChangeNumberState();
        CCNS.setdata(ItemPosition);
        Thread CheckChangeNumberStateThread = new Thread(CCNS);
        CheckChangeNumberStateThread.start();
        break;
      case 1:
        ImplementChangeNumber ICN = new ImplementChangeNumber();
        ICN.setData(1, ItemPosition);
        Thread ICNThread = new Thread(ICN);
        ICNThread.start();
        break;
      case 2:
        AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
        builder.setTitle("換號確認");
        builder.setMessage("你確定要換號?");
        builder.setPositiveButton(
            "確認",
            new AlertDialog.OnClickListener() {

              public void onClick(DialogInterface dialog, int which) {
                ImplementChangeNumber ICN = new ImplementChangeNumber();
                ICN.setData(2, ItemPosition);
                Thread ICNThread = new Thread(ICN);
                ICNThread.start();
              }
            });
        builder.setNegativeButton(
            "取消",
            new AlertDialog.OnClickListener() {

              public void onClick(DialogInterface dialog, int which) {
                // TODO Auto-generated method stub

              }
            });
        AlertDialog alert = builder.create();
        alert.show();

        break;
      case 3:
        GetMyItem GMI = new GetMyItem(ItemPosition);
        Thread GMIThread = new Thread(GMI);
        GMIThread.start();
        break;
      case 4:
        new DeleteItem().execute(ItemPosition);
        break;
    }

    return super.onContextItemSelected(item);
  }
 public void test() {
   Thread thread1 =
       new Thread() {
         public void run() {
           UnitOfWork uow = getSession().acquireUnitOfWork();
           cloned = (ConcurrentPerson) uow.registerObject(person);
         }
       };
   Thread thread2 =
       new Thread() {
         public void run() {
           getSession().refreshObject(person.address);
         }
       };
   thread1.start();
   thread2.start();
   try {
     thread1.join();
     thread2.join();
   } catch (Exception ex) {
     // just an inturrupt ignore
   }
   ConcurrentAddress.RUNNING_TEST = ConcurrentAddress.NONE;
   if (!(cloned.getAddress().getStreet().equals("Start")
       && cloned.getAddress().getPostalCode().equals("H0H0H0"))) {
     if (!(cloned.getAddress().getStreet().equals("Corrupted")
         && cloned.getAddress().getPostalCode().equals("A1A1A1"))) {
       throw new TestErrorException("Failed to wholly clone the object");
     } else {
       getSession().logMessage("LockOnCloneTest :-> Clone blocked on Refresh");
     }
   } else {
     getSession().logMessage(" LockOnCloneTest :-> refresh blocked on clone");
   }
 }
Esempio n. 13
0
  public static void main(String[] args) throws InterruptedException {
    Thread t1 =
        new Thread(
            new Runnable() {
              @Override
              public void run() {
                try {
                  producer();
                } catch (InterruptedException e) {
                  e.printStackTrace();
                }
              }
            });

    Thread t2 =
        new Thread(
            new Runnable() {
              @Override
              public void run() {
                try {
                  consumer();
                } catch (InterruptedException e) {
                  e.printStackTrace();
                }
              }
            });

    t1.start();
    t2.start();

    t1.join();
    t2.join();
  }
Esempio n. 14
0
  public static void main(String[] args) {
    System.out.println("Test");
    //        while (true) {
    //        }
    //        MyTaskThread taskThread = new MyTaskThread();
    //        taskThread.start();
    //        MyTaskThread taskThread1 = new MyTaskThread();
    //        taskThread1.start();
    //        MyTaskThread taskThread3 = new MyTaskThread();
    //        taskThread3.start();
    //        System.out.println("End of job");
    //
    //        System.out.println("----------------------------");
    //        Thread thread = new Thread((new MyTaskRunnible()));
    //        Thread thread1 = new Thread((new MyTaskRunnible()));
    //        Thread thread2 = new Thread((new MyTaskRunnible()));
    //
    //        thread.start();
    //        thread1.start();
    //        thread2.start();

    Thread timer1 = new Thread(new MyTimer(10, "First timer"));
    Thread timer2 = new Thread(new MyTimer(20, "Second timer"));
    Thread timer3 = new Thread(new MyTimer(30, "Third timer"));
    timer1.start();
    timer2.start();
    timer3.start();
    System.out.println("Main thread is over");
  }
 public static void main(String[] args) {
   final StoreBufferExample sbe1 = new StoreBufferExample();
   // Seems necessary to call threadA and threadB many times to make
   // sure they are compiled (JITted) to machine code:
   for (int i = 0; i < 100000; i++) {
     sbe1.threadA();
     sbe1.threadB();
   }
   final StoreBufferExample sbe2 = new StoreBufferExample();
   Thread
       tA =
           new Thread(
               new Runnable() {
                 public void run() {
                   sbe2.threadA();
                 }
               }),
       tB =
           new Thread(
               new Runnable() {
                 public void run() {
                   sbe2.threadB();
                 }
               });
   tA.start();
   tB.start();
 }
Esempio n. 16
0
 @BeforeClass
 public static void setUpOnce() throws IOException {
   proxyServer =
       new Thread(
           new Runnable() {
             public void run() {
               main.runMain(args);
             }
           });
   proxyServer.start();
   webServer =
       new Thread(
           new Runnable() {
             public void run() {
               try {
                 serverSocket = new ServerSocket(9001);
                 while (true) {
                   final Socket socket = serverSocket.accept();
                   new Thread(new PersistentStaticHttpServer(socket, CONTENT)).start();
                 }
               } catch (IOException e) {
                 // throw new RuntimeException(e);
               }
             }
           });
   webServer.start();
 }
Esempio n. 17
0
  public static void test() {

    Thread thread1 = new Thread(new ExtendThread(), "thread1");
    Thread thread2 = new Thread(new ExtendThread(), "thread2");

    // The below 2 threads are assigned default names
    Thread thread3 = new ExtendThread();
    Thread thread4 = new ExtendThread();

    Thread thread5 = new ExtendThread("thread5");

    // Start the threads
    thread1.start();

    thread2.start();

    /**
     * start() Causes this thread to begin execution; the Java Virtual Machine calls the run method
     * of this thread. IllegalThreadStateException is thrown if try to start the same thread again
     */

    // Display info about the main thread,since the exectuion is taking place in the main thread
    System.out.println("Current thread where sysout is provided-" + Thread.currentThread());

    thread3.start();
    thread4.start();

    try {
      // The sleep() method is invoked on the main thread to cause a one second delay.
      Thread.sleep(1000);
    } catch (InterruptedException e) {
    }

    // thread1.start(); //IllegalThreadStateException
  }
Esempio n. 18
0
  /**
   * Entry point into the program that creates two instances of SimpleQueue (aQueue and bQueue) and
   * two Threads that attempt to transfer the contents of aQueue and bQueue in opposite orders.
   * Although this will work sometimes, it also often deadlocks since the Deadlock.transfer() method
   * running in one Thread will acquire aQueue's monitor lock, while the Deadlock.transfer() method
   * running in another Thread will acquire bQueue's monitor lock. At this point, both Threads are
   * waiting to acquire the other SimpleQueue's monitor lock, which causes a circular wait that
   * doesn't terminate!
   */
  public static void main(String[] args) {
    // Designated the number of iterations to run in each thread.
    int iterations = args.length > 0 ? Integer.parseInt(args[0]) : 1000000;

    // Create two SimpleQueue's.
    final SimpleQueue<String> aQueue = new SimpleQueue<String>();
    final SimpleQueue<String> bQueue = new SimpleQueue<String>();

    // Create/start a Thread that transfers the contents of aQueue
    // to bQueue.
    Thread transfer1 = new Thread(new TransferRunnable(aQueue, bQueue, iterations));

    // Create/start a Thread that transfers the contents of bQueue
    // to aQueue, which is the reverse of what Thread t1 does (and
    // thus can lead to deadlock).
    Thread transfer2 = new Thread(new TransferRunnable(bQueue, aQueue, iterations));
    System.out.println("starting first transfer thread");
    transfer1.start();

    System.out.println("starting second transfer thread");
    transfer2.start();

    try {
      transfer1.join();
      System.out.println("joined first transfer thread");
      transfer2.join();
      System.out.println("joined second transfer thread");
    } catch (Exception e) {
      System.out.println("caught exception");
    }
  }
Esempio n. 19
0
  private void checkBoxMouseClicked(MouseEvent event, int index) {
    CheckBox cb = checkBoxArray[index];
    int y = (int) cb.getLayoutY() + radius;
    if (cb.isSelected() && index < 5) {

      // Reader selected
      Ball b = new Ball(minX, maxX, minCsX, maxCsX, y, balColor1, "reader");
      ballArray[index] = b;
      Thread t = new Thread(new BallRunnable(b, readWrite));
      threadArray[index] = t;
      circleArray[index].setVisible(true);
      t.start();

    } else if (cb.isSelected() && index >= 5) {
      // Writer selected
      Ball b = new Ball(minX, maxX, minCsX, maxCsX, y, balColor2, "writer");
      ballArray[index] = b;
      Thread t = new Thread(new BallRunnable(b, readWrite));
      threadArray[index] = t;
      circleArray[index].setVisible(true);
      t.start();

    } else {

      threadArray[index].interrupt();
      threadArray[index] = null;
      ballArray[index] = null;
      circleArray[index].setVisible(false);
      circleArray[index].setCenterX(minX);
    }
  }
Esempio n. 20
0
  public static void main(String[] args) {

    Thread t1 =
        new Thread() {
          @Override
          public void run() {
            for (int i = 0; i < 50; i++) {
              System.out.println(getName() + "..aaa");
            }
          }
        };
    Thread t2 =
        new Thread() {
          @Override
          public void run() {
            for (int i = 0; i < 50; i++) {
              if (i == 2) {
                try {
                  t1.join(10);
                } catch (InterruptedException e) {
                  e.printStackTrace();
                }
              }
              System.out.println(getName() + "...bbb");
            }
          }
        };

    t1.start();
    t2.start();
  }
  @Test
  public void testRootsHolder() throws InterruptedException {
    GroupID[] groupIds = new GroupID[NUM_GROUPS];
    for (int i = 0; i < NUM_GROUPS; i++) {
      groupIds[i] = new GroupID(i);
    }

    RootsHolder rootsHolder = new RootsHolder(groupIds);
    Thread tAlpha =
        new Thread(new RootsHolderTestRunnable(rootsHolder, barrier, 0, assertErrorMarker));
    Thread tBeta =
        new Thread(
            new RootsHolderTestRunnable(
                rootsHolder, barrier, NUM_GROUPS * INSERTIONS_PER_GROUP, assertErrorMarker));

    tAlpha.start();
    tBeta.start();

    tAlpha.join();
    tBeta.join();

    assertNull(assertErrorMarker.get());
    assertEquals(
        rootsHolder.getGroupIDForRoot(NAME_ZERO), rootsHolder.getGroupIDForRoot(NAME_ZERO));
    assertEquals(new ObjectID(1), rootsHolder.getRootIDForName(NAME_ZERO, GID_ZERO));
  }
Esempio n. 22
0
  @Test
  public void testInstanceRaceNoThrow() {
    if (verifyPropertyViolation(PROPERTY, LISTENER)) {
      final SharedObject o = new SharedObject();

      Runnable r1 =
          new Runnable() {

            SharedObject d = o;

            public void run() {
              d.instanceField = 1;
            }
          };

      Runnable r2 =
          new Runnable() {

            SharedObject d = o;

            public void run() {
              d.instanceField = 0;
            }
          };

      Thread t1 = new Thread(r1);
      Thread t2 = new Thread(r2);

      t1.start();
      t2.start();
    }
  }
Esempio n. 23
0
 // ----------------------------------------//
 public static void main(String[] args) {
   Vector trabajos = new Vector();
   Thread masterT = new Thread(new Master(trabajos));
   Thread workerT = new Thread(new Worker(trabajos));
   masterT.start();
   workerT.start();
 }
Esempio n. 24
0
  @Test
  public void testArrayRaceNoThrow() {
    if (verifyPropertyViolation(PROPERTY, LISTENER, "+cg.threads.break_arrays")) {
      final int[] shared = new int[1];

      Runnable r1 =
          new Runnable() {
            int[] a = shared;

            public void run() {
              a[0] = 0;
            }
          };

      Runnable r2 =
          new Runnable() {
            int[] a = shared;

            public void run() {
              a[0] = 1;
            }
          };

      Thread t1 = new Thread(r1);
      Thread t2 = new Thread(r2);

      t1.start();
      t2.start();
    }
  }
Esempio n. 25
0
  @Test
  public void test() {
    Cinema cinema = new Cinema();

    System.out.println(
        "Begin ticket number:"
            + cinema.getVacanciesCinema1()
            + ", "
            + cinema.getVacanciesCinema2());

    Thread ticketOffice1 = new Thread(new TicketOffice1(cinema));
    Thread ticketOffice2 = new Thread(new TicketOffice2(cinema));

    ticketOffice1.start();
    ticketOffice2.start();

    try {
      ticketOffice1.join();
      ticketOffice2.join();
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    System.out.println(
        "Finished ticket number:"
            + cinema.getVacanciesCinema1()
            + ", "
            + cinema.getVacanciesCinema2());
  }
Esempio n. 26
0
  @Test
  public void testNoArrayRaceElements() {
    if (verifyNoPropertyViolation(LISTENER, "+cg.threads.break_arrays")) {
      final int[] shared = new int[2];

      Runnable r1 =
          new Runnable() {
            int[] a = shared;

            public void run() {
              a[0] = 0;
            }
          };

      Runnable r2 =
          new Runnable() {
            int[] a = shared;

            public void run() {
              a[1] = 1;
            }
          };

      Thread t1 = new Thread(r1);
      Thread t2 = new Thread(r2);

      t1.start();
      t2.start();
    }
  }
Esempio n. 27
0
  @Test
  public void testProxy() throws Exception {
    int frontendPort = Utils.findOpenPort();
    int backendPort = Utils.findOpenPort();

    Context ctx = ZMQ.context(1);
    assert (ctx != null);

    Main mt = new Main(ctx, frontendPort, backendPort);
    mt.start();
    new Dealer(ctx, "AA", backendPort).start();
    new Dealer(ctx, "BB", backendPort).start();

    Thread.sleep(1000);
    Thread c1 = new Client(ctx, "X", frontendPort);
    c1.start();

    Thread c2 = new Client(ctx, "Y", frontendPort);
    c2.start();

    c1.join();
    c2.join();

    ctx.term();
  }
Esempio n. 28
0
  @Test
  public void testStaticRace() {
    if (verifyUnhandledException("java.lang.RuntimeException")) {

      Runnable r1 =
          new Runnable() {

            public void run() {
              staticField = 1;
              if (staticField != 1) {
                throw new RuntimeException("r1 detected race!");
              }
            }
          };

      Runnable r2 =
          new Runnable() {

            public void run() {
              staticField = 0;
              if (staticField != 0) {
                throw new RuntimeException("r2 detected race!");
              }
            }
          };

      Thread t1 = new Thread(r1);
      Thread t2 = new Thread(r2);

      t1.start();
      t2.start();
    }
  }
Esempio n. 29
0
  @Test
  public void testStaticRaceNoThrow() {
    if (verifyPropertyViolation(PROPERTY, LISTENER)) {
      Runnable r1 =
          new Runnable() {

            public void run() {
              staticField = 1;
            }
          };

      Runnable r2 =
          new Runnable() {

            public void run() {
              staticField = 0;
            }
          };

      Thread t1 = new Thread(r1);
      Thread t2 = new Thread(r2);

      t1.start();
      t2.start();
    }
  }
Esempio n. 30
0
 /**
  * Spawn the application
  *
  * @throws IOException IO problems
  * @throws SliderException internal state of this class is wrong
  */
 public void spawnApplication() throws IOException, SliderException {
   execThread = spawnIntoThread();
   execThread.start();
   processStreamReader = new ProcessStreamReader(processLog, STREAM_READER_SLEEP_TIME);
   logThread = new Thread(processStreamReader, "IO");
   logThread.start();
 }