UDP CLIENTSERVER Without Thread Extends

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;


public class ClientServer2 {
    String IP_SERVER="192.168.1.17";
    private InetAddress serverAddress;
   
    static int portTX=8213;
    static int portRX=8212;
   
    private DatagramSocket udpRX;
    private DatagramSocket udpTX;
   
    public ClientServer2(int port) throws SocketException, IOException {
        this.portRX = port;
        this.udpRX = new DatagramSocket(portRX);
    }
 
   
    public static void main(String[] args) throws Exception {
    new Thread(){
        public void run(){
            System.out.println("hello run");
            try {
//                    long start = System.currentTimeMillis();
//                    sleep(2000);
//                    System.out.println("Sleep time in ms = "+(System.currentTimeMillis()-start));
                    System.out.println("Thread");
                    ClientServer2 client = new ClientServer2(portRX);
                    client.listen();
       
            } catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("world");
        }
    }.start();

    }
   
private void listen() throws Exception {
        System.out.println("-- Running Main Server at " + InetAddress.getLocalHost() + "--");
        String msg;
       
        while (true) {   
            byte[] buf = new byte[256];
            DatagramPacket packet = new DatagramPacket(buf, buf.length);
            udpRX.receive(packet);
            msg = new String(packet.getData()).trim();
            System.out.println( "Message from " + packet.getAddress().getHostAddress() + ": " + msg);
           
                  if(msg.indexOf("WHAT IS")>=0){
                        ClientServer2 sender = null;
                        try {
                             sender = new ClientServer2(IP_SERVER, portTX);
                             sender.mulai();
                        } catch (IOException ex) {
                            Logger.getLogger(ClientServer2.class.getName()).log(Level.SEVERE, null, ex);
                        }
       
          }//if
                 
        }
    }

      private ClientServer2(String destinationAddr, int port) throws IOException {
        this.serverAddress = InetAddress.getByName(destinationAddr);
        this.portTX = port;
        udpTX = new DatagramSocket(this.portTX);
    }

    void mulai() throws IOException {
        String quote="Yg Running is......MP3 dll";
        byte[] buffer = quote.getBytes();
            DatagramPacket p = new DatagramPacket(quote.getBytes(), quote.getBytes().length, serverAddress, portTX);
            this.udpTX.send(p); 
            udpTX.close();
    }
   
}

Thread oh Thread and Runnable

Implementasi Runnable= Beda Class / U APlikasi terpisah


Buat FIle RunMyThread .java

package mythread;

public class RunMyThread {
    public static void main(String a[]){
        System.out.println("Starting Main Thread...");
        MyRunnableThread mrt = new MyRunnableThread();
        Thread t = new Thread(mrt);
        t.start();
        while(MyRunnableThread.myCount <= 10){
            try{
                System.out.println("Main Thread: "+(++MyRunnableThread.myCount));
                Thread.sleep(100);
            } catch (InterruptedException iex){
                System.out.println("Exception in main thread: "+iex.getMessage());
            }
        }
        System.out.println("End of Main Thread...");
    }
}

class MyRunnableThread implements Runnable{ 
    public static int myCount = 0;
    public MyRunnableThread(){
         
    }
    public void run() {
        while(MyRunnableThread.myCount <= 10){
            try{
                System.out.println("Expl Thread: "+(++MyRunnableThread.myCount));
                Thread.sleep(100);
            } catch (InterruptedException iex) {
                System.out.println("Exception in thread: "+iex.getMessage());
            }
        }
    } 
}

==============================================
Output:
run:
Starting Main Thread...
Main Thread: 1
Expl Thread: 2
Main Thread: 3
Expl Thread: 4
Main Thread: 5
Expl Thread: 6
Main Thread: 7
Expl Thread: 8
Main Thread: 9
Expl Thread: 10
Main Thread: 11
End of Main Thread...




INNER THREAD

buat file : MyThread .java

package mythread;

class MyRunnableThread2 implements Runnable{

    public static int myCount = 0;
    public MyRunnableThread2(){}
    public void run() {
       for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() +"\twith Runnable: MyRunnableImplementation runs..." + i);
        }
    } 
}


public class MyThread {
    public static void main(String a[]){
        System.out.println("Starting Main Thread...");
        
         Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                 System.out.println("Starting Inner Thread...");
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + "\twith Runnable: Inner class Runnable runs..." + i);
                }
            }
        }, "Thread 3");
        thread3.start();
        
       
        MyRunnableThread mrt = new MyRunnableThread();
        Thread t = new Thread(mrt);
        t.start();
        while(MyRunnableThread2.myCount <= 10){
            try{
                System.out.println("Main Thread: "+(++MyRunnableThread2.myCount));
                Thread.sleep(100);
            } catch (InterruptedException iex){
                System.out.println("Exception in main thread: "+iex.getMessage());
            }
        }
        
        //=====================================
        
        Thread thread1 = new Thread(mrt, "Thread 1");
        thread1.start();
        
        Thread thread2 = new Thread(mrt, "Thread 2");
        thread2.start();

        System.out.println("End of Main Thread...");
    }
}

============================output

run:
Starting Main Thread...
Main Thread: 1
Starting Inner Thread...
Thread 3 with Runnable: Inner class Runnable runs...0
Thread 3 with Runnable: Inner class Runnable runs...1
Thread 3 with Runnable: Inner class Runnable runs...2
Thread 3 with Runnable: Inner class Runnable runs...3
Thread 3 with Runnable: Inner class Runnable runs...4
Expl Thread: 1
Main Thread: 2
Expl Thread: 2
Main Thread: 3
Expl Thread: 3
Main Thread: 4
Expl Thread: 4
Main Thread: 5
Expl Thread: 5
Main Thread: 6
Expl Thread: 6
Main Thread: 7
Expl Thread: 7
Main Thread: 8
Expl Thread: 8
Main Thread: 9
Expl Thread: 9
Main Thread: 10
Expl Thread: 10
Expl Thread: 11
Main Thread: 11
End of Main Thread...
BUILD SUCCESSFUL (total time: 1 second)

+++++++++++++++++++++++++++++++++++++++++++++++++

INNER SIMPLE

package mythread;

public class InnerClassSImple {
  public static void main(String args[]){
    new Thread(){
        public void run(){
            System.out.println("hello");
            try {
                    long start = System.currentTimeMillis();
                    sleep(2000);
                    System.out.println("Sleep time in ms = "+(System.currentTimeMillis()-start));
       
            } catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.println("world");
        }
    }.start();
} 
}

run:

hello

Sleep time in ms = 2000

world

BUILD SUCCESSFUL (total time: 2 seconds)

IMPLEMENTAS INNER CLASS +SLEEP

buat file InnerThread.java

package mythread;

public class InnerThread {

    

    public static void main(String a[]){

        System.out.println("Starting Main Thread...");

        

         Thread thread2 = new Thread(new Runnable() {

            @Override

            public void run() {

                 System.out.println("Starting Inner Thread1...");

                for (int i = 0; i < 5; i++) {

                    System.out.println(Thread.currentThread().getName() + "\twith1 Runnable: Inner class Runnable runs..." + i);

              

                        try {

                    Thread.sleep(1000);

                 } catch (Exception e) {

                    System.out.println(e);

                 }

                

                }

            }

        }, "Thread 3");

        thread2.start();

        

        

        Thread thread3 = new Thread(new Runnable() {

            @Override

            public void run() {

                 System.out.println("Starting Inner Thread2...");

                for (int i = 0; i < 5; i++) {

                    System.out.println(Thread.currentThread().getName() + "\twith2 Runnable: Inner class Runnable runs..." + i);

                }

            }

        }, "Thread 3");

        thread3.start();

    

        System.out.println("Main Thread...");

    }

}

run:
Starting Main Thread...
Starting Inner Thread1...
Main Thread...
Starting Inner Thread2...
Thread 3 with2 Runnable: Inner class Runnable runs...0
Thread 3 with2 Runnable: Inner class Runnable runs...1
Thread 3 with1 Runnable: Inner class Runnable runs...0
Thread 3 with2 Runnable: Inner class Runnable runs...2
Thread 3 with2 Runnable: Inner class Runnable runs...3
Thread 3 with2 Runnable: Inner class Runnable runs...4
Thread 3 with1 Runnable: Inner class Runnable runs...1
Thread 3 with1 Runnable: Inner class Runnable runs...2
Thread 3 with1 Runnable: Inner class Runnable runs...3
Thread 3 with1 Runnable: Inner class Runnable runs...4
BUILD SUCCESSFUL (total time: 8 seconds)

+++++++++++++++++++++++++++++++

SCHEDULE1


package mythread;

public class Schedule1 {
 
   public static void main(String a[]){
        System.out.println("Starting Main Thread...");  

        int x=0;
while(x <= 5){
    x=x+1;
     System.out.println("Starting Delay..."+x);  
            try {
                 long start = System.currentTimeMillis();
                Thread.sleep(1000);
                System.out.println("Sleep time in ms = "+(System.currentTimeMillis()-start));
            } 
            catch(InterruptedException ex){
                Thread.currentThread().interrupt();
            }
    
   }
   }
}

run:

Starting Main Thread...

Starting Delay...1

Sleep time in ms = 1001

Starting Delay...2

Sleep time in ms = 1000

Starting Delay...3

Sleep time in ms = 1001

Starting Delay...4

Sleep time in ms = 1000

Starting Delay...5

Sleep time in ms = 1001

Starting Delay...6

Sleep time in ms = 1000

BUILD SUCCESSFUL (total time: 6 seconds)

+++++++++++++++++

TASK EVERY://to run the method myTask every second

package mythread;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

public class TaskEvery {

    

  public static void main(String[] args) {

final ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();

    executorService.scheduleAtFixedRate(new Runnable() {

        @Override

        public void run() {

            myTask();

        }

    }, 0, 1, TimeUnit.SECONDS);

}

private static void myTask() {

    System.out.println("Running Agains");

}  

}

run:
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
Running Agains
BUILD STOPPED (total time: 26 seconds)

UDP GET POST UNLIMITED

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;


public class GETPOST extends Thread{
    int lop=1;
    String IPDESTINATION="192.168.1.3";
    private InetAddress serverAddress;
    private static int portTX=8217;

    static int PORT=8218;
    private DatagramSocket udpSocket;
    private DatagramSocket udpSocketTX;
   
    public GETPOST(int port) throws SocketException, IOException {
        this.PORT = port;
        this.udpSocket = new DatagramSocket(PORT);
    }
 
   
    public static void main(String[] args) throws Exception {
       GETPOST client = new GETPOST(PORT);
       client.start();
    }
   
    public void run(){  //wait
        //System.out.println("I'm Wait " + InetAddress.getLocalHost() + "!");
        String msg;
        int ada=0;
        while (ada==0) {
            byte[] buf = new byte[256];
            DatagramPacket packet = new DatagramPacket(buf, buf.length);
            try {
                udpSocket.receive(packet);
            } catch (IOException ex) {
                Logger.getLogger(GETPOST.class.getName()).log(Level.SEVERE, null, ex);
            }
            msg = new String(packet.getData()).trim();
            System.out.println("Message From Server/" + packet.getAddress().getHostAddress() + ": " + msg);
          if(msg.indexOf("WHAT IS")>=0){
            GETPOST sender = null;
            try {
                sender = new GETPOST(IPDESTINATION, portTX);
                 sender.mulai();
            } catch (IOException ex) {
                Logger.getLogger(GETPOST.class.getName()).log(Level.SEVERE, null, ex);
            }
       
          }//if
       
        }
         
 
  } 
   
   
      private GETPOST(String destinationAddr, int port) throws IOException {
        this.serverAddress = InetAddress.getByName(destinationAddr);
        this.portTX = port;
        udpSocketTX = new DatagramSocket(this.portTX);
    }

    void mulai() throws IOException {
        String quote="Yg Running is......MP3 dll";
        byte[] buffer = quote.getBytes();
            DatagramPacket p = new DatagramPacket(quote.getBytes(), quote.getBytes().length, serverAddress, portTX);
            this.udpSocketTX.send(p); 
            udpSocketTX.close();
    }
   
}

THREAD AND UDP

class MultithreadingDemo extends Thread{  
  public void run(){  
    System.out.println("My thread is in running state.");  
  }   
  public static void main(String args[]){  
     MultithreadingDemo obj=new MultithreadingDemo();   
     obj.start();  
  }  
}

IMPLEMENTASI:

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;


public class GETPOST extends Thread{
    static int PORT=8212;
    private DatagramSocket udpSocket;
    private int port;

    public GETPOST(int port) throws SocketException, IOException {
        this.port = port;
        this.udpSocket = new DatagramSocket(this.port);
    }
 
   
    public static void main(String[] args) throws Exception {
        GETPOST client = new GETPOST(PORT);
        //client.listen();
        client.start();
    }

   
    public void run(){  //wait
        System.out.println("My thread is in running state."); 
        try{
        System.out.println("I'm Wait " + InetAddress.getLocalHost() + "!");
        String msg;
       
        while (true) {
            byte[] buf = new byte[256];
            DatagramPacket packet = new DatagramPacket(buf, buf.length);
            udpSocket.receive(packet);
            msg = new String(packet.getData()).trim();
            System.out.println("Message From Server/" + packet.getAddress().getHostAddress() + ": " + msg);
        }
        }
        catch(Exception ee){}
  } 
   
   
   
     private void listen() throws Exception {
        System.out.println("I'm Wait " + InetAddress.getLocalHost() + "!");
        String msg;
       
        while (true) {
            byte[] buf = new byte[256];
            DatagramPacket packet = new DatagramPacket(buf, buf.length);
            udpSocket.receive(packet);
            msg = new String(packet.getData()).trim();
            System.out.println("Message From Server/" + packet.getAddress().getHostAddress() + ": " + msg);
        }
    }
}

+++++++++++++++++++++++++++++++++++++++++

My thread is in running state.
I'm Wait DESKTOP-DBJ9C1E/169.254.19.56!
Message From Server/192.168.1.3: halo apakabar

IMPLEMENTASI

import java.io.IOException;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

import java.net.InetAddress;

import java.net.SocketException;

import java.util.Scanner;

public class GETPOST extends Thread{

    private DatagramSocket udpSocketTX;

    private InetAddress serverAddress;

    private static int portTX=8217;

    static int PORT=8218;

    private DatagramSocket udpSocket;

    

    public GETPOST(int port) throws SocketException, IOException {

        this.PORT = port;

        this.udpSocket = new DatagramSocket(PORT);

    }

   

    

    public static void main(String[] args) throws Exception {

        GETPOST client = new GETPOST(PORT);

        client.start();

    }

    

    

    public void run(){  //wait

        try{

        System.out.println("I'm Wait " + InetAddress.getLocalHost() + "!");

        String msg;

        int ada=0;

        while (ada==0) {

            byte[] buf = new byte[256];

            DatagramPacket packet = new DatagramPacket(buf, buf.length);

            udpSocket.receive(packet);

            msg = new String(packet.getData()).trim();

            System.out.println("Message From Server/" + packet.getAddress().getHostAddress() + ": " + msg);

          

                GETPOST sender = new GETPOST("192.168.1.3", portTX);

                sender.mulai();

         

        }

        }

        catch(Exception ee){}

  }   

    

    

      private GETPOST(String destinationAddr, int port) throws IOException {

        this.serverAddress = InetAddress.getByName(destinationAddr);

        this.portTX = port;

        udpSocketTX = new DatagramSocket(this.portTX);

    }

    void mulai() throws IOException {

    String quote="Yg Running is......MP3 dll";

    byte[] buffer = quote.getBytes();

            DatagramPacket p = new DatagramPacket(quote.getBytes(), quote.getBytes().length, serverAddress, portTX);

            this.udpSocketTX.send(p);   

    }

    

}

UDP GET AND POST

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class POST {
    private DatagramSocket udpSocket;
    private InetAddress serverAddress;
    private int port;
    private Scanner scanner;
   
    private POST(String destinationAddr, int port) throws IOException {
        this.serverAddress = InetAddress.getByName(destinationAddr);
        this.port = port;
        udpSocket = new DatagramSocket(this.port);
        scanner = new Scanner(System.in);
    }
   
    public static void main(String[] args) throws NumberFormatException, IOException {       
        POST sender = new POST("192.168.1.3", 8215);
        System.out.println("-- Running UDP Client at " + InetAddress.getLocalHost() + " --");
        sender.start();
    }
    private int start() throws IOException {
        String in;
//        while (true) {
//            in = scanner.nextLine();
       
String quote="WHAT";
  byte[] buffer = quote.getBytes();
 
            DatagramPacket p = new DatagramPacket(quote.getBytes(), quote.getBytes().length, serverAddress, port);
           
            this.udpSocket.send(p);                   
        //}
        return 0;
    }
}





======================

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
public class GET {
    private DatagramSocket udpSocket;
    private int port;

    public GET(int port) throws SocketException, IOException {
        this.port = port;
        this.udpSocket = new DatagramSocket(this.port);
    }
    private void listen() throws Exception {
        System.out.println("-- Running Server at " + InetAddress.getLocalHost() + "--");
        String msg;
       
        while (true) {
           
            byte[] buf = new byte[256];
            DatagramPacket packet = new DatagramPacket(buf, buf.length);
           
            // blocks until a packet is received
            udpSocket.receive(packet);
            msg = new String(packet.getData()).trim();
           
            System.out.println(
                "Message from " + packet.getAddress().getHostAddress() + ": " + msg);
        }
    }
   
    public static void main(String[] args) throws Exception {
        GET client = new GET(8212);//Integer.parseInt(args[0]));
        client.listen();
    }
}

Java UDP Communication

import java.io.*;
import java.net.*;

public class QuoteClient {

    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("Syntax: QuoteClient <hostname> <port>");
            return;
        }

        String hostname = args[0];
        int port = Integer.parseInt(args[1]);

        try {
            InetAddress address = InetAddress.getByName(hostname);
            DatagramSocket socket = new DatagramSocket();

            while (true) {

                DatagramPacket request = new DatagramPacket(new byte[1], 1, address, port);
                socket.send(request);

                byte[] buffer = new byte[512];
                DatagramPacket response = new DatagramPacket(buffer, buffer.length);
                socket.receive(response);

                String quote = new String(buffer, 0, response.getLength());

                System.out.println(quote);
                System.out.println();

                Thread.sleep(10000);
            }

        } catch (SocketTimeoutException ex) {
            System.out.println("Timeout error: " + ex.getMessage());
            ex.printStackTrace();
        } catch (IOException ex) {
            System.out.println("Client error: " + ex.getMessage());
            ex.printStackTrace();
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }
}


RUN:java QuoteClient localhost 17


===========================================================
import java.io.*;
import java.net.*;
import java.util.*;


public class QuoteServer {
    private DatagramSocket socket;
    private List<String> listQuotes = new ArrayList<String>();
    private Random random;

    public QuoteServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
        random = new Random();
    }

    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("Syntax: QuoteServer <file> <port>");
            return;
        }

        String quoteFile = args[0];
        int port = Integer.parseInt(args[1]);

        try {
            QuoteServer server = new QuoteServer(port);
            server.loadQuotesFromFile(quoteFile);
            server.service();
        } catch (SocketException ex) {
            System.out.println("Socket error: " + ex.getMessage());
        } catch (IOException ex) {
            System.out.println("I/O error: " + ex.getMessage());
        }
    }

    private void service() throws IOException {
        while (true) {
            DatagramPacket request = new DatagramPacket(new byte[1], 1);
            socket.receive(request);

            String quote = getRandomQuote();
            byte[] buffer = quote.getBytes();

            InetAddress clientAddress = request.getAddress();
            int clientPort = request.getPort();

            DatagramPacket response = new DatagramPacket(buffer, buffer.length, clientAddress, clientPort);
            socket.send(response);
        }
    }

    private void loadQuotesFromFile(String quoteFile) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader(quoteFile));
        String aQuote;

        while ((aQuote = reader.readLine()) != null) {
            listQuotes.add(aQuote);
        }

        reader.close();
    }

    private String getRandomQuote() {
        int randomIndex = random.nextInt(listQuotes.size());
        String randomQuote = listQuotes.get(randomIndex);
        return randomQuote;
    }
}

=====================
RUN: java QuoteServer Quotes.txt 17