Informatiker Board | Druckvorschau: Thread in Java

Geschrieben von neuling96 am 24.08.2015 um 01:04:

Thread in Java

Hey,

Das Objekt welches man in synchronized (..) übergibt, ist lock.

code:
1: 2:	synchronized ( objektMitDemMonitor ){ ...}

1. Spielt das eine Rolle welches object man in synchronized übergibt
2. Im Bsp objektMitDemMonitor ist Lock, welche Konsequenz hat über objektMitDemMonitor das ?

Geschrieben von eulerscheZahl am 24.08.2015 um 13:52:

synchronized stellt sicher, dass nur ein Trhead gleichzeitig auf die Variable zugreifen kann.
Folglich müsst du es auch verwenden, wenn priniziell mehrere Threads damit arbeiten.
Damit geht aber eine Verschlechterung der Laufzeit einher (da ja sichergestellt werden muss, dass keine doppelten Zugriffe erfolgen, intern läuft das meines Wissens mit Semaphoren). Deshalb solltest du synchronized auch nur verwenden, wenn du einen Grund dafür hast.

Hier noch etwas Lektüre:
offizielle Doku
Javainsel

Geschrieben von neuling96 am 25.08.2015 um 13:40:

wenn ich eine Klasse x erstelle, die als Interface Runnable bekommt

public class x implements Runnable {

...
..

void run {

...
..

wieso kann man folgends ausführen:

Thread y = new Thread(new x());

In Therad(..) erwartet man doch ein Objekt von Runnable?
und Wie soll das gehen? Runnable ist doch ein Interface?

docs.oracle.com/javase/7/docs/api/java/lang/Thread.html
Thread(Runnable target)
Allocates a new Thread object.

Geschrieben von eulerscheZahl am 25.08.2015 um 15:25:

Mit y.start() wird die run Methode des Interfaces aufgerufen.

Geschrieben von neuling96 am 25.08.2015 um 16:40:

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:

package control;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.List;

import org.json.JSONObject;
/**
 * SenderThread f&#65533;r Serverkommunikation, Grundstruktur zum erstellen bzw.
 * schicken von JSON-Pakete
 
 *
 */
//ToDo: Als Timeline l&#65533;sen
public class SenderThread extends Thread {

  private InetAddress server;

  private DatagramSocket socket;

  private boolean running = true;
  private boolean playing = false;

  private JSONObject send;
  
  private  List<JSONObject> toSend = new ArrayList<JSONObject>();
  
  private int port;

  /**
   * Adresse/Port/Socket wird bei erstellen angegeben
   * @param address
   * @param port
   * @throws SocketException
   */
  public SenderThread(InetAddress address, int port) throws SocketException {
    this.server = address;
    this.port = port;
    this.socket = new DatagramSocket();
    this.socket.connect(server, port);
    this.setDaemon(true);
    System.out.println("SenderThread erstellt");
  }
  
  /**
   * FÜgt ein JSON-Objekt in die Sendeliste hinzu + Aufwecken der Threads
   * @param send
   */
  public synchronized void addJSON(JSONObject send)
  {
	  toSend.add(send);
	  notifyAll();
  }
  
  /**
   * Ausschalten von run()
   */
  public void end() {
    running = false;
  }

  public DatagramSocket getSocket() {
    return this.socket;
  }

  /**
   * Sendet alle JSON-Pakete nacheinander und wartet falls es keins gibt
   */
  @Override
public synchronized void run() {

    try {
      //BufferedReader userInput = new BufferedReader(new InputStreamReader(System.in));
    	
      while (running) {
    	  //Update(); //Sollte ausgelagert werden
    	  //System.out.println("Anzahl Pakete: "+toSend.size());
		  while(toSend.isEmpty())
		  {
			  wait();
		  }
		  SendJSON(toSend.get(0));
		  toSend.remove(0);

		  Thread.yield();  
		  //Auch auslagern
		  
		  
      }
    }
    catch (IOException | InterruptedException ex) {
      System.err.println(ex);
    }
  }
  
  /**
   * Öffnet Verbindung zum senden
   * @param obj
   * @throws IOException
   */
  public void SendJSON(JSONObject obj) throws IOException
  {
	  //System.out.println("Send: "+ obj);
	  byte[] data = obj.toString().getBytes();
	  DatagramPacket output = new DatagramPacket(data, data.length, server, port);
	  socket.send(output);
  }

Im anderen Code Teil:
wird der Thread erzeugt

sender = new SenderThread(ia, 9999);
sender.start();

Meine Frage, braucht man hier die Methode synchronized?
Meiner Meinung nach nicht, da es nur ein Thread gibt