Home > Jaringan Komputer, Pemrograman Java, Sistem Terdistribusi > Server Multi-Thread di Java (1)

Server Multi-Thread di Java (1)


Tulisan ini mengenai cara membangun server multithread dalam Java. Karena kemampuan multithreading sudah built-in di dalam Java maka server yang bersifat multi-thread mudah diimplementasikan. Tetapi tidak semua rancangan server itu sama. Artikel ini akan memperlihatkan beberapa desain server dan mendiskusikan kelebihan dan kekurangannya.

Berikut ini adalah apa yang akan dibahas dalam tulisan ini:

  • Server thread tunggal (SingleThreaded)
  • Server multi-thread (MultiThreaded)
  • Thread Pooled Server

Catatan: Sebelum melanjutkan membaca tulisan ini, sebaiknya anda telah memahami konsep dan pemrograman multithreading dalam bahasa Java.

Singlethreaded Server Dalam Java

Bagian ini akan menjelaskan bagaimana mengimplementasikan singlethreaded server dalam Java. Singlethreaded server bukanlah desain yang paling optimal bagi suatu server, tetapi kode tersebut cukup baik untuk mengilustrasikan siklus hidup dari suatu server. Kode program multithreaded server nantinya akan dibangun berdasarkan pada template kode ini.
Berikut adalah contoh sebuah singlethreaded server sederhana:

package servers;

import java.net.ServerSocket;
import java.net.Socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class SingleThreadedServer implements Runnable{

protected int serverPort = 8080;
protected ServerSocket serverSocket = null;
protected boolean isStopped = false;
protected Thread runningThread= null;

public SingleThreadedServer(int port){
this.serverPort = port;
}

public void run(){
synchronized(this){
this.runningThread = Thread.currentThread();
}
openServerSocket();

while(! isStopped()){
Socket clientSocket = null;
try {
clientSocket = this.serverSocket.accept();
} catch (IOException e) {
if(isStopped()) {
System.out.println(“Server Stopped.”) ;
return;
}

throw new RuntimeException(“Error accepting client connection”, e);
}
try {
processClientRequest(clientSocket);
} catch (IOException e) {
//log exception and go on to next request.
}
}

System.out.println(“Server Stopped.”);
}

private void processClientRequest(Socket clientSocket)
throws IOException {
InputStream input = clientSocket.getInputStream();
OutputStream output = clientSocket.getOutputStream();
long time = System.currentTimeMillis();

output.write((“HTTP/1.1 200 OK\n\n<html><body>” +
“Singlethreaded Server: ” +
time +
“</body></html>”).getBytes());
output.close();
input.close();
System.out.println(“Request processed: ” + time);
}

private synchronized boolean isStopped() {
return this.isStopped;
}

public synchronized void stop(){
this.isStopped = true;
try {
this.serverSocket.close();
} catch (IOException e) {
throw new RuntimeException(“Error closing server”, e);
}
}

private void openServerSocket() {
try {
this.serverSocket = new ServerSocket(this.serverPort);
} catch (IOException e) {
throw new RuntimeException(“Cannot open port 8080”, e);
}
}
}

Dan di bawah ini adalah kode untuk menjalankan server tersebut:

SingleThreadedServer server = new SingleThreadedServer(9000);
new Thread(server).start();

try {
Thread.sleep(10 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(“Stopping Server”);
server.stop();

Ketika server berjalan anda dapat mengaksesnya mengunakan web browser biasa dengan memasukkan alamat http://localhost:9000/

Bagian yang paling menarik dari singlethreaded server di atas adalah perulangan (loop) utama yang ditulis ulang di bawah ini:

while(! isStopped()){
Socket clientSocket = null;
try {
clientSocket = this.serverSocket.accept();
} catch (IOException e) {
if(isStopped()) {
System.out.println(“Server Stopped.”) ;
return;
}
throw new RuntimeException(“Error accepting client connection”, e);
}
try {
processClientRequest(clientSocket);
} catch (IOException e) {
//log exception and go on to next request.
}
}

Secara singkat, apa yang dilakukan server ini adalah:

1. Tunggu suatu request dari client
2. Proses request dari client
3. Ulangi dari langkah 1.

Bentuk perulangan ini umum digunakan pada sebagian besar server yang diimplementasikan dengan Java. Apa yang membedakan server ber-thread tunggal dari server ber-thread banyak? Server ber-thread tunggal memroses request-request yang masuk dalam satu thread yang sama dengan yang menerima koneksi client. Sedangkan server multi-thread memberikan penanganan koneksi kepada thread pekerja yang memroses akan request tersebut.

Pemrosesan request yang masuk dalam thread yang sama dengan yang menerima koneksi client bukanlah ide yang baik. Client hanya dapat menghubungi server selama server tersebut berada dalam pemanggilan metode serverSocketaccept(). Lebih lama waktu thread yang mendengar menghabiskan waktu di luar pemanggilan serverSocket.accept(), lebih tinggi kemungkinan bahwa client akan ditolak mengakses ke server. Inilah alasan mengapa multithreaded server melewatkan koneksi-koneksi yang masuk kepada thread pekerja, yang akan memroses request tersebut. Pada cara demikian, thread yang mendengar menghabiskan sedikit mungkin waktu di luar pemanggilan serverSocket.accept().

Bagaimana cara melewatkan koneksi ke thread pekerja? Simak tulisan pada bagian berikutnya.

  1. 23 December 2008 at 8:08 am

    waduh…makacih bgt mas atas tulisannya
    sangat2 membantu saya yg sgt awam bgt tentang thread. palagi dengan bahasa dan contoh yang sangat mudah dipahami..lanjutkan berkarya mas
    ditunggu tulisan2 selanjutnya. moga bermanfaat

  1. No trackbacks yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: