LayeredCQExamples

All Implemented Interfaces:
```
public class LayeredCQExamples

                    
```
Examples demonstrating layered queueing networks with contention queues (CQ). This class provides Java implementations corresponding to the Kotlin notebooks in jline.examples.kotlin.advanced.layeredCQ package.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description

Field Summary

Fields
Modifier and Type	Field	Description

Constructor Summary

Constructors
Constructor	Description
`LayeredCQExamples()`

Enum Constant Summary

Enum Constants
Enum Constant	Description

Method Summary

Modifier and Type	Method	Description
`static void`	`lcq_singlehost()`	Demonstrates a layered CQ model with a single host (lcq_singlehost.ipynb).
`static void`	`lcq_threehosts()`	Demonstrates a layered CQ model with three hosts (lcq_threehosts.ipynb).
`static void`	`main(Array<String> args)`	Main method to run all layered CQ examples.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - LayeredCQExamples
```
LayeredCQExamples()
```
- Method Detail
  - lcq_singlehost
```
 static void lcq_singlehost()
```
    Demonstrates a layered CQ model with a single host (lcq_singlehost.ipynb). This example shows a basic layered queueing network where software tasks execute on a single host. The model captures both software contention (at the task level) and hardware contention (at the host level), typical in client-server architectures. Features: - Single host with multiple software tasks - Nested queueing structure (software and hardware layers) - Analysis of software bottlenecks vs. hardware bottlenecks - Mean value analysis for layered networks
  - lcq_threehosts
```
 static void lcq_threehosts()
```
    Demonstrates a layered CQ model with three hosts (lcq_threehosts.ipynb). This example extends the single host case to a distributed system with three hosts. Different software tasks are deployed on different hosts, creating a more complex interaction pattern typical of multi-tier architectures. Features: - Three hosts with distributed software tasks - Inter-host communication patterns - Analysis of distributed system bottlenecks - Load balancing considerations in layered networks
  - main
```
 static void main(Array<String> args)
```
    Main method to run all layered CQ examples.
    
    Parameters:
    
    args - command line arguments (not used)