java - 在不同线程中同时更新(或/和读取)共享可变对象的不同字段

Question

在不同线程中同时更新(或/和读取)共享对象的不同字段，线程安全吗？如果是的话，这是一个好的做法吗？

注意:假设我们知道在任何时候都没有两个(或更多)线程会对此共享可变对象的同一字段/属性进行操作(读取或写入)。

E.G 考虑这段代码 - 正在更新和读取共享可变对象的不同字段 emp在线程中t1 , t2和t3同时线程安全并且是一种可接受的做法？

package concurrency;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

public class SharedObjectApp {

  public static void main(String args[]){
      new App().doSomething();
  }

  public class App{

      Employee emp = new Employee(001, 100000, 32);

      public void doSomething(){

          Thread t1 = new Thread(new Runnable(){
              @Override
              public void run(){
                  emp.setSalary(emp.getSalary() + 1000);
              }
          });

          Thread t2 = new Thread(new Runnable() {
              @Override
              public void run() {
                  emp.setExp(emp.getExp() + 1);
              }
          });

          Thread t3 = new Thread(new Runnable() {
              @Override
              public void run() {
                  for(int i = 0; i < 10; i ++){
                      System.out.println(emp.getId());
                  }
              }
          });

          // is this thread safe?

          t1.start(); //updating salary
          t2.start(); //updating experience
          t3.start(); //getting id
      }
  }

  @NoArgsConstructor
  @AllArgsConstructor
  @Getter
  @Setter
  public static class Employee {
    int id;
    double salary;
    double exp;
  }

}

Answer 1

这不是未定义的行为，但它会减慢程序的速度。同时写入和/或读取不同的字段(知道它们不相互依赖)是非常安全的。尽管这是虚假共享的教科书示例，不应该这样做。

当访问内存位置(类及其成员)时，该位置会被复制到 CPU 缓存行中，以便更快地访问。如果更多线程尝试同时访问该内存位置，则可能会使这些缓存行无效以保持内存一致性，从而减慢执行速度。

From oracle docs :

However, simultaneous updates of individual elements in the same cache line coming from different processors invalidates entire cache lines, even though these updates are logically independent of each other. Each update of an individual element of a cache line marks the line as invalid. Other processors accessing a different element in the same line see the line marked as invalid. They are forced to fetch a more recent copy of the line from memory or elsewhere, even though the element accessed has not been modified. This is because cache coherency is maintained on a cache-line basis, and not for individual elements. As a result there will be an increase in interconnect traffic and overhead. Also, while the cache-line update is in progress, access to the elements in the line is inhibited.

Jenkov has great resource on this (他们谈论的是多 CPU 系统，但它仍然适用，因为平台线程共享缓存行)。