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

最新推荐文章于 2024-08-29 20:28:58 发布
最新推荐文章于 2024-08-29 20:28:58 发布
阅读量460 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45691220/article/details/106878337
版权

线程安全问题

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，但是实际执行结果到底是什么，我也不知道，我想应该没人知道吧，你说呢？
哈哈哈？为什么呢，学完下面你就知道了。

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 的静态方法
一只懐坏旭
关注
多线程会遇到什么问题？
Mr_YarNell的博客
08-29 1126
文章目录为什么多线程会出现各种各样的问题？线程执行单核CPU执行造成的问题gon多核CPU执行造成的问题JMM什么是JMM造成的问题重排序重排序遵守的规则Happens-beforeas-if-serial各种级别的重排序编译器级别的重排序处理器指令级别的重排序处理器内存级别的重排序造成的问题如何解决这些问题？总结 接着上篇文章，了解了一些线程的基本知识，知道了如何去使用线程，那么在多线程的环境下，我们会遇到什么问题呢？经常能遇到的JMM是啥？多线程的三大特性是啥，跟我们平时的使用有什么关系？ 为什么多线程
解决多线程安全问题
weixin_55782195的博客
05-18 678
解决多线程安全问题的方案： 一、使用同步代码块 格式：synchronized(锁对象){ 可能出现线程安全问题的代码（访问了共享数据的代码） } 注意：线程中的锁对象，可以使用任意的对象 必须保证多个线程使用的锁对象是同一个 锁对象的作用：把同步代码块锁住，只让一个线程在同步代码块中执行 总结：同步中的线程，没有执行完毕不会释放锁，同步外的线程没有锁进不去同步 二、使用同步方法 步骤：把访问共享数据的代码抽取出来，放到一个方法中 在方法上添加synchronized修饰符 格式： 修饰符 synchron
JAVA多线程的问题以及处理【转】
hjf19790118的专栏
12-18 763
12.4 多线程问题及处理          多线程编程为程序开发带来了很多的方便，但是也带来了一些问题，这些问题是在程序开发过程中必须进行处理的问题。          这些问题的核心是，如果多个线程同时访问一个资源，例如变量、文件等，时如何保证访问安全的问题。在多线程编程中，这种会被多个线程同时访问的资源叫做临界资源。          下面通过一个简单的示例，演示多个线程访
如何解决多线程的线程不安全问题
最新发布
huapiaoy的博客
08-29 1551
解决线程安全的思路和方法;1,使用没有共享资源的模型2.不对共享变量进行写操作3.通过加锁和一些原子操作来保证线程的顺序，可见性，和原子性。
如何解决线程安全问题
weixin_34304013的博客
04-14 4767
什么是线程安全问题？ 当多个线程共享一个全局变量，对其做写操作时，可能会受到其他线程的干扰，从而引发线程安全问题 内置锁（synchronized） 内置锁也叫互斥锁，可以保证线程的原子性，当线程进入方法时，会自动获得一个锁，一旦锁被获得，其他线程必须等待获得锁的线程执行完代码释放锁，会降低程序的执行效率 使用方式： 同步方法 public synchr...
java 多线程同步方法的实现
weixin_34138255的博客
11-23 103
java 多线程同步方法的实现 同步方法：在方法声明上加上synchronized public synchronized void method(){ 可能会产生线程安全问题的代码 } 同步方法中的锁对象是 this 使用同步方法，对电影院卖票案例中Ticket类进行如下代码修改： public clas...
Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题
02-02
### Java多线程-避免同步机制带来的死锁问题及用Lock锁解决线程安全问题 #### 死锁 ##### 1. 说明 在多线程编程中，死锁是一种常见的问题，指的是两个或多个线程在执行过程中，因为竞争资源而造成的一种相互等待...
Java多线程-同步机制解决线程安全问题方式二：同步方法
01-30
总之，Java的同步方法是一种有效的解决线程安全问题的手段，它可以确保共享资源在多线程环境中的正确访问和更新。但是，过度使用同步可能会导致性能下降，因此在设计多线程程序时，需要根据具体需求和性能考虑来选择...
Java多线程-解决单例模式中的懒汉式的线程安全问题
02-01
### Java多线程—解决单例模式中的懒汉式的线程安全问题 #### 一、单例设计模式的线程安全问题 ##### （1）饿汉式没有线程安全问题 **饿汉式**是一种非常典型的单例模式实现方式，其特点是在类加载时就完成了实例...
Java多线程-线程的安全问题与线程的同步机制介绍
01-29
Java多线程-线程的安全问题与线程的同步机制介绍 在 Java 多线程编程中，线程安全问题是非常重要的一个话题。...通过了解线程安全问题的原因和解决方案，可以更好地编写多线程程序，避免线程安全问题的出现。
C# 高效线程安全，解决多线程写txt日志类.zip
07-25
"C# 高效线程安全，解决多线程写txt日志类.zip" 提供了一个专门用于多线程环境下写入txt日志文件的解决方案，确保了在并发写入时的数据一致性与程序稳定性。 首先，我们要理解什么是线程安全。线程安全是指当多个...
多线程（四）：线程的同步
RufyHuang的博客
02-02 173
文章目录1.经典线程同步例子——卖票 1.经典线程同步例子——卖票 理想状态下卖票 极端状态下卖票
多线程安全问题及解决办法
fandoudou123的专栏
08-31 507
【多线程-安全性问题的解决】
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
04-27 469
多线程的安全性问题解析 我们在使用多线程的时候，可以进行异步操作提高我们程序执行的效率，比如，我们一个页面需要3个接口，后端返回的时候将这个三个接口统一成一个接口执行，这三个接口在这个大接口中，如果按串行的方式执行，那么时间就是这三个接口所需时间之和，如果我们采用多线程的方式，那么返回的时间取决于这三个接口中所用时间最大的接口。 我们再来看一下他的问题。 package com.broky.multiThread.safeThread; /** * @author zxd * @date 2022-
【多线程】线程安全问题及解决方法
weixin_62848751的博客
07-23 1330
而load操作时间开销很大，远远高于cmp ，此时CPU有个大胆的操作，将load操作优化了，就导致只有第一次读取flag的值的时候t1线程会从主存中进行读取，之后则在本地内存进行读取，这就会导致当t2线程修改flag的值并同步到主存的时候，t1线程并没有读取到更新的值，这和我们上述提到过的Java内存模型对应，当我们给flag变量加上volatile关键字的时候问题就解决了，这是由于加了volatile关键字的变量，会指示JVM每次读取这个变量的时候都需要从主存中进行读取。
多线程并发原理，解决线程安全问题
Get
03-20 1634
线程安全问题，归根到底一句话：在多线程之间修改共享数据引起的。 解决线程安全问题 ：关键词：修改，共享 1、不共享 没变量 （无状态类 （不做值的修改，只有方法）） 变量不可变 （Akka） 栈封闭 （方法内部定义变量） 2、共享但加锁 CAS操作（乐观锁）：操作时先判断下，拿到的数据是否跟主内存的数据是否相同，如不相同则取到主内存的值再操作。 乐观锁： 乐观的认为，这个数值只有我自己...
多线程问题的解决思路
weixin_30444105的博客
12-18 455
多线程问题的解决思路一般分为以下几个部分（适用情况的区别） 1、最常用的解决办法是使用线程同步，使得一个共享变量在同一时间只能被一个线程访问。这样可以有效避免变量被多个线程访问的时候出现的数据不一致问题。但是当线程比较多，竞争比较激烈的时候多个线程排队等待同一个资源会导致效率的下降，并且有可能导致死锁的发生。 　　（1）、使用synchronized进行加锁。 　　　　这是在JVM...
解决多线程安全问题三种方式
weixin_44769733的博客
02-06 357
解决多线程安全问题的三种方式: 一:同步代码块 同步代码块格式: synchronized (锁对象){被多线程执行的代码} 锁对象: 锁对象可以实任意对象 3 1.声明线程 //声明线程 public class MyRunnable implements Runnable { //1.定义全局变量 private int i = 100; //2.创建对象,作为同步代码...
解决多线程安全问题的三种方式
qq_58068014的博客
05-16 146
1.同步代码块 2.同步方法 3.lock方法
C#多线程同步：lock与monitor解析及问题解决
理解和掌握C#中的`lock`和`Monitor`是解决多线程同步问题的基础，通过它们可以创建出高效且线程安全的程序。在设计多线程程序时，应充分考虑线程同步、资源管理以及性能优化，确保程序的稳定性和可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值