使用原子类替代synchronized和Lock(重量级锁)

volatile、原子类简单介绍

我们都知道，synchronized和Lock是比较重量级的锁，多线程进行操作时，会锁住一段代码，这样高并发下效率就比较低。

而juc提供了原子类和volatile，就是解决重量级锁的效率问题，原子类会调用native方法，native方法调用操作系统的接口（汇编指令：cmpxchg），在硬件层面对变量进行加锁，这种细粒度的锁，效率更高。而volatile保证了多线程之间变量的可见性，修改变量后立即写回到主存并让其他线程可见。

替代synchronized和Lock

基本类型及包装类

以int为例：

需求：

以一种线程安全的方式操作非线程安全对象的某些字段。

需求：

• 10个线程，
• 每个线程转账1000，
• 不使用synchronized,尝试使用AtomicIntegerFieldUpdater来实现。

解决思路：使用volatile修饰字段（保证线程之间可见性）、原子类AtomicIntegerFieldUpdater来包装类、CountDownLatch（保证线程操作完）

代码：

class BankAccount//资源类
{
    String bankName = "CCB";

    //更新的对象属性必须使用 public volatile 修饰符。
    public volatile int money = 0;//钱数

    public void add()
    {
        money++;
    }

    //因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须
    // 使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。

    AtomicIntegerFieldUpdater<BankAccount> fieldUpdater =
            AtomicIntegerFieldUpdater.newUpdater(BankAccount.class,"money");

    //不加synchronized，保证高性能原子性，局部微创小手术
    public void transMoney(BankAccount bankAccount)
    {
        fieldUpdater.getAndIncrement(bankAccount);
    }


}

/**
 * 以一种线程安全的方式操作非线程安全对象的某些字段。
 *
 * 需求：
 * 10个线程，
 * 每个线程转账1000，
 * 不使用synchronized,尝试使用AtomicIntegerFieldUpdater来实现。
 */
public class AtomicIntegerFieldUpdaterDemo
{
    public static void main(String[] args) throws InterruptedException
    {
        BankAccount bankAccount = new BankAccount();
        CountDownLatch countDownLatch = new CountDownLatch(10);

        for (int i = 1; i <=10; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <=1000; j++) {
                        //bankAccount.add();
                        bankAccount.transMoney(bankAccount);
                    }
                } finally {
                    countDownLatch.countDown();
                }
            },String.valueOf(i)).start();
        }

        countDownLatch.await();

        System.out.println(Thread.currentThread().getName()+"\t"+"result: "+bankAccount.money);
    }
}

引用类型

需求：

需求：

*多线程并发调用一个类的初始化方法，如果未被初始化过，将执行初始化工作，

*要求只能被初始化一次，只有一个线程操作成功

解决思路：使用volatile修饰期望值（保证线程之间可见性）、原子类AtomicReferenceFieldUpdater包装资源类。

代码：

class MyVar //资源类
{
    public volatile Boolean isInit = Boolean.FALSE;

    AtomicReferenceFieldUpdater<MyVar,Boolean> referenceFieldUpdater =
            AtomicReferenceFieldUpdater.newUpdater(MyVar.class,Boolean.class,"isInit");

    public void init(MyVar myVar)
    {
        if (referenceFieldUpdater.compareAndSet(myVar,Boolean.FALSE,Boolean.TRUE))
        {
            System.out.println(Thread.currentThread().getName()+"\t"+"----- start init,need 2 seconds");
            //暂停几秒钟线程
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName()+"\t"+"----- over init");
        }else{
            System.out.println(Thread.currentThread().getName()+"\t"+"----- 已经有线程在进行初始化工作。。。。。");
        }
    }
}


/**
 * 需求：
 * 多线程并发调用一个类的初始化方法，如果未被初始化过，将执行初始化工作，
 * 要求只能被初始化一次，只有一个线程操作成功
 */
public class AtomicReferenceFieldUpdaterDemo
{
    public static void main(String[] args)
    {
        MyVar myVar = new MyVar();

        for (int i = 1; i <=5; i++) {
            new Thread(() -> {
                myVar.init(myVar);
            },String.valueOf(i)).start();
        }
    }
}