https://kotlinlang.org logo
Channels
Powered by
#coroutines
  • g

    groostav

    08/07/2018, 12:12 AM
    Hey gents, does anybody have a good blog post or guide on using 
    kotlinx.coroutines.experimental.internal.LockFreeLinkedListHead
    and friends? I'm using 
    AtomicReference
    with immutable classes and its working, but at this point I'm now asking my 
    getAndUpdate
    call to allocate a lot of new data in its `update`er method. some notes: - yes I know that class isnt formally part of the API, I will update as appropriate, and either copy-paste that code or keep everything at version zero. - my existing solution probably would be fine if 
    kotlinx.collections.immutable
    was part of the stdlib, or I wanted to include it as an external dep, but its not, and I don't, and it seems to have lost all steam, much to my shigrin - no, I dont want to use 
    atomicfu
    because I dont understand what atomicfu is asking me to do to my build system, ill poke around at gradle + byte code manipulation later.
    e
    a
    • 3
    • 2
  • v

    v0ldem0rt

    08/07/2018, 12:35 AM
    Is there any overhead of multiple coroutines waiting on same Deferred<T> (race conditions/thread safety)?
    p
    g
    +2
    • 5
    • 8
  • b

    bdawg.io

    08/07/2018, 7:17 PM
    Does anyone know of any Async JDBC-esque DataSource implementations that aren’t just delegating to a separate thread to block on?
    c
    w
    +2
    • 5
    • 6
  • b

    bdawg.io

    08/07/2018, 7:31 PM
    And if not, if I wanted to have a coroutine context for database access, is the current practice to have an 
    N
    thread coroutine context with a 
    N
    sized pooled data source?
    g
    • 2
    • 1
  • p

    pavel

    08/07/2018, 9:26 PM
  • g

    groostav

    08/09/2018, 9:41 AM
    So the first thing that might help here is using the 
    Unconfined
    dispatcher in your 
    map
    function, I think this will get your outer deferred running on the inner deferred's thread, which might make this a bit more straight forward to debug
    n
    • 2
    • 1
  • u

    uli

    08/09/2018, 12:54 PM
    @groostav await should preserve the happens before semantic. Everything happening inside the async should be visible to everything happening after the async But I would also guess for some threading issue. @nayanjyoti is your 
    a
    shared somewhere else, where it could be reset to null?
    n
    • 2
    • 2
  • g

    groostav

    08/09/2018, 6:51 PM
    Everything happening inside the async should be visible to everything happening after the async
    My reading of java concurrency in practice is that this is not accurate
    j
    • 2
    • 1
  • g

    groostav

    08/09/2018, 6:54 PM
    Copy code
    val notThreadSafe: Int? = null

fun doStuff() = runBlocking {
  val updateJob = launch(CommonPool) { notThreadSafe = 1 }

  updateJob.join()
  val result = notThreadSafe // <- no gaurentee this isnt null, in fact theres no gaurentee that your thread will _ever_ see the value `1` on that field.
}
    this is true despite happens before semantics. the assignment of 
    1
    to 
    notThreadSafe
    happens before the assignment of 
    notThreadSafe
    to 
    result
    , but because its not marked as 
    @Volatile
    you have no gaurentees about when the value 
    notTHreadSafe
    will actually be written to main memory. Your only gaurentee is that all downstream operations on that thread on the common pool will see the value 
    1
    for not thread safe. I could be mistaken. Java Concurrency in Practice is a uniquely horrifying book to read.
    e
    g
    • 3
    • 4
  • m

    mp

    08/09/2018, 7:40 PM
    I think it's more that memory models are uniquely horrifying 😉
    g
    e
    • 3
    • 2
  • s

    Seri

    08/09/2018, 7:52 PM
    Does anyone have examples of Channels in use in real projects?
    👍 3
    g
    l
    • 3
    • 2
  • s

    Seri

    08/09/2018, 9:10 PM
    Ah gotcha, I appreciate the response nonetheless.
    g
    c
    • 3
    • 4
  • i

    igorvd

    08/10/2018, 5:18 PM
    What is the best way to achieve some periodic task with coroutines? I'm simply starting a coroutine with launch and using a 
    while (isActive)
    with a delay. Is this the best approach?
    v
    w
    • 3
    • 4
  • v

    v0ldem0rt

    08/11/2018, 5:22 AM
    If I want to invoke a suspend fun from Java what is the return type?
    e
    • 2
    • 1
  • p

    Paul Woitaschek

    08/13/2018, 2:16 PM
  • e

    elizarov

    08/13/2018, 5:01 PM
    Some Samsung Android 5.x devices do not properly support 
    Atomic*FieldUpdater
    Java APIs which leads to crashes with 
    kotlinx.coroutines
    . Do you know more details? How shall we work around this problem? You opinion is welcome here: https://github.com/Kotlin/kotlinx.coroutines/issues/490
    t
    • 2
    • 1
  • v

    v0ldem0rt

    08/13/2018, 5:13 PM
    why don't we already have a Semaphore implementation in coroutines?
    m
    e
    l
    • 4
    • 15
  • a

    Albert

    08/14/2018, 12:02 PM
    Is there a way to cap the concurrency with coroutines? when I run a lot of 
    async { ... http request ... }
    at some point I am hitting connection refused, because the other end can not keep up.
    v
    • 2
    • 2
  • w

    withoutclass

    08/14/2018, 2:06 PM
    While loop probably, since the for loop will suspend waiting on items as I recall
    l
    m
    • 3
    • 13
  • r

    Ruckus

    08/14/2018, 5:11 PM
    I have a use case that I'm not sure how to solve (my experience with async/concurrent code is rather simplistic). Basically I have two types of tasks: generate tasks and a combine task. I would like generate tasks to run concurrently from a queue (the generate tasks are quite CPU intensive, so I want to limit the number that run at a time). When the queue runs dry, it should then run the combine task. While the combine task is running, new generate tasks can be added to the queue, but should not run till the combine task is done. (By extension, the combine task should not run if there are any generate tasks running.) Also, there will often be long periouds of time where no tasks are running, so I don't want a busy wait for new generate tasks. What would be the correct way to handle this? Is there a common idiom or pattern for such a use case?
    • 1
    • 1
  • b

    bj0

    08/14/2018, 5:16 PM
    you can probably handle the selection of which task to run using a select clause, which bias the first clause (generate tasks) over the second (combine task)
    r
    • 2
    • 26
  • b

    bdawg.io

    08/14/2018, 5:19 PM
    Copy code
    val result = async(myContext) { doSomething() }.await()
// vs
val result = withContext(myContext) { doSomething() }
    i
    w
    +4
    • 7
    • 8
  • v

    v0ldem0rt

    08/14/2018, 5:56 PM
    How can I get current Continuation inside a coroutine?
    e
    • 2
    • 1
  • v

    v0ldem0rt

    08/15/2018, 3:25 AM
    When do we think https://github.com/Kotlin/kotlinx.coroutines/pull/455 will be availble GA? I desperately need MDCContext
    v
    • 2
    • 3
  • d

    DALDEI

    08/15/2018, 10:25 PM
    Recomendation for what api/syntax/idiom to use when running in a coroutine or suspendinmg function and calling a known 'blocking' API (e.g. normal java IO blocking apis). Docs say do NOT use runBlocking() -- so ok. what do I use ?
    g
    w
    • 3
    • 4
  • a

    alex.tavella

    08/17/2018, 11:52 AM
    No, right?
    m
    b
    u
    • 4
    • 12
  • t

    tianhao

    08/19/2018, 11:19 PM
    Will coroutines team consider to work with gRPC team?
    v
    v
    • 3
    • 2
  • e

    elizarov

    08/20/2018, 7:39 AM
    @louiscad Coroutines don’t immediately allow recursive methods without StackOverflow, but you can use Kotlin coroutines machinery to transform any recursive algorithm that uses call stack into one that uses heap to maintain its stack, thus supporting much deeper recursion without running out of resources. I wrote a prototype at one point. See this gist: https://gist.github.com/elizarov/d715c9564288c2635bb55687e7341717
    👍 2
    l
    • 2
    • 3
  • l

    louiscad

    08/20/2018, 8:22 AM
    What's the most idiomatic way to listen to multiple channels of different types and run a method with all the latest values each time? I mean, let's say I have 
    channelA: Channel<A>
    and 
    channelB: Channel<B>
    , I want to call a method like 
    update(a: A, b: B)
    each time I get a value from any channel, that is, if I receive from 
    channelA
    , I want it to be called with the new 
    A
    value, and the same 
    B
    value as previously received. Each time I have a use case for it, I feel like I'm writing disposable/throwaway code that is a bit error-prone and quite boilerplate-y. If you have any clue about a solution to do it right once for all, in a kind of generic way, please tell! Bonus points if your solution can also work with other callbacks and not just 
    Channel
    g
    j
    +3
    • 6
    • 24
  • a

    aeruhxi

    08/20/2018, 12:18 PM
    when I swap 
    launch
    with 
    runBlocking
    , everything works though
    u
    • 2
    • 3
1...272829...571Latest