i have a bit of parallel processing along the lines of

val targetFiles = Collections.synchronizedMap(mutableMapOf<String, File>())
val features = Collections.synchronizedList(mutableListOf<SKFeatureComposite>())

val jobs = mutableListOf<Job>()
for(...) {
   jobs += launch {
      //do work here
      targetFile[id] = someFIle
      if(feature != null) {
         features += feature
      }
   }
}

jobs.forEach { it.join() }

is there cleaner ways to handle collecting data that lets me juggle less mutable collections ?

You might want to consider using

async

instead of

launch

, then return the

feature

,

someFile

and

id

. Then collect the results in the

forEach

. To avoid the synchronization when using those collections.

well feature might not be there.. so i would have to use a nullable and split it up again later

I guess for the case of feature, you could use a

Channel

.

is there any resources you could recommend to learn about Channels ?

xo i would use 2 seperate channels here, send to each when i get data and then collect it in synchronous code in the end ?

That's because it is. 🙂

thanks for the help.. this is quite helpful

Yeah, it more of a pipe than an actual collection.

well for your job list, you can surely do targetFiles.map {}?

this is based on files that were read from disk, so i aleady have a list of entries, in this case mabe i could have mapped some parts of it to deferred wrappers,, but i'd rather learn how to make it owrk for the harder cases.. which i did.. channels are quite handy