Java之线程安全问题浅析

在java开发中确保线程安全已成为基本要求，线程安全就是指某段代码在多线程环境下能够正确的执行，不会出现数据不一致的情况，反之就是非线程安全。
目前解决线程安全的方式有：

• 线程安全类，如AtomicInteger
• 加锁排队执行，如synchronized、reentrantLock
• 线程本地变量，如ThreadLocal

场景分析：创建一个变量num等于0，然后创建线程1，执行1000000次++操作，然后在创建线程2执行1000000次–操作，等线程1和2都执行完之后，打印num变量值，若结果为0，则说明是线程安全的，反之是非线程安全的。
实例1

public class ThreadSafeTest {
    // 全局变量
    private static int number = 0;
    // 循环次数(100W)
    private static final int COUNT = 1000000;

    public static void main(String[] args) throws InterruptedException {
        // 线程1：执行 100W 次 ++ 操作
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                number++;
            }
        });
        t1.start();

        // 线程2：执行 100W 次 -- 操作
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                number--;
            }
        });
        t2.start();

        // 等待线程 1 和线程 2，执行完，打印 number 最终的结果
        t1.join();
        t2.join();
        System.out.println("最终结果：" + number);
    }
}

可见，结果不为0，此为非线程安全。
实例2

public class AtomicIntegerTest {
    // 创建 AtomicInteger
    private static AtomicInteger number = new AtomicInteger(0);
    // 循环次数
    private static final int COUNT = 1000000;

    public static void main(String[] args) throws InterruptedException {
        // 线程1：执行 100W 次 ++ 操作
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                // ++ 操作
                number.incrementAndGet();
            }
        });
        t1.start();

        // 线程2：执行 100W 次 -- 操作
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                // -- 操作
                number.decrementAndGet();
            }
        });
        t2.start();

        // 等待线程 1 和线程 2，执行完，打印 number 最终的结果
        t1.join();
        t2.join();
        System.out.println("最终结果：" + number.get());
    }
}

可见，结果为0，此为线程安全的，AtomicInteger是线程安全类，++，–操作为原子性操作，解决了非线程安全问题。
实例3

public class SynchronizedTest {
    // 全局变量
    private static int number = 0;
    // 循环次数(100W)
    private static final int COUNT = 1000000;

    public static void main(String[] args) throws InterruptedException {
        // 线程1：执行 100W 次 ++ 操作
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                // 加锁排队执行
                synchronized (SynchronizedTest.class) {
                    number++;
                }
            }
        });
        t1.start();

        // 线程2：执行 100W 次 -- 操作
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                // 加锁排队执行
                synchronized (SynchronizedTest.class) {
                    number--;
                }
            }
        });
        t2.start();

        // 等待线程 1 和线程 2，执行完，打印 number 最终的结果
        t1.join();
        t2.join();
        System.out.println("最终结果：" + number);
    }
}

可见，结果为0，此为线程安全的，synchronized是jvm实现的同步锁，解决了非线程安全问题。
实例4

public class ReentrantLockTest {
    // 全局变量
    private static int number = 0;
    // 循环次数(100W)
    private static final int COUNT = 1000000;
    // 创建 ReentrantLock
    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        // 线程1：执行 100W 次 ++ 操作
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                lock.lock();    // 手动加锁
                try {
                    number++;       // ++ 操作
                } finally {
                    lock.unlock();  // 手动释放锁
                }
            }
        });
        t1.start();

        // 线程2：执行 100W 次 -- 操作
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                lock.lock();    // 手动加锁
                try {
                    number--;       // -- 操作
                } finally {
                    lock.unlock();  // 手动释放锁
                }
            }
        });
        t2.start();

        // 等待线程 1 和线程 2，执行完，打印 number 最终的结果
        t1.join();
        t2.join();
        System.out.println("最终结果：" + number);
    }
}

可见，结果为0，此为线程安全的，reentrantLock为可重入锁，通过自己加锁和释放锁解决非线程安全问题。
实例5

public class ThreadLocalTest {
    // 创建 ThreadLocal（设置每个线程中的初始值为 0）
    private static ThreadLocal threadLocal = ThreadLocal.withInitial(() -> 0);
    // 全局变量
    private static int number = 0;
    // 循环次数(100W)
    private static final int COUNT = 1000000;

    public static void main(String[] args) throws InterruptedException {
        // 线程1：执行 100W 次 ++ 操作
        Thread t1 = new Thread(() -> {
            try {
                for (int i = 0; i < COUNT; i++) {
                    // ++ 操作
                    threadLocal.set(threadLocal.get() + 1);
                }
                // 将 ThreadLocal 中的值进行累加
                number += threadLocal.get();
            } finally {
                threadLocal.remove(); // 清除资源，防止内存溢出
            }
        });
        t1.start();

        // 线程2：执行 100W 次 -- 操作
        Thread t2 = new Thread(() -> {
            try {
                for (int i = 0; i < COUNT; i++) {
                    // -- 操作
                    threadLocal.set(threadLocal.get() - 1);
                }
                // 将 ThreadLocal 中的值进行累加
                number += threadLocal.get();
            } finally {
                threadLocal.remove(); // 清除资源，防止内存溢出
            }
        });
        t2.start();

        // 等待线程 1 和线程 2，执行完，打印 number 最终的结果
        t1.join();
        t2.join();
        System.out.println("最终结果：" + number);
    }
}

可见，结果为0，此为线程安全的，通过threadLocal线程本地变量解决线程安全问题，给每个线程独自创建一份属于自己的私有变量，不同的线程操作的是不同的变量，从而解决非线程安全问题。