PreemptChannelSupport

```
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 freeze nor running freezer
- a freezer 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

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)`

Method Summary

Modifier and Type	Method	Description
`final Boolean`	`getIsPreempted()`
`final Boolean`	`getIsNormal()`
`final Boolean`	`getHasEvent()`
`final String`	`getName()`
`final <T extends Any> T`	`preempt(Function0<T> preemptiveTask)`	The freezer is preemptive, if there is at least one freezer task attempt enter the critical section without obtaining a lock, all task attempt 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

getIsPreempted
```
 final Boolean getIsPreempted()
```

getIsNormal
```
 final Boolean getIsNormal()
```

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

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

preempt
```
 final <T extends Any> T preempt(Function0<T> preemptiveTask)
```
The freezer is preemptive, if there is at least one freezer task attempt enter the critical section without obtaining a lock, all task attempt 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()