Prepare multi-threading with core.async

image


This increasingly popular pattern used when creating
multi-threaded applications. The idea is not new, its design is founded in 1978.
as CSP.The most famous implementation of the now universally used in Golang.


We're in the paper, we consider the implementation of the CSP core.for async in Clojure, if you're interested, welcome to under the cat.



the article discusses the simple and basic practices for working with core.async described in the article would be enough for a good start in multi-threaded programming.


In contrast to Golang where the paradigm of threading through the channels built into the language core.async is just a library for Clojure, if you are impressed with another paradigm, then the choice is: pulsar, promesa, manifold


this core.async and promesa can also be used on the browser side in ClojureScript, of course, in this case, none of what multithreading can not speak, because all that stuff is compiled into ES5 and executed in a browser, but a familiar and comfortable interface to work with the async may well serve.


So what gives us the core.async? If to explain on fingers that core.we provides async dispatch through go-blocks in your fixed Thread Pool with 8 threads (the Thread Pool size can be changed using a special option). When a message arrives in the channel core.async itself will find the free flow, and will give him a task, or put the message in the queue. Who first hears about the Thread Pool, you can read a note on pattern Worker Thread



Example 1


the 
(defonce log-chan (chan))

(defn loop-worker [msg]
(println msg))

(go-loop []
(let [msg (<! log-chan)]
(loop-worker msg)
(recur)))

In the example above, we create a channel log-chan, and determined the function of a loop-worker that will process messages from the channel.Then created a go-block with the endless cycle, put our loop-worker.Now we can send data to a channel: (>!! log-chan "Hello")


the Function loop-worker was submitted separately for the go-block intentionally, for the sake of convenient debugging via the REPL.


the body of a go-loop as this macro is baked somewhere inside the core.async, and recompiling it on the fly in the REPL is a strange character, so the handler is easier to make separately and live in peace.


it is worth noting that there is no infinite loop in the usual understanding of go-loop does not.
After receiving the message, is a one-time execution of the handler function, and then go block is parked with <! which will wait for a new message. Thus, you can create a lot of channels and handlers for them.


within the go-block read function from the channel <! carries out the Parking of the thread.
Outside the go block it is possible to use to read from the channel function <!! which blocks the main thread until the message is received. The behavior of <!! can be compared with the function of the await keyword in ES7.


Parking is a go block, it is a term core.async means that the thread is released and available for other tasks. There is also the term blocking, which means that the stream will be immediately blocked and is not available for new task until it is freed.


In example # 1 there is a flaw, if the loop-worker will be called Exception, it will interrupt the execution of the form, and (recur) will never be called, thus waiting for data from the channel log-chan will stop, correct this in example # 2.


Example 2


the 
(defonce log-chan (chan))

(defn loop-worker [msg]
(throw (Exception. "my exception message")))

(go-loop []
(let [msg (<! log-chan)
res (try
(loop-worker msg)
:ok
(catch Exception e
(println (.getMessage e))
:error))]
(recur)))

In this example, we wrapped the whole call loop-worker in the form try and res will contain a flag indicating a successful execution or error. This flag can be useful, for example, if we want to close the channel in case of an error. A working example of this approach can be viewed tut


the 
 (let [R1 (go (<! (timeout (rand-int 1000))) 5)
c2 (go (<! (timeout (rand-int 1000))) 7)]
(go (let [v1 (<! c1)
v2 (<! c2)]
(println {:v1 v1
:v2 v2
:summ (+ v1 v2)}))))

This example will wait for the result of all asynchronous operations listed in the let. This practice is very convenient to solve the callback hell in JavaScript, and another reason to be glad that it can be used on the browser side in the face of ClojureScript.


Example 4


the 
(defn upload 
"upload emulator"
[headshot c time]
(go (Thread/sleep time)
(>! headshot c)))

(let [c1 (chan) c2 (chan)]
(upload "pic1.jpg" c1 30)
(upload "pic2.jpg" c2 40)
(let [[headshot channel] (alts!! [c1 c2 (timeout 20)])]
(if headshot
(println "Sending headshot notification for" headshot)
(println "Timed out!"))))

In this example we have created a upload function emulates an asynchronous operation, in this case a file download. The last argument upload, accepts the delay time in milliseconds. Using the function alts!!! we can get the first result that we will return one of the following in the vector channels. In our vector, the last channel is (timeout 20), this channel will return the result through 20 milliseconds, and this will be the first value to be written to the variable headshot and continue running the form. Thus, this example emulates the time setting for timeout, during which we wait to perform a set of asynchronous operations.


Example 5


the 
(def ping (chan))
(def pong (chan))

(go-loop []
(let [msg (<! ping)]
(when (= msg :ping)
(println msg)
(>! pong :pong)
(Thread/sleep 1000))
(recur)))

(go-loop []
(let [msg (<! pong)]
(when (= msg :pong)
(println msg)
(>! ping :ping)
(Thread/sleep 1000))
(recur)))

(>!! ping :ping)

an Example of communication of two channels, classic Ping-Pong.


It was the last example that I wanted to show. Separately it is also worth to highlight the presence of clojure's data types, created specifically for the recording of information in multiple threads, it is atom and agent as well as the General immutablelist other types, it's all very makes life easier for the developer when developing a multithreaded application.



Useful links:


" http://clojure.com/blog/2013/06/28/clojure-core-async-channels.html
"https://github.com/clojure/core.async
"https://github.com/clojure/core.async/wiki/Getting-Started
"http://www.braveclojure.com/core-async/
"http://go.cognitect.com/core_async_webinar_recording
Article based on information from habrahabr.ru

Комментарии

Отправить комментарий

Популярные сообщения из этого блога

Integration of PostgreSQL with MS SQL Server for those who want faster and deeper

Изображение
Recently habré was already published integration PostgreSQL and MSSQL. But, items there is categorically not enough. Therefore, the objectives of this publication are the following: the the to broaden and deepen publicly available information about FDW for MSSQL-called tds_fdw to tell the difference in major versions and describe basic compatibility issues; the to talk about the possibilities of optimization of queries that use the foreign table; the to address the subject of caching external data in a materialized view; the to say a few words about the exotic ways to integrate PostgreSQL and MSSQL. the Installing and configuring TDS FDW The guys from PostgresPro already sufficiently said about this process, I will not repeat. Will leave a few links to the official PostgreSQL documentation and examples from tds_fdw: the the creating an extension (extension) in PG: off.dokumentacija ; the server: off.documentation , example of tds_fdw ; the creating
Далее...

Custom database queries in MODx Revolution

This topic will certainly be useful for those who have quite a lot of projects on MODx Revolution, as with the usual sites of business cards is enough and the standard working methods of a La $modx- > getObject() , $modx->getCollection() , etc., and these methods are inherently not just a job database, but also with the objects of MODx. When working with large projects methods a La $modx- > getCollection() for us is not the best solution for two reasons: 1. The overexpenditures. These methods are not just getting data from DB, but also create instance of the retrieved objects. In this case, getting information about 10000 documents, we get 10000 objects of modResource that it is not very cool. 2. The task is complicated by the count of records. In addition to the direct difficulties of counting even at the query level, even if you get 10 records of the same document (for example), MODx will return as a result only one object modResource. Although often that will su
Далее...

Parse URL in Zend Framework 2

Objective: the Have a method to disassemble the components of the string containing the URL. The string can contain both absolute and relative URLS and both these options should be correctly parsed. the And in the drain, let's say the "wrong" format absolute links without "http://". Further in the text links to the "wrong" format will be called partial absolute references . the Implement support for the "RF" domain. the Example: site.ru/page.php /page.php site.ru/page.php the scheme http the host site.ru site.ru the path page.php page.php page.php Implementation of paragraphs 1 and 2 of our problem In this we should help the class Zend\Uri\Http . He has we need methods parse($uri) , getHost() , getPath() , etc. But! When we parse the URL and type " site.ru/page.php " (without the " http:// ") getHost() will return an empty string and getPath()
Далее...