Add Virtual Threads documentation with 60 examples

[Copilot]

Create comprehensive technical documentation for Virtual Threads (Project Loom) in Java, covering creation patterns, performance characteristics, integration with existing APIs, and best practices.

Note: This PR is incomplete due to technical issues during implementation. The task requires:

• Introduction: Define virtual threads, purpose, and differences from platform threads
• Background: History of Java concurrency, limitations of traditional threading
• Core Concepts: Lightweight JVM-managed threads, decoupling from OS threads
• Creation Patterns: Thread.ofVirtual().start(), Executors.newVirtualThreadPerTaskExecutor()
• Performance: Millions of concurrent tasks, reduced memory footprint
• Integration: Blocking I/O compatibility, structured concurrency, scoped values
• Use Cases: Server-side applications, parallel data processing
• Limitations: Thread-local restrictions, debugging challenges, migration pitfalls
• Best Practices: Guidelines for virtual vs platform threads, monitoring

Document should follow repository conventions:

void main() throws InterruptedException {

    var thread = Thread.startVirtualThread(() -> {
        println("Virtual thread running");
    });
    
    thread.join();
}

Style requirements: 80-char lines, Java 25 compact source files, implicit imports, void main() entry points, explanations after each code block.

Warning

Firewall rules blocked me from connecting to one or more addresses (expand for details)

I tried to connect to the following addresses, but was blocked by firewall rules:

• https://api.github.com//advisories
  • Triggering command: /home/REDACTED/work/_temp/ghcca-node/node/bin/node /home/REDACTED/work/_temp/ghcca-node/node/bin/node --enable-source-maps /home/REDACTED/work/_temp/copilot-developer-action-main/dist/index.js (http block)

If you need me to access, download, or install something from one of these locations, you can either:

• Configure Actions setup steps to set up my environment, which run before the firewall is enabled
• Add the appropriate URLs or hosts to the custom allowlist in this repository's Copilot coding agent settings (admins only)

Original prompt

On virtual-threads.md, Create a detailed technical document explaining Virtual Threads in Java (Project Loom). create 60 examples.

The document should include:

Introduction

Define virtual threads and their purpose.
Explain how they differ from traditional platform threads.
Highlight why Project Loom was introduced.
Background

Brief history of Java concurrency (threads, executors, fork/join).
Limitations of traditional threading (resource-heavy, scalability issues).
What are Virtual Threads?

Explain the concept of lightweight threads managed by the JVM.
Describe how they decouple concurrency from OS threads.
Provide diagrams showing the difference between platform threads and virtual threads.
Creating Virtual Threads

Show code examples using Thread.ofVirtual().start(...).
Demonstrate usage with Executors.newVirtualThreadPerTaskExecutor().
Compare syntax with traditional thread creation.
Performance and Scalability

Explain how virtual threads allow millions of concurrent tasks.
Discuss reduced memory footprint and context-switching overhead.
Provide benchmarks or conceptual comparisons.
Integration with Existing APIs

Show how virtual threads work seamlessly with blocking I/O.
Explain compatibility with existing Java concurrency utilities.
Discuss structured concurrency (scoped values, task grouping).
Use Cases

Server-side applications (handling thousands of requests).
Parallel data processing.
Simplifying asynchronous programming.
Limitations and Considerations

Current restrictions (e.g., thread-local usage, debugging challenges).
Potential pitfalls when migrating from traditional threads.
Discuss maturity and adoption status.
Best Practices

Guidelines for when to use virtual threads vs platform threads.
Tips for writing scalable, maintainable concurrent code.
Monitoring and profiling virtual-thread applications.
Conclusion

Summarize the importance of virtual threads.
Emphasize how they simplify concurrency and improve scalability in modern Java.
Formatting Requirements:

Use clear section headings.
Include code snippets for clarity.
Provide diagrams or tables to illustrate differences between thread models.
Write in a professional, educational tone suitable for intermediate to advanced Java developers.
Ensure the document is cohesive, well-organized, and easy to follow.

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.