జావా థ్రెడింగ్ - ప్రోగ్రామింగ్ ఉదాహరణలు
మల్టీథ్రెడింగ్ అనేది జావాలో ఒక శక్తివంతమైన టెక్నిక్, ఇది డెవలపర్‌లను ఏకకాలిక మరియు సమాంతర ప్రోగ్రామ్‌లను వ్రాయడానికి వీలు కల్పిస్తుంది. ఈ కథనంలో, మల్టీథ్రెడ్ అప్లికేషన్‌లను రూపొందించడానికి జావా థ్రెడింగ్ APIలను ఎలా ఉపయోగించాలో ప్రదర్శించడానికి మేము ప్రోగ్రామింగ్ ఉదాహరణలను అందిస్తాము.
థ్రెడ్ సృష్టి ఉదాహరణ
ఈ ఉదాహరణలో, మేము థ్రెడ్ క్లాస్‌ని పొడిగించడం ద్వారా అనుకూల థ్రెడ్ క్లాస్‌ని సృష్టిస్తాము మరియు కొంత పనిని నిర్వహించడానికి రన్() పద్ధతిని భర్తీ చేస్తాము. మేము ఈ తరగతి యొక్క ఉదాహరణను సృష్టించి, థ్రెడ్‌ను ప్రారంభిస్తాము.
జావాpublic class CustomThread extends Thread {
@Override
public void run() {
System.out.println("Custom thread is running.");
}
public static void main(String[] args) {
CustomThread thread = new CustomThread();
thread.start();
}
}
ఈ ఉదాహరణలో, కస్టమ్‌థ్రెడ్ క్లాస్ థ్రెడ్ క్లాస్‌ని పొడిగిస్తుంది మరియు సందేశాన్ని ప్రింట్ చేయడానికి రన్() పద్ధతిని ఓవర్‌రైడ్ చేస్తుంది. మేము ఈ తరగతి యొక్క ఉదాహరణను సృష్టించాము మరియు ప్రారంభ() పద్ధతిని ఉపయోగించి థ్రెడ్‌ను ప్రారంభిస్తాము.
అమలు చేయగల ఇంటర్‌ఫేస్ ఉదాహరణ
ఈ ఉదాహరణలో, మేము రన్ చేయదగిన ఇంటర్‌ఫేస్‌ను అమలు చేయడం ద్వారా అనుకూల థ్రెడ్ క్లాస్‌ను సృష్టిస్తాము మరియు కొంత పనిని నిర్వహించడానికి రన్() పద్ధతిని భర్తీ చేస్తాము. మేము ఈ తరగతి యొక్క ఉదాహరణను సృష్టించి, థ్రెడ్‌ను ప్రారంభిస్తాము.
జావాpublic class CustomRunnable implements Runnable {
@Override
public void run() {
System.out.println("Custom runnable is running.");
}
public static void main(String[] args) {
CustomRunnable runnable = new CustomRunnable();
Thread thread = new Thread(runnable);
thread.start();
}
}
ఈ ఉదాహరణలో, CustomRunnable క్లాస్ రన్ చేయదగిన ఇంటర్‌ఫేస్‌ను అమలు చేస్తుంది మరియు సందేశాన్ని ప్రింట్ చేయడానికి రన్() పద్ధతిని భర్తీ చేస్తుంది. మేము ఈ తరగతి యొక్క ఉదాహరణను సృష్టించి, థ్రెడ్ ఆబ్జెక్ట్‌ని ఉపయోగించి థ్రెడ్‌ను ప్రారంభిస్తాము మరియు CustomRunnable క్లాస్ యొక్క ఉదాహరణను దాని కన్స్ట్రక్టర్‌కు పంపుతాము.
సమకాలీకరణ ఉదాహరణ
ఈ ఉదాహరణలో, రెండు థ్రెడ్‌లు భాగస్వామ్య వేరియబుల్‌ను యాక్సెస్ చేసే మల్టీథ్రెడ్ ప్రోగ్రామ్‌ను మేము సృష్టిస్తాము. డేటా రేసులను నివారించడానికి మేము ఈ వేరియబుల్‌కు యాక్సెస్‌ని సమకాలీకరించాము.
జావాpublic class SynchronizedCounter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
public static void main(String[] args) {
SynchronizedCounter counter = new SynchronizedCounter();
Runnable task = () -> {
for (int i = 0; i < 10000; i++) {
counter.increment();
}
};
Thread thread1 = new Thread(task);
Thread thread2 = new Thread(task);
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(counter.getCount());
}
}
ఈ ఉదాహరణలో, SynchronizedCounter క్లాస్ రెండు పద్ధతులను అందిస్తుంది, ఇంక్రిమెంట్() మరియు getCount(), ఇది షేర్డ్ వేరియబుల్ కౌంట్‌ని యాక్సెస్ చేస్తుంది. డేటా రేసులను నివారించి, ఒకేసారి ఒక థ్రెడ్ మాత్రమే వాటిని యాక్సెస్ చేయగలదని నిర్ధారించడానికి ఈ పద్ధతులు సమకాలీకరించబడ్డాయి. మేము కౌంటర్ వేరియబుల్‌ను పెంచే పనిని అమలు చేసే రెండు థ్రెడ్‌లను సృష్టిస్తాము మరియు అవి పూర్తయ్యే వరకు వేచి ఉండటానికి మేము వాటిని కలుస్తాము. చివరగా, మేము కౌంటర్ వేరియబుల్ యొక్క విలువను ముద్రిస్తాము.
థ్రెడ్ పూల్ ఉదాహరణ
ఈ ఉదాహరణలో, మేము ExecutorService తరగతిని ఉపయోగించి థ్రెడ్ పూల్‌ని సృష్టిస్తాము మరియు దానికి టాస్క్‌లను సమర్పిస్తాము.
జావాimport java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(2);
Runnable task1 = () -> {
System.out.println("Task 1 is running.");
};
Runnable task2 = () -> {
System.out.println("Task 2 is running.");
};
executorService.submit(task1);
executorService
