S12L02 - Criando uma thread estendendo a classe Thread

html


Criando Aplicações Multi-Threaded: Um Guia Abrangente
Índice

1. Introdução ................................................................................... 3
2. Compreendendo Aplicações Multi-Threaded ... 5

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

3. Construindo uma Aplicação Multi-Threaded ............... 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 Medindo o Tempo de Execução .................................... 21

4. Execução Síncrona vs. Multi-Threaded .... 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 múltiplas tarefas simultaneamente é crucial. Aplicações multi-threaded permitem que desenvolvedores executem múltiplas operações concorrentemente, melhorando o desempenho e a capacidade de resposta. Este eBook explora as complexidades das aplicações multi-threaded, guiando você pela criação de um programa multi-threaded simples. Seja você um iniciante ou um desenvolvedor com conhecimento básico, este guia oferece um caminho claro e conciso para dominar o multi-threading em Java.
---
Compreendendo Aplicações Multi-Threaded
O que é Multi-Threading?
Multi-threading é uma técnica de programação que permite que múltiplas threads sejam executadas concorrentemente dentro de um único processo. Cada thread representa um caminho independente de execução, permitindo que tarefas sejam realizadas simultaneamente. Isso é particularmente benéfico para aplicações que requerem alto desempenho e capacidade de resposta, como servidores web, motores de jogos e sistemas de processamento de dados em tempo real.
Benefícios do Multi-Threading


Benefício
Descrição


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


Capacidade de Resposta Melhorada
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 através de 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 Multi-Threading
Compreender os métodos fundamentais associados ao multi-threading é 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 esteja disposta a ceder seu uso atual de um processador.

Estes métodos formam a espinha dorsal do gerenciamento e sincronização de threads em Java.
---
Construindo uma Aplicação Multi-Threaded
Configurando o Projeto
Para começar a construir nossa aplicação multi-threaded, 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 multi-threaded. Ela contém a lógica para contar e exibir 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, auxiliando na distinção da 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 coordena 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 as 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, vamos introduzir 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); // Pausa a thread por 500 milissegundos
        }
    }
}

			
				
					
				
					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); // Pausa a thread por 500 milissegundos
        }
    }
}
 
					
				
			
		


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, necessitando de tratamento de exceção no método main.

Método Main 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.
Medindo o Tempo de Execução
Para avaliar o impacto da sincronização no desempenho, vamos medir 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.

Saída de Exemplo:




		
		
			
			
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. Multi-Threaded
Na implementação atual, a aplicação é executada 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 acumulativo proporcional ao número de threads.
Características da Execução Síncrona:

Processamento Sequencial: Uma thread é executada de cada vez.
Comportamento Previsível: Fácil de rastrear o fluxo de execução.
Tempo de Processamento Mais Longo: O tempo total aumenta com o número de threads.

Vantagens da Execução Multi-Threaded:

Processamento Concorrente: Múltiplas threads são executadas simultaneamente.
Redução do Tempo Total: O tempo de execução diminui à medida que as threads operam em paralelo.
Capacidade de Resposta Aprimorada: Aplicações permanecem responsivas, especialmente em aplicações GUI.

Para transitar da execução síncrona para a multi-threaded, vamos utilizar a classe Thread do Java ou implementar a interface Runnable, permitindo que as threads sejam executadas concorrentemente.
---
Conclusão
Este guia forneceu uma compreensão fundamental das aplicações multi-threaded em Java. Ao criar uma simples classe MyCounter e coordenar 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 multi-threading pode aprimorar significativamente o desempenho e a capacidade de resposta das aplicações. À medida que você continua sua jornada, aprofundar-se no gerenciamento de threads, mecanismos de sincronização e utilitários avançados de concorrência permitirá que você construa 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 que múltiplas operações sejam executadas em paralelo, reduzindo o tempo total de execução.
Capacidade de Resposta Melhorada	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 através de múltiplas threads.
Escalabilidade	Facilita a criação de aplicações escaláveis capazes de lidar com cargas de trabalho aumentadas.

---

html


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

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

2.1 什么是Multi-Threading？ .................................... 6
2.2 Multi-Threading的好处 .......................... 7
2.3 Multi-Threading中的关键方法 .................... 8

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

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

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

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


好处
描述


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


改善响应能力
通过执行后台任务而不打断主进程，使应用程序保持响应。


资源利用
通过在多个线程间分配任务，最大化 CPU 的使用率。


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


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

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

这些方法构成了 Java 中线程管理和同步的基础。
---
构建一个多线程应用程序
设置项目
要开始构建我们的 multi-threaded application，我们将设置一个 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 application 的基础。它包含用于计数和显示迭代值的逻辑。




		
		
			
			
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); // 暂停线程 500 毫秒
        }
    }
}

			
				
					
				
					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); // 暂停线程 500 毫秒
        }
    }
}
 
					
				
			
		


解释：

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
(线程暂停 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(线程暂停 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
(线程暂停 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(线程暂停 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: 减去 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
					
				
			
		


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

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

多线程执行的优势：

并发处理: 多个线程同时运行。
减少总时间: 执行时间随着线程并行运行而减少。
增强响应能力: 应用程序保持响应，特别是在 GUI 应用程序中。

要从同步执行转向多线程执行，我们将利用 Java 的 Thread 类或实现 Runnable 接口，允许线程同时运行。
---
结论
本指南提供了对 Java 中 multi-threaded applications 的基础理解。通过创建一个简单的 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 文档：Threads
《Java Concurrency in Practice》作者 Brian Goetz
TutorialsPoint: Java Multithreading
Baeldung: Java 中线程简介
GeeksforGeeks: Java 中的 Multithreading

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

---

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 applications는 개발자가 여러 작업을 동시에 수행할 수 있게 하여 성능과 반응성을 향상시킵니다. 이 전자책은 multi-threaded applications의 복잡성을 파고들어 간단한 multi-threaded 프로그램을 만드는 과정을 안내합니다. 초보자이든 기본 지식을 가진 개발자이든 관계없이 이 가이드는 Java에서 multi-threading을 마스터하는 명확하고 간결한 경로를 제공합니다.
---
멀티스레드 애플리케이션 이해하기
멀티스레딩이란?
Multi-threading은 단일 프로세스 내에서 여러 스레드가 동시에 실행될 수 있도록 하는 프로그래밍 기술입니다. 각 스레드는 독립적인 실행 경로를 나타내어 작업을 동시에 수행할 수 있게 합니다. 이는 web servers, gaming engines 및 real-time data processing systems와 같은 높은 성능과 반응성이 요구되는 애플리케이션에 특히 유용합니다.
멀티스레딩의 장점


장점
설명


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


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


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


확장성
증가된 작업 부하를 처리할 수 있는 확장 가능한 애플리케이션 생성에 도움이 됩니다.


멀티스레딩의 주요 메서드
멀티스레딩과 관련된 기본 메서드를 이해하는 것은 효과적인 구현에 필수적입니다. 주요 메서드에는 다음이 포함됩니다:

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

이러한 메서드는 Java에서 스레드 관리 및 동기화의 근간을 이룹니다.
---
멀티스레드 애플리케이션 구축
프로젝트 설정
멀티스레드 애플리케이션을 구축하기 시작하려면 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); // 스레드를 500 밀리초 동안 일시 정지
        }
    }
}

			
				
					
				
					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); // 스레드를 500 밀리초 동안 일시 정지
        }
    }
}
 
					
				
			
		


설명:

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 applications에 대한 기초적인 이해를 제공했습니다. 간단한 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 문서: Threads
Brian Goetz의 Java Concurrency in Practice
TutorialsPoint: Java Multithreading
Baeldung: Java에서 Threads 소개
GeeksforGeeks: Java에서 Multithreading

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

---

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

---
परिचय
सॉफ्टवेयर विकास की तेजी से विकसित हो रही दुनिया में, एक साथ कई कार्यों को प्रभावी ढंग से प्रबंधित करना समझना महत्वपूर्ण है। मल्टी-थ्रेडेड एप्लिकेशन डेवलपर्स को कई ऑपरेशन्स को साथ-साथ निष्पादित करने में सक्षम बनाते हैं, जिससे प्रदर्शन और प्रतिक्रियाशीलता बढ़ती है। यह ईबुक मल्टी-थ्रेडेड एप्लिकेशन की पेचीदगियों में गहराई से उतरता है, आपको एक सरल मल्टी-थ्रेडेड प्रोग्राम बनाने के माध्यम से मार्गदर्शन करता है। चाहे आप शुरुआती हों या बुनियादी ज्ञान वाले डेवलपर, यह मार्गदर्शिका जावा में मल्टी-थ्रेडिंग को मास्टर करने के लिए एक स्पष्ट और संक्षिप्त पथ प्रदान करती है।
---
मल्टी-थ्रेडेड एप्लिकेशन को समझना
मल्टी-थ्रेडिंग क्या है?
मल्टी-थ्रेडिंग एक प्रोग्रामिंग तकनीक है जो एक ही प्रक्रिया के भीतर कई थ्रेड्स को एक साथ चलाने की अनुमति देती है। प्रत्येक थ्रेड स्वतंत्र निष्पादन पथ का प्रतिनिधित्व करता है, जिससे कार्यों को एक साथ पूरा किया जा सकता है। यह विशेष रूप से उन एप्लिकेशनों के लिए फायदेमंद है जिन्हें उच्च प्रदर्शन और प्रतिक्रियाशीलता की आवश्यकता होती है, जैसे कि web servers, gaming engines, और real-time data processing systems।
मल्टी-थ्रेडिंग के लाभ


लाभ
विवरण


परफॉर्मेंस में सुधार
एक ही समय में कई ऑपरेशन्स को निष्पादित करने की अनुमति देता है, कुल निष्पादन समय को कम करता है।


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


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


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


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

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

ये विधियाँ जावा में थ्रेड प्रबंधन और सिंक्रोनाइज़ेशन की रीढ़ हैं।
---
एक मल्टी-थ्रेडेड एप्लिकेशन बनाना
परियोजना सेटअप करना
हमारी मल्टी-थ्रेडेड एप्लिकेशन बनाने के लिए, हम एक 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 क्लास हमारी मल्टी-थ्रेडेड एप्लिकेशन की नींव के रूप में कार्य करता है। इसमें काउंटिंग और पुनरावृत्ति मानों को डिस्प्ले करने के लिए लॉजिक शामिल है।




		
		
			
			
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); // थ्रेड को 500 मिलीसेकंड के लिए रोकता है
        }
    }
}

			
				
					
				
					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); // थ्रेड को 500 मिलीसेकंड के लिए रोकता है
        }
    }
}
 
					
				
			
		


व्याख्या:

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 अवधि के अनुरूप है, जो सिंक्रोनस निष्पादन को हाइलाइट करता है।
---
सिंक्रोनस बनाम मल्टी-थ्रेडेड निष्पादन
वर्तमान कार्यान्वयन में, एप्लिकेशन सिंक्रोनस रूप से चलता है, जिसका अर्थ है कि प्रत्येक थ्रेड अपना निष्पादन पूरा करता है इससे पहले कि अगला शुरू हो। इससे कुल प्रोसेसिंग समय थ्रेड की संख्या के समानुपाती रूप से बढ़ जाता है।
सिंक्रोनस निष्पादन की विशेषताएं:

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

मल्टी-थ्रेडेड निष्पादन के लाभ:

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

सिंक्रोनस निष्पादन से मल्टी-थ्रेडेड निष्पादन में संक्रमण करने के लिए, हम Java की Thread क्लास का उपयोग करेंगे या Runnable इंटरफेस को लागू करेंगे, जिससे थ्रेड्स एक साथ चल सकते हैं।
---
निष्कर्ष
इस मार्गदर्शिका ने जावा में multi-threaded applications की बुनियादी समझ प्रदान की। एक सरल MyCounter क्लास बनाकर और इसे Main क्लास में निष्पादित करके, हमने थ्रेड निर्माण, सिंक्रोनाइज़ेशन और प्रदर्शन माप के मूल बातें explored। जबकि सिंक्रोनस दृष्टिकोण सरलता प्रदान करता है, multi-threading को अपनाना एप्लिकेशन के प्रदर्शन और प्रतिक्रियाशीलता को काफी हद तक बढ़ा सकता है। जैसे ही आप अपनी यात्रा जारी रखते हैं, थ्रेड प्रबंधन, सिंक्रोनाइज़ेशन मेकेनिज्म, और उन्नत concurrency utilities में गहराई से उतरना आपको मजबूत और कुशल एप्लिकेशन बनाने में सशक्त करेगा।
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 दस्तावेज़: Threads
Java Concurrency in Practice लेखक Brian Goetz
TutorialsPoint: Java Multithreading
Baeldung: Java में Threads की परिचय
GeeksforGeeks: जावा में Multithreading

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

---

html


Creando Aplicaciones Multi-Threaded: Una Guía Integral
Tabla de Contenidos

1. Introducción ................................................................................... 3
2. Comprendiendo Aplicaciones Multi-Threaded ... 5

2.1 ¿Qué es Multi-Threading? .................................... 6
2.2 Beneficios del Multi-Threading .......................... 7
2.3 Métodos Clave en Multi-Threading .................... 8

3. Construyendo una Aplicación Multi-Threaded ............... 10

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

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

---
Introducción
En el mundo en rápida evolución del desarrollo de software, comprender cómo gestionar eficazmente múltiples tareas simultáneamente es crucial. Multi-threaded applications permiten a los desarrolladores realizar múltiples operaciones de manera concurrente, mejorando el rendimiento y la capacidad de respuesta. Este eBook profundiza en las complejidades de las multi-threaded applications, guiándote a través de la creación de un programa multi-threaded simple. Ya seas un principiante o un desarrollador con conocimientos básicos, esta guía ofrece una vía clara y concisa para dominar el multi-threading en Java.
---
Comprendiendo Aplicaciones Multi-Threaded
¿Qué es Multi-Threading?
Multi-threading es una técnica de programación que permite que múltiples threads se ejecuten simultáneamente dentro de un solo proceso. Cada thread representa una ruta de ejecución independiente, lo que permite que las tareas se realicen al mismo tiempo. 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 del Multi-Threading


Beneficio
Descripción


Mejora del Rendimiento
Permite que múltiples operaciones se ejecuten en paralelo, reduciendo el tiempo total de ejecución.


Mayor Capacidad de Respuesta
Mantiene las aplicaciones responsivas realizando tareas de fondo sin interrumpir el proceso principal.


Utilización de Recursos
Maximiza el uso de la CPU distribuyendo tareas a través de múltiples threads.


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


Métodos Clave en Multi-Threading
Comprender los métodos fundamentales asociados con el multi-threading es esencial para una implementación eficaz. 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 de threads y sincronización en Java.
---
Construyendo una Aplicación Multi-Threaded
Configurando el Proyecto
Para comenzar a construir nuestra multi-threaded application, 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 multi-threaded application. Contiene la lógica para contar y mostrar 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 la salida de múltiples threads.
Constructor: Inicializa el threadNumber.
countMe(): Itera de 0 a 9, imprimiendo el número del thread actual y el conteo de iteración.

Implementando el Método Main
La clase Main coordina 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
					
				
			
		


Añadiendo 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); // Pausa el thread por 500 milisegundos
        }
    }
}

			
				
					
				
					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); // Pausa el thread por 500 milisegundos
        }
    }
}
 
					
				
			
		


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, requiriendo 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 se alinea 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.

Salida de Ejemplo:




		
		
			
			
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 se alinea con las duraciones acumulativas de sleep, destacando la ejecución síncrona.
---
Ejecución Síncrona vs. Multi-Threaded
En la implementación actual, la aplicación se ejecuta de manera síncrona, lo que significa que cada thread completa su ejecución antes de que comience el siguiente. 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 ejecuta a la vez.
Comportamiento Predecible: Fácil de rastrear el flujo de ejecución.
Tiempo de Procesamiento Prolongado: El tiempo total aumenta con el número de threads.

Ventajas de la Ejecución Multi-Threaded:

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 Capacidad de Respuesta: Las aplicaciones permanecen reactivas, especialmente en aplicaciones GUI.

Para pasar de la ejecución síncrona a la multi-threaded, utilizaremos la clase Thread de Java o implementaremos la interfaz Runnable, permitiendo que los threads se ejecuten de manera concurrente.
---
Conclusión
Esta guía proporcionó una comprensión fundamental de las multi-threaded applications en Java. Al crear una clase MyCounter simple y coordinar su ejecución en la clase Main, exploramos los conceptos básicos de creación de threads, sincronización y medición de rendimiento. Mientras que el enfoque síncrono ofrece simplicidad, adoptar el multi-threading puede mejorar significativamente el rendimiento y la capacidad de respuesta 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 empoderará 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
Mejora del Rendimiento	Permite que múltiples operaciones se ejecuten en paralelo, reduciendo el tiempo total de ejecución.
Mayor Capacidad de Respuesta	Mantiene las aplicaciones responsivas realizando tareas de fondo sin interrumpir el proceso principal.
Utilización de Recursos	Maximiza el uso de la CPU distribuyendo tareas a través de múltiples threads.
Escalabilidad	Facilita la creación de aplicaciones escalables capaces de manejar cargas de trabajo incrementadas.

---