You are viewing a plain text version of this content. The canonical link for it is here.
Posted to issues@cxf.apache.org by "Yu Lin (JIRA)" <ji...@apache.org> on 2012/07/03 00:54:57 UTC
[jira] [Created] (CXF-4404) atomicity violation bugs because of
misusing concurrent collections
Yu Lin created CXF-4404:
---------------------------
Summary: atomicity violation bugs because of misusing concurrent collections
Key: CXF-4404
URL: https://issues.apache.org/jira/browse/CXF-4404
Project: CXF
Issue Type: Bug
Affects Versions: 2.6.1
Reporter: Yu Lin
My name is Yu Lin. I'm a Ph.D. student in the CS department at
UIUC. I'm currently doing research on mining Java concurrent library
misusages. I found some misusages of ConcurrentHashMap in CXF 2.6.1,
which may result in potential atomicity violation bugs or harm the
performance.
The code below is a snapshot of the code in file
api/src/main/java/org/apache/cxf/common/util/ASMHelper.java from line
306 to 327.
L306 public synchronized Class<?> defineClass(String name, byte bytes[]) {
L307 Class<?> ret = defined.get(name.replace('/', '.'));
L308 if (ret != null) {
L309 return ret;
L310 }
L311 if (name.endsWith("package-info")) {
...
L323 }
L324
L325 ret = super.defineClass(name.replace('/', '.'), bytes, 0, bytes.length);
L326 defined.put(name.replace('/', '.'), ret);
L327 return ret;
In the code above, the synchronized key word at line 306 can be
removed if we use putIfAbsent at line 326. If we remove the
synchronized without using putIfAbsent, an atomicity violation may
occur between lines <310 and 326>: Suppose a thread T1 executes line
307 and finds out the concurrent hashmap dose not contain the key
"name.replace('/','.')". Before it gets to execute line 326, another
thread T2 puts a pair <name.replace('/','.'), v> in the concurrent
hashmap "defined". Now thread T1 resumes execution and it will
overwrite the value written by thread T2. Thus, the code no longer
preserves the "put-if-absent" semantics. However, such atomicity
violation bug can be eliminated by using putIfAbsent at line 326 (see
the patch).
I found some similar misusages in other files:
In
api/src/main/java/org/apache/cxf/configuration/spring/AbstractSpringBeanMap.java,
synchronized key word at line 67 can be removed by using putIfAbsent
at line 71. Also, atomicity violations may occur when T2 removes key
"key" from the concurrent hashmap "putStore" before T1 executes line
155; or T2 puts a pair <(X)key, v> to "putStore" before T1 executes
line 158.
In api/src/main/java/org/apache/cxf/endpoint/ClientImpl.java, an
atomicity violation may occur when thread T2 removes key
"THREAD_LOCAL_REQUEST_CONTEXT" from the concurrent hashmap
"currentRequestContext" before thread T1 executes line 303.
In api/src/main/java/org/apache/cxf/helpers/HttpHeaderHelper.java, an
atomicity violation may occur when thread T2 puts a pair <enc, v> to
concurrent hashmap "encodings" before T1 executes line 127.
In
rt/core/src/main/java/org/apache/cxf/bus/osgi/CXFExtensionBundleListener.java,
an atomicity violation may occur when thread T2 puts a pair
<bundle.getBundleId(), v> to concurrent hashmap "extensions" before T1
executes line 93.
In
rt/features/clustering/src/main/java/org/apache/cxf/clustering/FailoverTargetSelector.java,
synchronized key word at line 76 can be removed by using putIfAbsent
at line 91.
In
rt/frontend/jaxrs/src/main/java/org/apache/cxf/jaxrs/model/ClassResourceInfo.java,
if another thread T2 puts a pair <key, v> into concurrent hashmap
"subResources" before thread T1 executes line 136, the "cri" in T1
won't be put into "subResources" at line 136. In this case, the
"getSubResource" method returns the wrong "cri".
In
rt/rs/extensions/providers/src/main/java/org/apache/cxf/jaxrs/provider/json/JSONProvider.java,
an atomicity violation may occur when thread T2 removes key
"qname.getNamespaceURI()" from the concurrent hashmap "namespaceMap"
before thread T1 executes line 405. Another atomicity violation is
when thread T2 puts a pair <namespace, v> to concurrent hashmap
"namespaceMap" before T1 executes line 530.
In
rt/transports/http-jetty/src/main/java/org/apache/cxf/transport/http_jetty/JettyHTTPServerEngineFactory.java,
synchronized key word at line 107 can be removed by using putIfAbsent
at line 118.
In
rt/transports/local/src/main/java/org/apache/cxf/transport/local/LocalTransportFactory.java,
an atomicity violation may occur when thread T2 puts a pair <addr, v>
to concurrent hashmap "destinations" before T1 executes line 128.
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators: https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Updated] (CXF-4404) atomicity violation bugs because of
misusing concurrent collections
Posted by "Yu Lin (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/CXF-4404?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Yu Lin updated CXF-4404:
------------------------
Attachment: cxf-2.6.1.patch
This is a patch that fixes the atomicity violation problem.
> atomicity violation bugs because of misusing concurrent collections
> -------------------------------------------------------------------
>
> Key: CXF-4404
> URL: https://issues.apache.org/jira/browse/CXF-4404
> Project: CXF
> Issue Type: Bug
> Affects Versions: 2.6.1
> Reporter: Yu Lin
> Labels: patch
> Attachments: cxf-2.6.1.patch
>
> Original Estimate: 504h
> Remaining Estimate: 504h
>
> My name is Yu Lin. I'm a Ph.D. student in the CS department at
> UIUC. I'm currently doing research on mining Java concurrent library
> misusages. I found some misusages of ConcurrentHashMap in CXF 2.6.1,
> which may result in potential atomicity violation bugs or harm the
> performance.
> The code below is a snapshot of the code in file
> api/src/main/java/org/apache/cxf/common/util/ASMHelper.java from line
> 306 to 327.
> L306 public synchronized Class<?> defineClass(String name, byte bytes[]) {
> L307 Class<?> ret = defined.get(name.replace('/', '.'));
> L308 if (ret != null) {
> L309 return ret;
> L310 }
> L311 if (name.endsWith("package-info")) {
> ...
> L323 }
> L324
> L325 ret = super.defineClass(name.replace('/', '.'), bytes, 0, bytes.length);
> L326 defined.put(name.replace('/', '.'), ret);
> L327 return ret;
> In the code above, the synchronized key word at line 306 can be
> removed if we use putIfAbsent at line 326. If we remove the
> synchronized without using putIfAbsent, an atomicity violation may
> occur between lines <310 and 326>: Suppose a thread T1 executes line
> 307 and finds out the concurrent hashmap dose not contain the key
> "name.replace('/','.')". Before it gets to execute line 326, another
> thread T2 puts a pair <name.replace('/','.'), v> in the concurrent
> hashmap "defined". Now thread T1 resumes execution and it will
> overwrite the value written by thread T2. Thus, the code no longer
> preserves the "put-if-absent" semantics. However, such atomicity
> violation bug can be eliminated by using putIfAbsent at line 326 (see
> the patch).
> I found some similar misusages in other files:
> In
> api/src/main/java/org/apache/cxf/configuration/spring/AbstractSpringBeanMap.java,
> synchronized key word at line 67 can be removed by using putIfAbsent
> at line 71. Also, atomicity violations may occur when T2 removes key
> "key" from the concurrent hashmap "putStore" before T1 executes line
> 155; or T2 puts a pair <(X)key, v> to "putStore" before T1 executes
> line 158.
> In api/src/main/java/org/apache/cxf/endpoint/ClientImpl.java, an
> atomicity violation may occur when thread T2 removes key
> "THREAD_LOCAL_REQUEST_CONTEXT" from the concurrent hashmap
> "currentRequestContext" before thread T1 executes line 303.
> In api/src/main/java/org/apache/cxf/helpers/HttpHeaderHelper.java, an
> atomicity violation may occur when thread T2 puts a pair <enc, v> to
> concurrent hashmap "encodings" before T1 executes line 127.
> In
> rt/core/src/main/java/org/apache/cxf/bus/osgi/CXFExtensionBundleListener.java,
> an atomicity violation may occur when thread T2 puts a pair
> <bundle.getBundleId(), v> to concurrent hashmap "extensions" before T1
> executes line 93.
> In
> rt/features/clustering/src/main/java/org/apache/cxf/clustering/FailoverTargetSelector.java,
> synchronized key word at line 76 can be removed by using putIfAbsent
> at line 91.
> In
> rt/frontend/jaxrs/src/main/java/org/apache/cxf/jaxrs/model/ClassResourceInfo.java,
> if another thread T2 puts a pair <key, v> into concurrent hashmap
> "subResources" before thread T1 executes line 136, the "cri" in T1
> won't be put into "subResources" at line 136. In this case, the
> "getSubResource" method returns the wrong "cri".
> In
> rt/rs/extensions/providers/src/main/java/org/apache/cxf/jaxrs/provider/json/JSONProvider.java,
> an atomicity violation may occur when thread T2 removes key
> "qname.getNamespaceURI()" from the concurrent hashmap "namespaceMap"
> before thread T1 executes line 405. Another atomicity violation is
> when thread T2 puts a pair <namespace, v> to concurrent hashmap
> "namespaceMap" before T1 executes line 530.
> In
> rt/transports/http-jetty/src/main/java/org/apache/cxf/transport/http_jetty/JettyHTTPServerEngineFactory.java,
> synchronized key word at line 107 can be removed by using putIfAbsent
> at line 118.
> In
> rt/transports/local/src/main/java/org/apache/cxf/transport/local/LocalTransportFactory.java,
> an atomicity violation may occur when thread T2 puts a pair <addr, v>
> to concurrent hashmap "destinations" before T1 executes line 128.
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators: https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Assigned] (CXF-4404) atomicity violation bugs because of
misusing concurrent collections
Posted by "Freeman Fang (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/CXF-4404?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Freeman Fang reassigned CXF-4404:
---------------------------------
Assignee: Freeman Fang
> atomicity violation bugs because of misusing concurrent collections
> -------------------------------------------------------------------
>
> Key: CXF-4404
> URL: https://issues.apache.org/jira/browse/CXF-4404
> Project: CXF
> Issue Type: Bug
> Affects Versions: 2.6.1
> Reporter: Yu Lin
> Assignee: Freeman Fang
> Labels: patch
> Attachments: cxf-2.6.1.patch
>
> Original Estimate: 504h
> Remaining Estimate: 504h
>
> My name is Yu Lin. I'm a Ph.D. student in the CS department at
> UIUC. I'm currently doing research on mining Java concurrent library
> misusages. I found some misusages of ConcurrentHashMap in CXF 2.6.1,
> which may result in potential atomicity violation bugs or harm the
> performance.
> The code below is a snapshot of the code in file
> api/src/main/java/org/apache/cxf/common/util/ASMHelper.java from line
> 306 to 327.
> L306 public synchronized Class<?> defineClass(String name, byte bytes[]) {
> L307 Class<?> ret = defined.get(name.replace('/', '.'));
> L308 if (ret != null) {
> L309 return ret;
> L310 }
> L311 if (name.endsWith("package-info")) {
> ...
> L323 }
> L324
> L325 ret = super.defineClass(name.replace('/', '.'), bytes, 0, bytes.length);
> L326 defined.put(name.replace('/', '.'), ret);
> L327 return ret;
> In the code above, the synchronized key word at line 306 can be
> removed if we use putIfAbsent at line 326. If we remove the
> synchronized without using putIfAbsent, an atomicity violation may
> occur between lines <310 and 326>: Suppose a thread T1 executes line
> 307 and finds out the concurrent hashmap dose not contain the key
> "name.replace('/','.')". Before it gets to execute line 326, another
> thread T2 puts a pair <name.replace('/','.'), v> in the concurrent
> hashmap "defined". Now thread T1 resumes execution and it will
> overwrite the value written by thread T2. Thus, the code no longer
> preserves the "put-if-absent" semantics. However, such atomicity
> violation bug can be eliminated by using putIfAbsent at line 326 (see
> the patch).
> I found some similar misusages in other files:
> In
> api/src/main/java/org/apache/cxf/configuration/spring/AbstractSpringBeanMap.java,
> synchronized key word at line 67 can be removed by using putIfAbsent
> at line 71. Also, atomicity violations may occur when T2 removes key
> "key" from the concurrent hashmap "putStore" before T1 executes line
> 155; or T2 puts a pair <(X)key, v> to "putStore" before T1 executes
> line 158.
> In api/src/main/java/org/apache/cxf/endpoint/ClientImpl.java, an
> atomicity violation may occur when thread T2 removes key
> "THREAD_LOCAL_REQUEST_CONTEXT" from the concurrent hashmap
> "currentRequestContext" before thread T1 executes line 303.
> In api/src/main/java/org/apache/cxf/helpers/HttpHeaderHelper.java, an
> atomicity violation may occur when thread T2 puts a pair <enc, v> to
> concurrent hashmap "encodings" before T1 executes line 127.
> In
> rt/core/src/main/java/org/apache/cxf/bus/osgi/CXFExtensionBundleListener.java,
> an atomicity violation may occur when thread T2 puts a pair
> <bundle.getBundleId(), v> to concurrent hashmap "extensions" before T1
> executes line 93.
> In
> rt/features/clustering/src/main/java/org/apache/cxf/clustering/FailoverTargetSelector.java,
> synchronized key word at line 76 can be removed by using putIfAbsent
> at line 91.
> In
> rt/frontend/jaxrs/src/main/java/org/apache/cxf/jaxrs/model/ClassResourceInfo.java,
> if another thread T2 puts a pair <key, v> into concurrent hashmap
> "subResources" before thread T1 executes line 136, the "cri" in T1
> won't be put into "subResources" at line 136. In this case, the
> "getSubResource" method returns the wrong "cri".
> In
> rt/rs/extensions/providers/src/main/java/org/apache/cxf/jaxrs/provider/json/JSONProvider.java,
> an atomicity violation may occur when thread T2 removes key
> "qname.getNamespaceURI()" from the concurrent hashmap "namespaceMap"
> before thread T1 executes line 405. Another atomicity violation is
> when thread T2 puts a pair <namespace, v> to concurrent hashmap
> "namespaceMap" before T1 executes line 530.
> In
> rt/transports/http-jetty/src/main/java/org/apache/cxf/transport/http_jetty/JettyHTTPServerEngineFactory.java,
> synchronized key word at line 107 can be removed by using putIfAbsent
> at line 118.
> In
> rt/transports/local/src/main/java/org/apache/cxf/transport/local/LocalTransportFactory.java,
> an atomicity violation may occur when thread T2 puts a pair <addr, v>
> to concurrent hashmap "destinations" before T1 executes line 128.
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators: https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Resolved] (CXF-4404) atomicity violation bugs because of
misusing concurrent collections
Posted by "Freeman Fang (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/CXF-4404?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Freeman Fang resolved CXF-4404.
-------------------------------
Resolution: Fixed
Fix Version/s: 2.7.0
2.6.2
Apply patch on behalf of Yu Lin with thanks
> atomicity violation bugs because of misusing concurrent collections
> -------------------------------------------------------------------
>
> Key: CXF-4404
> URL: https://issues.apache.org/jira/browse/CXF-4404
> Project: CXF
> Issue Type: Bug
> Affects Versions: 2.6.1
> Reporter: Yu Lin
> Assignee: Freeman Fang
> Labels: patch
> Fix For: 2.6.2, 2.7.0
>
> Attachments: cxf-2.6.1.patch
>
> Original Estimate: 504h
> Remaining Estimate: 504h
>
> My name is Yu Lin. I'm a Ph.D. student in the CS department at
> UIUC. I'm currently doing research on mining Java concurrent library
> misusages. I found some misusages of ConcurrentHashMap in CXF 2.6.1,
> which may result in potential atomicity violation bugs or harm the
> performance.
> The code below is a snapshot of the code in file
> api/src/main/java/org/apache/cxf/common/util/ASMHelper.java from line
> 306 to 327.
> L306 public synchronized Class<?> defineClass(String name, byte bytes[]) {
> L307 Class<?> ret = defined.get(name.replace('/', '.'));
> L308 if (ret != null) {
> L309 return ret;
> L310 }
> L311 if (name.endsWith("package-info")) {
> ...
> L323 }
> L324
> L325 ret = super.defineClass(name.replace('/', '.'), bytes, 0, bytes.length);
> L326 defined.put(name.replace('/', '.'), ret);
> L327 return ret;
> In the code above, the synchronized key word at line 306 can be
> removed if we use putIfAbsent at line 326. If we remove the
> synchronized without using putIfAbsent, an atomicity violation may
> occur between lines <310 and 326>: Suppose a thread T1 executes line
> 307 and finds out the concurrent hashmap dose not contain the key
> "name.replace('/','.')". Before it gets to execute line 326, another
> thread T2 puts a pair <name.replace('/','.'), v> in the concurrent
> hashmap "defined". Now thread T1 resumes execution and it will
> overwrite the value written by thread T2. Thus, the code no longer
> preserves the "put-if-absent" semantics. However, such atomicity
> violation bug can be eliminated by using putIfAbsent at line 326 (see
> the patch).
> I found some similar misusages in other files:
> In
> api/src/main/java/org/apache/cxf/configuration/spring/AbstractSpringBeanMap.java,
> synchronized key word at line 67 can be removed by using putIfAbsent
> at line 71. Also, atomicity violations may occur when T2 removes key
> "key" from the concurrent hashmap "putStore" before T1 executes line
> 155; or T2 puts a pair <(X)key, v> to "putStore" before T1 executes
> line 158.
> In api/src/main/java/org/apache/cxf/endpoint/ClientImpl.java, an
> atomicity violation may occur when thread T2 removes key
> "THREAD_LOCAL_REQUEST_CONTEXT" from the concurrent hashmap
> "currentRequestContext" before thread T1 executes line 303.
> In api/src/main/java/org/apache/cxf/helpers/HttpHeaderHelper.java, an
> atomicity violation may occur when thread T2 puts a pair <enc, v> to
> concurrent hashmap "encodings" before T1 executes line 127.
> In
> rt/core/src/main/java/org/apache/cxf/bus/osgi/CXFExtensionBundleListener.java,
> an atomicity violation may occur when thread T2 puts a pair
> <bundle.getBundleId(), v> to concurrent hashmap "extensions" before T1
> executes line 93.
> In
> rt/features/clustering/src/main/java/org/apache/cxf/clustering/FailoverTargetSelector.java,
> synchronized key word at line 76 can be removed by using putIfAbsent
> at line 91.
> In
> rt/frontend/jaxrs/src/main/java/org/apache/cxf/jaxrs/model/ClassResourceInfo.java,
> if another thread T2 puts a pair <key, v> into concurrent hashmap
> "subResources" before thread T1 executes line 136, the "cri" in T1
> won't be put into "subResources" at line 136. In this case, the
> "getSubResource" method returns the wrong "cri".
> In
> rt/rs/extensions/providers/src/main/java/org/apache/cxf/jaxrs/provider/json/JSONProvider.java,
> an atomicity violation may occur when thread T2 removes key
> "qname.getNamespaceURI()" from the concurrent hashmap "namespaceMap"
> before thread T1 executes line 405. Another atomicity violation is
> when thread T2 puts a pair <namespace, v> to concurrent hashmap
> "namespaceMap" before T1 executes line 530.
> In
> rt/transports/http-jetty/src/main/java/org/apache/cxf/transport/http_jetty/JettyHTTPServerEngineFactory.java,
> synchronized key word at line 107 can be removed by using putIfAbsent
> at line 118.
> In
> rt/transports/local/src/main/java/org/apache/cxf/transport/local/LocalTransportFactory.java,
> an atomicity violation may occur when thread T2 puts a pair <addr, v>
> to concurrent hashmap "destinations" before T1 executes line 128.
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators: https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Commented] (CXF-4404) atomicity violation bugs because of
misusing concurrent collections
Posted by "Freeman Fang (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/CXF-4404?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=13405605#comment-13405605 ]
Freeman Fang commented on CXF-4404:
-----------------------------------
Hi,
Just one issue, the rt/core/src/main/java/org/apache/cxf/bus/osgi/CXFExtensionBundleListener.java change should be
{code}
@@ -90,7 +90,10 @@
List<Extension> list = extensions.get(bundle.getBundleId());
if (list == null) {
list = new CopyOnWriteArrayList<Extension>();
- extensions.put(bundle.getBundleId(), list);
+ List<Extension> preList = extensions.putIfAbsent(bundle.getBundleId(), list);
+ if (preList != null) {
+ list = preList;
+ }
}
{code}
to ensure we won't lost extensions in a pre-saved list
Also correct checkstyle.
Thanks for the patch
Freeman
> atomicity violation bugs because of misusing concurrent collections
> -------------------------------------------------------------------
>
> Key: CXF-4404
> URL: https://issues.apache.org/jira/browse/CXF-4404
> Project: CXF
> Issue Type: Bug
> Affects Versions: 2.6.1
> Reporter: Yu Lin
> Assignee: Freeman Fang
> Labels: patch
> Attachments: cxf-2.6.1.patch
>
> Original Estimate: 504h
> Remaining Estimate: 504h
>
> My name is Yu Lin. I'm a Ph.D. student in the CS department at
> UIUC. I'm currently doing research on mining Java concurrent library
> misusages. I found some misusages of ConcurrentHashMap in CXF 2.6.1,
> which may result in potential atomicity violation bugs or harm the
> performance.
> The code below is a snapshot of the code in file
> api/src/main/java/org/apache/cxf/common/util/ASMHelper.java from line
> 306 to 327.
> L306 public synchronized Class<?> defineClass(String name, byte bytes[]) {
> L307 Class<?> ret = defined.get(name.replace('/', '.'));
> L308 if (ret != null) {
> L309 return ret;
> L310 }
> L311 if (name.endsWith("package-info")) {
> ...
> L323 }
> L324
> L325 ret = super.defineClass(name.replace('/', '.'), bytes, 0, bytes.length);
> L326 defined.put(name.replace('/', '.'), ret);
> L327 return ret;
> In the code above, the synchronized key word at line 306 can be
> removed if we use putIfAbsent at line 326. If we remove the
> synchronized without using putIfAbsent, an atomicity violation may
> occur between lines <310 and 326>: Suppose a thread T1 executes line
> 307 and finds out the concurrent hashmap dose not contain the key
> "name.replace('/','.')". Before it gets to execute line 326, another
> thread T2 puts a pair <name.replace('/','.'), v> in the concurrent
> hashmap "defined". Now thread T1 resumes execution and it will
> overwrite the value written by thread T2. Thus, the code no longer
> preserves the "put-if-absent" semantics. However, such atomicity
> violation bug can be eliminated by using putIfAbsent at line 326 (see
> the patch).
> I found some similar misusages in other files:
> In
> api/src/main/java/org/apache/cxf/configuration/spring/AbstractSpringBeanMap.java,
> synchronized key word at line 67 can be removed by using putIfAbsent
> at line 71. Also, atomicity violations may occur when T2 removes key
> "key" from the concurrent hashmap "putStore" before T1 executes line
> 155; or T2 puts a pair <(X)key, v> to "putStore" before T1 executes
> line 158.
> In api/src/main/java/org/apache/cxf/endpoint/ClientImpl.java, an
> atomicity violation may occur when thread T2 removes key
> "THREAD_LOCAL_REQUEST_CONTEXT" from the concurrent hashmap
> "currentRequestContext" before thread T1 executes line 303.
> In api/src/main/java/org/apache/cxf/helpers/HttpHeaderHelper.java, an
> atomicity violation may occur when thread T2 puts a pair <enc, v> to
> concurrent hashmap "encodings" before T1 executes line 127.
> In
> rt/core/src/main/java/org/apache/cxf/bus/osgi/CXFExtensionBundleListener.java,
> an atomicity violation may occur when thread T2 puts a pair
> <bundle.getBundleId(), v> to concurrent hashmap "extensions" before T1
> executes line 93.
> In
> rt/features/clustering/src/main/java/org/apache/cxf/clustering/FailoverTargetSelector.java,
> synchronized key word at line 76 can be removed by using putIfAbsent
> at line 91.
> In
> rt/frontend/jaxrs/src/main/java/org/apache/cxf/jaxrs/model/ClassResourceInfo.java,
> if another thread T2 puts a pair <key, v> into concurrent hashmap
> "subResources" before thread T1 executes line 136, the "cri" in T1
> won't be put into "subResources" at line 136. In this case, the
> "getSubResource" method returns the wrong "cri".
> In
> rt/rs/extensions/providers/src/main/java/org/apache/cxf/jaxrs/provider/json/JSONProvider.java,
> an atomicity violation may occur when thread T2 removes key
> "qname.getNamespaceURI()" from the concurrent hashmap "namespaceMap"
> before thread T1 executes line 405. Another atomicity violation is
> when thread T2 puts a pair <namespace, v> to concurrent hashmap
> "namespaceMap" before T1 executes line 530.
> In
> rt/transports/http-jetty/src/main/java/org/apache/cxf/transport/http_jetty/JettyHTTPServerEngineFactory.java,
> synchronized key word at line 107 can be removed by using putIfAbsent
> at line 118.
> In
> rt/transports/local/src/main/java/org/apache/cxf/transport/local/LocalTransportFactory.java,
> an atomicity violation may occur when thread T2 puts a pair <addr, v>
> to concurrent hashmap "destinations" before T1 executes line 128.
--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators: https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira