<html>
<head>
<base href="http://bugzilla.slf4j.org/" />
</head>
<body><span class="vcard"><a class="email" href="mailto:bugzilla.slf4j.simon@arlott.org" title="Simon Arlott <bugzilla.slf4j.simon@arlott.org>"> <span class="fn">Simon Arlott</span></a>
</span> changed
<a class="bz_bug_link
bz_status_NEW "
title="NEW --- - Initialization (getILoggerFactory) is not thread safe"
href="http://bugzilla.slf4j.org/show_bug.cgi?id=176">bug 176</a>
<br>
<table border="1" cellspacing="0" cellpadding="8">
<tr>
<th>What</th>
<th>Removed</th>
<th>Added</th>
</tr>
<tr>
<td style="text-align:right;">CC</td>
<td>
</td>
<td>bugzilla.slf4j.simon@arlott.org
</td>
</tr></table>
<p>
<div>
<b><a class="bz_bug_link
bz_status_NEW "
title="NEW --- - Initialization (getILoggerFactory) is not thread safe"
href="http://bugzilla.slf4j.org/show_bug.cgi?id=176#c20">Comment # 20</a>
on <a class="bz_bug_link
bz_status_NEW "
title="NEW --- - Initialization (getILoggerFactory) is not thread safe"
href="http://bugzilla.slf4j.org/show_bug.cgi?id=176">bug 176</a>
from <span class="vcard"><a class="email" href="mailto:bugzilla.slf4j.simon@arlott.org" title="Simon Arlott <bugzilla.slf4j.simon@arlott.org>"> <span class="fn">Simon Arlott</span></a>
</span></b>
<pre>(In reply to <a href="show_bug.cgi?id=176#c19">comment #19</a>)
<span class="quote">> What is the status of this? If you want an alternative thread-safe
> initialisation that is not bespoke, we have a class that encapsulates lazy
> but thread-safe initialisation:</span >
The problem is that the logger initialisation process may try to log something
via SLF4J.
There are three scenarios for calling getILoggerFactory() during
initialisation:
1. This is the thread that is doing the initialisation.
2. This is another thread that just wants to create a Logger.
3. This is another thread that the initialisation thread is blocked on (e.g.
the logger factory initialises itself in another thread which then tries to log
something).
For scenario 1, we return a TEMP_FACTORY and everything is ok.
For scenario 2, we should wait indefinitely for initialisation to complete or
fail.
For scenario 3, we need to return a TEMP_FACTORY or a deadlock will occur.
One way to distinguish between 2 and 3 is to wait N seconds for initialisation
to complete before giving up, but there is no good value for N (perhaps you're
logging over NFS and the network is temporarily overloaded).
Ideally all locking performed during logger factory initialisation would be
performed with something like Guava's CycleDetectingLockFactory so that we
could detect deadlocks, but that would impose a requirement on all of the
logging frameworks (and not just the binding code).
To resolve this bug, either:
1. Allow scenario 3 to cause a deadlock so that scenario 2 works.
2. Implement a long enough timeout before failing, to cover most environments.
This could log warnings to System.err after a short period of time.
3. Return a proxy factory that uses a caching logger until initialisation is
complete. All loggers obtained during concurrent initialisation will be less
efficient. On servers with many CPUs this could potentially be a lot of static
class loggers.
4. Find a VM independent mechanism for detecting a deadlock that doesn't
require modifying code outside of the binding.
Note that scenario 1 is unchanged. It must return a NOP factory (or the proxy
factory if option 3 is used).
MarkerFactory and MDC have a similar problem. MarkerFactory will throw a
NullPointerException and MDC will throw an IllegalStateException.</pre>
</div>
</p>
<hr>
<span>You are receiving this mail because:</span>
<ul>
<li>You are the assignee for the bug.</li>
</ul>
</body>
</html>