Socket communication in Java enables communication between two endpoints over a network. There are two main types of sockets: TCP sockets and UDP sockets. Let's explain both types with examples: TCP Socket Communication: 1. **Server Side**: - The server creates a `ServerSocket` object to listen for incoming connections on a specific port. - When a client connects, the server accepts the connection and creates a `Socket` object to communicate with the client. - The server reads from and writes to the socket's input and output streams to communicate with the client. import java.io.*; import java.net.*; public class TCPServer { public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(12345); System.out.println("Server started. Waiting for client..."); Socket clientSocket = serverSocket.accept(); ...
In Java, there are two primary ways to create threads:
1. Extending the `Thread` class: You can create a new class that extends the `Thread` class and override its `run()` method to define the code that the thread will execute.
2. Implementing the `Runnable` interface: You can create a class that implements the `Runnable` interface and provide the implementation for its `run()` method. Then, you can pass an instance of this class to a `Thread` object.
Let's see examples for both approaches:
1. Extending the `Thread` class:
class MyThread extends Thread {
public void run() {
// Code to be executed by the thread
for (int i = 0; i < 5; i++) {
System.out.println("Thread: " + i);
try {
Thread.sleep(1000); // Pause execution for 1 second
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); // Start the thread
}
}
2. Implementing the `Runnable` interface:
class MyRunnable implements Runnable {
public void run() {
// Code to be executed by the thread
for (int i = 0; i < 5; i++) {
System.out.println("Runnable: " + i);
try {
Thread.sleep(1000); // Pause execution for 1 second
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start(); // Start the thread
}
}
Both approaches will create a separate thread of execution, allowing the code within the `run()` method (defined in either the `Thread` subclass or the `Runnable` implementation) to run concurrently with the main program.
Remember to call the `start()` method on the `Thread` object to start the execution of the thread. Do not call the `run()` method directly, as it will execute in the same thread as the caller, not in a separate thread.
Comments
Post a Comment