logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

如何解决多线程带来的线程安全问题

 昵称70680357 2020-07-02

线程安全问题

 

1，观察代码（存在线程安全问题）

public class ThreadDemo {
    private static class Counter {
        private long n = 0;

        public void increment() {
            n++;
        }

        public void decrement() {
            n--;
        }

        public long value() {
            return n;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final int COUNT = 1000_0000;
        Counter counter = new Counter();

        Thread thread = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                counter.increment();
            }
        }, "李四");

        thread.start();
        for (int i = 0; i < COUNT; i++) {
            counter.decrement();
        }
        thread.join();
        // 期望最终结果应该是 0
        System.out.println(counter.value());  
    }
}

如果你对多线程有一点了解的话，肯定会看出其中的问题吧！
在代码中，启用了一个子线程对变量n++了count次，main线程对变量n–了count次，按照预期结果应该最终结果是0，但是实际执行结果到底是什么，我也不知道，我想应该没人知道吧，你说呢？

语言 方法
7265 zru6mF649j
7QA2g 抖音公会
8519 2006.02.07 20-37-25

哈哈哈？为什么呢，学完下面你就知道了。

2，线程安全的概念

想给出一个线程安全的确切定义是复杂的，但我们可以这样认为：
如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。

3， 线程不安全的原因

3.1 原子性

在这里插入图片描述
上图中为火车票售票系统，AB客户端同时运行，A检测到票数为1，将票售出，还没有将更新数据写入数据库时，B检测到票数为1,也将票售出，这样，一张票就被卖了两次。

什么是原子性

我们把一段代码想象成一个房间，每个线程就是要进入这个房间的人。如果没有任何机制保证，A进入房间之后，还 没有出来；B 是不是也可以进入房间，打断 A 在房间里的隐私。这个就是不具备原子性的。
那我们应该如何解决这个问题呢？是不是只要给房间加一把锁，A 进去就把门锁上，其他人是不是就进不来了。这样 就保证了这段代码的原子性了。

有时也把这个现象叫做同步互斥，表示操作是互相排斥的

一条 java 语句不一定是原子的，也不一定只是一条指令

比如刚才我们看到的 n++，其实是由三步操作组成的：

  1. 从内存把数据读到 CPU
  2. 进行数据更新
  3. 把数据写回到 CPU

不保证原子性会给多线程带来什么问题

如果一个线程正在对一个变量操作，中途其他线程插入进来了，如果这个操作被打断了，结果就可能是错误的。

那么学到这里，你是不是对刚开始的问题有了一定的见解了呢？？？

3.2 可见性

主内存-工作内存

在这里插入图片描述

为了提高效率，JVM在执行过程中，会尽可能的将数据在工作内存中执行，但这样会造成一个问题，共享变量在多线 程之间不能及时看到改变，这个就是可见性问题。

3.3 代码顺序性

什么是代码重排序

一段代码是这样的：

  1. 去宿舍取下 U 盘
  2. 去教室写 10 分钟作业
  3. 去宿舍取下水杯

如果是在单线程情况下，JVM、CPU指令集会对其进行优化，比如，按 1->3->2的方式执行，也是没问题，可以少跑 一次宿舍。这种叫做指令重排。

public class ThreadDemo {
    private static class Counter {
        private int n1 = 0;
        private int n2 = 0;
        private int n3 = 0;
        private int n4 = 0;
        private int n5 = 0;
        private int n6 = 0;
        private int n7 = 0;
        private int n8 = 0;
        private int n9 = 0;
        private int n10 = 0;

        public void write() {
            n1 = 1;
            n2 = 2;
            n3 = 3;
            n4 = 4;
            n5 = 5;
            n6 = 6;
            n7 = 7;
            n8 = 8;
            n9 = 9;
            n10 = 10;
        }

        public void read() {
            System.out.println("n1 = " + n1);
            System.out.println("n2 = " + n2);
            System.out.println("n3 = " + n3);
            System.out.println("n4 = " + n4);
            System.out.println("n5 = " + n5);
            System.out.println("n6 = " + n6);
            System.out.println("n7 = " + n7);
            System.out.println("n8 = " + n8);
            System.out.println("n9 = " + n9);
            System.out.println("n10 = " + n10);
        }
    }

    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(() -> {
            counter.read();
        }, "读");
        Thread thread2 = new Thread(() -> {
            counter.write();
        }, "写");
        thread1.start();
        thread2.start();
    }
}

代码重排序会给多线程带来什么问题

刚才那个例子中，单线程情况是没问题的，优化是正确的，但在多线程场景下就有问题了，什么问题呢。可能水杯是在你写作业的10分钟内被舍友过来的，如果指令重排序了，代码就会是错误的。

4 解决之前的线程不安全问题

public class ThreadDemo {
    private static class Counter {
        private long n = 0;

        public synchronized void increment() {
            n++;
        }

        public synchronized void decrement() {
            n--;
        }

        public synchronized long value() {
            return n;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final int COUNT = 1000_0000;
        Counter counter = new Counter();

        Thread thread = new Thread(() -> {
            for (int i = 0; i < COUNT; i++) {
                counter.increment();
            }
        }, "李四");

        thread.start();
        for (int i = 0; i < COUNT; i++) {
            counter.decrement();
        }
        thread.join();

        // 期望最终结果应该是 0 
        System.out.println(counter.value());     
    }
}

这里的方式主要是给每个方法，添加了synchronized关键字，解决了存在的线程安全问题，那么是如何做到的呢？？？，下面来专门看一下。

5， synchronized 关键字-监视器锁monitor lock

synchronized的底层是使用操作系统的mutex lock实现的。

  • 当线程释放锁时，JMM会把该线程对应的工作内存中的共享变量刷新到主内存中
  • 当线程获取锁时，JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须从主内 存中读取共享变量

synchronized用的锁是存在Java对象头里的。
在这里插入图片描述

synchronized同步快对同一条线程来说是可重入的，不会出现自己把自己锁死的问题；
同步块在已进入的线程执行完之前，会阻塞后面其他线程的进入。

锁的 SynchronizedDemo 对象

public class SynchronizedDemo {  
   public synchronized void methond() {}     
      public static void main(String[] args) {         SynchronizedDemo demo = new SynchronizedDemo();         demo.method(); 
      // 进入方法会锁 demo 指向对象中的锁；出方法会释放 demo 指向的对象中的锁 
     }
 }

锁的 SynchronizedDemo 类的对象

public class SynchronizedDemo {
    public synchronized static void methond() {
    }

    public static void main(String[] args) {
        method(); 
        // 进入方法会锁 SynchronizedDemo.class 指向对象中的锁；出方法会释放 SynchronizedDemo.class 指向的对象中的锁 
          } 
}

明确锁的对象

public class SynchronizedDemo {
    public void methond() {      
        // 进入代码块会锁 this 指向对象中的锁；出代码块会释放 this 指向的对象中的锁 
        synchronized (this) {          
            
        }  
    }   
    public static void main(String[] args) {     
        SynchronizedDemo demo = new SynchronizedDemo();     
        demo.method();   
    }
}
public class SynchronizedDemo {
    public void methond() {       
        // 进入代码块会锁 SynchronizedDemo.class 指向对象中的锁；出代码块会释放 SynchronizedDemo.class 指向的对象中的锁 
        synchronized (SynchronizedDemo.class) {            
            
        }  
    }   
    public static void main(String[] args) {      
        SynchronizedDemo demo = new SynchronizedDemo();     
        demo.method();   
    } 
}

6. volatile 关键

修饰的共享变量，可以保证可见性，部分保证顺序性

class ThraedDemo {   
  private volatile int n;
}

作用：
（1）保证可见性：变量都是从主内存进行操作
（2）禁止指令重排序，建立内存屏障
注意事项：
不保证原子性

如果一个变量的操作不会分解为多条指令，就是线程安全，否则就是线程不安全。

如何判断变量的操作会不会分解为多条指令呢？？？

依赖某个共享变量的值进行修改操作就会分解
》例如： n++,n–,++n,–n,!flag,new 对象都是非线程安全

7， 通信-对象的等待集wait set

1.wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此 对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)
2.notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的 线程。
3.wait(long timeout)让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的notify()方法或 notifyAll() 方法， 或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。

7.1 wait()方法

其实wait()方法就是使线程停止运行。

  1. 方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法是用来将当前线程 置入“预执行队列”中，并且在wait()所在的代码处停止执行，直到接到通知或被中断为止。
  2. wait()方法只能在同步方法中或同步块中调用。如果调用wait()时，没有持有适当的锁，会抛出异常。
  3. wait()方法执行后，当前线程释放锁，线程与其它线程竞争重新获取锁。

范例：观察wait()方法使用

public static void main(String[]args)throws InterruptedException{
    Object object=new Object();
    synchronized (object){
        System.out.println("等待中...");
        object.wait();System.out.println("等待已过...");
    }
    System.out.println("main方法结束...");
}

这样在执行到object.wait()之后就一直等待下去，那么程序肯定不能一直这么等待下去了。这个时候就需要使用到了 另外一个方法唤醒的方法notify()。

7.2 notify()方法

notify方法就是使停止的线程继续运行。

  1. 方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对 其发出通知notify，并使它们重新获取该对象的对象锁。如果有多个线程等待，则有线程规划器随机挑选出一个 呈wait状态的线程。
  2. 在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出 同步代码块之后才会释放对象锁。

范例：使用notify()方法唤醒线程

class MyThread implements Runnable {
    private boolean flag;
    private Object obj;

    public MyThread(boolean flag, Object obj) {
        super();
        this.flag = flag;
        this.obj = obj;
    }

    public void waitMethod() {
        synchronized (obj) {
            try {
                while (true) {
                    System.out.println("wait()方法开始.. " + Thread.currentThread().getName());
                    obj.wait();
                    System.out.println("wait()方法结束.. " + Thread.currentThread().getName());
                    return;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void notifyMethod() {
        synchronized (obj) {
            try {
                System.out.println("notify()方法开始.. " + Thread.currentThread().getName());
                obj.notify();
                System.out.println("notify()方法结束.. " + Thread.currentThread().getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void run() {
        if (flag) {
            this.waitMethod();
        } else {
            this.notifyMethod();
        }
    }

}

public class TestThread {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        MyThread waitThread = new MyThread(true, object);
        MyThread notifyThread = new MyThread(false, object);
        Thread thread1 = new Thread(waitThread, "wait线程");
        Thread thread2 = new Thread(notifyThread, "notify线程");
        thread1.start();
        Thread.sleep(1000);
        thread2.start();
        System.out.println("main方法结束!!");
    }
}

从结果上来看第一个线程执行的是一个waitMethod方法，该方法里面有个死循环并且使用了wait方法进入等待状态 将释放锁，如果这个线程不被唤醒的话将会一直等待下去，这个时候第二个线程执行的是notifyMethod方法，该方 法里面执行了一个唤醒线程的操作，并且一直将notify的同步代码块执行完毕之后才会释放锁然后继续执行wait结束 打印语句。

注意：wait，notify必须使用在synchronized同步方法或者代码块内

7.3 notifyAll()方法

以上讲解了notify方法只是唤醒某一个等待线程，那么如果有多个线程都在等待中怎么办呢，这个时候就可以使用 notifyAll方法可以一次唤醒所有的等待线程，看示例。

范例：使用notifyAll()方法唤醒所有等待线

class MyThread implements Runnable {
    private boolean flag;
    private Object obj;

    public MyThread(boolean flag, Object obj) {
        super();
        this.flag = flag;
        this.obj = obj;
    }

    public void waitMethod() {
        synchronized (obj) {
            try {
                while (true) {
                    System.out.println("wait()方法开始.. " + Thread.currentThread().getName());
                    obj.wait();
                    System.out.println("wait()方法结束.. " + Thread.currentThread().getName());
                    return;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void notifyMethod() {
        synchronized (obj) {
            try {
                System.out.println("notifyAll()方法开始.. " + Thread.currentThread().getName());
                obj.notifyAll();
                System.out.println("notifyAll()方法结束.. " + Thread.currentThread().getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void run() {
        if (flag) {
            this.waitMethod();
        } else {
            this.notifyMethod();
        }
    }
}

public class TestThread {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        MyThread waitThread1 = new MyThread(true, object);
        MyThread waitThread2 = new MyThread(true, object);
        MyThread waitThread3 = new MyThread(true, object);
        MyThread notifyThread = new MyThread(false, object);
        Thread thread1 = new Thread(waitThread1, "wait线程A");
        Thread thread2 = new Thread(waitThread2, "wait线程B");
        Thread thread3 = new Thread(waitThread3, "wait线程C");
        Thread thread4 = new Thread(notifyThread, "notify线程");
        thread1.start();
        thread2.start();
        thread3.start();
        Thread.sleep(1000);
        thread4.start();
        System.out.println("main方法结束!!");
    }
}

现在可以看出notifyAll确实是唤醒了所有线程了。

注意：唤醒线程不能过早，如果在还没有线程在等待中时，过早的唤醒线程，这个时候就会出现先唤醒，在等待的效果了。这样 就没有必要在去运行wait方法了。

7.4 wait 和 sleep 的对比（面试题）

其实理论上 wait 和 sleep 完全是没有可比性的，因为一个是用于线程之间的通信的，一个是让线程阻塞一段时间， 唯一的相同点就是都可以让线程放弃执行一段时间。说白了放弃线程执行只是 wait 的一小段现象。

面试总结：

  1. wait 之前需要请求锁，而wait执行时会先释放锁，等被唤醒时再重新请求锁。这个锁是 wait 对象上的 monitor lock
  2. sleep 是无视锁的存在的，即之前请求的锁不会释放，没有锁也不会请求。
  3. wait 是 Object 的方法
  4. sleep 是 Thread 的静态方法

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 昵称70680357 > 《待分类》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多