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

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 的静态方法
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值