Class: OperationQueue

• Inheritance
• Description
• Related information
• Class protocol
  • instance creation
• Instance protocol
  • accessing
  • consumer
  • debugging support
  • initialization
  • producer
  • queries
• Private classes
• Examples

Inheritance:

   Object
   |
   +--OperationQueue

Package:

stx:libbasic2

Category:

Kernel-Processes

Version:

rev: 1.11 date: 2019/05/16 12:54:03

user: stefan

file: OperationQueue.st directory: libbasic2

module: stx stc-classLibrary: libbasic2

Author:

Martin Walser

Claus Gittinger

Description:

An operationQueue allows operations (i.e. actions) to be evaluated in
a first-come-first-serve queue like fashion. A single consumer process
waits for orders to be enqueued and evaluates them (as they come).
Producer processes which want to have some operation performed may
enqueue these. Producers are suspended, until the operation is finished.
If multiple orders which compare equal are enqueued by multiple producers,
the operation is only evaluated once, and both producers will wake up when
the operation has finished.

Related information:

    SharedQueue
    Queue

Class protocol:

 new

 new: n

Instance protocol:

 consumerProcess

return the value of the instance variable 'consumerProcess' (automatically generated)

 consumerProcessPriority

return the value of the instance variable 'consumerProcessPriority' (automatically generated)

 consumerProcessPriority: something

set the value of the instance variable 'consumerProcessPriority' (automatically generated)

 fetchNextOperationAndExecute

dequeue the next order, evaluate it and wake up waiters

 startConsumerProcess

 stopConsumerProcess

 copyContextChain: aContext

dequeue the next order, evaluate it and wake up waiters

 linkContextChain: aConsumerChain

for debugging - concatenate aConsumerChain to my own context chain (to make debugging easier)

 initializeLock

 scheduleOperation: anotherOperation

enqueue an order (something that understands #value) to the op-queue;
wait until the operation has performed (#value been sent),
return the result of the #value send.
If a similar order is already in the queue, wait for that one to finish.

 scheduleOperation: anotherOperation asynchronous: asynchronous

enqueue an order (something that understands #value) to the op-queue;
if asynchronous is false, wait until the operation has performed (#value been sent),
return the result of the #value send.
If a similar order is already in the queue, wait for that one to finish.
If asynchronous is true, do not wait (but also: do not return a return value)

 size

return the number of operations in the queue

Private classes:

    OperationInQueue

Examples:

    |opQ|

    opQ := OperationQueue new.
    opQ scheduleOperation:[ Transcript showCR:'hello world-1'].
    opQ scheduleOperation:[ Transcript showCR:'hello world-2'].

only 10 outputs (same operation entered by multiple producers):

    |p1 p2 p3 opQ order|

    opQ := OperationQueue new.
    order := [ Transcript showCR:'hello world '].
    p1 := [
            1 to:10 do:[:i |
                opQ scheduleOperation:order.
            ]
          ] fork.
    p2 := [
            1 to:10 do:[:i |
                opQ scheduleOperation:order.
            ]
          ] fork.
    p3 := [
            1 to:10 do:[:i |
                opQ scheduleOperation:order.
            ]
          ] fork.