Java 设计决策：我应该为所有低级库提供线程安全版本吗？
我经历了一段非常痛苦的java学习过程，还是一个新手 我正在设计一个低级库类，将来它可能会在多线程环境中使用，也可能只在单个线程中使用。我不知道 我可以让这个类的用户从外部同步。但这比提供线程安全版本效率要低得多 这是p代码Java 设计决策：我应该为所有低级库提供线程安全版本吗？,java,multithreading,concurrency,Java,Multithreading,Concurrency,我经历了一段非常痛苦的java学习过程，还是一个新手 我正在设计一个低级库类，将来它可能会在多线程环境中使用，也可能只在单个线程中使用。我不知道 我可以让这个类的用户从外部同步。但这比提供线程安全版本效率要低得多 这是p代码 Class Example{ public int checkAndProcess(){ WriteLock writeLock=this.getWriteLock(); ReadLock readLock=new ReadLock(
Class Example{
public int checkAndProcess(){
WriteLock writeLock=this.getWriteLock();
ReadLock readLock=new ReadLock(writeLock);
int a;
try{
lockManager.lock(readLock);
a=readSomething();
}finally{
lockManager.release(readLock);
}
if(a!=null){
return a;
}
try{
lockManager.lock(writeLock);
a=doSomeProcessing();
}finally{
lockManager.release(writeLock);
}
return a;
}
}
package lazycatTools.runtime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.jobs.Job;
import org.osgi.framework.AllServiceListener;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceEvent;
import org.osgi.framework.ServiceListener;
import org.osgi.framework.ServiceReference;
public class DynamicServiceTracker {
private final HashMap<Long,Object> _serviceCache;
private final HashMap<String,Long> _keyCache;
private final MultiResourceSchedulingRule _writeLock;
private final ServiceListener _tracker;
private final BundleContext _context;
public DynamicServiceTracker(BundleContext context){
Assert.isLegal(context!=null);
_serviceCache=new HashMap<Long,Object>();
_keyCache=new HashMap<String,Long>();
HashSet<Object> lockResource=new HashSet<Object>(4);
lockResource.add(_serviceCache);
lockResource.add(_keyCache);
_writeLock=new MultiResourceSchedulingRule<DynamicServiceTracker,Object>(this,lockResource);
_context=context;
_tracker=new AllServiceListener(){
@Override
public void serviceChanged(ServiceEvent event) {
if(event.getType()==ServiceEvent.UNREGISTERING){
ServiceReference<?> ref=event.getServiceReference();
Long sid=(Long)ref.getProperty(Constants.SERVICE_ID);
String[] classes=(String[])ref.getProperty(Constants.OBJECTCLASS);
boolean ungetService=false;
try{
Job.getJobManager().beginRule(_writeLock, null);
for(String clazz : classes){
if(_keyCache.get(clazz)==sid){
_keyCache.remove(clazz);
break;
}
}
if(_serviceCache.containsKey(sid)){
_serviceCache.remove(sid);
ungetService=true;
}
}finally{
Job.getJobManager().endRule(_writeLock);
}
if(ungetService){
//The order of ungetting a serviceReference is not important
_context.ungetService(ref);
}
SharedSchedulingRule readLock=new SharedSchedulingRule(_writeLock);
try{
Job.getJobManager().beginRule(readLock, null);
if(_serviceCache.size()==0){
_context.removeServiceListener(_tracker);
}
}finally{
Job.getJobManager().endRule(readLock);
}
}
}
};
}
public Object getService(String clazz) throws Exception{
Object cachedService=null;
Long key;
SharedSchedulingRule readLock=new SharedSchedulingRule(_writeLock);
try{
Job.getJobManager().beginRule(readLock, null);
key=_keyCache.get(clazz);
if(key!=null){
cachedService=_serviceCache.get(key);
}
}finally{
Job.getJobManager().endRule(readLock);
}
if(cachedService!=null){
return cachedService;
}
ServiceReference<?> ref=_context.getServiceReference(clazz);
Long sid=(Long)ref.getProperty(Constants.SERVICE_ID);
Object newService=_context.getService(ref);
try{
Job.getJobManager().beginRule(_writeLock, null);
key=_keyCache.get(clazz);
if(key!=null){
cachedService=_serviceCache.get(key);
}else{
_keyCache.put(clazz,sid);
_serviceCache.put(sid, newService);
}
}finally{
Job.getJobManager().endRule(_writeLock);
}
if(cachedService!=null){
_context.ungetService(ref);
return cachedService;
}else{
_context.addServiceListener(_tracker);
return newService;
}
}
public <Type> Type getService(Class<Type> clazz){
Object cachedService=null;
Long key;
SharedSchedulingRule readLock=new SharedSchedulingRule(_writeLock);
try{
Job.getJobManager().beginRule(readLock, null);
key=_keyCache.get(clazz);
if(key!=null){
cachedService=_serviceCache.get(key);
}
}finally{
Job.getJobManager().endRule(readLock);
}
if(cachedService!=null){
@SuppressWarnings("unchecked")
Type castedService=(Type)cachedService;
return castedService;
}
ServiceReference<Type> ref=_context.getServiceReference(clazz);
Long sid=(Long)ref.getProperty(Constants.SERVICE_ID);
Type newService=_context.getService(ref);
try{
Job.getJobManager().beginRule(_writeLock, null);
key=_keyCache.get(clazz);
if(key!=null){
cachedService=_serviceCache.get(key);
}else{
_keyCache.put(clazz.getName(),sid);
_serviceCache.put(sid, newService);
}
}finally{
Job.getJobManager().endRule(_writeLock);
}
if(cachedService!=null){
_context.ungetService(ref);
@SuppressWarnings("unchecked")
Type castedService=(Type)cachedService;
return castedService;
}else{
_context.addServiceListener(_tracker);
return newService;
}
}
public Object[] getServices(String clazz,String filter) throws InvalidSyntaxException{
ServiceReference<?>[] refs=_context.getServiceReferences(clazz,filter);
if(refs==null){
return null;
}
Object[] services=new Object[refs.length];
int count=refs.length;
boolean[] serviceAbsence=new boolean[refs.length];
Long[] SIDs=new Long[refs.length];
for(int i=0;i<=count-1;i++){
ServiceReference<?> ref=refs[i];
SIDs[i]=(Long)ref.getProperty(Constants.SERVICE_ID);
}
boolean loop=true;
SharedSchedulingRule readLock=new SharedSchedulingRule(_writeLock);
while(loop){
try{
Job.getJobManager().beginRule(readLock, null);
for(int i=0;i<=count-1;i++){
if(_serviceCache.containsKey(SIDs[i])==false){
serviceAbsence[i]=true;
}
}
}finally{
Job.getJobManager().endRule(readLock);
}
for(int i=0;i<=count-1;i++){
if(serviceAbsence[i]==true){
services[i]=_context.getService(refs[i]);
}
}
try{
Job.getJobManager().beginRule(_writeLock, null);
boolean gotNewRequire=false;
for(int i=0;i<=count-1;i++){
if(_serviceCache.containsKey(SIDs[i])==false && services[i]==null){
serviceAbsence[i]=true;
gotNewRequire=true;
}
}
if(gotNewRequire==false){
for(int i=0;i<=count-1;i++){
Object service=services[i];
if(service!=null){
_serviceCache.put(SIDs[i], service);
}else{
services[i]=_serviceCache.get(SIDs[i]);
}
}
loop=false;
}
}finally{
Job.getJobManager().endRule(_writeLock);
}
}
_context.addServiceListener(_tracker);
return services;
}
public <Type> Collection<Type> getServices(Class<Type> clazz,String filter) throws InvalidSyntaxException{
Collection<ServiceReference<Type>> refsCollection=_context.getServiceReferences(clazz,filter);
HashMap<Integer,Type> services=new HashMap<Integer,Type>(refsCollection.size()+1,1.0f);
if(refsCollection.size()==0){
return services.values();
}
ArrayList<ServiceReference<Type>> refs=new ArrayList<ServiceReference<Type>>(refsCollection);
int count=refs.size();
boolean[] serviceAbsence=new boolean[refs.size()];
Long[] SIDs=new Long[refs.size()];
for(int i=0;i<=count-1;i++){
ServiceReference<Type> ref=refs.get(i);
SIDs[i]=(Long)ref.getProperty(Constants.SERVICE_ID);
}
boolean loop=true;
SharedSchedulingRule readLock=new SharedSchedulingRule(_writeLock);
while(loop){
try{
Job.getJobManager().beginRule(readLock, null);
for(int i=0;i<=count-1;i++){
if(_serviceCache.containsKey(SIDs[i])==false){
serviceAbsence[i]=true;
}
}
}finally{
Job.getJobManager().endRule(readLock);
}
for(int i=0;i<=count-1;i++){
if(serviceAbsence[i]==true){
services.put(i, _context.getService(refs.get(i)));
}
}
try{
Job.getJobManager().beginRule(_writeLock, null);
boolean gotNewRequire=false;
for(int i=0;i<=count-1;i++){
if(_serviceCache.containsKey(SIDs[i])==false && services.containsKey(i)==false){
serviceAbsence[i]=true;
gotNewRequire=true;
}
}
if(gotNewRequire==false){
for(int i=0;i<=count-1;i++){
Object service=services.get(i);
if(service!=null){
_serviceCache.put(SIDs[i], service);
}else{
@SuppressWarnings("unchecked")
Type cachedService=(Type)_serviceCache.get(SIDs[i]);
services.put(i,cachedService);
}
}
loop=false;
}
}finally{
Job.getJobManager().endRule(_writeLock);
}
}
_context.addServiceListener(_tracker);
return services.values();
}
}
了解你的用户。如果你不能提前决定或者不能对这个问题做出有根据的猜测，就不要这样做
库发布后，倾听用户的意见，他们会告诉您。这完全取决于您的用户类型以及他们使用api的方式。没有永远正确的答案
如果您决定使用同步，请查看使用，而不是您使用的方式。这取决于您的程序将应用于什么用途，但在进行必要的更改之前，您最好不要使代码过于复杂。多线程优化可以在以后添加，但要在程序成熟后进行。您可以使其线程安全，但效率要高得多，在常见情况下，可能只需一次易失性读取。您可以提供更现实的问题版本，以便我们更好地理解。我同意前面的所有答案。这可能意味着过早地进行优化，试图找出并发使用模式。最好不要提供对多线程的支持，而是将其推给库的用户。有点像JCF类；请参见ArrayList、LinkedList，列表还会继续。最好的选择是使所有内容都不可变。那么你就不必担心任何事情：- 假设这是不可能的，那么我建议不要使库线程安全 线程安全通常会增加开销。在低级库中，您不应该强制用户为他们可能不需要的安全性支付性能罚款。 即使在库级别添加线程安全性，用户也可能需要在更高级别添加自己的锁定，这是因为锁不会组合。因此，您可能实际上并没有为用户节省任何工作。 如果需要，您可以随时在以后添加同步包装。但是，如果同步已烘焙，则无法删除同步。 它将使您自己的库代码更简单。您可以专注于更好的功能，而不是担心锁。
Java标准库中有一些遵循这种方法和逻辑的好例子，例如ArrayList不是线程安全的。我正在eclipse RCP中编程。它不是独立的。数据在两个HashMap中，类中的所有变量都是finalI，我认为在您的情况下，简单地同步会更快。您可以使用基准测试来查看差异。读锁适用于重叠读卡器。但您的读取很短，不太可能重叠。java同步系统可能会导致死锁。使用eclipse作业框架，以及实现良好的contains方法，理论上不会出现死锁。
package lazycatTools.runtime;
import java.util.Collections;
import java.util.Set;
import java.util.HashSet;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
public class MultiResourceSchedulingRule<ParentType,ResourceType> extends ResourceBindingSchedulingRule<ParentType> implements IMultiResourceSchedulingRule<ParentType,ResourceType> {
private final Set<ResourceType> _resources;
public MultiResourceSchedulingRule(ParentType parent){
this(parent,new HashSet<ResourceType>());
}
public MultiResourceSchedulingRule(ParentType parent,Set<ResourceType> resources){
super(parent);
Assert.isLegal(resources!=null);
_resources=resources;
}
@Override
public boolean isConflicting(ISchedulingRule rule){
if(rule==this){
return true;
}
if(rule instanceof IResourceBindingSchedulingRule<?>){
final IResourceBindingSchedulingRule<?> casted=(IResourceBindingSchedulingRule<?>)rule;
if(_resources.contains(casted.getResource())){
return true;
}
}
if(rule instanceof IMultiResourceSchedulingRule<?,?>){
final IMultiResourceSchedulingRule<?,?> casted=(IMultiResourceSchedulingRule<?,?>)rule;
if(Collections.disjoint(_resources,casted.getResources())==false){
return true;
}
}
return false;
}
@Override
public boolean contains(ISchedulingRule rule){
if(rule==this){
return true;
}
if(rule instanceof IResourceBindingSchedulingRule<?>){
final IResourceBindingSchedulingRule<?> casted=(IResourceBindingSchedulingRule<?>)rule;
if(_resources.contains(casted.getResource())){
return true;
}
}
if(rule instanceof IMultiResourceSchedulingRule){
final IMultiResourceSchedulingRule<?,?> casted=(IMultiResourceSchedulingRule<?,?>)rule;
if(_resources.containsAll(casted.getResources())){
return true;
}
}
return false;
}
@Override
public Set<ResourceType> getResources() {
return Collections.<ResourceType>unmodifiableSet(_resources);
}
}
package lazycatTools.runtime;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
public class ResourceBindingSchedulingRule<ResourceType> implements IResourceBindingSchedulingRule<ResourceType> {
private final ResourceType _resource;
public ResourceBindingSchedulingRule(ResourceType resource){
Assert.isLegal(resource!=null);
_resource=resource;
}
/* (non-Javadoc)
* @see lazycatTools.runtime.IResourceBindingSchedulingRule#getResource()
*/
@Override
public ResourceType getResource() {
return _resource;
}
@Override
public boolean contains(ISchedulingRule rule) {
return isConflicting(rule);
}
@Override
public boolean isConflicting(ISchedulingRule rule) {
if(rule==this){
return true;
}
if(rule instanceof IResourceBindingSchedulingRule<?>){
final IResourceBindingSchedulingRule<?> casted=(IResourceBindingSchedulingRule<?>)rule;
return _resource==casted.getResource();
}
return false;
}
}
package lazycatTools.runtime;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
public class SharedSchedulingRule implements ISchedulingRule {
private final ISchedulingRule _rule;
public SharedSchedulingRule(ISchedulingRule rule){
_rule=rule;
}
@Override
public boolean contains(ISchedulingRule rule) {
if(rule==this){
return true;
}
return _rule.contains(rule);
}
@Override
public boolean isConflicting(ISchedulingRule rule) {
if(rule==this){
return true;
}
return _rule.isConflicting(rule);
}
}