S12L02 - थ्रेड क्लास का विस्तार करके थ्रेड बनाना

### Hindi

html


मल्टी-थ्रेडेड एप्लिकेशन बनाना: एक व्यापक मार्गदर्शिका
सामग्री तालिका

1. परिचय ................................................................................... 3
2. मल्टी-थ्रेडेड एप्लिकेशन को समझना ... 5

2.1 मल्टी-थ्रेडिंग क्या है? .................................... 6
2.2 मल्टी-थ्रेडिंग के लाभ .......................... 7
2.3 मल्टी-थ्रेडिंग में प्रमुख विधियाँ .................... 8

3. मल्टी-थ्रेडेड एप्लिकेशन बनाना ............... 10

3.1 परियोजना सेटअप करना .......................................... 11
3.2 MyCounter क्लास बनाना ............................ 13
3.3 Main मेथड को लागू करना ............................ 16
3.4 Thread Sleep जोड़ना .................................................... 19
3.5 एक्जीक्यूशन समय मापना .................................... 21

4. सिंक्रोनस बनाम मल्टी-थ्रेडेड एक्जीक्यूशन .... 24
5. निष्कर्ष ................................................................................... 28
6. अतिरिक्त संसाधन ....................................................... 29

---
परिचय
सॉफ़्टवेयर विकास की तेजी से बदलती दुनिया में, कई कार्यों को एक ही समय में प्रभावी ढंग से प्रबंधित करना समझना महत्वपूर्ण है। Multi-threaded एप्लिकेशन डेवलपर्स को कई ऑपरेशनों को एक साथ निष्पादित करने में सक्षम बनाते हैं, जिससे प्रदर्शन और प्रतिक्रिया क्षमता बढ़ती है। यह ई-बुक Multi-threaded एप्लिकेशन की जटिलताओं में गहराई से जाती है, आपको एक सरल Multi-threaded प्रोग्राम बनाने के माध्यम से मार्गदर्शन करती है। चाहे आप एक शुरुआती हों या बुनियादी ज्ञान वाले डेवलपर, यह मार्गदर्शिका जावा में Multi-threading में महारत हासिल करने के लिए एक स्पष्ट और संक्षिप्त मार्ग प्रदान करती है।
---
मल्टी-थ्रेडेड एप्लिकेशन को समझना
मल्टी-थ्रेडिंग क्या है?
Multi-threading एक प्रोग्रामिंग तकनीक है जो एकल प्रोसेस के भीतर कई थ्रेड्स को एक साथ चलाने की अनुमति देती है। प्रत्येक थ्रेड निष्पादन का एक स्वतंत्र पथ प्रतिनिधित्व करता है, जिससे कार्यों को एक साथ निष्पादित करना संभव होता है। यह उन एप्लिकेशनों के लिए विशेष रूप से लाभकारी है जिन्हें उच्च प्रदर्शन और प्रतिक्रिया क्षमता की आवश्यकता होती है, जैसे कि वेब सर्वर, गेमिंग इंजन, और रियल-टाइम डेटा प्रोसेसिंग सिस्टम।
मल्टी-थ्रेडिंग के लाभ


लाभ
विवरण


बढ़ा हुआ प्रदर्शन
कई ऑपरेशनों को समानांतर निष्पादित करने की अनुमति देता है, कुल निष्पादन समय को कम करता है।


सुधरी हुई प्रतिक्रिया क्षमता
मुख्य प्रोसेस को बाधित किए बिना बैकग्राउंड कार्यों को निष्पादित करके एप्लिकेशन को प्रतिक्रियाशील बनाए रखता है।


संसाधन उपयोग
कई थ्रेड्स में कार्यों का वितरण करके सीपीयू उपयोग को अधिकतम करता है।


स्केलेबिलिटी
बढ़ते कार्यभार को संभालने में सक्षम स्केलेबल एप्लिकेशन बनाने की सुविधा प्रदान करता है।


मल्टी-थ्रेडिंग में प्रमुख विधियाँ
Multi-threading से संबंधित मौलिक विधियों को समझना प्रभावी कार्यान्वयन के लिए आवश्यक है। कुछ प्रमुख विधियाँ निम्नलिखित हैं:

start(): एक नया थ्रेड शुरू करता है।
run(): उस कोड को शामिल करता है जिसे थ्रेड निष्पादित करता है।
sleep(long millis): निर्धारित अवधि के लिए थ्रेड को रोकता है।
wait(): जब तक कोई अन्य थ्रेड notify() नहीं बुलाता, वर्तमान थ्रेड को प्रतीक्षा में डालता है।
yield(): सुझाव देता है कि वर्तमान थ्रेड अपने वर्तमान प्रोसेसर उपयोग को छोड़ने के इच्छुक है।

ये विधियाँ जावा में थ्रेड प्रबंधन और सिंक्रोनाइजेशन की रीढ़ बनाती हैं।
---
मल्टी-थ्रेडेड एप्लिकेशन बनाना
परियोजना सेटअप करना
हमारा Multi-threaded एप्लिकेशन बनाने शुरू करने के लिए, हम एक जावा प्रोजेक्ट सेटअप करेंगे। सुनिश्चित करें कि आपके मशीन पर Java Development Kit (JDK) स्थापित है। IntelliJ IDEA या Eclipse जैसे एकीकृत विकास पर्यावरण (IDE) का उपयोग करना प्रक्रिया को सरल बना सकता है।
परियोजना संरचना:




		
		
			
			
Java
			
			S12L02 - Creating thread by extending the thread class/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/
│   │           └── studyeasy/
│   │               ├── Main.java
│   │               └── MyCounter.java
│   └── test/
│       └── java/
├── target/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						S12L02 - Creating thread by extending the thread class/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/
│   │           └── studyeasy/
│   │               ├── Main.java
│   │               └── MyCounter.java
│   └── test/
│       └── java/
├── target/
					
				
			
		


नोट: pom.xml फाइल Maven में परियोजना कॉन्फ़िगरेशन के लिए प्रयोग की जाती है।
MyCounter क्लास बनाना
MyCounter क्लास हमारे Multi-threaded एप्लिकेशन की नींव के रूप में कार्य करती है। इसमें गिनती और पुनरावृत्ति मानों को प्रदर्शित करने के लिए लॉजिक होता है।




		
		
			
			
Java
			
			
package org.studyeasy;

public class MyCounter {
    private int threadNumber;

    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }

    // Method to perform counting
    public void countMe() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						 
package org.studyeasy;
 
public class MyCounter {
    private int threadNumber;
 
    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }
 
    // Method to perform counting
    public void countMe() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
        }
    }
}
 
					
				
			
		


व्याख्या:

threadNumber: थ्रेड की पहचान करता है, जिससे कई थ्रेड्स से आउटपुट को अलग करने में मदद मिलती है।
Constructor: threadNumber को प्रारंभ करता है।
countMe(): 0 से 9 तक आवृत्त करता है, वर्तमान थ्रेड नंबर और पुनरावृत्ति गिनती को प्रिंट करता है।

Main मेथड को लागू करना
Main क्लास कई MyCounter इंस्टेंसेस के निर्माण और निष्पादन का संचालन करती है।




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}
 
					
				
			
		


व्याख्या:

counter1 & counter2: भिन्न थ्रेड नंबर के साथ MyCounter ऑब्जेक्ट्स इंस्टैंटिएट करते हैं।
countMe(): प्रत्येक काउंटर के लिए गिनती विधि को बुलाता है।
Separator: विभिन्न थ्रेड्स से आउटपुट को अलग करके पठनीयता बढ़ाता है।

आउटपुट:




		
		
			
			
Java
			
			Thread 1: Iteration 0
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
Thread 2: Iteration 1
...
Thread 2: Iteration 9
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						Thread 1: Iteration 0
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
Thread 2: Iteration 1
...
Thread 2: Iteration 9
					
				
			
		


Thread Sleep जोड़ना
प्रोसेसिंग देरी को सिम्युलेट करने और सिंक्रोनस निष्पादन को देखने के लिए, हम sleep मेथड जोड़ेंगे।




		
		
			
			
Java
			
			
package org.studyeasy;

public class MyCounter {
    private int threadNumber;

    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }

    // Method to perform counting with sleep
    public void countMe() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
            Thread.sleep(500); // Pauses the thread for 500 milliseconds
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						 
package org.studyeasy;
 
public class MyCounter {
    private int threadNumber;
 
    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }
 
    // Method to perform counting with sleep
    public void countMe() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
            Thread.sleep(500); // Pauses the thread for 500 milliseconds
        }
    }
}
 
					
				
			
		


व्याख्या:

Thread.sleep(500): प्रत्येक पुनरावृत्ति के बाद 500-मिलिसेकेंड का विराम डालता है, प्रोसेसिंग समय को सिम्युलेट करता है।
throws InterruptedException: इंगित करता है कि यह मेथड एक InterruptedException फेंक सकता है, जिससे main मेथड में अपवाद प्रबंधन की आवश्यकता होती है।

Updated Main Method:




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}
 
					
				
			
		


Output with Sleep:




		
		
			
			
Java
			
			Thread 1: Iteration 0
(Thread pauses for 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(Thread pauses for 500ms)
Thread 2: Iteration 1
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						Thread 1: Iteration 0
(Thread pauses for 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(Thread pauses for 500ms)
Thread 2: Iteration 1
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
					
				
			
		


नोट: कुल समय सामूहिक sleep अवधि के साथ मेल खाता है, जो सिंक्रोनस निष्पादन को दर्शाता है।
एक्जीक्यूशन समय मापना
सिन्क्रोनाइजेशन के प्रदर्शन प्रभाव का आकलन करने के लिए, हम कुल एक्जीक्यूशन समय मापेंगे।




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();

        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();

        long endTime = System.currentTimeMillis();
        System.out.println("Total time required for processing: " + (endTime - startTime)/1000 + " seconds");
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
 
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
 
        long endTime = System.currentTimeMillis();
        System.out.println("Total time required for processing: " + (endTime - startTime)/1000 + " seconds");
    }
}
 
					
				
			
		


व्याख्या:

startTime & endTime: निष्पादन से पहले और बाद में सिस्टम का वर्तमान समय कैप्चर करते हैं।
Total Time Calculation: कुल प्रोसेसिंग अवधि निर्धारित करने के लिए startTime को endTime से घटाता है।

Sample Output:




		
		
			
			
Java
			
			Thread 1: Iteration 0
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
			
				
					
				
					1
2
3
4
5
6
7
8
				
						Thread 1: Iteration 0
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
					
				
			
		


नोट: कुल समय सामूहिक sleep अवधि के साथ मेल खाता है, जो सिंक्रोनस निष्पादन को दर्शाता है।
---
सिंक्रोनस बनाम मल्टी-थ्रेडेड एक्जीक्यूशन
वर्तमान कार्यान्वयन में, एप्लिकेशन सिंक्रोनस रूप से चलता है, जिसका अर्थ है कि प्रत्येक थ्रेड अपने निष्पादन को पूरा करता है इससे पहले कि अगला शुरू हो। इससे कुल प्रोसेसिंग समय थ्रेड्स की संख्या के अनुपात में बढ़ता है।
Synchronous Execution Characteristics:

समानांतर प्रोसेसिंग: एक समय में एक थ्रेड निष्पादित होता है।
पूर्वानुमान योग्य व्यवहार: निष्पादन प्रवाह को ट्रैक करना आसान है।
लंबा प्रोसेसिंग समय: कुल समय थ्रेड्स की संख्या के साथ बढ़ता है।

मल्टी-थ्रेडेड Execution Advantages:

समानांतर प्रोसेसिंग: कई थ्रेड्स एक साथ चलते हैं।
कुल समय में कमी: थ्रेड्स समानांतर कार्य करते हैं जिससे एक्जीक्यूशन समय कम होता है।
बढ़ी हुई प्रतिक्रिया क्षमता: एप्लिकेशन प्रतिक्रियाशील रहते हैं, विशेष रूप से GUI एप्लिकेशनों में।

सिंक्रोनस से मल्टी-थ्रेडेड एक्जीक्यूशन पर संक्रमण के लिए, हम जावा के Thread क्लास का लाभ उठाएंगे या Runnable इंटरफेस को लागू करेंगे, जिससे थ्रेड्स समानांतर रूप से चल सकें।
---
निष्कर्ष
इस मार्गदर्शिका ने जावा में Multi-threaded एप्लिकेशन की बुनियादी समझ प्रदान की। एक सरल MyCounter क्लास बनाने और इसे Main क्लास में निष्पादित करके, हमने थ्रेड निर्माण, सिंक्रोनाइजेशन, और प्रदर्शन मापन की मूल बातें खोजीं। जबकि सिंक्रोनस दृष्टिकोण सरलता प्रदान करता है, Multi-threading को अपनाने से एप्लिकेशन के प्रदर्शन और प्रतिक्रिया क्षमता में काफी सुधार हो सकता है। जैसे-जैसे आप अपनी यात्रा जारी रखते हैं, थ्रेड प्रबंधन, सिंक्रोनाइजेशन मेकानिज्म, और उन्नत कॉन्करेंसी यूटिलिटीज में गहराई से उतरना आपको मजबूत और कुशल एप्लिकेशन बनाने में सशक्त करेगा।
SEO Keywords: multi-threaded applications, Java multi-threading, thread management, synchronous execution, Thread.sleep, Java Thread class, concurrency in Java, improving application performance, beginner's guide to multi-threading, creating threads in Java
नोट: यह लेख AI द्वारा जनरेट किया गया है।









---
अतिरिक्त संसाधन

Oracle Java Documentation: Threads
Java Concurrency in Practice by Brian Goetz
TutorialsPoint: Java Multithreading
Baeldung: Introduction to Threads in Java
GeeksforGeeks: Multithreading in Java

---

लाभ	विवरण
बढ़ा हुआ प्रदर्शन	कई ऑपरेशनों को समानांतर निष्पादित करने की अनुमति देता है, कुल निष्पादन समय को कम करता है।
सुधरी हुई प्रतिक्रिया क्षमता	मुख्य प्रोसेस को बाधित किए बिना बैकग्राउंड कार्यों को निष्पादित करके एप्लिकेशन को प्रतिक्रियाशील बनाए रखता है।
संसाधन उपयोग	कई थ्रेड्स में कार्यों का वितरण करके सीपीयू उपयोग को अधिकतम करता है।
स्केलेबिलिटी	बढ़ते कार्यभार को संभालने में सक्षम स्केलेबल एप्लिकेशन बनाने की सुविधा प्रदान करता है।

### Chinese

html


创建多线程应用程序：全面指南
目录

1. 介绍 ................................................................................... 3
2. 理解多线程应用程序 ... 5

2.1 什么是多线程？ .................................... 6
2.2 多线程的好处 .......................... 7
2.3 多线程中的关键方法 .................... 8

3. 构建多线程应用程序 ............... 10

3.1 设置项目 .......................................... 11
3.2 创建 MyCounter 类 ............................ 13
3.3 实现 Main 方法 ............................ 16
3.4 添加线程休眠 .................................................... 19
3.5 测量执行时间 .................................... 21

4. 同步与多线程执行 .... 24
5. 结论 ................................................................................... 28
6. 附加资源 ....................................................... 29

---
介绍
在快速发展的软件开发世界中，理解如何有效地同时管理多个任务至关重要。Multi-threaded 应用程序使开发人员能够同时执行多个操作，增强了性能和响应能力。本电子书深入探讨了多线程应用程序的复杂性，指导您创建一个简单的多线程程序。无论您是初学者还是具有基本知识的开发人员，本指南都为您掌握 Java 中的 Multi-threading 提供了清晰简洁的路径。
---
理解多线程应用程序
什么是多线程？
Multi-threading 是一种编程技术，允许在单个进程内并发运行多个线程。每个线程代表一个独立的执行路径，使任务能够同时执行。这对于需要高性能和响应能力的应用程序特别有利，如 Web 服务器、游戏引擎和实时数据处理系统。
多线程的好处


好处
描述


性能增强
允许多个操作并行执行，减少整体执行时间。


响应能力提升
通过在后台执行任务而不干扰主进程，保持应用程序响应。


资源利用率
通过将任务分配到多个线程中，最大化 CPU 使用率。


可扩展性
促进创建能够处理增加工作负载的可扩展应用程序。


多线程中的关键方法
理解与 Multi-threading 相关的基本方法对于有效实现至关重要。一些关键方法包括：

start()：启动一个新线程。
run()：包含线程执行的代码。
sleep(long millis)：暂停线程指定的时间。
wait()：使当前线程等待，直到另一个线程调用 notify()。
yield()：建议当前线程愿意放弃当前的处理器使用。

这些方法构成了 Java 中线程管理和同步的基础。
---
构建多线程应用程序
设置项目
要开始构建我们的 Multi-threaded 应用程序，我们将设置一个 Java 项目。确保您的计算机上已安装 Java Development Kit (JDK)。使用像 IntelliJ IDEA 或 Eclipse 这样的集成开发环境 (IDE) 可以简化过程。
项目结构：




		
		
			
			
Java
			
			S12L02 - Creating thread by extending the thread class/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/
│   │           └── studyeasy/
│   │               ├── Main.java
│   │               └── MyCounter.java
│   └── test/
│       └── java/
├── target/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						S12L02 - Creating thread by extending the thread class/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/
│   │           └── studyeasy/
│   │               ├── Main.java
│   │               └── MyCounter.java
│   └── test/
│       └── java/
├── target/
					
				
			
		


注意：pom.xml 文件用于 Maven 中的项目配置。
创建 MyCounter 类
MyCounter 类作为我们 Multi-threaded 应用程序的基础。它包含计数和显示迭代值的逻辑。




		
		
			
			
Java
			
			
package org.studyeasy;

public class MyCounter {
    private int threadNumber;

    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }

    // Method to perform counting
    public void countMe() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						 
package org.studyeasy;
 
public class MyCounter {
    private int threadNumber;
 
    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }
 
    // Method to perform counting
    public void countMe() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
        }
    }
}
 
					
				
			
		


解释：

threadNumber：标识线程，有助于区分多个线程的输出。
Constructor：初始化 threadNumber。
countMe()：从 0 到 9 迭代，打印当前线程编号和迭代计数。

实现 Main 方法
Main 类负责创建和执行多个 MyCounter 实例。




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}
 
					
				
			
		


解释：

counter1 & counter2：使用不同的线程编号实例化 MyCounter 对象。
countMe()：调用每个计数器的计数方法。
Separator：通过区分不同线程的输出增强可读性。

输出：




		
		
			
			
Java
			
			Thread 1: Iteration 0
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
Thread 2: Iteration 1
...
Thread 2: Iteration 9
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						Thread 1: Iteration 0
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
Thread 2: Iteration 1
...
Thread 2: Iteration 9
					
				
			
		


添加线程休眠
为了模拟处理延迟并观察同步执行，我们将引入 sleep 方法。




		
		
			
			
Java
			
			
package org.studyeasy;

public class MyCounter {
    private int threadNumber;

    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }

    // Method to perform counting with sleep
    public void countMe() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
            Thread.sleep(500); // Pauses the thread for 500 milliseconds
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						 
package org.studyeasy;
 
public class MyCounter {
    private int threadNumber;
 
    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }
 
    // Method to perform counting with sleep
    public void countMe() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
            Thread.sleep(500); // Pauses the thread for 500 milliseconds
        }
    }
}
 
					
				
			
		


解释：

Thread.sleep(500)：每次迭代后暂停 500 毫秒，模拟处理时间。
throws InterruptedException：表明该方法可能抛出 InterruptedException，需要在 main 方法中处理异常。

更新后的 Main 方法：




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}
 
					
				
			
		


带休眠的输出：




		
		
			
			
Java
			
			Thread 1: Iteration 0
(Thread pauses for 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(Thread pauses for 500ms)
Thread 2: Iteration 1
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						Thread 1: Iteration 0
(Thread pauses for 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(Thread pauses for 500ms)
Thread 2: Iteration 1
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
					
				
			
		


注意：总时间与累计的休眠时间一致，突出了同步执行。
测量执行时间
为了评估同步的性能影响，我们将测量总执行时间。




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();

        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();

        long endTime = System.currentTimeMillis();
        System.out.println("Total time required for processing: " + (endTime - startTime)/1000 + " seconds");
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
 
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
 
        long endTime = System.currentTimeMillis();
        System.out.println("Total time required for processing: " + (endTime - startTime)/1000 + " seconds");
    }
}
 
					
				
			
		


解释：

startTime & endTime：在执行前后捕捉系统当前时间。
Total Time Calculation：通过从 endTime 中减去 startTime 来确定总处理时长。

示例输出：




		
		
			
			
Java
			
			Thread 1: Iteration 0
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
			
				
					
				
					1
2
3
4
5
6
7
8
				
						Thread 1: Iteration 0
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
					
				
			
		


注意：总时间与累计的休眠时间一致，突出了同步执行。
---
同步与多线程执行
在当前的实现中，应用程序同步运行，意味着每个线程在下一个线程开始之前完成其执行。这导致总处理时间与线程数量成正比。
同步执行的特点：

顺序处理：一次执行一个线程。
可预测的行为：易于跟踪执行流程。
较长的处理时间：总时间随着线程数量的增加而增加。

多线程执行的优势：

并发处理：多个线程同时运行。
减少总时间：随着线程并行操作，执行时间减少。
增强的响应能力：应用程序保持响应，尤其是在 GUI 应用程序中。

要从同步过渡到多线程执行，我们将利用 Java 的 Thread 类或实现 Runnable 接口，使线程能够同时运行。
---
结论
本指南提供了对 Java 中 Multi-threaded 应用程序的基础理解。通过创建一个简单的 MyCounter 类并在 Main 类中协调其执行，我们探索了线程创建、同步和性能测量的基础知识。虽然同步方法提供了简单性，但采用多线程可以显著提升应用程序的性能和响应能力。随着您继续前行，深入研究线程管理、同步机制和高级并发工具将使您能够构建强大而高效的应用程序。
SEO Keywords: multi-threaded applications, Java multi-threading, thread management, synchronous execution, Thread.sleep, Java Thread class, concurrency in Java, improving application performance, beginner's guide to multi-threading, creating threads in Java
注意：本文是由 AI 生成的。









---
附加资源

Oracle Java Documentation: Threads
Java Concurrency in Practice by Brian Goetz
TutorialsPoint: Java Multithreading
Baeldung: Introduction to Threads in Java
GeeksforGeeks: Multithreading in Java

---

好处	描述
性能增强	允许多个操作并行执行，减少整体执行时间。
响应能力提升	通过在后台执行任务而不干扰主进程，保持应用程序响应。
资源利用率	通过将任务分配到多个线程中，最大化 CPU 使用率。
可扩展性	促进创建能够处理增加工作负载的可扩展应用程序。

### Korean

html


멀티 스레드 애플리케이션 만들기: 종합 가이드
목차

1. 소개 ................................................................................... 3
2. 멀티 스레드 애플리케이션 이해하기 ... 5

2.1 멀티 스레딩이란? .................................... 6
2.2 멀티 스레딩의 장점 .......................... 7
2.3 멀티 스레딩의 주요 메서드 .................... 8

3. 멀티 스레드 애플리케이션 구축하기 ............... 10

3.1 프로젝트 설정하기 .......................................... 11
3.2 MyCounter 클래스 만들기 ............................ 13
3.3 Main 메서드 구현하기 ............................ 16
3.4 Thread Sleep 추가하기 .................................................... 19
3.5 실행 시간 측정하기 .................................... 21

4. 동기식 vs. 멀티 스레드 실행 .... 24
5. 결론 ................................................................................... 28
6. 추가 자료 ....................................................... 29

---
소개
빠르게 발전하는 소프트웨어 개발 세계에서, 여러 작업을 동시에 효율적으로 관리하는 방법을 이해하는 것은 매우 중요합니다. Multi-threaded 애플리케이션은 개발자가 여러 작업을 동시에 수행할 수 있게 하여 성능과 응답성을 향상시킵니다. 이 전자책은 Multi-threaded 애플리케이션의 복잡성에 깊이 들어가 간단한 멀티 스레드 프로그램을 만드는 방법을 안내합니다. 당신이 초보자이든 기본 지식을 가진 개발자이든, 이 가이드는 Java에서 Multi-threading을 마스터하기 위한 명확하고 간결한 경로를 제공합니다.
---
멀티 스레드 애플리케이션 이해하기
멀티 스레딩이란?
Multi-threading은 단일 프로세스 내에서 여러 스레드를 동시에 실행할 수 있게 하는 프로그래밍 기술입니다. 각 스레드는 독립적인 실행 경로를 나타내어 작업을 동시에 수행할 수 있게 합니다. 이는 웹 서버, 게임 엔진, 실시간 데이터 처리 시스템과 같이 높은 성능과 응답성이 요구되는 애플리케이션에 특히 유용합니다.
멀티 스레딩의 장점


장점
설명


성능 향상
여러 작업을 병렬로 실행할 수 있어 전체 실행 시간을 단축합니다.


응답성 개선
백그라운드 작업을 수행하여 주요 프로세스를 방해하지 않고 애플리케이션의 응답성을 유지합니다.


자원 활용
여러 스레드에 작업을 분산시켜 CPU 사용률을 극대화합니다.


확장성
작업 부하가 증가해도 처리할 수 있는 확장 가능한 애플리케이션을 만드는 데 도움이 됩니다.


멀티 스레딩의 주요 메서드
Multi-threading과 관련된 기본 메서드를 이해하는 것은 효과적인 구현을 위해 필수적입니다. 주요 메서드는 다음과 같습니다:

start(): 새로운 스레드를 시작합니다.
run(): 스레드가 실행하는 코드를 포함합니다.
sleep(long millis): 스레드를 지정된 시간 동안 일시 중지합니다.
wait(): 다른 스레드가 notify()를 호출할 때까지 현재 스레드를 대기시킵니다.
yield(): 현재 스레드가 프로세서 사용을 양보할 의향이 있음을 제안합니다.

이 메서드들은 Java에서 스레드를 관리하고 동기화하는 기본적인 기능을 담당합니다.
---
멀티 스레드 애플리케이션 구축하기
프로젝트 설정하기
우리의 Multi-threaded 애플리케이션을 구축하기 시작하려면, Java 프로젝트를 설정할 것입니다. 컴퓨터에 Java Development Kit (JDK)가 설치되어 있는지 확인하세요. IntelliJ IDEA 또는 Eclipse와 같은 통합 개발 환경 (IDE)을 사용하는 것이 과정을 단순화할 수 있습니다.
프로젝트 구조:




		
		
			
			
Java
			
			S12L02 - Creating thread by extending the thread class/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/
│   │           └── studyeasy/
│   │               ├── Main.java
│   │               └── MyCounter.java
│   └── test/
│       └── java/
├── target/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						S12L02 - Creating thread by extending the thread class/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/
│   │           └── studyeasy/
│   │               ├── Main.java
│   │               └── MyCounter.java
│   └── test/
│       └── java/
├── target/
					
				
			
		


참고: pom.xml 파일은 Maven에서 프로젝트 구성을 위해 사용됩니다.
MyCounter 클래스 만들기
MyCounter 클래스는 우리의 Multi-threaded 애플리케이션의 기초를 제공합니다. 이 클래스는 카운팅 및 반복 값을 표시하는 로직을 포함하고 있습니다.




		
		
			
			
Java
			
			
package org.studyeasy;

public class MyCounter {
    private int threadNumber;

    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }

    // Method to perform counting
    public void countMe() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						 
package org.studyeasy;
 
public class MyCounter {
    private int threadNumber;
 
    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }
 
    // Method to perform counting
    public void countMe() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
        }
    }
}
 
					
				
			
		


설명:

threadNumber: 스레드를 식별하여 여러 스레드의 출력을 구분하는 데 도움을 줍니다.
Constructor: threadNumber를 초기화합니다.
countMe(): 0부터 9까지 반복하며 현재 스레드 번호와 반복 횟수를 출력합니다.

Main 메서드 구현하기
Main 클래스는 여러 MyCounter 인스턴스의 생성 및 실행을 조율합니다.




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}
 
					
				
			
		


설명:

counter1 & counter2: 다른 스레드 번호로 MyCounter 객체를 인스턴스화합니다.
countMe(): 각 카운터에 대한 카운팅 메서드를 호출합니다.
Separator: 다른 스레드의 출력을 구분하여 가독성을 높입니다.

출력:




		
		
			
			
Java
			
			Thread 1: Iteration 0
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
Thread 2: Iteration 1
...
Thread 2: Iteration 9
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						Thread 1: Iteration 0
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
Thread 2: Iteration 1
...
Thread 2: Iteration 9
					
				
			
		


Thread Sleep 추가하기
처리 지연을 시뮬레이션하고 동기식 실행을 관찰하기 위해 sleep 메서드를 도입할 것입니다.




		
		
			
			
Java
			
			
package org.studyeasy;

public class MyCounter {
    private int threadNumber;

    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }

    // Method to perform counting with sleep
    public void countMe() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
            Thread.sleep(500); // Pauses the thread for 500 milliseconds
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						 
package org.studyeasy;
 
public class MyCounter {
    private int threadNumber;
 
    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }
 
    // Method to perform counting with sleep
    public void countMe() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
            Thread.sleep(500); // Pauses the thread for 500 milliseconds
        }
    }
}
 
					
				
			
		


설명:

Thread.sleep(500): 각 반복 후 500밀리초 동안 스레드를 일시 중지하여 처리 시간을 시뮬레이션합니다.
throws InterruptedException: 이 메서드가 InterruptedException을 던질 수 있음을 나타내며, main 메서드에서 예외 처리가 필요합니다.

업데이트된 Main 메서드:




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}
 
					
				
			
		


Sleep 포함 출력:




		
		
			
			
Java
			
			Thread 1: Iteration 0
(Thread pauses for 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(Thread pauses for 500ms)
Thread 2: Iteration 1
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						Thread 1: Iteration 0
(Thread pauses for 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(Thread pauses for 500ms)
Thread 2: Iteration 1
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
					
				
			
		


참고: 총 시간은 누적된 sleep 기간과 일치하여 동기식 실행을 강조합니다.
실행 시간 측정하기
동기화의 성능 영향을 평가하기 위해 총 실행 시간을 측정할 것입니다.




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();

        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();

        long endTime = System.currentTimeMillis();
        System.out.println("Total time required for processing: " + (endTime - startTime)/1000 + " seconds");
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
 
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
 
        long endTime = System.currentTimeMillis();
        System.out.println("Total time required for processing: " + (endTime - startTime)/1000 + " seconds");
    }
}
 
					
				
			
		


설명:

startTime & endTime: 실행 전후에 시스템의 현재 시간을 캡처합니다.
Total Time Calculation: startTime에서 endTime을 빼서 총 처리 시간을 결정합니다.

샘플 출력:




		
		
			
			
Java
			
			Thread 1: Iteration 0
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
			
				
					
				
					1
2
3
4
5
6
7
8
				
						Thread 1: Iteration 0
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
					
				
			
		


참고: 총 시간은 누적된 sleep 기간과 일치하여 동기식 실행을 강조합니다.
---
동기식 vs. 멀티 스레드 실행
현재 구현에서는 애플리케이션이 동기식으로 실행됩니다. 즉, 각 스레드가 다음 스레드가 시작되기 전에 실행을 완료합니다. 이로 인해 총 처리 시간이 스레드 수에 비례하여 누적됩니다.
동기식 실행 특성:

순차 처리: 한 번에 하나의 스레드가 실행됩니다.
예측 가능한 동작: 실행 흐름을 추적하기 쉽습니다.
더 긴 처리 시간: 전체 시간이 스레드 수에 따라 증가합니다.

멀티 스레드 실행의 장점:

동시 처리: 여러 스레드가 동시에 실행됩니다.
총 시간 감소: 스레드가 병렬로 작동함에 따라 실행 시간이 단축됩니다.
향상된 응답성: 특히 GUI 애플리케이션에서 애플리케이션이 응답성을 유지합니다.

동기식에서 멀티 스레드 실행으로 전환하기 위해, 우리는 Java의 Thread 클래스를 활용하거나 Runnable 인터페이스를 구현하여 스레드가 동시에 실행될 수 있도록 할 것입니다.
---
결론
이 가이드는 Java에서 Multi-threaded 애플리케이션에 대한 기본적인 이해를 제공했습니다. 간단한 MyCounter 클래스를 만들고 Main 클래스에서 이를 조율함으로써, 우리는 스레드 생성, 동기화, 및 성능 측정의 기초를 탐구했습니다. 동기식 접근 방식은 단순성을 제공하지만, 멀티 스레딩을 채택하면 애플리케이션의 성능과 응답성을 크게 향상시킬 수 있습니다. 여정을 계속하면서 스레드 관리, 동기화 메커니즘, 및 고급 동시성 유틸리티를 깊이 파고들면 견고하고 효율적인 애플리케이션을 구축할 수 있게 될 것입니다.
SEO Keywords: multi-threaded applications, Java multi-threading, thread management, synchronous execution, Thread.sleep, Java Thread class, concurrency in Java, improving application performance, beginner's guide to multi-threading, creating threads in Java
참고: 이 글은 AI에 의해 생성되었습니다.









---
추가 자료

Oracle Java Documentation: Threads
Java Concurrency in Practice by Brian Goetz
TutorialsPoint: Java Multithreading
Baeldung: Introduction to Threads in Java
GeeksforGeeks: Multithreading in Java

---

장점	설명
성능 향상	여러 작업을 병렬로 실행할 수 있어 전체 실행 시간을 단축합니다.
응답성 개선	백그라운드 작업을 수행하여 주요 프로세스를 방해하지 않고 애플리케이션의 응답성을 유지합니다.
자원 활용	여러 스레드에 작업을 분산시켜 CPU 사용률을 극대화합니다.
확장성	작업 부하가 증가해도 처리할 수 있는 확장 가능한 애플리케이션을 만드는 데 도움이 됩니다.

### Portuguese

html


Criando Aplicações Multithread: Um Guia Abrangente
Índice

1. Introdução ................................................................................... 3
2. Entendendo Aplicações Multithread ... 5

2.1 O que é Multithreading? .................................... 6
2.2 Benefícios do Multithreading .......................... 7
2.3 Métodos Principais em Multithreading .................... 8

3. Construindo uma Aplicação Multithread ............... 10

3.1 Configurando o Projeto .......................................... 11
3.2 Criando a Classe MyCounter ............................ 13
3.3 Implementando o Método Main ............................ 16
3.4 Adicionando Thread Sleep .................................................... 19
3.5 Mensurando o Tempo de Execução .................................... 21

4. Execução Síncrona vs. Multithread .... 24
5. Conclusão ................................................................................... 28
6. Recursos Adicionais ....................................................... 29

---
Introdução
No mundo em rápida evolução do desenvolvimento de software, entender como gerenciar efetivamente várias tarefas simultaneamente é crucial. Multi-threaded aplicações permitem que desenvolvedores realizem múltiplas operações concorrentes, melhorando desempenho e responsividade. Este eBook mergulha nas complexidades das aplicações multithread, guiando você através da criação de um programa multithread simples. Seja você um iniciante ou um desenvolvedor com conhecimentos básicos, este guia oferece um caminho claro e conciso para dominar o multithreading em Java.
---
Entendendo Aplicações Multithread
O que é Multithreading?
Multithreading é uma técnica de programação que permite que múltiplas threads sejam executadas concorrente dentro de um único processo. Cada thread representa um caminho de execução independente, permitindo que tarefas sejam realizadas simultaneamente. Isso é particularmente benéfico para aplicações que requerem alto desempenho e responsividade, como servidores web, motores de jogos e sistemas de processamento de dados em tempo real.
Benefícios do Multithreading


Benefício
Descrição


Desempenho Aprimorado
Permite a execução de múltiplas operações em paralelo, reduzindo o tempo total de execução.


Melhoria na Responsividade
Mantém as aplicações responsivas realizando tarefas de fundo sem interromper o processo principal.


Utilização de Recursos
Maximiza o uso da CPU distribuindo tarefas entre múltiplas threads.


Escalabilidade
Facilita a criação de aplicações escaláveis capazes de lidar com cargas de trabalho aumentadas.


Métodos Principais em Multithreading
Entender os métodos fundamentais associados ao multithreading é essencial para uma implementação eficaz. Alguns dos métodos principais incluem:

start(): Inicia uma nova thread.
run(): Contém o código que a thread executa.
sleep(long millis): Pausa a thread por uma duração especificada.
wait(): Faz com que a thread atual espere até que outra thread invoque notify().
yield(): Sugere que a thread atual está disposta a ceder seu uso atual de um processador.

Esses métodos formam a espinha dorsal do gerenciamento e sincronização de threads em Java.
---
Construindo uma Aplicação Multithread
Configurando o Projeto
Para começar a construir nossa aplicação multithread, vamos configurar um projeto Java. Certifique-se de que você tem o Java Development Kit (JDK) instalado em sua máquina. Usar um Ambiente de Desenvolvimento Integrado (IDE) como IntelliJ IDEA ou Eclipse pode simplificar o processo.
Estrutura do Projeto:




		
		
			
			
Java
			
			S12L02 - Creating thread by extending the thread class/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/
│   │           └── studyeasy/
│   │               ├── Main.java
│   │               └── MyCounter.java
│   └── test/
│       └── java/
├── target/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						S12L02 - Creating thread by extending the thread class/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/
│   │           └── studyeasy/
│   │               ├── Main.java
│   │               └── MyCounter.java
│   └── test/
│       └── java/
├── target/
					
				
			
		


Nota: O arquivo pom.xml é usado para configuração do projeto no Maven.
Criando a Classe MyCounter
A classe MyCounter serve como a base de nossa aplicação multithread. Ela contém a lógica para contagem e exibição dos valores de iteração.




		
		
			
			
Java
			
			
package org.studyeasy;

public class MyCounter {
    private int threadNumber;

    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }

    // Method to perform counting
    public void countMe() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						 
package org.studyeasy;
 
public class MyCounter {
    private int threadNumber;
 
    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }
 
    // Method to perform counting
    public void countMe() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
        }
    }
}
 
					
				
			
		


Explicação:

threadNumber: Identifica a thread, ajudando a distinguir a saída de múltiplas threads.
Constructor: Inicializa o threadNumber.
countMe(): Itera de 0 a 9, imprimindo o número da thread atual e a contagem da iteração.

Implementando o Método Main
A classe Main orquestra a criação e execução de múltiplas instâncias de MyCounter.




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}
 
					
				
			
		


Explicação:

counter1 & counter2: Instanciam objetos MyCounter com números de thread distintos.
countMe(): Invoca o método de contagem para cada contador.
Separator: Melhora a legibilidade distinguindo saídas de diferentes threads.

Saída:




		
		
			
			
Java
			
			Thread 1: Iteration 0
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
Thread 2: Iteration 1
...
Thread 2: Iteration 9
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						Thread 1: Iteration 0
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
Thread 2: Iteration 1
...
Thread 2: Iteration 9
					
				
			
		


Adicionando Thread Sleep
Para simular atrasos no processamento e observar a execução síncrona, introduziremos o método sleep.




		
		
			
			
Java
			
			
package org.studyeasy;

public class MyCounter {
    private int threadNumber;

    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }

    // Method to perform counting with sleep
    public void countMe() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
            Thread.sleep(500); // Pauses the thread for 500 milliseconds
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						 
package org.studyeasy;
 
public class MyCounter {
    private int threadNumber;
 
    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }
 
    // Method to perform counting with sleep
    public void countMe() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
            Thread.sleep(500); // Pauses the thread for 500 milliseconds
        }
    }
}
 
					
				
			
		


Explicação:

Thread.sleep(500): Introduz uma pausa de 500 milissegundos após cada iteração, simulando tempo de processamento.
throws InterruptedException: Indica que o método pode lançar uma InterruptedException, exigindo tratamento de exceção no método main.

Main Método Atualizado:




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}
 
					
				
			
		


Saída com Sleep:




		
		
			
			
Java
			
			Thread 1: Iteration 0
(Thread pauses for 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(Thread pauses for 500ms)
Thread 2: Iteration 1
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						Thread 1: Iteration 0
(Thread pauses for 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(Thread pauses for 500ms)
Thread 2: Iteration 1
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
					
				
			
		


Nota: O tempo total alinha-se com as durações cumulativas de sleep, destacando a execução síncrona.
Mensurando o Tempo de Execução
Para avaliar o impacto da sincronização no desempenho, mediremos o tempo total de execução.




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();

        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();

        long endTime = System.currentTimeMillis();
        System.out.println("Total time required for processing: " + (endTime - startTime)/1000 + " seconds");
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
 
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
 
        long endTime = System.currentTimeMillis();
        System.out.println("Total time required for processing: " + (endTime - startTime)/1000 + " seconds");
    }
}
 
					
				
			
		


Explicação:

startTime & endTime: Capturam o tempo atual do sistema antes e depois da execução.
Total Time Calculation: Subtrai startTime de endTime para determinar a duração total do processamento.

Exemplo de Saída:




		
		
			
			
Java
			
			Thread 1: Iteration 0
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
			
				
					
				
					1
2
3
4
5
6
7
8
				
						Thread 1: Iteration 0
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
					
				
			
		


Nota: O tempo total alinha-se com as durações cumulativas de sleep, destacando a execução síncrona.
---
Execução Síncrona vs. Multithread
Na implementação atual, a aplicação roda de forma síncrona, significando que cada thread completa sua execução antes que a próxima comece. Isso resulta em um tempo de processamento cumulativo proporcional ao número de threads.
Características da Execução Síncrona:

Processamento Sequencial: Um thread é executado por vez.
Comportamento Previsível: Fácil de rastrear o fluxo de execução.
Tempo de Processamento Maior: O tempo total aumenta com o número de threads.

Vantagens da Execução Multithread:

Processamento Concorrente: Múltiplos threads rodam simultaneamente.
Redução do Tempo Total: O tempo de execução diminui conforme os threads operam em paralelo.
Responsividade Aprimorada: Aplicações permanecem responsivas, especialmente em aplicações GUI.

Para transitar de execução síncrona para multithread, utilizaremos a classe Thread de Java ou implementaremos a interface Runnable, permitindo que os threads rodem concorrente.
---
Conclusão
Este guia forneceu uma compreensão fundamental das aplicações multithread em Java. Ao criar uma classe MyCounter simples e orquestrar sua execução na classe Main, exploramos os conceitos básicos de criação de threads, sincronização e medição de desempenho. Embora a abordagem síncrona ofereça simplicidade, adotar o multithreading pode significativamente aprimorar o desempenho e a responsividade da aplicação. À medida que você continua sua jornada, aprofundar-se no gerenciamento de threads, mecanismos de sincronização e utilitários avançados de concorrência o capacitará a construir aplicações robustas e eficientes.
SEO Keywords: multi-threaded applications, Java multi-threading, thread management, synchronous execution, Thread.sleep, Java Thread class, concurrency in Java, improving application performance, beginner's guide to multi-threading, creating threads in Java
Nota: Este artigo foi gerado por IA.









---
Recursos Adicionais

Documentação Oracle Java: Threads
Java Concurrency in Practice por Brian Goetz
TutorialsPoint: Java Multithreading
Baeldung: Introdução às Threads em Java
GeeksforGeeks: Multithreading em Java

---

Benefício	Descrição
Desempenho Aprimorado	Permite a execução de múltiplas operações em paralelo, reduzindo o tempo total de execução.
Melhoria na Responsividade	Mantém as aplicações responsivas realizando tarefas de fundo sem interromper o processo principal.
Utilização de Recursos	Maximiza o uso da CPU distribuindo tarefas entre múltiplas threads.
Escalabilidade	Facilita a criação de aplicações escaláveis capazes de lidar com cargas de trabalho aumentadas.

### Spanish

html


Creando Aplicaciones Multithread: Una Guía Completa
Tabla de Contenidos

1. Introducción ................................................................................... 3
2. Entendiendo Aplicaciones Multithread ... 5

2.1 ¿Qué es Multithreading? .................................... 6
2.2 Beneficios de Multithreading .......................... 7
2.3 Métodos Clave en Multithreading .................... 8

3. Construyendo una Aplicación Multithread ............... 10

3.1 Configurando el Proyecto .......................................... 11
3.2 Creando la Clase MyCounter ............................ 13
3.3 Implementando el Método Main ............................ 16
3.4 Agregando Thread Sleep .................................................... 19
3.5 Midiendo el Tiempo de Ejecución .................................... 21

4. Ejecución Síncrona vs. Multithread .... 24
5. Conclusión ................................................................................... 28
6. Recursos Adicionales ....................................................... 29

---
Introducción
En el mundo en rápida evolución del desarrollo de software, entender cómo gestionar efectivamente múltiples tareas simultáneamente es crucial. Las aplicaciones Multi-threaded permiten a los desarrolladores realizar múltiples operaciones concurrentemente, mejorando el rendimiento y la capacidad de respuesta. Este eBook profundiza en las complejidades de las aplicaciones multithread, guiándote a través de la creación de un programa multithread simple. Ya seas un principiante o un desarrollador con conocimientos básicos, esta guía ofrece un camino claro y conciso para dominar el multithreading en Java.
---
Entendiendo Aplicaciones Multithread
¿Qué es Multithreading?
Multithreading es una técnica de programación que permite que múltiples threads se ejecuten concurrentemente dentro de un solo proceso. Cada thread representa una ruta de ejecución independiente, permitiendo que las tareas se realicen simultáneamente. Esto es particularmente beneficioso para aplicaciones que requieren alto rendimiento y capacidad de respuesta, como servidores web, motores de juegos y sistemas de procesamiento de datos en tiempo real.
Beneficios de Multithreading


Beneficio
Descripción


Rendimiento Mejorado
Permite la ejecución de múltiples operaciones en paralelo, reduciendo el tiempo total de ejecución.


Mejora de la Capacidad de Respuesta
Mantiene las aplicaciones responsivas realizando tareas en segundo plano sin interrumpir el proceso principal.


Utilización de Recursos
Maximiza el uso de la CPU distribuendo tareas entre múltiples threads.


Escalabilidad
Facilita la creación de aplicaciones escalables capaces de manejar cargas de trabajo incrementadas.


Métodos Clave en Multithreading
Entender los métodos fundamentales asociados con el multithreading es esencial para una implementación efectiva. Algunos de los métodos clave incluyen:

start(): Inicia un nuevo thread.
run(): Contiene el código que el thread ejecuta.
sleep(long millis): Pausa el thread por una duración especificada.
wait(): Hace que el thread actual espere hasta que otro thread invoque notify().
yield(): Sugiere que el thread actual está dispuesto a ceder su uso actual de un procesador.

Estos métodos forman la columna vertebral de la gestión y sincronización de threads en Java.
---
Construyendo una Aplicación Multithread
Configurando el Proyecto
Para comenzar a construir nuestra aplicación multithread, configuraremos un proyecto Java. Asegúrate de tener instalado el Java Development Kit (JDK) en tu máquina. Usar un Entorno de Desarrollo Integrado (IDE) como IntelliJ IDEA o Eclipse puede simplificar el proceso.
Estructura del Proyecto:




		
		
			
			
Java
			
			S12L02 - Creating thread by extending the thread class/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/
│   │           └── studyeasy/
│   │               ├── Main.java
│   │               └── MyCounter.java
│   └── test/
│       └── java/
├── target/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						S12L02 - Creating thread by extending the thread class/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/
│   │           └── studyeasy/
│   │               ├── Main.java
│   │               └── MyCounter.java
│   └── test/
│       └── java/
├── target/
					
				
			
		


Nota: El archivo pom.xml se utiliza para la configuración del proyecto en Maven.
Creando la Clase MyCounter
La clase MyCounter sirve como la base de nuestra aplicación multithread. Contiene la lógica para contar y mostrar los valores de iteración.




		
		
			
			
Java
			
			
package org.studyeasy;

public class MyCounter {
    private int threadNumber;

    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }

    // Method to perform counting
    public void countMe() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						 
package org.studyeasy;
 
public class MyCounter {
    private int threadNumber;
 
    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }
 
    // Method to perform counting
    public void countMe() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
        }
    }
}
 
					
				
			
		


Explicación:

threadNumber: Identifica el thread, ayudando a distinguir las salidas de múltiples threads.
Constructor: Inicializa el threadNumber.
countMe(): Itera de 0 a 9, imprimiendo el número del thread actual y la cuenta de iteración.

Implementando el Método Main
La clase Main orquesta la creación y ejecución de múltiples instancias de MyCounter.




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}
 
					
				
			
		


Explicación:

counter1 & counter2: Instancian objetos MyCounter con números de thread distintos.
countMe(): Invoca el método de conteo para cada contador.
Separator: Mejora la legibilidad distinguiendo las salidas de diferentes threads.

Salida:




		
		
			
			
Java
			
			Thread 1: Iteration 0
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
Thread 2: Iteration 1
...
Thread 2: Iteration 9
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						Thread 1: Iteration 0
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
Thread 2: Iteration 1
...
Thread 2: Iteration 9
					
				
			
		


Agregando Thread Sleep
Para simular retrasos en el procesamiento y observar la ejecución síncrona, introduciremos el método sleep.




		
		
			
			
Java
			
			
package org.studyeasy;

public class MyCounter {
    private int threadNumber;

    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }

    // Method to perform counting with sleep
    public void countMe() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
            Thread.sleep(500); // Pauses the thread for 500 milliseconds
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						 
package org.studyeasy;
 
public class MyCounter {
    private int threadNumber;
 
    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }
 
    // Method to perform counting with sleep
    public void countMe() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
            Thread.sleep(500); // Pauses the thread for 500 milliseconds
        }
    }
}
 
					
				
			
		


Explicación:

Thread.sleep(500): Introduce una pausa de 500 milisegundos después de cada iteración, simulando tiempo de procesamiento.
throws InterruptedException: Indica que el método puede lanzar una InterruptedException, lo que requiere manejo de excepciones en el método main.

Método Main Actualizado:




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}
 
					
				
			
		


Salida con Sleep:




		
		
			
			
Java
			
			Thread 1: Iteration 0
(Thread pauses for 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(Thread pauses for 500ms)
Thread 2: Iteration 1
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						Thread 1: Iteration 0
(Thread pauses for 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(Thread pauses for 500ms)
Thread 2: Iteration 1
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
					
				
			
		


Nota: El tiempo total coincide con las duraciones acumulativas de sleep, destacando la ejecución síncrona.
Midiendo el Tiempo de Ejecución
Para evaluar el impacto de la sincronización en el rendimiento, mediremos el tiempo total de ejecución.




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();

        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Displaying separator
        System.out.println("**********");

        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();

        long endTime = System.currentTimeMillis();
        System.out.println("Total time required for processing: " + (endTime - startTime)/1000 + " seconds");
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
 
        // Creating first counter
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Displaying separator
        System.out.println("**********");
 
        // Creating second counter
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
 
        long endTime = System.currentTimeMillis();
        System.out.println("Total time required for processing: " + (endTime - startTime)/1000 + " seconds");
    }
}
 
					
				
			
		


Explicación:

startTime & endTime: Capturan el tiempo actual del sistema antes y después de la ejecución.
Total Time Calculation: Resta startTime de endTime para determinar la duración total del procesamiento.

Ejemplo de Salida:




		
		
			
			
Java
			
			Thread 1: Iteration 0
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
			
				
					
				
					1
2
3
4
5
6
7
8
				
						Thread 1: Iteration 0
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
...
Thread 2: Iteration 9
Total time required for processing: 10 seconds
					
				
			
		


Nota: El tiempo total coincide con las duraciones acumulativas de sleep, destacando la ejecución síncrona.
---
Ejecución Síncrona vs. Multithread
En la implementación actual, la aplicación se ejecuta de forma síncrona, lo que significa que cada thread completa su ejecución antes de que el siguiente comience. Esto resulta en un tiempo de procesamiento acumulativo proporcional al número de threads.
Características de la Ejecución Síncrona:

Procesamiento Secuencial: Un thread se ejecuta a la vez.
Comportamiento Predecible: Fácil de rastrear el flujo de ejecución.
Tiempo de Procesamiento Mayor: El tiempo total aumenta con el número de threads.

Ventajas de la Ejecución Multithread:

Procesamiento Concurrente: Múltiples threads se ejecutan simultáneamente.
Reducción del Tiempo Total: El tiempo de ejecución disminuye a medida que los threads operan en paralelo.
Mayor Responsividad: Las aplicaciones permanecen responsivas, especialmente en aplicaciones GUI.

Para transicionar de ejecución síncrona a multithread, utilizaremos la clase Thread de Java o implementaremos la interfaz Runnable, permitiendo que los threads se ejecuten concurrentemente.
---
Conclusión
Esta guía proporcionó una comprensión fundamental de las aplicaciones multithread en Java. Al crear una clase MyCounter simple y orquestar su ejecución en la clase Main, exploramos los conceptos básicos de creación de threads, sincronización y medición de desempeño. Mientras que el enfoque síncrono ofrece simplicidad, adoptar el multithreading puede mejorar significativamente el rendimiento y la responsividad de las aplicaciones. A medida que continúas tu viaje, profundizar en la gestión de threads, mecanismos de sincronización y utilidades avanzadas de concurrencia te capacitará para construir aplicaciones robustas y eficientes.
SEO Keywords: multi-threaded applications, Java multi-threading, thread management, synchronous execution, Thread.sleep, Java Thread class, concurrency in Java, improving application performance, beginner's guide to multi-threading, creating threads in Java
Nota: Este artículo fue generado por IA.









---
Recursos Adicionales

Documentación de Oracle Java: Threads
Java Concurrency in Practice por Brian Goetz
TutorialsPoint: Java Multithreading
Baeldung: Introducción a Threads en Java
GeeksforGeeks: Multithreading en Java

---

Beneficio	Descripción
Rendimiento Mejorado	Permite la ejecución de múltiples operaciones en paralelo, reduciendo el tiempo total de ejecución.
Mejora de la Capacidad de Respuesta	Mantiene las aplicaciones responsivas realizando tareas en segundo plano sin interrumpir el proceso principal.
Utilización de Recursos	Maximiza el uso de la CPU distribuendo tareas entre múltiples threads.
Escalabilidad	Facilita la creación de aplicaciones escalables capaces de manejar cargas de trabajo incrementadas.