使用Synchronized和Atomic控制并发对比

按照我们往常的经验，我们看到多线程就可能习惯性地将Synchonized往上怼，Synchronized中使用了悲观锁思想，它是可重入锁，实现了多线程的原子性、可见性保证了线程安全，但是有些场景下使用Atomic原子类往往会取得更好的效果，因为Atomic原子类使用的是CAS无锁机制，更加高效地帮助我们实现多线程并发工作，下面是两个代码对比，看到执行结果，你可能会大吃一惊！

目录

一、Synchronized实现多线程并发

二、使用AtomicInteger原子类实现多线程并发

三、效果对比

---

一、Synchronized实现多线程并发

package com.important.lock;

// 连个线程，同事操作一个全局变量，演示线程安全问题
public class UserSynchronize implements Runnable {

    // 共享的全局变量
    private static int count = 1;

    static long time1;
    static long time2;

    @Override
    public void run() {
        while (true) {
            Integer count = getCount();
            if (count >= 1000) {
                time2 = System.currentTimeMillis();
                int time = (int) ((time2 - time1)/1000);
                System.out.println("执行了："+time+"秒！");
                break;
            }
            System.out.println(count);
        }
    }

    // 使用synchronize
    private synchronized Integer getCount() {
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return count++;
    }

    public static void main(String[] args) {
        time1 = System.currentTimeMillis();
        UserSynchronize userSynchronize = new UserSynchronize();
        Thread t1 = new Thread(userSynchronize);
        Thread t2 = new Thread(userSynchronize);
        t1.start();
        t2.start();
    }
}

二、使用AtomicInteger原子类实现多线程并发

package com.important.lock;

import java.util.concurrent.atomic.AtomicInteger;

public class UseAtomic implements Runnable {

    // 共享全局变量
    AtomicInteger atomicInteger = new AtomicInteger();

    static long time1;
    static long time2;

    @Override
    public void run() {
        while (true) {
            Integer count = getCount();
            if (count >= 1000) {
                time2 = System.currentTimeMillis();
                int time = (int) ((time2 - time1)/1000);
                System.out.println("执行了："+time+"秒！");
                break;
            }
            System.out.println(count);
        }
    }

    private Integer getCount() {
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return atomicInteger.incrementAndGet();
    }

    public static void main(String[] args) {
        time1 = System.currentTimeMillis();
        UseAtomic useAtomic = new UseAtomic();
        Thread t1 = new Thread(useAtomic);
        Thread t2 = new Thread(useAtomic);
        t1.start();
        t2.start();
    }
}

三、效果对比

上面的两个执行的内容是从1数到1000，中间过程都是一样的，使用了两个线程去跑，一个是Synchronized控制并发，另个是使用AtomicInteger来解决并发，效果对比：

 效果简直是太Amazing了。

另外，Atomic常用的原子类还有：

1. AtomicBoolean
2. AtomicLong
3. AtomicReference 

适当的场景可以使用。