PreemptChannelSupport

All Implemented Interfaces:
```
public abstract class PreemptChannelSupport

                    
```
The preemptive channel concurrency pattern, there are two channels: preemptive channel and normal channel
TODO: compare with ReadWriteLock
- both channel allows multiple threads
- new workers have to wait until there is no ready preemptive tasks nor running preemptive tasks
- a preemptive task locks the working channel immediately, but have to wait to run util all workers are finished
  |------ waiting ------------|- ready -|-------------- critical -------------------|---finished----
```
                      The entrance gate                                    The exit gate
```
Preemptive channel: ------------#1--#1--#1------|----#2---|-----------------------------------#3-------|--- #4 -------- | | | Normal channel: ----*1----*1--*1------*1----|---------|-----------*2--*2------*2--*2---------------|--- *3 --------
#1 The waiting preemptive tasks #2 The ready preemptive tasks #3 The running preemptive tasks #4 The finished preemptive tasks
*1 The waiting workers *2 The running workers *3 The finished workers

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description

Field Summary

Fields
Modifier and Type	Field	Description
`private final Boolean`	`isPreempted`
`private final Boolean`	`isNormal`
`private final Boolean`	`hasEvent`
`private final String`	`name`

Constructor Summary

Constructors
Constructor	Description
`PreemptChannelSupport(String name)`

Enum Constant Summary

Enum Constants
Enum Constant	Description

Method Summary

Modifier and Type	Method	Description
`final Boolean`	`isPreempted()`
`final Boolean`	`isNormal()`
`final Boolean`	`getHasEvent()`
`final String`	`getName()`
`final <T extends Any> T`	`preempt(Function0<T> preemptiveTask)`	If there is at least one preemptive task in the critical section, all normal tasks must wait.
`final <T extends Any> T`	`whenNormal(Function0<T> task)`
`final <T extends Any> T`	`whenNormalDeferred(SuspendFunction0<T> task)`
`final Unit`	`releaseLocks()`
`final String`	`formatPreemptChannelStatus()`

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

Constructor Detail
- PreemptChannelSupport
```
PreemptChannelSupport(String name)
```

Method Detail

isPreempted
```
 final Boolean isPreempted()
```

isNormal
```
 final Boolean isNormal()
```

getHasEvent
```
 final Boolean getHasEvent()
```

getName
```
 final String getName()
```

preempt
```
 final <T extends Any> T preempt(Function0<T> preemptiveTask)
```
If there is at least one preemptive task in the critical section, all normal tasks must wait.

whenNormal

 final <T extends Any> T whenNormal(Function0<T> task)

whenNormalDeferred

 final <T extends Any> T whenNormalDeferred(SuspendFunction0<T> task)

releaseLocks
```
 final Unit releaseLocks()
```

formatPreemptChannelStatus

 final String formatPreemptChannelStatus()