Publication Guidelines

Article Presentation

Articles must be submitted in digital format (preferably .txt) and must adhere to the following guidelines:

• Format:.txt, .doc or .docx
• Submission email: na.sabbag@gmail.com

Article Structure (in sequence)

• Portuguese Abstract:

  Maximum of 50 words.

  Example:

• English Abstract:

  Maximum of 50 words.

  Example:

• Portuguese Keywords:

  At least 6 terms that describe the content of the article.

  Example:

• English Keywords:

  At least 6 terms that describe the content of the article.

  Example:

• Portuguese Title:

  Should accurately reflect the article’s content. Maximum of 100 characters.

  Example:

• English Title:

  Should accurately reflect the article’s content. Maximum of 100 characters.

  Example:

• Portuguese Body (HTML format):

  Provide a clear and detailed development of the article.

  Example:

  <div> <h2>Introdução ao Controle de Concorrência</h2> <p>O controle de concorrência é um conceito fundamental em programação multithread. Enquanto um programa sequencial possui apenas uma thread ativa em qualquer momento da execução, em um programa concorrente há várias threads ativas <a href="#references">(GABBRIELLI; MARTINI, 2023)</a>.</p> <p>O controle de concorrência permite que múltiplas threads acessem recursos compartilhados de maneira segura e eficiente. Quando o acesso a esses recursos não é gerenciado adequadamente, podem ocorrer problemas sérios, como condições de corrida, deadlocks e violações de dados <a href="#references">(ANTONINO et al., 2022)</a>. </p> <p>Neste artigo, vamos explorar o uso da classe <code class="language-csharp">SemaphoreSlim</code> em C# como uma solução eficaz para gerenciar a concorrência em aplicações multithread. Veremos como essa classe pode facilitar o desenvolvimento de aplicações robustas e eficientes, protegendo-as contra os riscos associados ao acesso simultâneo a recursos compartilhados.</p> <h3>Introdução ao SemaphoreSlim</h3> <p>A classe <code class="language-csharp">SemaphoreSlim</code> em C# é uma implementação leve do conceito de semáforo, que serve para limitar o número de threads que podem acessar um determinado recurso simultaneamente <a href="#references">(JUNIOR; MANÇANO, 2021)</a>. Diferente do semáforo tradicional, que é mais pesado e pode introduzir sobrecargas desnecessárias em aplicações de alta concorrência, o <code class="language-csharp">SemaphoreSlim</code> é otimizado para cenários onde o número de threads concorrentes é relativamente pequeno. Isso o torna ideal para operações de I/O, onde o acesso a recursos externos, como arquivos ou bancos de dados, é comum <a href="#references">(MICROSOFT, 2025)</a>.</p> <h3>Funcionamento</h3> <p>A classe <code class="language-csharp">SemaphoreSlim</code> permite que você especifique um número máximo de threads que podem acessar um recurso ao mesmo tempo <a href="#references">(MICROSOFT, 2025)</a>. Quando uma thread tenta acessar o recurso, ela chama o método <code class="language-csharp">Wait()</code>. Se o número máximo de threads já estiver em uso, a thread ficará bloqueada até que uma thread liberada chame o método <code class="language-csharp">Release()</code>. A implementação é simples e eficaz, permitindo que desenvolvedores implementem controle de concorrência com facilidade.</p> <pre><code class="language-csharp">using System; using System.Threading; class Program { private static SemaphoreSlim semaphore = new SemaphoreSlim(2); // Permite 2 threads static void Main() { for (int i = 0; i < 10; i++) { new Thread(AccessResource).Start(i); } } static void AccessResource(object id) { Console.WriteLine($"Thread {id} aguardando para acessar o recurso."); semaphore.Wait(); try { Console.WriteLine($"Thread {id} acessando o recurso."); Thread.Sleep(2000); // Simula trabalho } finally { Console.WriteLine($"Thread {id} liberando o recurso."); semaphore.Release(); } } }</code></pre> <h2>Implementação prática do SemaphoreSlim</h2> <p>Vamos considerar um cenário onde várias threads precisam acessar um banco de dados. Nesse caso, podemos usar <code class="language-csharp">SemaphoreSlim</code> para limitar o número de conexões simultâneas. Isso pode ajudar a evitar sobrecargas no servidor e garantir que as consultas sejam executadas de maneira eficiente <a href="#references">(MICROSOFT, 2025)</a>. Com <code class="language-csharp">SemaphoreSlim</code>, podemos evitar que muitas threads acessem o banco de dados ao mesmo tempo, o que pode resultar em lentidão ou falhas na aplicação.</p> <pre><code class="language-csharp">using System; using System.Collections.Generic; using System.Threading; using System.Threading.Tasks; class DatabaseAccess { private static SemaphoreSlim semaphore = new SemaphoreSlim(3); // Limita a 3 conexões public async Task AccessDatabase(int id) { await semaphore.WaitAsync(); try { Console.WriteLine($"Thread {id} acessando o banco de dados."); await Task.Delay(1000); // Simula uma operação de banco de dados } finally { Console.WriteLine($"Thread {id} liberando a conexão."); semaphore.Release(); } } } class Program { static async Task Main() { var dbAccess = new DatabaseAccess(); var tasks = new List<Task>(); for (int i = 0; i < 10; i++) { tasks.Add(dbAccess.AccessDatabase(i)); } await Task.WhenAll(tasks); } }</code></pre> <h3>Vantagens do Uso de SemaphoreSlim</h3> <p>O uso de <code class="language-csharp">SemaphoreSlim</code> oferece várias vantagens significativas:</p> <ul> <li><strong>Desempenho:</strong> É mais leve que o semáforo tradicional, resultando em melhor desempenho em cenários de alta concorrência.</li> <li><strong>Facilidade de Uso:</strong> O procedimento é simples e direto, facilitando a implementação em aplicações existentes, mesmo para desenvolvedores iniciantes.</li> <li><strong>Suporte Assíncrono:</strong> Suporta operações assíncronas, permitindo que você escreva código mais responsivo e que não bloqueia o thread principal.</li> <li><strong>Flexibilidade:</strong> Permite a configuração de um número variável de permissões, que pode ser ajustado conforme a necessidade do aplicativo.</li> </ul> <h3>Considerações ao Usar SemaphoreSlim</h3> <p>Embora o <code class="language-csharp">SemaphoreSlim</code> seja uma ferramenta poderosa, existem algumas considerações importantes que os desenvolvedores devem ter em mente:</p> <ul> <li><strong>Não Substitui Locks:</strong> Para proteção de seção crítica, o uso de <code class="language-csharp">lock</code> deve ser considerado em vez de <code class="language-csharp">SemaphoreSlim</code>. O <code class="language-csharp">lock</code> é mais adequado para situações onde é necessário garantir que apenas uma thread execute um bloco de código específico.</li> <li><strong>Evitar Deadlocks:</strong> Certifique-se de que as threads liberem o semáforo em todos os cenários, mesmo em caso de exceções. Isso pode ser feito colocando a chamada para <code class="language-csharp">Release()</code> dentro de um bloco <code class="language-csharp">finally</code>.</li> <li><strong>Limitação de Recursos:</strong> O número de permissões deve ser cuidadosamente avaliado para não restringir excessivamente o desempenho da aplicação. Um número muito baixo de permissões pode levar a tempos de espera excessivos, enquanto um número muito alto pode causar sobrecarga no sistema.</li> </ul> <h2>Exemplo Avançado: Controle de Acesso a um Serviço Externo</h2> <p>Considere um cenário em que um serviço externo possui limitações de taxa. Podemos usar <code class="language-csharp">SemaphoreSlim</code> para garantir que não ultrapassamos o número máximo de requisições simultâneas. Isso é particularmente útil em serviços de API, onde as chamadas são limitadas por regras de uso.</p> <pre><code class="language-csharp">using System; using System.Net.Http; using System.Threading; using System.Threading.Tasks; class ApiClient { private static SemaphoreSlim semaphore = new SemaphoreSlim(5); // Limita a 5 requisições public async Task<string> FetchData(string url) { await semaphore.WaitAsync(); try { using (var client = new HttpClient()) { Console.WriteLine($"Requisição para {url} em andamento."); var response = await client.GetStringAsync(url); return response; } } finally { Console.WriteLine($"Requisição para {url} concluída."); semaphore.Release(); } } } class Program { static async Task Main() { var apiClient = new ApiClient(); var tasks = new List<Task>(); string[] urls = { "http://example.com/1", "http://example.com/2", "http://example.com/3" }; foreach (var url in urls) { tasks.Add(apiClient.FetchData(url)); } await Task.WhenAll(tasks); } }</code></pre> <h2>Conclusão</h2> <p>O <code class="language-csharp">SemaphoreSlim</code> é uma ferramenta essencial para o controle de concorrência em aplicações multithread em C#. Ele fornece um meio eficiente e fácil de gerenciar o acesso a recursos compartilhados, assegurando que a aplicação mantenha um desempenho adequado e evite problemas comuns de concorrência. Ao implementar <code class="language-csharp">SemaphoreSlim</code>, é importante considerar o contexto em que ele será utilizado e como ele se encaixa na lógica da aplicação. Com uma abordagem cuidadosa e uma implementação adequada, o <code class="language-csharp">SemaphoreSlim</code> pode ser uma solução eficaz para garantir a segurança e a eficiência em ambientes multithread.</p> </div>
• English Body (HTML format):

  Provide a clear and detailed development of the article.

  Example:

  <div> <h2>Introduction to Concurrency Control</h2> <p>Concurrency control is a fundamental concept in multithreaded programming. While a sequential program has only one active thread at any time during execution, a concurrent program has multiple active threads <a href="#references">(GABBRIELLI; MARTINI, 2023)</a>.</p> <p>Concurrency control allows multiple threads to access shared resources safely and efficiently. When access to these resources is not properly managed, serious problems can occur, such as race conditions, deadlocks, and data breaches <a href="#references">(ANTONINO et al., 2022)</a>.</p> <p>In this article, we will explore the use of the <code class="language-csharp">SemaphoreSlim</code> class in C# as an effective solution for managing concurrency in multithreaded applications. We will see how this class can facilitate the development of robust and efficient applications, protecting them against the risks associated with simultaneous access to shared resources.</p> <h3>Introduction to SemaphoreSlim</h3> <p>The <code class="language-csharp">SemaphoreSlim</code> class in C# is a lightweight implementation of the semaphore concept, which serves to limit the number of threads that can access a given resource simultaneously <a href="#references">(JUNIOR; MANÇANO, 2021)</a>. Unlike traditional semaphores, which are heavier and can introduce unnecessary overhead in high-concurrency applications, <code class="language-csharp">SemaphoreSlim</code> is optimized for scenarios where the number of concurrent threads is relatively small. This makes it ideal for I/O operations, where access to external resources, such as files or databases, is common <a href="#references">(MICROSOFT, 2025)</a>.</p> <h3>How It Works</h3> <p>The <code class="language-csharp">SemaphoreSlim</code> class allows you to specify a maximum number of threads that can access a resource at the same time <a href="#references">(MICROSOFT, 2025)</a>. When a thread attempts to access the resource, it calls the <code class="language-csharp">Wait()</code> method. If the maximum number of threads is already in use, the thread will be blocked until a released thread calls the <code class="language-csharp">Release()</code> method. The implementation is simple and effective, allowing developers to easily implement concurrency control.</p> <pre><code class="language-csharp">using System; using System.Threading; class Program { private static SemaphoreSlim semaphore = new SemaphoreSlim(2); // Allows 2 threads static void Main() { for (int i = 0; i < 10; i++) { new Thread(AccessResource).Start(i); } } static void AccessResource(object id) { Console.WriteLine($"Thread {id} waiting to access the resource."); semaphore.Wait(); try { Console.WriteLine($"Thread {id} accessing the resource."); Thread.Sleep(2000); // Simulates work } finally { Console.WriteLine($"Thread {id} releasing the resource."); semaphore.Release(); } } }</code></pre> <h3>Practical Implementation of SemaphoreSlim</h3> <p>Let’s consider a scenario where multiple threads need to access a database. In this case, we can use <code class="language-csharp">SemaphoreSlim</code> to limit the number of simultaneous connections. This can help avoid server overload and ensure that queries are executed efficiently <a href="#references">(MICROSOFT, 2025)</a>. With <code class="language-csharp">SemaphoreSlim</code>, we can prevent too many threads from accessing the database at the same time, which could lead to slowdowns or application failures.</p> <pre><code class="language-csharp">using System; using System.Collections.Generic; using System.Threading; using System.Threading.Tasks; class DatabaseAccess { private static SemaphoreSlim semaphore = new SemaphoreSlim(3); // Limits to 3 connections public async Task AccessDatabase(int id) { await semaphore.WaitAsync(); try { Console.WriteLine($"Thread {id} accessing the database."); await Task.Delay(1000); // Simulates a database operation } finally { Console.WriteLine($"Thread {id} releasing the connection."); semaphore.Release(); } } } class Program { static async Task Main() { var dbAccess = new DatabaseAccess(); var tasks = new List<Task>(); for (int i = 0; i < 10; i++) { tasks.Add(dbAccess.AccessDatabase(i)); } await Task.WhenAll(tasks); } }</code></pre> <h3>Advantages of Using SemaphoreSlim</h3> <p>The use of <code class="language-csharp">SemaphoreSlim</code> offers several significant advantages:</p> <ul> <li><strong>Performance:</strong> It is lighter than traditional semaphores, resulting in better performance in high-concurrency scenarios.</li> <li><strong>Ease of Use:</strong> The procedure is simple and straightforward, making it easy to implement in existing applications, even for beginner developers.</li> <li><strong>Asynchronous Support:</strong> Supports asynchronous operations, allowing you to write more responsive code that does not block the main thread.</li> <li><strong>Flexibility:</strong> Allows for the configuration of a variable number of permissions, which can be adjusted according to the needs of the application.</li> </ul> <h3>Considerations When Using SemaphoreSlim</h3> <p>Although <code class="language-csharp">SemaphoreSlim</code> is a powerful tool, there are some important considerations that developers should keep in mind:</p> <ul> <li><strong>Does Not Replace Locks:</strong> For critical section protection, the use of <code class="language-csharp">lock</code> should be considered instead of <code class="language-csharp">SemaphoreSlim</code>. The <code class="language-csharp">lock</code> is more suitable for situations where it is necessary to ensure that only one thread executes a specific block of code.</li> <li><strong>Avoid Deadlocks:</strong> Ensure that threads release the semaphore in all scenarios, even in the event of exceptions. This can be done by placing the call to <code class="language-csharp">Release()</code> within a <code class="language-csharp">finally</code> block.</li> <li><strong>Resource Limitation:</strong> The number of permissions should be carefully evaluated to avoid excessively restricting the performance of the application. A very low number of permissions can lead to excessive waiting times, while a very high number can cause system overload.</li> </ul> <h3>Advanced Example: Access Control to an External Service</h3> <p>Consider a scenario where an external service has rate limitations. We can use <code class="language-csharp">SemaphoreSlim</code> to ensure that we do not exceed the maximum number of simultaneous requests. This is particularly useful in API services, where calls are limited by usage rules.</p> <pre><code class="language-csharp">using System; using System.Net.Http; using System.Threading; using System.Threading.Tasks; class ApiClient { private static SemaphoreSlim semaphore = new SemaphoreSlim(5); // Limits to 5 requests public async Task<string> FetchData(string url) { await semaphore.WaitAsync(); try { using (var client = new HttpClient()) { Console.WriteLine($"Request to {url} in progress."); var response = await client.GetStringAsync(url); return response; } } finally { Console.WriteLine($"Request to {url} completed."); semaphore.Release(); } } } class Program { static async Task Main() { var apiClient = new ApiClient(); var tasks = new List<Task>(); string[] urls = { "http://example.com/1", "http://example.com/2", "http://example.com/3" }; foreach (var url in urls) { tasks.Add(apiClient.FetchData(url)); } await Task.WhenAll(tasks); } }</code></pre> <h3>Conclusion</h3> <p>The <code class="language-csharp">SemaphoreSlim</code> is an essential tool for concurrency control in multithreaded applications in C#. It provides an efficient and easy means to manage access to shared resources, ensuring that the application maintains adequate performance and avoids common concurrency issues. When implementing <code class="language-csharp">SemaphoreSlim</code>, it is important to consider the context in which it will be used and how it fits into the application logic. With careful consideration and proper implementation, <code class="language-csharp">SemaphoreSlim</code> can be an effective solution for ensuring safety and efficiency in multithreaded environments.</p> </div>
• Body Artifacts:

  Include only text, code, and .drawio diagrams (in draw.io, diagrams must be in English).

• Portuguese References:

  Preferably follow ABNT standards or relevant field-specific citation style.

  Example:

• English References:

  Preferably follow ABNT standards or relevant field-specific citation style.

  Example:

• Link References:

  Provide reference URLs.

  Example:

• Author LinkedIn Link:

  Provide your LinkedIn profile link.

  Example:

• Portuguese Author Resume:

  Provide a short author bio in Portuguese.

  Example:

  <a href="https://leaders.tec.br/nagib">Nagib</a> é Professor Universitário e Arquiteto Líder de Sistemas, com uma trajetória marcada por diversas conquistas em certificações técnicas e ágeis, incluindo o <a href="https://www.credly.com/badges/347e9c69-4c69-41b5-8b89-ad385d7f6b65">GitHub Copilot</a> e o <a href="https://www.scrum.org/user/501597">PSM1</a>. Com duas pós-graduações Lato Sensu (SENAC e Mackenzie) e um MBA em Tecnologia de Software pela USP, Nagib também participou de programas de extensão do <a href="https://scl.io/csmJcPe">MIT</a> e <a href="https://sgq.io/wG2PIGA">Universidade de Chicago</a>. Entre outras realizações, é autor de um <a href="https://scholar.google.com.br/scholar?oi=bibs&cluster=15911391760633391312&btnI=1&hl=pt-BR">artigo sobre chatbots</a>, revisado por pares e apresentado presencialmente na <a href="https://www.iacsit.org/index.php?m=content&c=index&a=show&catid=16&id=649">Universidade de Barcelona</a>. Nagib também possui forte atuação na comunidade técnica, com mais de <a href="https://leaders.tec.br/nagib">40 artigos técnicos</a> publicados em menos de um ano, incluindo <a href="https://imasters.com.br/perfil/nagibsabbagfilho">8 artigos no iMasters</a>. Foi palestrante na trilha "Arquitetura .NET" no <a href="https://thedevconf.com/tdc/2024/sao-paulo/trilha-arquitetura-net">TDC São Paulo 2024</a> e está confirmado para palestrar na trilha "Arquitetura de Soluções" no <a href="https://thedevconf.com/palestrante/nagib-sabbag-filho">TDC Floripa 2025</a>.
• English Author Resume:

  Provide a short author bio in English.

  Example:

  <a href="https://leaders.tec.br/nagib">Nagib</a> is a University Professor and Lead Systems Architect, with a career marked by various achievements in technical and agile certifications, including <a href="https://www.credly.com/badges/347e9c69-4c69-41b5-8b89-ad385d7f6b65">GitHub Copilot</a> and <a href="https://www.scrum.org/user/501597">PSM1</a>. With two Lato Sensu postgraduate degrees (SENAC and Mackenzie) and an MBA in Software Technology from USP, Nagib also participated in extension programs at <a href="https://scl.io/csmJcPe">MIT</a> and <a href="https://sgq.io/wG2PIGA">the University of Chicago</a>. Among other achievements, he is the author of a <a href="https://scholar.google.com.br/scholar?oi=bibs&cluster=15911391760633391312&btnI=1&hl=pt-BR">peer-reviewed article on chatbots</a>, presented in person at <a href="https://www.iacsit.org/index.php?m=content&c=index&a=show&catid=16&id=649">the University of Barcelona</a>. Nagib also has a strong presence in the technical community, with more than <a href="https://leaders.tec.br/nagib">40 technical articles</a> published in less than a year, including <a href="https://imasters.com.br/perfil/nagibsabbagfilho">8 articles on iMasters</a>. He was a speaker in the ".NET Architecture" track at <a href="https://thedevconf.com/tdc/2024/sao-paulo/trilha-arquitetura-net">TDC São Paulo 2024</a> and is confirmed to speak in the "Solutions Architecture" track at <a href="https://thedevconf.com/palestrante/nagib-sabbag-filho">TDC Floripa 2025</a>.

Copyright

By submitting an article, the author agrees to transfer the copyright to the journal upon acceptance. The author is also responsible for ensuring the originality and authenticity of the submitted content.

Publication Ethics

The journal adheres to strict ethical standards. Any suspicion of plagiarism, data fabrication, or other misconduct will be investigated and may result in rejection or corrective measures.

Contact

For questions regarding these guidelines, please contact the editorial team at na.sabbag@gmail.com.