我按照这个问题中给出的指示(Jason的答案)来编写我的PriorityQueue<T>使用a SortedList.我知道count这个类中的字段用于确保唯一的优先级并保持相同优先级的排队顺序.
但是,当count达到其最大值并且I加1时,后者将从0开始,因此后续项的优先级将高于先前项的优先级.使用这种方法我可能需要一种"安全"重置计数器的方法count......实际上,假设有以下队列状态(格式为priority | count | item):
0 | 123 | A
0 | 345 | B
1 | 234 | C
2 | 200 | d
现在假设计数器限制已达到,所以我必须将其重置为0:因此,下一个插入的项目将具有计数器0:例如,如果我插入优先级等于1的元素,它将被错误地插入之前1 | 234 | d
0 | 123 | A
0 | 345 | B
1 | 000 | 新元素
1 | 234 | C
2 | 200 | d
优先级的问题可以通过实现堆来解决:我创建了一个Heap类,然后我使用Heap<KeyValuePair<TPriority, TElement>了一个自定义PriorityComparer以便按元素排序TPriority …
我创建了一个简单的语音识别服务:为此,我创建了一个子类,android.speech.RecognitionService并创建了一个活动来启动和停止此服务.
我的自定义语音识别服务通常使用默认的语音识别器,因为我的目标只是了解RecognitionService和RecognitionService.Callback类的工作方式.
public class SimpleVoiceService extends RecognitionService {
private SpeechRecognizer m_EngineSR;
@Override
public void onCreate() {
super.onCreate();
Log.i("SimpleVoiceService", "Service started");
}
@Override
public void onDestroy() {
super.onDestroy();
Log.i("SimpleVoiceService", "Service stopped");
}
@Override
protected void onCancel(Callback listener) {
m_EngineSR.cancel();
}
@Override
protected void onStartListening(Intent recognizerIntent, Callback listener) {
m_EngineSR.setRecognitionListener(new VoiceResultsListener(listener));
m_EngineSR.startListening(recognizerIntent);
}
@Override
protected void onStopListening(Callback listener) {
m_EngineSR.stopListening();
}
/**
*
*/
private class VoiceResultsListener implements RecognitionListener {
private Callback m_UserSpecifiedListener;
/**
*
* …我读了一些关于SyncRoot模式的内容,作为避免死锁的一般规则.阅读几年前的问题(见此链接),我想我明白这种模式的一些用法可能是不正确的.特别是,我专注于本主题的以下句子:
您会注意到System.Collections中许多集合上的SyncRoot属性.在回顾中,我认为这个属性是一个错误......请放心,我们不会犯这个错误,因为我们构建这些集合的通用版本.
实际上,例如,List<T>类不实现SyncRoot属性,或者更正确地实现它是显式实现的(请参阅此答案),因此必须强制转换ICollection才能使用它.但是这篇评论认为,SyncRoot公开私人领域与锁定一样糟糕this(见这个答案),这也在本评论中得到证实.
因此,如果我理解正确,当我实现非线程安全的数据结构时,因为它可以在多线程上下文中使用,所以我不应该(实际上,我不能)提供该SyncRoot属性.但是我应该让开发人员(将使用此数据结构)的任务是将其与私有SyncRoot对象相关联,如下面的示例代码所示.
public class A
{
private MyNonThreadSafeDataStructure list;
private readonly object list_SyncRoot = new object;
public Method1()
{
lock(list_SyncRoot)
{
// access to "list" private field
}
}
public Method2()
{
lock(list_SyncRoot)
{
// access to "list" private field
}
}
}
总之,我了解同步/锁定的最佳实践应如下所示:
为了获得包含在一个指定的目录,并根据一些扩展的所有文件,我使用的方法listFiles类的FileUtils从阿帕奇百科全书IO库,如下面的代码样本.
ArrayList<String> wildcards = new ArrayList<>();
wildcards.add("*.cpp");
wildcards.add("*.h");
wildcards.add("*.txt");
File dir = new File("/path/to/dir");
Collection<File> found = FileUtils.listFiles(
dir,
new WildcardFileFilter(wildcards, IOCase.SENSITIVE),
DirectoryFileFilter.DIRECTORY);
List<File> files = new ArrayList<>(found);
结果中的项目顺序Collection<File>在不同的操作系统中有所不同,因此我会files根据以下规则对它们(即包装列表)进行排序.
例:
/path/to/dir/first/subpath/main.cpp
/path/to/dir/first/subpath/utils.cpp
/path/to/dir/first/subpath/utils.h
/path/to/dir/first/main.cpp
/path/to/dir/first/utils.cpp
/path/to/dir/first/utils.h
/path/to/dir/second/main.cpp
/path/to/dir/second/utils.cpp
/path/to/dir/second/utils.h
/path/to/dir/README.txt
is运算符仅考虑引用转换,装箱转换和拆箱转换.其他转换(例如用户定义的转化)不予考虑.
这在实践中意味着什么？用它来检查结构是否是某种类型是错误的吗？例如,
public struct Point2D
{
public int X;
public int Y;
...
public override bool Equals(Object value)
{
if (value != null && value is Point2D) // or if (value != null && GetType() == value.GetType())
{
Point2D right = (Point2D)value;
return (X == right.X && Y == right.Y);
}
else return false;
}
...
}
OpenCV中的CvCapture结构和VideoCapture结构有什么区别吗？如果是这样,我应该CvCapture何时使用以及何时使用VideoCapture？
Android中两个不同进程(服务和活动)之间的通信可以通过Messenger或AIDL进行管理:活动绑定到服务就足够了.
但是,如果此活动有一个或多个子活动会发生什么？从主要活动开始子活动的那一刻起,我希望将通信重定向到子活动; 同样,当子活动被销毁时,我希望将通信重定向回主活动等.
示例#1:
示例#2:
如何处理这些案件？
的模板的方法图案提供的抽象基类具有不可重写方法:该方法中实现了通用算法,并且不应当在子类覆盖.在Java中,模板方法final在抽象基类中声明,在C#中,sealed关键字具有类似的含义,但不能声明未重写的方法sealed.
public abstract class Base
{
protected abstract AlgorithmStep1();
protected abstract AlgorithmStep2();
public sealed void TemplateMethod() // sealed: compile error
{
AlgorithmStep1();
AlgorithmStep2();
}
}
我怎么解决这个问题？为什么不能阻止子类覆盖一个方法(在C#中)？
假设多个线程定期执行DoWork()下面的方法.假设在某个时刻,两个线程几乎同时开始执行此方法,因此两个本地时间戳对象中的一个比另一个更大.
ICollection collection = // ...
public void DoWork()
{
DateTime timestamp = DateTime.Now;
lock(collection.SyncRoot)
{
// critical section
}
}
如果线程A的特征在于时间戳等于t1,而线程B的特征在于时间戳t2等于t1 + 1 tick,则线程A将首先需要访问临界区.
.NET如何通过多个线程管理对关键部分的访问？它是否将访问请求放入队列中,以便它们按时间顺序排列？换句话说,是否根据线程访问请求的顺序保证对关键部分的访问？
我在Protege 4.3.0中创建了一个本体,并存储在一个OWL文件中.为了使用OWL API加载此本体,我使用以下代码示例.
public class MySampleClass {
private final OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
private final OWLDataFactory df = manager.getOWLDataFactory();
private final OWLReasonerFactory rf = new StructuralReasonerFactory();
private final OWLOntology ontology;
private final OWLOntologyID id;
private final IRI iri;
private final PrefixManager pm;
private final OWLReasoner reasoner;
/**
*
* @param file
*/
public MySampleClass(File file) {
try {
ontology = manager.loadOntologyFromOntologyDocument(file);
} catch (OWLOntologyInputSourceException | OWLOntologyCreationException ex) {
// throw custom exception
}
id = ontology.getOntologyID();
iri = …