Thread I/O test - gehts vlt besser?

  • Thread I/O test - gehts vlt besser?

    Nabend Leute,
    Ich bin neu hier im Board und dachte mir ich veröffentliche als Einstand mal eben einen kleinen Code...
    Ich bin relativ neu im umgang mit Java und habe dieses Prog. als vorarbeit auf einen Server welcher zwischen mehreren
    Clients(Threads) I/O durchführen kann (soll mal ein chatserver werden).
    Ich würde gerne wissen ob dies schon eine relativ gute Lösung ist oder ob ich mich mit meinem halbwissen doch schon zu sehr
    verrannt habe.
    Wer Lust und Zeit hat kanns sich ja mal angucken.

    Über feedback freue ich mich natürlich immer :)

    Quellcode

    1. // Thread IO Example -- by Bakero
    2. // + mehrere Threads, welche ein und die Selbe aufgabe erledigen (zB verb. clients
    3. // abfertigen) starten und deren IO regeln.
    6. package thread_io;
    8. import java.io.*;
    9. public class Thread_io {
    11. public static void main(String[] args)
    12. {
    13. //code für die comm von 2 threads bzw father2child
    14. try
    15. {
    16. PipedInputStream thread1_out = new PipedInputStream();
    17. PipedOutputStream thread1_outt = new PipedOutputStream(thread1_out);
    19. PipedOutputStream thread1_inn = new PipedOutputStream();
    20. PipedInputStream thread1_in = new PipedInputStream(thread1_inn);
    21. //---------------------------------------------------------------------------
    23. //möglichkeit für egal anzahl an threats
    24. int thread_id = 0; //id des ersten threads + current thread
    25. int max_threads = 3; //anzahl der maximal möglichen threads
    26. int counter = 0; //allgemeiner counter
    27. PipedInputStream[] thread_out = new PipedInputStream[max_threads];
    28. PipedOutputStream[] thread_outt = new PipedOutputStream[max_threads];
    29. PipedOutputStream[] thread_inn = new PipedOutputStream[max_threads];
    30. PipedInputStream[] thread_in = new PipedInputStream[max_threads];
    31. //Pipes Conf
    32. while(counter <= (thread_inn.length-1))
    33. {
    34. thread_out[counter] = new PipedInputStream();
    35. thread_outt[counter] = new PipedOutputStream(thread_out[counter]);
    36. thread_inn[counter] = new PipedOutputStream();
    37. thread_in[counter] = new PipedInputStream(thread_inn[counter]);
    38. counter++;
    39. }
    40. counter=0; //counter reset
    41. //--------------------------------------------------------------------------
    43. //Einzelnen thread starten
    44. Thread_1 t1 = new Thread_1(thread1_in,thread1_outt);
    45. //--------------------------------------------------------------------------
    47. // beliebige anzahl eines threads starten welche die gleiche aufgabe lösen
    48. Thread_[] t = new Thread_[max_threads]; //threads initialisieren
    50. while(thread_id <= max_threads-1) //Threads starten
    51. {
    52. t[thread_id] = new Thread_(thread_in[thread_id],thread_outt[thread_id],thread_id);
    53. System.out.println("Starte Thread : " + thread_id);
    54. t[thread_id].start();
    55. thread_id++;
    56. }
    57. //---------------------------------------------------------------------------
    59. //Von allen threads lesen und anschliesend senden
    60. while(true)
    61. {
    62. while(counter <= (max_threads-1))
    63. {
    64. System.out.println("Master:lese" + thread_out[counter].read());
    65. System.out.println("Master:schreibe");
    66. thread_inn[counter].write(0);
    67. //System.out.println("Master:lese von 2" + thread_out[counter].read());
    68. //System.out.println("Master:schreibe an 2");
    69. //thread_inn[counter].write(3);
    70. counter++;
    71. }
    72. counter=0;
    73. }
    74. }
    75. catch(IOException e)
    76. {
    77. System.out.println("I/O ERROR!");
    78. }
    79. //---------------------------------------------------------------------------
    80. }
    81. }
    82. class Thread_1 extends Thread
    83. {
    84. PipedInputStream thread_in = null;
    85. PipedOutputStream thread_out = null;
    86. Thread_1(PipedInputStream thread_in,PipedOutputStream thread_out)
    87. {
    88. this.thread_in=thread_in;
    89. this.thread_out=thread_out;
    90. }
    91. public void run()
    92. {
    93. while(true)
    94. {
    95. try{
    96. System.out.println("Thread:schreibe");
    97. thread_out.write(1);
    99. System.out.println("Thread:lese" + thread_in.read());
    100. }
    101. catch(IOException e)
    102. {
    103. System.out.println("Fehler");
    104. }
    105. }
    107. }
    108. }
    109. class Thread_ extends Thread
    110. {
    111. int thread_id;
    112. PipedInputStream thread_in = null;
    113. PipedOutputStream thread_out = null;
    114. Thread_(PipedInputStream thread_in,PipedOutputStream thread_out,int thread_id)
    115. {
    116. this.thread_id = thread_id;
    117. this.thread_in=thread_in;
    118. this.thread_out=thread_out;
    119. }
    120. public void run()
    121. {
    122. while(true)
    123. {
    124. try{
    125. System.out.println("Thread"+thread_id+":schreibe");
    126. thread_out.write(1);
    127. System.out.println("Thread:habe geschrieben");
    128. System.out.println("Thread:lese" + thread_in.read());
    129. }
    130. catch(IOException e)
    131. {
    132. System.out.println("Fehler");
    133. }
    134. //catch(NullPointerException b)
    135. //{
    136. // System.out.println("I/O ERROR");
    137. //}
    138. }
    140. }
    141. }
    Alles anzeigen