| 24.08.2015, 01:04 |
Auf diesen Beitrag antworten » |
| neuling96 |
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 ? |
| 24.08.2015, 13:52 |
Auf diesen Beitrag antworten » |
| eulerscheZahl |
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 |
| 25.08.2015, 13:40 |
Auf diesen Beitrag antworten » |
| neuling96 |
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. |
| 25.08.2015, 15:25 |
Auf diesen Beitrag antworten » |
| eulerscheZahl |
Mit y.start() wird die run Methode des Interfaces aufgerufen. |
| 25.08.2015, 16:40 |
Auf diesen Beitrag antworten » |
| neuling96 |
| 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�r Serverkommunikation, Grundstruktur zum erstellen bzw.
* schicken von JSON-Pakete
*
*/
//ToDo: Als Timeline l�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 |
