A modern programming language that makes developers happier.

kotlinlang

is it `synchronized` / monitor expression?

You can find more information here <https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/lazy.html>

Koin inject implemented as
```inline fun &lt;reified T : Any&gt; ComponentCallbacks.inject(
        qualifier: Qualifier? = null,
        noinline parameters: ParametersDefinition? = null
) = lazy { get&lt;T&gt;(qualifier, parameters) }```

That is the same
```lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
    get&lt;T&gt;(qualifier, parameters)
}```

That implementation has impact on performance

We need options to use unsafe lazy (`lazy(LazyThreadSafetyMode.NONE)`) for injecting

It’s not good always use synchronization

on one side, we don’t know if current environment is running multithread or not

but the other, we lock instance resolution in the tree ... then we should not be exposed to problem

and then we would allow LazyThreadSafetyMode.NONE

I think it will be good to have option for inject without thread safety

Resolution of an instance must be locked inside depencies tree, not via lazy resolution from client side (via lazy delegate)

I’m reworking internal engine to clearly optimize just to lock in on tree resolution

I can make some work around it directly :wink:

<https://github.com/InsertKoinIO/koin/issues/669>

&gt; I’m reworking internal engine to clearly optimize just to lock in on tree resolution
You need to lock only `scoped` and `single`  dependncies, because factory need to be created every time and no need to lock thread for resolution

this is what this is in current engine version

check `SingleInstanceFactory`  &amp; `FactoryInstanceFactory`