Fork me on GitHub

java并发之线程安全

字数统计: 2.1k字   |   阅读时长≈ 8分

介绍

什么是线程安全

当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或则在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象是线程安全的

  • 线程不安全示例：在get变量属性同时有其他线程set变量属性值，此时就需要额外的同步才能保证线程安全，这就是做了额外处理，因此代表get同时set这种操作是线程不安全的。

什么情况下会出现线程安全？

  • 多个线程同时读写一个变量
  • 活跃性问题：死锁、活锁、饥饿
  • 对象发布和初始化时
    • 对象发布：使一个对象能够被当前范围之外的代码所使用
    • 出现问题：
      1. 方法错误返回了一个private对象，我们定义private对象的目的就是不想让外界访问，如果方法返回了这个对象，就可能出现一些未知错误
        • 给private对象复制一个新的对象
        • 将新的对象返回，新的对象如何改变，都不会影响private对象
      2. 还未完成初始化（构造函数没完全执行完毕），就把对象提供给外界
        • 在构造函数中未初始化完成就this赋值
        • 隐式逸出：对象还未构造完成，就被其他线程看见了（单例模式中双重检验锁专门为了防止此情况）
        • 构造函数中运行线程：在构造函数中启动线程，如果使用了this对象，就相当于本类的构造函数尚未初始化完成，就已经使用了它的对象，会出现未知的行为。

示例

多线程同时读写

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
/**
 * @author xcz
 * @ClassName MultiThreadReadWrite.java
 * @createTime 2020年03月16日 10:04:00
 * @Description: 展示多线程进行读写同一个变量，发生错误的场景
 */
public class MultiThreadReadWrite implements Runnable{
    int index = 0;
    static AtomicInteger wrongIndex = new AtomicInteger(0);
    static boolean[] marked = new boolean[200000];
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            index++;
            //如果marked[index]是true，就代表这个值已经进行过一次新增了
            if(marked[index]==true){
                wrongIndex.incrementAndGet();
            }
            marked[index]= true;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MultiThreadReadWrite instance = new MultiThreadReadWrite();
        Thread thread1 = new Thread(instance);
        Thread thread2 = new Thread(instance);
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println("实际数字："+instance.index);
        System.out.println("错误次数："+instance.wrongIndex.get());
    }
}

输出结果：

1
2
实际数字：16630
错误次数：294

可以看到，设置两个线程共享同一个变量进行写操作，每个线程进行1W次++操作，正常来说，最后结果值应该是2W，但是实际运行结果是16630次，被记录下来的错误次数共294次。
错误原因：当线程1对index进行写操作，比如 30++变为31，但是线程2中也在进行操作，没有接收到这个31值，还是对原来读写到线程2中的index值进行++，也许是28++变成29，然后写回主存，就会覆盖掉线程1的值，造成错乱。

死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。

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
44
45
46
47
48
49
50
51
52
53
54
/**
 * @author xcz
 * @ClassName MustDeadLock.java
 * @createTime 2020年03月11日 13:31:00
 * @Description: 必定发生死锁的情况
 */
public class MustDeadLock implements Runnable {
    int flag = 1;

    //创建两把锁
    static Object o1 = new Object();
    static Object o2 = new Object();

    @Override
    public void run() {
        System.out.println("flag= "+flag);
        if(flag==1){
            synchronized(o1){
                try{
                    Thread.sleep(1000);
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
                synchronized(o2){
                    System.out.println("线程1成功拿到两把锁");
                }
            }
        }
        if(flag==0){
            synchronized(o2){
                try{
                    Thread.sleep(1000);
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
                synchronized(o1){
                    System.out.println("线程2成功拿到两把锁");
                }
            }
        }
    }

    public static void main(String[] args) {
        MustDeadLock r1 = new MustDeadLock();
        MustDeadLock r2 = new MustDeadLock();
        r1.flag=1;
        r2.flag=0;
        Thread thread1 = new Thread(r1);
        Thread thread2 = new Thread(r2);
        thread1.start();
        thread2.start();

    }
}

运行结果：
deadlock

在程序中，我们创建两个不同的对象作为两把锁，当线程1获得一把锁之后休眠1秒，线程2此时就获得了另一把锁，并且也休眠一秒。当两个线程继续执行时，就会发现所需要的锁被对方拿走了，而两个线程都不愿意释放自己持有的锁对象，就会一直等待对方释放锁，直到永恒，这就是死锁。

活锁

在完全相同的时刻，多个线程获取对方的资源，等待一段时间后，还是拿不到剩下所需的锁，就判断可能发生了死锁，就释放自己的锁，如果等待时间相同，就可能造成活锁。

  • 虽然线程并没有阻塞，也是始终在运行（所以叫活锁，线程是活的），但是程序却得不到进展，因为线程始终重复同样的事情。
    • 活锁的线程仍然会消耗CPU资源，而死锁的线程不需要消耗CPU资源。
  • 活锁和死锁的结果是一样的

活锁发生的原因：重试机制始终不变

示例：

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
/**
 * @author xcz
 * @ClassName LiveLock.java
 * @createTime 2020年03月12日 08:38:00
 * @Description: 演示活锁问题
 * 创建两个类，都需要同一个资源，但是两个类获取资源后，都会判断如果其他类需要此资源，就会马上释放资源
 */
public class LiveLock {
	//勺子类，被两个线程所共同需要的资源
    static class Spoon {
        private Diner owner;

        public Spoon(Diner owner) {
            this.owner = owner;
        }

        public synchronized void use() {
            System.out.printf("%s has eaten!", owner.name);
        }

        public Diner getOwner() {
            return owner;
        }

        public void setOwner(Diner owner) {
            this.owner = owner;
        }
    }

    //需要资源的对象类
    static class Diner {
        private String name;

        public Diner(String name) {
            this.name = name;
        }

        private boolean isHungry = true;

        public void eatWith(Spoon spoon, Diner spouse) {
            while(isHungry) {
                if(spoon.owner!=this){
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    continue;
                }
                Random random = new Random();
                if(spouse.isHungry){
                    System.out.println(name+"：亲爱的"+spouse.name+"，你先吃吧");
                    spoon.setOwner(spouse);
                    continue;
                }
                spoon.use();
                isHungry = false;
                System.out.println(name+"：我吃完了");
                spoon.setOwner(spouse);
            }
        }
    }

    public static void main(String[] args) {
        Diner husband = new Diner("牛郎");
        Diner wife = new Diner("织女");
        Spoon spoon = new Spoon(husband);
        new Thread(new Runnable() {
            @Override
            public void run() {
                husband.eatWith(spoon,wife);
            }
        }).start();
        new Thread(new Runnable(){

            @Override
            public void run() {
                wife.eatWith(spoon,husband);
            }
        }).start();
    }
}

输出结果

1
2
3
4
5
6
7
8
9
10
牛郎：亲爱的织女，你先吃吧
织女：亲爱的牛郎，你先吃吧
牛郎：亲爱的织女，你先吃吧
织女：亲爱的牛郎，你先吃吧
牛郎：亲爱的织女，你先吃吧
织女：亲爱的牛郎，你先吃吧
牛郎：亲爱的织女，你先吃吧
织女：亲爱的牛郎，你先吃吧
牛郎：亲爱的织女，你先吃吧
...

从例子中，我们就能发现两个对象相互谦让，使用同种谦让策略，导致两个类一直阻塞，无法进行接下来的操作。

饥饿

  • 当线程需要某些资源（例如CPU），但是却始终得不到
  • 线程的优先级设置的过低，或则有某线程持有锁同时又无限循环从而不释放锁，或则某程序始终占用某文件的写锁

未初始化完成

返回private对象错误可以通过设计模式中的原型模式解决，通过Cloneable.clone()方法即可生成相同对象

在构造函数中进行this赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
class MyClass implements Runnable{
   int a = 0;
   String b = null;

   public MyClass(){
       new Thread(this).start();
       b ="Foo";
   }

   public void run(){
      a = b.length(); //can throw NullPointerException
   }
}

可以看到在此类中，构造方法中进行创建线程，并且使用了this对象，在jvm中，对象的构建完成分为三步，划分内存、调用构造函数、指向引用

  • 在构造函数中使用了this对象，此时的this对象并没有正确初始化类变量，就会造成一些错误。
  • 在构造函数中使用this对象，还让对象没有构造完成就被其他线程看见了

参考

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

xczll：
努力打工中
Golang后台开发、摄影爱好者

很惭愧

只做了一点微小的工作，希望能帮助到你
谢谢大家