关于 Builder 模式线程安全的疑问

public class Address {

    private final Long id;
    private final String street;

    Address(Long id, String street) {
        this.id = id;
        this.street = street;
    }

    public static AddressBuilder builder() {
       return new AddressBuilder();
    }

    public static class AddressBuilder {
        private Long id;
        private String street;

        AddressBuilder() {
        }

        public AddressBuilder id(Long id) {
            this.id = id;
            return this;
        }

        public AddressBuilder street(String street) {
            this.street = street;
            return this;
        }

        public Address build() {
            return new Address(id, street);
        }

        public String toString() {
            return "Address.AddressBuilder(id=" + this.id + ", street=" + this.street + ")";
        }
    }
}

//测试类
public class Test {

    Address obj;
    
    public void write() {
    	Address address = Address.builder()
                            .id(1L)
                            .street("street 1")
                            .build();
       	obj = address;
    }
    
    public void read() {
    	Long id = obj.id;
    }
}

现在，线程 A 调用 write 方法，创建 Address 实例并赋值给 obj，线程 B 调用 read 方法，读取 id 值。 这样子应该不是线程安全的吧，即使 id 有 final 修饰。

现在疑惑是，使用 Builder 模式创建对象一定是线程安全的吗？

虽然理论每次调用 build 方法会创建一个新实例，各线程之间不共享该实例也就不会出现并发问题。 但是，使用 Java Bean 也可以这样子

Address address = new Address();
address.setId(99L);
address.setStreet("Street 2");

每个线程都创建一个新实例啊，即使指令重排也没有影响啊。

但是 Effective Java 中又强调使用 Builder 模式可以规避 Jave Bean 创建对象时，出现的线程不安全问题。