小编Var*_*rde的帖子

我正在阅读Java 1.6 API提供的HashMap类的代码,无法完全理解以下操作的需要(在put和get方法的主体中找到):

int hash = hash(key.hashCode());

方法hash()具有以下主体:

 private static int hash(int h) {
         h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

这通过对提供的哈希码执行位操作来有效地重新计算哈希值.即使API声明如下,我也无法理解这样做的必要性:

这很关键,因为HashMap使用两个幂的长度哈希表,否则会遇到低位不同的hashCodes的冲突.

我确实理解键值是存储在数据结构数组中的,并且该数组中项的索引位置由其哈希确定.我无法理解的是这个函数如何为哈希分布添加任何值.

我刚刚加入了一个团队,这个团队在过去的5年里一直在主要模式(java,maven为基础的项目).因此,利用单元测试的计划一直在进行中,从未实现(到目前为止).一个伟大的开发团队已经确保代码质量通常很好,并且没有结构代码问题,但是没有编写jnuit测试的文化.但是,我看到了单元测试的好处,我在这里推动采用自动测试.

团队布局使得单独的测试团队在推出代码之前对功能进行手动测试,并且变更管理团队是变更审批和构建的检查门(到目前为止还没有持续集成).

以下是障碍:因为代码库很大,而且一些原始开发人员离开了团队,所以任何额外的单元测试都可能太少,太晚了.除此之外,我可能是唯一一个推动单元测试的人.虽然我的经理一直支持这个想法,但他并不希望变更团队因测试运行所需的额外时间而陷入困境.

我认为可以使用独立的CI工具开始,并且变更团队必须改变他们的脚本以跳过测试,当它们被添加时.

你会穿什么鞋子？

PS:我知道在stackoverflow上有一个类似的问题,但在这个问题上,目的是说服不同的利益相关者和最佳的接受途径; 不是技术比较.

我正在尝试扩展和定制外部xsd架构(fixml标准).我需要更改某些元素的数据类型,而不是触及原始模式,而是重新定义它; 但一直发现它非常麻烦.

存在的是什么

场,base.xsd

<xs:simpleType name="LastUpdateTime_t">
           <xs:restriction base="UTCTimestamp">
<xs:simpleType>

我希望它变成什么:

<xs:simpleType name="LastUpdateTime_t">
           <xs:restriction base="xs:string">
<xs:simpleType>

我尝试了什么(但失败了):

<xs:redefine schemaLocation="fields-base.xsd">
            <xs:simpleType name="LastUpdateTime_t">
              <xs:restriction base="xs:string" />
            </xs:simpleType>
 </xs:redefine>

书籍和网似乎也没有太大的帮助,所以我开始质疑这在理论上是否可行.

我试图在BlockingQueue上使用迭代器方法并发现hasNext()是非阻塞的 - 即它不会等到添加更多元素,而是在没有元素时返回false.

所以这里是问题:

1. 这是糟糕的设计还是错误的期望？
2. 有没有办法使用BLockingQueue的阻塞方法及其父类Collection方法(例如,如果某些方法需要一个集合,我可以传递一个阻塞队列,并希望它的处理将等到Queue有更多元素)

这是一个示例代码块

public class SomeContainer{
     public static void main(String[] args){
        BlockingQueue bq = new LinkedBlockingQueue();
        SomeContainer h = new SomeContainer();
        Producer p = new Producer(bq);
        Consumer c = new Consumer(bq);
        p.produce();
        c.consume();
    }

    static class Producer{
        BlockingQueue q;
        public Producer(BlockingQueue q) {
            this.q = q;
        }

        void produce(){
        new Thread(){
            public void run() {
            for(int i=0; i<10; i++){
                for(int j=0;j<10; j++){
                    q.add(i+" - "+j);
                }
                try {
                    Thread.sleep(30000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } …

我需要在一个功能中锁定两个对象,并且当前代码如下所示;

Object obj1  = ...//get from somewhere
Object obj2 = ...//get from somewhere

synchronized(obj1){
  ...//blah
  synchronized(obj2){
     ...//blah
  }
}

正如你所看到的,如果另一个线程使用obj1运行这段代码并且两个反转,这是一个简单而直接的死锁配方.
有没有办法使用concurrency-utils锁来避免这种情况？

我正在考虑维护一个物体及其锁的地图,并验证它们是否可以使用,但似乎无法想出一种可以预测锁定顺序的清洁方式.