Channels are the preferred way to communicate between coroutines. V’s channels work basically like those in Go. You can push objects into a channel on one end and pop objects from the other end. Channels can be buffered or unbuffered and it is possible to select from multiple channels.

    Syntax and Usage

    Channels have the type chan objtype. An optional buffer length can specified as the cap property in the declaration:

    1. ch := chan int{}          // unbuffered - "synchronous"
    2. ch2 := chan f64{cap: 100} // buffer length 100

    Channels do not have to be declared as mut. The buffer length is not part of the type but a property of the individual channel object. Channels can be passed to coroutines like normal variables:

    1. import sync
    3. fn f(ch chan int) {
    4.     // ...
    5. }
    7. fn main() {
    8.     ch := chan int{}
    9.     go f(ch)
    10.     // ...
    11. }

    A channel can be closed to indicate that no further objects can be pushed. Any attempt to do so will then result in a runtime panic (with the exception of select and try_push() - see below). Attempts to pop will return immediately if the associated channel has been closed and the buffer is empty. This situation can be handled using an or branch (see ).

    1. mut ch := chan int{}
    2. mut ch2 := chan f64{}
    3. // ...
    4. ch.close()
    5. // ...
    6. m := <-ch or {
    7.     println('channel has been closed')
    8. }
    10. // propagate error
    11. y := <-ch2 ?

    Channel Select

    The select command allows monitoring several channels at the same time without noticeable CPU load. It consists of a list of possible transfers and associated branches of statements - similar to the match command:

    1. import time
    2. fn main () {
    3.   mut ch := chan f64{}
    5.   mut ch3 := chan f64{}
    6.   mut b := 0.0
    7.   // ...
    8.   select {
    9.     a := <-ch {
    10.         // do something with `a`
    11.     }
    12.     b = <-ch2 {
    13.         // do something with predeclared variable `b`
    14.     }
    15.     ch3 <- c {
    16.         // do something if `c` was sent
    17.     }
    18.     > 500 * time.millisecond {
    19.         // do something if no channel has become ready within 0.5s
    20.     }
    21.   }
    22. }

    The timeout branch is optional. If it is absent select waits for an unlimited amount of time. It is also possible to proceed immediately if no channel is ready in the moment select is called by adding an else { ... } branch. else and > timeout are mutually exclusive.

    Special Channel Features

    For special purposes there are some builtin properties and methods:

    1. import sync
    3. struct Abc{x int}
    5. a := 2.13
    6. mut ch := chan f64{}
    8. res := ch.try_push(a)      // try to perform `ch <- a`
    9. println(res)
    10. l := ch.len                // number of elements in queue
    11. println(l)
    12. println(c)
    14. // mut b := Abc{}
    15. // mut ch2 := chan f64{}
    16. // res2 := ch2.try_pop(mut b) // try to perform `b = <-ch2

    The try_push/pop() methods will return immediately with one of the results .success, .not_ready or .closed - dependent on whether the object has been transferred or the reason why not. Usage of these methods and properties in production is not recommended - algorithms based on them are often subject to race conditions. Use select instead.

    Data can be exchanged between a coroutine and the calling thread via a shared variable. Such variables should be created as references and passed to the coroutine as mut. The underlying struct should also contain a mutex to lock concurrent access:

    1. import sync
    3. struct St {
    4. mut:
    5.     x   int // share data
    6.     mtx &sync.Mutex
    7. }
    9. fn (mut b St) g() {
    10.     b.mtx.m_lock()
    11.     // read/modify/write b.x
    12.     b.mtx.unlock()
    13. }
    15. fn caller() {
    16.     mut a := &St{ // create as reference so it's on the heap
    17.         x: 10
    18.         mtx: sync.new_mutex()
    19.     }
    20.     go a.g()
    21.     a.mtx.m_lock()
    22.     // read/modify/write a.x
    24. }