多线程并发编程笔记#

原子整数#

AtomicInteger

public class Auto {
    public static void main(String[] args) {
        AtomicInteger i = new AtomicInteger(100);
        i.incrementAndGet();//自增并且获取值++i
        i.getAndIncrement();//返回结果再自增i++
        i.addAndGet(10);//自增10再获取
        i.getAndAdd(10);//先获取再加10
    }
}

改造一下原先的CAS实现，使用getAndAdd再次封装的类

public void withdraw(int amount) {
    balance.getAndAdd(amount);
}

自定义原子操作

public class Auto {
    public static void main(String[] args) {
        AtomicInteger i = new AtomicInteger(100);
        i.updateAndGet(x -> 5 * x);
        System.out.println(i);//500
    }
}

源子引用#

AtomicReference、AtomicMarkableReference、AtomicStampedReference

public class Auto {
    public static void main(String[] args) {
        AtomicAccount balance = new AtomicAccount(new BigDecimal("100.00"));
        balance.withdraw(new BigDecimal("50"));
        System.out.println(balance.getBalance());
    }
}

class AtomicAccount {
    private AtomicReference<BigDecimal> balance;

    public AtomicAccount(BigDecimal balance) {
        this.balance = new AtomicReference<>(balance);
    }
    public BigDecimal getBalance() {
        return balance.get();
    }
    public void withdraw(BigDecimal amount) {
        while (true) {
            BigDecimal prev = balance.get();
            BigDecimal next = prev.subtract(amount);
            if (balance.compareAndSet(prev, next)) {
                break;
            }
        }
    }
}

ABA问题：在查询和修改之间如果另外一个线程修改过A，又修改过为B，则对于compareAndSet是没有办法直到其中有没有修改的，在大多数业务是没有问题的，但是主线程没法感知修改，我们要做到这一步需要使用AtomicStampedReference，设置版本号

public class Auto {
    public static void main(String[] args) {
        AtomicAccount balance = new AtomicAccount(new BigDecimal("100.00"));
        balance.withdraw(new BigDecimal("50"));
        System.out.println(balance.getBalance());
    }
}

class AtomicAccount {
    private AtomicStampedReference<BigDecimal> balance;

    public AtomicAccount(BigDecimal balance) {
        this.balance = new AtomicStampedReference<>(balance, 0);
    }
    public BigDecimal getBalance() {
        return balance.getReference();
    }
    public void withdraw(BigDecimal amount) {
        while (true) {
            BigDecimal prev = balance.getReference();
            int stamp = balance.getStamp();
            BigDecimal next = prev.subtract(amount);
            if (balance.compareAndSet(prev, next, stamp, stamp + 1)) {
                break;
            }
        }
    }
}

AtomicMarkableReference不关心更改了几次，而是关心是否更改过

class AtomicAccount {
    private AtomicMarkableReference<BigDecimal> balance;

    public AtomicAccount(BigDecimal balance) {
        this.balance = new AtomicMarkableReference<>(balance, false);
    }
    public BigDecimal getBalance() {
        return balance.getReference();
    }
    public void withdraw(BigDecimal amount) {
        while (true) {
            BigDecimal prev = balance.getReference();
            boolean marked = balance.isMarked();
            BigDecimal next = prev.subtract(amount);
            if (balance.compareAndSet(prev, next, marked, true)) {
                break;
            }
        }
    }
}

原子累加器#

LongAdder

可以提升性能，在竞争的时候，设置多个累加单元（Cell），最后再将结果汇总，这样可以有效地减少CAS重试失败的次数

Unsafe#

Unsafe对象提供了非常底层的内存操作，线程，Unsafe对象不可以直接调用，只能通过反射获取，直接使用getUnsafe会报错

Unsafe unsafe = Unsafe.getUnsafe(); // 抛出 java.lang.SecurityException

JVM 会检查调用类的类加载器，只有由 Bootstrap ClassLoader 加载的类（如 JRE 核心库）才能直接获取 Unsafe 实例

@Slf4j
public class Main {
    public static void main(String[] args) throws Exception {
        Field field = Unsafe.class.getDeclaredField("theUnsafe");
        field.setAccessible(true);
        Unsafe unsafe = (Unsafe) field.get(null);
        System.out.println(unsafe);
    }
}

@Slf4j
public class Main {
    public static void main(String[] args) throws Exception {
        Field field = Unsafe.class.getDeclaredField("theUnsafe");
        field.setAccessible(true);
        Unsafe unsafe = (Unsafe) field.get(null);
        System.out.println(unsafe);
        long idOffset = unsafe.objectFieldOffset(Teacher.class.getDeclaredField("id"));
        long nameOffset = unsafe.objectFieldOffset(Teacher.class.getDeclaredField("name"));
        Teacher teacher = new Teacher();
        unsafe.compareAndSwapInt(teacher, idOffset, 0, 1);
        unsafe.compareAndSwapObject(teacher, nameOffset, null, "李四");
        System.out.println(teacher);
    }
}

@Data
class Teacher {
    volatile long id;
    volatile String name;
}

sun.misc.Unsafe@490d6c15
Teacher(id=1, name=李四)