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线程本地变量解决线程安全问题,给每个线程独自创建一份属于自己的私有变量,不同的线程操作的是不同的变量,从而解决非线程安全问题。

你可能感兴趣的:(Java,线程安全)