IM IN YR LOOP\n VISIBLE FOO\n IM OUTTA YR LOOP - Der Programmierer-Spamthread #2

[Engel der Furcht]

Ich hab das ganze mit einem Interface gelöst.
UNd stehe gerade vor einem erneuten Problem:

Ich hab 'ne Klasse, in der ein Objekt erzeugt wird, das von Thread erbt.
In diesem Thread wartet ein Socket auf Empfang von Daten.
Ich kann den Thread nicht schließen/killen/terminieren/whatever.
Ich kann von der Oberklasse auch nicht auf das Socket zugreifen und es schließen.
Hier mal mein Programmcode:

Code:

package UDP;

import java.awt.*;
import java.awt.event.*;
import java.io.IOException;
import java.util.*;
import java.net.*;
import java.util.logging.Level;
import java.util.logging.Logger;

public class UDPTransceiver extends Frame implements ActionListener,
        ReceiverInterface
{

  private Label adressnumber;
  private TextArea history;
  private TextArea sendArea;
  private Panel centerPanel;
  private Button sendButton;
  private Receiver receiver;
  private InetAddress address;
  private byte[] data;
  public boolean receiverON = false;
  private DatagramSocket socket;
  private DatagramPacket packet;
  private String name;
  MenuBar mb;
  Menu logMenu;
  MenuItem openLog;

  public UDPTransceiver(String name, InetAddress address)
  {
    super(name);
    this.address = address;
    this.name = name;
    makeGUI();
    setSize(500, 500);
    sendButton.addActionListener(this);
    setVisible(true);

    addWindowListener(new WindowAdapter()
    {

      public void windowClosing(WindowEvent windowEvent)
      {
        if (receiverON)
        {
          receiver.status = false;
          System.out.println(receiver.status);
          receiver.socket.close();
          receiver.interrupt();
        }
        dispose();
      }
    });
    runReceiver();
  }

  private void makeGUI()
  {
    mb = new MenuBar();
    logMenu = new Menu("Log");
    openLog = new MenuItem("Logdatei öffnen");
    logMenu.add(openLog);
    mb.add(logMenu);
    setMenuBar(mb);
    adressnumber = new Label();
    history = new TextArea();
    sendArea = new TextArea();
    centerPanel = new Panel();
    sendButton = new Button("Senden");
    setLayout(new BorderLayout());

    centerPanel.setLayout(new GridLayout(2, 1));
    centerPanel.add(history);
    centerPanel.add(sendArea);
    add("North", adressnumber);
    add("Center", centerPanel);
    add("South", sendButton);
    history.setEditable(false);
  }

  public void actionPerformed(ActionEvent event)
  {
    if (event.getSource() == sendButton)
    {
      send();
    }
  }

  private void runReceiver()
  {
    receiverON = true;
    receiver = new Receiver(address, this);
  }

  private void send()
  {
    try
    {
      logMessage("Du - " + new GregorianCalendar().get(Calendar.HOUR_OF_DAY)
              + ":"
              + new GregorianCalendar().get(Calendar.MINUTE) + ":"
              + new GregorianCalendar().get(Calendar.SECOND) + ":\n "
              + sendArea.getText()
              + "\n");
      socket = new DatagramSocket();
      data = new byte[sendArea.getText().length()];
      data = sendArea.getText().getBytes();
      packet = new DatagramPacket(data, data.length, address, 4711);
      try
      {
        socket.send(packet);
      }
      catch (IOException ex)
      {
        System.out.println(ex);
      }
    }
    catch (SocketException ex)
    {
      System.out.println(ex);
    }
  }

  public void logMessage(String message, InetAddress receiveIp)
  {
    history.append(receiveIp + " - "
            + new GregorianCalendar().get(Calendar.HOUR_OF_DAY) + ":"
            + new GregorianCalendar().get(Calendar.MINUTE) + ":"
            + new GregorianCalendar().get(Calendar.SECOND) + ":\n" + message);
  }

  public void logMessage(String message)
  {
    history.append("\n" + message + "\n");
  }

  public static void main(String args[]) throws UnknownHostException
  {
    new UDPTransceiver("Lokal", InetAddress.getByName("localhost"));
  }
}

Code:

package UDP;

import java.io.IOException;
import java.net.*;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Receiver extends Thread implements Runnable, ReceiverInterface
{

  private InetAddress receiveIp;
  public DatagramSocket socket;
  public DatagramPacket packet;
  private byte[] buffer;
  private String message;
  public boolean status = true;
  ReceiverInterface receiverInterface;

  public Receiver(InetAddress receiveIp, ReceiverInterface receiverInterface)
  {
    message = "";
    this.receiverInterface = receiverInterface;
    this.receiveIp = receiveIp;
    run();
  }

  public void run()
  {
    while (status)
    {
      buffer = new byte[4098];
      packet = new DatagramPacket(buffer, buffer.length);
      try
      {
        socket = new DatagramSocket(4711);
        try
        {
          socket.receive(packet);
          logMessage(new String(buffer), receiveIp);
          socket.close();
        }
        catch (IOException ex)
        {
          System.out.println(ex);
        }
      }
      catch (SocketException ex)
      {
        System.out.println(ex);
      }

    }
    interrupt();
  }

  public void logMessage(String message, InetAddress receiveIp)
  {
    receiverInterface.logMessage(message, receiveIp);
  }
}

Is das mit dem WindowAdapter eigentlich so richtig, ich kriege immer eine NullpointerException(der receiver existiert doch?)

Jedenfalls kann ich den Thread nicht schließen und habe irgendwie auch sonst keinen Zugriff auf Attribute etc.
Ich kann also receiver.socket.close() nicht anwenden und receiver.status kann ich auch nicht auf false setzen.
receiver.interrupt(), .stop() etc. kann ich auch nicht anwenden.

Als Test ist Sender/Empfängeraddresse auf Localhost gesetzt. "Senden" und "Empfangen" kann ich wohl und auch die ganze Zeit.