小编St.*_*rio的帖子

我有三个班级(这个数字将来可能会增长):

public inteface Base{ }

public class Select implements Base{ }

public class Ast implements Base{ }

public class Gt implements Base{ }

我也需要List上课

BaseList extends ArrayList<Base>{
    public boolean add(Base b){
        throw new UnsupportedOperationException("You should use add%ConcereteBaseType% method instead");
    }

    public boolean add(Select s){ }

    public boolean add(Ast a){ }

    public boolean add(Gt g){ }
}

我这样做的原因是我不希望任何人通过指针添加元素Base.在我的具体情况下,这将是不安全的.

但缺点是只能在运行时才能发现它.

我还需要迭代列表.

做这些事情是一种好习惯吗？

我正在阅读J. Bloch的Effective Java,现在我正在继承vs组成部分.据我所知,他说继承并不总是好的.

子类中脆弱性的一个相关原因是它们的超类可以在后续版本中获取新方法.假设程序依赖于其安全性,因为插入到某个集合中的所有元素都满足某些谓词.这可以通过 继承集合并覆盖每个能够 添加元素的方法来保证,以确保在 添加元素之前满足谓词.这可以正常工作,直到在后续版本中将能够插入元素的新方法添加到超类中.

但为什么它不起作用？超类只是Collection接口,如果我们添加一个新方法,我们只是一个编译时错误.那不是有害的......

我已经阅读了这个答案,最后写了以下内容:

使用volatile可以完成的任何事情都可以通过同步来完成,但反之亦然.

目前尚不清楚.JLS 8.3.1.4定义了volatile字段,如下所示:

字段可以声明为volatile,在这种情况下,Java Memory Model可以确保所有线程都看到变量的一致值(第17.4节).

因此,volatile字段与内存可见性有关.另外,据我所提到的答案,读取和写入易失性字段是同步的.

同步反过来保证只有一个线程可以访问同步块.正如我所知,它与内存可见性无关.我错过了什么？

我正在尝试使用EXPLAIN命令并试图找出它是什么shared hit.

Seq Scan on foo  (cost=0.00..18334.00 rows=1000000 width=37) (actual time=0.030..90.500 rows=1000000 loops=1)
  Buffers: shared hit=512 read=7822
Total runtime: 116.080 ms

我注意到,我们拥有的共享命中数越多,执行查询的速度就越快.但那是什么？就我而言,shared read只是从物理存储中读取RAID或者SSD.但为什么shared hit速度更快？它存储在RAM内还是哪里？

我正在阅读B. Goetz Java Concurrency在实践中,现在我正处于section 3.5安全的出版物中.他说:

// Unsafe publication
public Holder holder;
public void initialize() {
    holder = new Holder(42);
}

这种不正确的发布可能允许另一个线程观察部分构造的对象.

我不明白为什么可以观察到部分构造的子对象.假设构造函数Holder(int)不允许this转义.因此,构造的引用只能由调用者观察到.现在,正如JLS 17.7所述:

无论是否将它们实现为32位或64位值,对引用的写入和读取始终是原子的.

线程不可能观察到部分构造的对象.

我哪里错了？

我试图了解如何衡量性能并决定编写非常简单的程序:

section .text
    global _start

_start:
    mov rax, 60
    syscall

我用perf stat ./bin 这个程序运行我感到惊讶的stalled-cycles-frontend是太高了.

      0.038132      task-clock (msec)         #    0.148 CPUs utilized          
             0      context-switches          #    0.000 K/sec                  
             0      cpu-migrations            #    0.000 K/sec                  
             2      page-faults               #    0.052 M/sec                  
       107,386      cycles                    #    2.816 GHz                    
        81,229      stalled-cycles-frontend   #   75.64% frontend cycles idle   
        47,654      instructions              #    0.44  insn per cycle         
                                              #    1.70  stalled cycles per insn
         8,601      branches                  #  225.559 M/sec                  
           929      branch-misses             #   10.80% of all branches        

   0.000256994 seconds time elapsed …

我在Whiskey Lake i7-8565U 上分析性能计数器和复制 512 KiB 数据（比 L2 缓存大小大两倍）的时间，并在 L2 硬件预取器的工作方面遇到了一些误解。

在Intel Manual Vol.4 MSR 中，MSR0x1A4的位 0 用于控制 L2 HW 预取器（1 表示禁用）。

考虑以下基准：

memcopy.h：

void *avx_memcpy_forward_lsls(void *restrict, const void *restrict, size_t);

memcopy.S：

avx_memcpy_forward_lsls:
    shr rdx, 0x3
    xor rcx, rcx
avx_memcpy_forward_loop_lsls:
    vmovdqa ymm0, [rsi + 8*rcx]
    vmovdqa [rdi + rcx*8], ymm0
    vmovdqa ymm1, [rsi + 8*rcx + 0x20]
    vmovdqa [rdi + rcx*8 + 0x20], ymm1
    add rcx, 0x08
    cmp rdx, rcx
    ja avx_memcpy_forward_loop_lsls …

cppreference有一个引用:

每个对象类型都有称为对齐要求的属性,它是一个整数值(类型为std :: size_t,总是2的幂),表示可以分配此类对象的连续地址之间的字节数.

据我所知,这个参考文献是非规范性的.但是alignof(T)标准中没有关于价值的东西,而不是它alignof(std::max_align_t).

显然,对齐是2的幂.为什么对齐不是3？

由于PostgreSQL不支持聚簇索引,我正在考虑MSSQL服务器.我已经阅读了比较聚簇索引和非聚簇索引的文章.文章的要点是(强调我的):

非聚簇索引存储值和指向包含该值的实际行的指针.

和

由于表中的行以与聚簇索引完全相同的顺序存储在磁盘上,因此聚簇索引不需要存储指向实际行的指针

据我所知,有和没有是很困难的,支持物理表的数据进行排序,特别是如果表是多个驱动器之间的分裂.现在,我遇到了聚集索引概念,假设数据以某种顺序存储在物理上.这就是我所困惑的.

问题:什么是聚簇索引结构？它支持tree式的结构穿越过来,像PosgtreSQL做了btree索引？

基准测试是在 intel core i5, Ubuntu

java version "1.8.0_144"
Java(TM) SE Runtime Environment (build 1.8.0_144-b01)
Java HotSpot(TM) 64-Bit Server VM (build 25.144-b01, mixed mode)

我正在比较Collectors.counting和的表现Collectors.summingLong(x -> 1L).这是基准:

public List<Integer> ints = new ArrayList<>();

Collector<Integer, ?, Long> counting = Collectors.counting();
Collector<Integer, ?, Long> summingLong = Collectors.summingLong(x -> 1L);

@Setup
public void setup() throws Exception{
    ints.add(new Random().nextInt(1000));
    ints.add(new Random().nextInt(1000));
    ints.add(new Random().nextInt(1000));
    ints.add(new Random().nextInt(1000));
    ints.add(new Random().nextInt(1000));
    ints.add(new Random().nextInt(1000));
    ints.add(new Random().nextInt(1000));
    ints.add(new Random().nextInt(1000));
    ints.add(new Random().nextInt(1000));
    ints.add(new Random().nextInt(1000));
}

@Benchmark
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime) …