并发编程01--线程安全性

最新推荐文章于 2024-07-22 16:30:20 发布

zero _s

最新推荐文章于 2024-07-22 16:30:20 发布

阅读量120

点赞数

分类专栏：并发编程

本文链接：https://blog.csdn.net/weixin_45063957/article/details/119391556

版权

并发编程专栏收录该内容

7 篇文章 0 订阅

订阅专栏

当多个线程访问某个类,不管运行时环境采用何种调度方式或者这些线程如何交替执行,并且在主调代码中不需要任何额外的同步或协同,这个类都能表现出正确的行为,那么就称这个类为线程安全的。----《并发编程实战》

什么是线程不安全？
多线程并发访问时，得不到正确的结果。

javac -c demo.class 可以进行反编译
javac demo 编译

产生线程不安全问题的原因： num++ 不是原子性操作，被拆分成好几个步骤，在多线程并发执行的情况下，因为cpu调度，多线程快递切换，有可能两个同一时刻都读取了同一个num值，之后对它进行+1操作，导致线程安全性。·

原子性：

什么是原子性操作：
一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

如何把非原子性操作变成原子性：
volatile关键字仅仅保证可见性，并不保证原子性 synchronize关键字，使得操作具有原子性

/**
 * 线程不安全操作代码实例
 */
public class UnSafeThread {

    private static int num = 0;

    //是一个同步计数器  CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。
    private static CountDownLatch countDownLatch = new CountDownLatch(10);

    /**
     * 每次调用对num进行++操作
     * synchronized这个关键字使得线程安全
     */
    public static synchronized void  inCreate() {
        num++;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                for (int j = 0; j < 100; j++) {
                    inCreate();
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //每个线程执行完成之后，调用countDownLatch
                countDownLatch.countDown();
            }).start();
        }

        while (true) {
            if (countDownLatch.getCount() == 0) {
                System.out.println(num);
                break;
            }
        }

    }
}

synchronized关键字：不能修饰类，可以修饰方法、属性、代码块

内置锁：

每个java对象都可以用做一个实现同步的锁，这些锁称为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。

互斥锁
内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。
修饰普通方法：锁住对象的实例，new两个实例，锁住的是各自的，相互之间不影响

修饰静态方法：锁住整个类实际开发中不采用

修饰代码块：锁住一个对象 synchronized (lock) 即synchronized后面括号里的内容，需要传入一个对象

 private Object lock = new Object();

    public void myOut() {
        synchronized (lock) {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(5000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

volatile关键字只能修饰变量

保证该变量的可见性，volatile关键字仅仅保证可见性，并不保证原子性

可以禁止指令重排序？？？
A、B两个线程同时读取volatile关键字修饰的对象，A读取之后，修改了变量的值,修改后的值，对B线程来说，是可见
使用场景 1：作为线程开关

2：单例，修饰对象实例，禁止指令重排序

单例与线程安全：

单例有两种模式

饿汉式--本身线程安全
在类加载的时候，就已经进行实例化，无论之后用不用到。如果该类比较占内存，之后又没用到，就白白浪费了资源。
懒汉式 -- 最简单的写法是非线程安全的
在需要的时候再实例化

/**
 * 饿汉式单例
 * 在类加载的时候，就已经进行实例化，无论之后用不用到。
 * 如果该类比较占内存，之后又没用到，就白白浪费了资源。
 */
public class HungerSingleton {

    private static HungerSingleton ourInstance = new HungerSingleton();

    // 用于获取方法
    public static HungerSingleton getInstance() {
        return ourInstance;
    }

    // 需要构造私有化
    private HungerSingleton() {
    }

    
    //
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(HungerSingleton.getInstance());
            }).start();
        }
    }
}

指令重排序是指为了优化性能，会对字节码指令进行重新排序


/**
 * 懒汉式单例
 * 在需要的时候再实例化
 */

public class LazySingleton {
    
        // volatile 关键字可以防止指令重排序，所以懒汉式的必须加这个关键字

        private static volatile LazySingleton lazySingleton = null;

        // 构造私有
        private LazySingleton() {

        }

        // 对外提供的方法
        public static LazySingleton getInstance() {
            //判断实例是否为空，为空则实例化
            if (null == lazySingleton) {
                //模拟实例化时耗时的操作
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 对类加锁，这样可以避免加在静态方法上面
                synchronized (LazySingleton.class) {
                    if (null == lazySingleton) {
                        lazySingleton = new LazySingleton();
                    }
                }
            }
            //否则直接返回
            return lazySingleton;
        }

        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                new Thread(() -> {
                    System.out.println(LazySingleton.getInstance());
                }).start();
            }
        }
}

线程安全性问题成因
多线程环境
多个线程操作同一共享资源
对该共享资源进行了非原子性操作
如何避免
打破成因中三点任意一点

1：多线程环境--将多线程改单线程（必要的代码，加锁访问）

2：多个线程操作同
一共享资源--不共享资源（ThreadLocal、不共享、操作无状态化、不可变）

3：对该共享资源进行了非原子性操作-- 将非原子性操作改成原子性操作（加锁、使用JDK自带的原子性操作的类、JUC提供的相应的并发工具类）