Home
Getting Started
Current Status
Documentation
- frostc
- Syntax
  - Keywords
  - Statements
    - Assignment
    - Method Calls
    - if
    - for
    - while
    - do
    - loop
    - break
    - continue
    - return
    - assert
    - unreachable
    - match
    - try
  - Expressions
  - Annotations
  - Comments
  - Documentation Comments
  - Error Handling
- Classes
  - Interfaces
  - Choices
  - Values
  - Immutability
  - Packages
    - Uses
  - Generics
  - Bare Code
- Methods
- Fields
- Types
- Variables and Constants
- Memory
  - Weak References
- Threads
API Documentation
- frostcollections Array Collection CollectionView CollectionWriter DefaultHashMap HashKey HashMap HashSet IdentityMap IdentitySet ImmutableArray Iterable Iterator List ListView ListWriter Map MapView MapWriter Stack core Bit Char16 Char32 Char8 Comparable Equatable Error Formattable Immutable Int Int16 Int32 Int64 Int8 Matcher Maybe MutableString Index MutableValue Object Range Real32 Real64 RegularExpression SteppedRange String Index Match System Process UInt UInt16 UInt32 UInt64 UInt8 Value Weak io ByteOrder Console File IndentedOutputStream InputStream LineNumberInputStream MemoryInputStream MemoryOutputStream OutputStream PushbackInputStream math Random XorShift128Plus threads Lock MessageQueue Notifier ScopedLock Thread time Timer unsafe Pointer UnsafeMessageQueue

Threads

A thread is an independent stream of execution. A complete program may consist of many threads, all running different code at the same time.

Threads are created by the Thread.start(()=&>*()) method, passing in the method to run in the background. The method will run asynchronously in a separate system thread.

Example:

class ThreadExample {
    @class
    method count() {
        for i in 0 .. 1000 {
            Console.printLine("background: " + i)
        }
    }

    @class
    method doOtherThings() {
        for i in 0 .. 1000 {
            Console.printLine("foreground: " + i)
        }
    }

    @class
    method main() {
        Thread.start(ThreadExample.count)
        -- we have now started counting in the background, but we can keep 
        -- doing things in the foreground
        doOtherThings()
    }
}

Threads communicate with each other by passing messages using MessageQueues. Normally, threads may only exchange immutable data. Combined with the fact that there is no global mutable state, this means that under normal circumstances threads may not see each other's mutable data and therefore there is no need for mutexes, semaphores, or other synchronization constructs unless the clearly-marked unsafe APIs have been used.