Channel (programming)

<h2 id="libthread-channels">libthread channels</h2>
<p>The <a href="/facts/Multithreading_(computer_architecture)/ojEKsSNP">multithreading</a> library, libthread, which was first created for the operating system <a href="/facts/Plan_9_from_Bell_Labs/pQjPlS7w">Plan 9</a>, offers inter-thread communication based on fixed-size channels.
</p>
<h2 id="ocaml-events">OCaml events</h2>
<p>The <a href="/facts/OCaml/ThBGLND8">OCaml</a> event module offers typed channels for synchronization. When the module's send and receive functions are called, they create corresponding send and receive events which can be synchronized.
</p>
<h2 id="examples">Examples</h2>
<h3>Lua Love2D</h3><p>
The <a href="/facts/L%25C3%25B6ve_(game_engine)/MRybbLMG">Love2D</a> library which uses the <a href="/facts/Lua_(programming_language)/xkBCgta0">Lua</a> programming language implements channels with push and pop operations similar to stacks. The pop operation will block so as long as there is data resident on the stack. A demand operation is equivalent to pop, except it will block until there is data on the stack</p>-- A string containing code which will be interpreted by a function such as loadstring(),
-- but on the C side to start a native thread.

local threadCode = [[
    love.thread.getChannel("test"):push("Hello world!")
]]

function love.load()
    -- Start the thread.
    
    thread = love.thread.newThread(threadCode)
    thread:start()
    
    -- The thread will block until "Hello world!" is popped off channel test's stack.
    -- Because the channel can be popped from before the thread first executes, there may not be data on the stack.
    -- in that case use :demand() instead of :pop() because :demand() will block until there is data on the stack and then return the data.
    
    print(love.thread.getChannel("test"):demand())
    
    -- The thread can now finish.
end

<h3>XMOS XC</h3>
<p>The <a href="/facts/XMOS/QluHmnd6">XMOS</a> programming language <a href="/facts/XC_(programming_language)/QluHmnd6">XC</a> provides a primitive type "Chan" and two operators "<:" and ":>" for sending and receiving data from a channel.<a class="footnote-ref" id="fnref:1" href="#fn:1"><sup>1</sup></a>
</p><p>In this example, two hardware threads are started on the XMOS, running the two lines in the "par" block. The first line transmits the number 42 through the channel while the second waits until it is received and sets the value of x. The XC language also allows asynchronous receiving on channels through a select statement.
</p>
chan c;
int x;
par {
  c <: 42;
  c :> x;
}

<h3>Go</h3>
<p>This snippet of <a href="/facts/Go_(programming_language)/oWlsmAFJ">Go</a> code performs similarly to the XC code. First the channel c is created, then a <a href="/facts/Goroutine/oWlsmAFJ">goroutine</a> is spawned which sends 42 through the channel. When the number is put in the channel x is set to 42. Go allows channels to buffer contents, as well as non blocking receiving through the use of a select block.<a class="footnote-ref" id="fnref:2" href="#fn:2"><sup>2</sup></a>
</p>
c := make(chan int)

go func() {c <- 42}()

x := <- c

<h3>Rust</h3>
<p><a href="/facts/Rust_(programming_language)/8JNMV19F">Rust</a> provides asynchronous channels for communication between threads. Channels allow a unidirectional flow of information between two endpoints: the Sender and the Receiver.<a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a>
</p>
use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

thread::spawn(move || {
        tx.send(123).unwrap();
    });

let result = rx.recv();
    println!("{:?}", result);
}

<h2 id="applications">Applications</h2>
<p>In addition to their fundamental use for interprocess communication, channels can be used as a primitive to implement various other concurrent programming constructs which can be realized as streams. For example, channels can be used to construct <a href="/facts/Futures_and_promises/5Mpgxv4m">futures and promises</a>, where a future is a one-element channel, and a promise is a process that sends to the channel, fulfilling the future.<a class="footnote-ref" id="fnref:4" href="#fn:4"><sup>4</sup></a> Similarly, <a href="/facts/Iterator/f0HhTBWz">iterators</a> can be constructed directly from channels.<a class="footnote-ref" id="fnref:5" href="#fn:5"><sup>5</sup></a>
</p>
<h2 id="list-of-implementations">List of implementations</h2>
<p>List of non-standard, library-based implementations of channels
</p>
<ul><li>For Scala:
<ul><li>CSO -- Communicating Scala Objects<a class="footnote-ref" id="fnref:6" href="#fn:6"><sup>6</sup></a> is a complete DSL for channel-based communication and concurrency whose semantic primitives are generalizations of the OCCAM primitives. CSO has been used since 2007 in the teaching of concurrent programming, and relevant lectures can be found with the ThreadCSO implementation.<a class="footnote-ref" id="fnref:7" href="#fn:7"><sup>7</sup></a></li></ul></li></ul>
<ul><li>For C++:
<ul><li>stlab<a class="footnote-ref" id="fnref:8" href="#fn:8"><sup>8</sup></a> This implementation supports splits, and different merge and zip operations. Different executors can be attached to the individual nodes.</li></ul></li></ul>
<ul><li>For Rust:
<ul><li><a href="/facts/Tokio_(software)/kCGcMhnU">Tokio</a></li></ul></li></ul>

<h2 id="external-links">External links</h2>
<ul><li><a href="https://github.com/brho/plan9/blob/master/sys/src/libthread/channel.c">Libthread Channel Implementation</a></li>
<li><a href="http://swtch.com/~rsc/thread/">Bell Labs and CSP Threads</a></li>
<li><a href="http://www.vitanuova.com/inferno/limbo.html">Limbo – Inferno Application Programming</a></li>
<li><a href="https://web.archive.org/web/20071202115445/http://www.stackless.com/wiki/Channels">Stackless.com – Channels</a></li>
<li><a href="http://caml.inria.fr/pub/docs/manual-ocaml/libref/Event.html">– OCaml Events</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>"XMOS Programming Guide | XMOS". Archived from the original on 2016-03-04. Retrieved 2015-05-10. <a href="https://web.archive.org/web/20160304132653/https://www.xmos.com/node/17653?version=&page=23" target="_blank">https://web.archive.org/web/20160304132653/https://www.xmos.com/node/17653?version=&page=23</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>"Effective Go - the Go Programming Language". <a href="https://golang.org/doc/effective_go.html#channels" target="_blank">https://golang.org/doc/effective_go.html#channels</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>"Channels - Rust By Example". doc.rust-lang.org. Retrieved 28 November 2020. <a href="https://doc.rust-lang.org/rust-by-example/std_misc/channels.html" target="_blank">https://doc.rust-lang.org/rust-by-example/std_misc/channels.html</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
<li id="fn:4"><p>"Futures Archived 2020-12-04 at the Wayback Machine", Go Language Patterns Archived 2020-11-11 at the Wayback Machine <a href="https://sites.google.com/site/gopatterns/concurrency/futures" target="_blank">https://sites.google.com/site/gopatterns/concurrency/futures</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li>
<li id="fn:5"><p>"Iterators Archived 2020-10-15 at the Wayback Machine", Go Language Patterns Archived 2020-11-11 at the Wayback Machine <a href="https://sites.google.com/site/gopatterns/object-oriented/iterators" target="_blank">https://sites.google.com/site/gopatterns/object-oriented/iterators</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li>
<li id="fn:6"><p>Sufrin, Bernard (2021-07-13), ThreadCSO (PDF), retrieved 2023-02-17 <a href="https://github.com/sufrin/ThreadCSO/blob/5f8ef6eebdfd8e001e45af18fea52fec36ff7ddd/Lectures/cso-paper.pdf" target="_blank">https://github.com/sufrin/ThreadCSO/blob/5f8ef6eebdfd8e001e45af18fea52fec36ff7ddd/Lectures/cso-paper.pdf</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></p></li>
<li id="fn:7"><p>Sufrin, Bernard (2021-07-13), ThreadCSO, retrieved 2023-02-17 <a href="https://github.com/sufrin/ThreadCSO" target="_blank">https://github.com/sufrin/ThreadCSO</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></p></li>
<li id="fn:8"><p>"stlab is the ongoing work of what was Adobe's Software Technology Lab. The Adobe Source Libraries (ASL), Platform Libraries, and new stlab libraries are hosted on github". 2021-01-31. <a href="https://stlab.cc/libraries/concurrency" target="_blank">https://stlab.cc/libraries/concurrency</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></p></li>
</ol>

Channel (programming) open-in-new

Channel (programming)