线程安全相关问题总结

发表于 | 分类于
当多个线程访问某个类,不管运行时环境采用何种调度方式或者这些线程如何交替执行,并且在主调代码中不需 要任何额外的同步或协同...

1. 什么是线程安全性？

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

2. 从字节码角度剖析线程不安全操作

javac -encoding UTF-8 UnsafeThread.java 编译成.class
1
2
3
4
编译命令:
javac -encoding UTF-8 UnSafeThread.java
将class文件反编译为字节码:
javap -c UnSafeThread.class
javap -c UnsafeThread.class 进行反编译，得到相应的字节码指令
1
2
3
4
5
6
7
8
9
10
0: getstatic #2       获取指定类的静态域，并将其押入栈顶 

3: iconst_1          将int型1押入栈顶

 4: iadd             将栈顶两个int型相加，将结果押入栈顶

 5: putstatic #2      为指定类静态域赋值

 8: return

Vsqyt0.png

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

3. 原子性操作

3.1什么是原子性操作

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

3.2例子:

​ A想要从自己的帐户中转1000块钱到B的帐户里。那个从A开始转帐，到转帐结束的这一个过程，称之为一个事务。在这个事务里，要做如下操作： 从A的帐户中减去1000块钱。如果A的帐户原来有3000块钱，现在就变成2000块钱了。

​ 在B的帐户里加1000块钱。如果B的帐户如果原来有2000块钱，现在则变成3000块钱了。如果在A的帐 户已经减去了1000块钱的时候，忽然发生了意外，比如停电什么的，导致转帐事务意外终止了，而此时B的帐 户里 还没有增加1000块钱。那么，我们称这个操作失败了，要进行回滚。回滚就是回到事务开始之前的状 态，也就是回到A的帐户还没减1000块的状态，B的帐户的原来的状态。此时A的帐户仍然有3000块，B的帐 户仍然有 2000块。

​ 通俗点讲：操作要成功一起成功、要失败大家一起失败如何把非原子性操作变成原子性

​ volatile关键字仅仅保证可见性，并不保证原子性 synchronize关机字，使得操作具有原子性

4. 深入理解synchronized

内置锁
每个java对象都可以用做一个实现同步的锁，这些锁称为内置锁

线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。

互斥锁
内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，

当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。 修饰普通方法：锁住对象的实例 修饰静态方法：锁住整个类 修饰代码块： 锁住一个对象 synchronized (lock) 即synchronized后面括号里的内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public class SynDemo {
    /**
     * 不要用synchronized修饰静态方法 因为他是锁住的整个类
     */
//    public  synchronized  void  out() throws InterruptedException {
//        Thread.sleep(5000L);
//        System.out.println(Thread.currentThread().getName());
//    }


    private Object lock = new Object();

    public  void  out() throws InterruptedException {
        synchronized(lock){
            Thread.sleep(1000L);
            System.out.println(Thread.currentThread().getName());
        }
    }


    public static void main(String[] args) {

        SynDemo synDemo = new SynDemo();
        SynDemo synDemo2 = new SynDemo();

        new Thread(()->{
            try {
                synDemo.out();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(()->{
            try {
                synDemo2.out();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

}

5. volatile关键字及其使用场景

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

禁止指令重排序

A、B两个线程同时读取volatile关键字修饰的对象，A读取之后，修改了变量的值,修改后的值，对B线程来说， 是可见 使用场景

  • 1：作为线程开关
  • 2：单例，修饰对象实例，禁止指令重排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
  /**
   * volatile
   * 1：作为线程开关 2：单例，修饰对象实例，禁止指令重排序
   */
  public class VolatileDemo implements Runnable {
  
      private static volatile boolean flag = true;
  
      @Override
      public void run() {
          while (flag){
              System.out.println(Thread.currentThread().getName());
          }
      }
  
      public static void main(String[] args) throws InterruptedException {
  
          Thread thread = new Thread(new VolatileDemo());
          thread.start();
          Thread.sleep(1000L);
          flag=false;
  
      }
  }

6. 单例与线程安全

饿汉式–本身线程安全 在类加载的时候，就已经进行实例化，无论之后用不用到。如果该类比较占内存，之后又没用到，就白白浪费 了资源。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
 * 饿汉式单例
 * 本身就是线程安全的
 */
public class HungerSingleton {

    private static HungerSingleton ourInstance = new HungerSingleton();

    public static HungerSingleton getInstance() {
        return ourInstance;
    }

    private HungerSingleton() {
    }

    public static void main(String[] args) {

        HungerSingleton hungerSingleton = new HungerSingleton();

        for (int i = 0; i < 10; i++) {

            new Thread(() -> {
                System.out.println(HungerSingleton.getInstance());
            }).start();


        }

    }

}

懒汉式 – 最简单的写法是非线程安全的 在需要的时候再实例化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
 * 懒汉式单例 线程安全的写法
 */
public class LazySingleton {

    //这里一定要使用volatile,可以禁止指令重排序
    private static volatile LazySingleton lazySingleton = null;

    private LazySingleton() {

    }

    public static  LazySingleton getInstance() {
        //判断实例是否为空,为空才实例化
        if (lazySingleton == null) {
            //模拟实例化耗时操作
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (LazySingleton.class) {
                if (lazySingleton == null) {
                    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();
        }
    }
}

7.如何避免线程安全性问题

线程安全性问题成因

  • 多线程环境
  • 多个线程操作同一共享资源
  • 对该共享资源进行了非原子性操作
7.1如何避免

打破成因中三点任意一点

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

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

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

城南少年与猫 wechat
欢迎您扫一扫订阅我的微信公众号！
0%