小编Sha*_*kar的帖子

根据我的理解,并发集合类优先于同步集合,因为并发集合类不会锁定整个集合对象.相反,他们会对集合对象的一小部分进行锁定.

但是当我检查add方法时CopyOnWriteArrayList,我们正在获取完整集合对象的锁定.那么为什么CopyOnWriteArrayList比返回的列表更好Collections.synchronizedList？我在add方法中看到的唯一区别CopyOnWriteArrayList是每次add调用方法时我们都在创建该数组的副本.

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

我正在尝试示例fetchType.Lazy,但在调试代码时,它似乎fetchType.Lazy无法正常工作.

实体bean:地址

在区域字段上添加了注释@Basic,其属性为fetch = fetchType.Lazy.

我的实体bean由以下代码定义:

    package model;

    import java.io.Serializable;
    import javax.persistence.*;
    import java.util.List;


    /**
     * The persistent class for the address database table.
     */
    @Entity
    @Table(name="address", schema="home")
    public class Address implements Serializable {
        private static final long serialVersionUID = 1L;

        @TableGenerator(name = "addr_gen", table = "table_generator", pkColumnName = "gen_name", valueColumnName = "gen_val", allocationSize=1)
        @Id
        @GeneratedValue(strategy=GenerationType.TABLE, generator="addr_gen")
        private String addressId;

        private String city;

        @Basic(fetch=FetchType.LAZY)
        @Column(name="district")
        private String district;

        private String houseNumber;

        private String pincode;

        private String …

JVM内存分为:1.方法区2.堆区3.堆栈4. PC寄存器5.本机堆栈

1. 现在假设我有一个具有"int [] dealCodes"属性的类(int primitive的数组).根据内存管理,一旦交易代码被初始化,内存中将存在(total_elements*4字节)的连续内存分配.因此,如果数组大小为10,则JVM内存中将分配40个字节.

   我的问题是这个40字节将分配到哪个区域(堆或堆栈)？

   我对数组的理解是:它就像任何其他对象一样,驻留在堆区域下,但不知道数组指向的基元.

2. 当数组保存引用时(例如,Employees类型的数组),也想知道类似的情况.我认为在这种情况下,一切都将在堆区域.由于这些是引用,因此数组将为每个引用(3​​2位系统)保存4个字节,并且这些引用将指向不同大小的对象.数组内存分配将根据引用大小而非对象大小计算.

请帮助我清楚以上2点.

我有打包为可执行jar的spring boot应用程序。应用程序具有一个带有主方法的实用程序类，我想通过命令行调用它，但是似乎命令无法在类路径中找到该类。

命令：

java -cp client-stp-grid-publisher-SNAPSHOT.jar com.client.stp.util.JMXClientUtils

我试图使用gradle jar任务在MANIFEST.MF中设置jar类路径，但没有帮助：

jar {
    baseName = 'client-stp-grid-publisher'
    manifest {
        attributes(
                'Class-Path': "BOOT-INF/classes/*"
        )
    }
}

生成的MANIFEST.MF：

Manifest-Version: 1.0
Main-Class: org.springframework.boot.loader.JarLauncher
Class-path: BOOT-INF/classes/*
Start-Class: com.client.stp.ClientStpGridPublisherMain
Spring-Boot-Version: 1.5.10.RELEASE
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/

我了解理想情况下不能将可执行jar用作依赖库，但是有没有解决方法来实现我的用例？

其他解决方案可以通过传递一个标志来将主类或实用程序类作为Spring Boot应用程序运行，但我不想将实用程序类作为Spring Boot进程运行。

根据文档https://users.scala-lang.org/t/sip-13-implicit-classes-scala-documentation/705，隐式类的用例是
“提出了一种新的语言构造来简化类的创建为另一种类型提供扩展方法。”
这需要创建新类、各自的函数并导入。
通过创建具有静态方法的 Utils 类可以实现相同的效果。我无法理解隐式类在这里添加了哪些额外的好处，而这些好处是通过具有静态方法的 Utils 类无法实现的。

任何人都可以帮我理解为什么Int类型溢出结果与更高的数字不一致.有时它是正的,有时是负的,最后收敛到零.

import scala.annotation.tailrec

object FactorialExample {

  def main(args: Array[String]): Unit = {
    (1 to 100).foreach(i => println(s"Factorial of ${i} is " + factorial(i)))
  }

  def factorial(i: Int): Int = {
    @tailrec
    def fact(i: Int, acc: Int): Int = {
      if (i <= 0) acc
      else fact(i - 1, acc * i)
    }
    fact(i, 1)
  }
}

AtomicReference 实例使用 Unsafe CAS 操作来利用处理器指令进行锁定。但是我有点困惑它在复杂对象的情况下是如何工作的。

例如，让我们假设我有一个 Person 类的实例（id、firstName、lastName）。我将对象实例共享给多个线程 t1、t2 和 t3。由于操作应该是原子的，所以我不会共享 Person 类对象实例，而是将该对象包装到 AtomicReference 实例中并与所有线程共享。

现在线程 t1 只更新 firstName，线程 t2 只更新 lastName，线程 t3 更新 firstName 和 lastName。之后每个线程都会调用 compareAndSet 方法来反映新的变化。

此外，我正在使用易失性引用，以便写入可以发生在主内存中并对所有线程可见。

我想明白：

1. 在上面的场景中，当 compareAndSet 被调用时，Person 类实例（例如 id、firstName、lastName）的预期值和新值之间将比较哪些内容？

2. 假设线程 t1 更新了 firstName 并调用了 compareAndSet。线程 t2 已更新 lastName 并且将调用 compareAndSet。在这种情况下，AtomicReference 如何保证线程 t2 不会擦除线程 t1 所做的更改，即更新 firstName？

3. 假设 2 个线程 t1 和 t2 同时调用 compareAndSet 那么谁将赢得比赛，而其他失败的线程会怎样？