JAVA ILU INU IMU: Juli 2018

Senin, 02 Juli 2018

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)

Minggu, 01 Juli 2018

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();
}
}