代码没有使用多线程

Question

调用同步（通知）的Java工作后

我读这样的： How to use wait and notify in Java?

我想要实现的等待的例子/通知对生产者/消费者模型在Java中使用线程。

消费者是一个服务器，其中有一个存储在列表中的对象。可以添加/删除此列表。

只有消费者服务器存储了对象（整数），生产者才发送数据（使用PipedInputStream/PipedOutputStream），否则生产者停止。当服务器再次有对象时，生产者开始发送数据。

问题兴起，当我打电话下一方法

public void addInteger() { 
     new Thread (new Runnable() { 
     public void run() { 
      try { 
      System.out.println ("Add before size:" + lConsumerClient.size()); 
      lConsumerClient.add((int)(Math.random()*100.0)); 
      synchronized(oSignalExternal) { 
       oSignalExternal.notify(); 
      } 
      System.out.println ("Add after size:" + lConsumerClient.size()); 
      } catch (Exception e) { e.printStackTrace(); } 
     } 
     }).start(); 
    } 

    public void removeFirst() { 
     new Thread (new Runnable() { 
     public void run() { 
      try { 
      System.out.println ("Remove before size:" + lConsumerClient.size()); 
      if (hasInteger()) { 
       lConsumerClient.remove(0); 
      } 
      synchronized(oSignalExternal) { 
       oSignalExternal.notify(); 
      } 
      System.out.println ("Remove after size:" + lConsumerClient.size()); 
      } catch (Exception e) { e.printStackTrace(); } 
     } 
     }).start(); 
    } 

输出：

Add before size:0 
Add after size:1 
     i:0 ->18 =218 
     i:0 ->18 =218 
Add before size:1 
     i:0 ->18 =218 
     i:1 ->90 =290 
     i:0 ->18 =218 
     i:1 ->90 =290 
Add before size:2 
     i:0 ->18 =218 
     i:1 ->90 =290 
     i:2 ->76 =276 
Add before size:3 
     i:0 ->18 =218 
     i:1 ->90 =290 
     i:2 ->76 =276 
     i:3 ->43 =243 
Remove before size:4 
Remove before size:3 
Remove before size:2 
     i:0 ->43 =243 
     i:0 ->43 =243 
Remove before size:1 
ExtSynchro$ExtClient sleeping 
Remove after size:0 
Remove after size:0 
Remove after size:0 
ExtSynchro$ExtClient sleeping 
Add after size:0 
Add after size:0 
Add after size:0 
Remove after size:0 

等待和通知工作。

我想知道为什么调用后：

synchronized(oSignalExternal) { 
    oSignalExternal.notify(); 
} 

不执行任何代码？

这里的完整代码

import java.awt.*; 
import java.awt.event.*; 
import java.io.*; 
import java.util.*; 
import java.util.concurrent.BlockingQueue; 
import java.util.concurrent.ArrayBlockingQueue; 

import javax.swing.*; 
public class ExtSynchro extends JFrame { 

    JButton jbSync = new JButton("Sync"); 
    JButton jbPlus = new JButton("+"); 
    JButton jbMinus = new JButton("-"); 
    JButton jbStop = new JButton("Stop"); 

    Object oSignalExternal = new Object(); 
    ExtServer exConsumerServer; 
    ExtClient exProducerClient; 
    PipedInputStream pSnk = new PipedInputStream(); 
    PipedOutputStream pSrc = new PipedOutputStream(); 
    static final String NL = System.getProperty("line.separator"); 

    public ExtSynchro() { 
    setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); 

    jbSync.addActionListener((ActionEvent e) -> { 
     try { pSrc.connect(pSnk); } catch (IOException ex) {} 
     exConsumerServer = new ExtServer(); 
     exProducerClient = new ExtClient(); 
     exConsumerServer.start(); 
     exProducerClient.start(); 
    }); 

    jbPlus.addActionListener((ActionEvent e) -> { 
     exConsumerServer.addInteger(); 
    }); 

    jbMinus.addActionListener((ActionEvent e) -> { 
     exConsumerServer.removeFirst(); 
    }); 

    jbStop.addActionListener((ActionEvent e) -> { 
     exConsumerServer.stopThread(); 
     exProducerClient.stopThread(); 
     exConsumerServer = null; 
     exProducerClient = null; 
    }); 

    JPanel jpButtons = new JPanel(); 
    jpButtons.setLayout(new BoxLayout(jpButtons, BoxLayout.PAGE_AXIS)); 
    jpButtons.add(jbSync); 
    jpButtons.add(jbPlus); 
    jpButtons.add(jbMinus); 
    jpButtons.add(jbStop); 
    add(jpButtons); 
    pack(); 
    } 

    public static void main(String args[]) { 
    EventQueue.invokeLater(() -> { 
     new ExtSynchro().setVisible(true); 
    }); 
    } 

    class ExtClient extends Thread { 
    private volatile boolean bRunning; 

    @Override public void run() { 
     bRunning = true; 
     while (bRunning) { 
     try { 
      synchronized(oSignalExternal) { 
      try { 
       while (exConsumerServer.hasInteger()) { 
       pSrc.write(200); 
       try { Thread.sleep(3000); } catch (InterruptedException ex) { } 
       } 
       System.out.println(getClass().getName() + "\tsleeping"); 
       oSignalExternal.wait(); 
      } catch (InterruptedException e2) {} 
      if (!bRunning) break; // To exit from synchronized 
      } 
     } catch (IOException e) { 
      bRunning = false; 
     } 
     } 
     System.out.println(getClass().getName() + "\tfinishing"); 
    } 

    public void stopThread() { 
     bRunning = false; 
     synchronized(oSignalExternal) { 
     oSignalExternal.notify(); 
     } 
    } 
    }; 

//The Consumer Server. 

    class ExtServer extends Thread { 
    private volatile boolean bRunning; 
    //BlockingQueue<Integer> lConsumerClient =new ArrayBlockingQueue<>(10); 
    java.util.List<Integer> lConsumerClient = Collections.synchronizedList(new ArrayList<>(4)); 


    @Override public void run() { 
     bRunning = true; 
     while (bRunning) { 
     int iRd; 
     try { 
      while ((iRd = pSnk.read()) != -1) { 
      for (int i = 0; i < lConsumerClient.size(); i++) { 
       int n = lConsumerClient.get(i); 
       System.out.println ("\t\ti:" + i + " ->" + n +"\t=" + (n + iRd)); 
      } 
      } 
     } catch (IOException e) {} 
     } 
     System.out.println(getClass().getName() + "\tfinishing"); 
    } 

    public void addInteger() { 
     new Thread (new Runnable() { 
     public void run() { 
      try { 
      System.out.println ("Add before size:" + lConsumerClient.size()); 
      lConsumerClient.add((int)(Math.random()*100.0)); 
      synchronized(oSignalExternal) { 
       oSignalExternal.notify(); 
      } 
      System.out.println ("Add after size:" + lConsumerClient.size()); 
      } catch (Exception e) { e.printStackTrace(); } 
     } 
     }).start(); 
    } 

    public void removeFirst() { 
     new Thread (new Runnable() { 
     public void run() { 
      try { 
      System.out.println ("Remove before size:" + lConsumerClient.size()); 
      if (hasInteger()) { 
       lConsumerClient.remove(0); 
      } 
      synchronized(oSignalExternal) { 
       oSignalExternal.notify(); 
      } 
      System.out.println ("Remove after size:" + lConsumerClient.size()); 
      } catch (Exception e) { e.printStackTrace(); } 
     } 
     }).start(); 
    } 

    public boolean hasInteger() { 
     return lConsumerClient.size() > 0; 
    } 
    public void stopThread() { 
     bRunning = false; 
     try { pSrc.close();pSnk.close(); } catch (IOException e) {} 
    } 
    }; 
} 

Answer 1

本节伤了你的代码

synchronized(oSignalExternal) { 
     try { 
     while (exConsumerServer.hasInteger()) { 
      pSrc.write(200); 
      try { Thread.sleep(3000); } catch (InterruptedException ex) { } 
     } 
     System.out.println(getClass().getName() + "\tsleeping"); 
     oSignalExternal.wait(); 
     } catch (InterruptedException e2) {} 
     if (!bRunning) break; // To exit from synchronized 
    } 

你不删除元素，让你的exConsumerServer总是有元素。使用阻塞队列。

BlockingQueue<Integer> valuesToTake = new LinkedBlockingQueue(); 

然后你的运行方法变成了。

while (bRunning) { 
    try{ 
     pSrc.write(valuesToTake.take()); 
    } catch (IOException e) { 
     bRunning = false; 
    } 
} 

然后，您只需将整数发送到值并将客户端发送它们。