【JavaEE】synchronized监视锁 volatile关键字wait和notify

淡淡的烟草味﹌ 2024-03-27 12:55 60阅读 0赞

**目录**

synchronized监视锁：

1、互斥性

2、 可重入性

synchronized的用法：

volatile ：

volatile的用法：

volatile和synchronized的区别：

wait和notify:

wait和sleep的区别（面试）：

--------------------

由于我们在使用多线程的过程中会出现线程安全的问题的。然后我们可以通过这几个方案来进行解决线程安全问题。

## synchronized监视锁： ##

**方案一：监视锁**

synchronized关键字有以下几个特征：

### 1、互斥性 ###

当程序进入到synchronized关键字修饰的代码块时，这个时候就被加锁了。当执行出该代码块时就解锁了。当我们的一个线程对该对象加锁后，另外一个线程执行到该对象时，就会阻塞等待。

我们可以简单的理解为：这里以上厕所为一个例子，当有人（一个线程）进入厕所（执行到监视的锁对象）进行解决的时候，就要进行锁门（也就是加锁），后面有人（另一个线程）也要来上厕所（执行到该对象）的时候就需要在门外等待（阻塞对待），直到里面的人出来了（解锁），再进去（再获取进行加锁）。

### 2、 可重入性 ###

synchronized是可重入锁。可重入锁就是同一个线程对于同一个对象同时加锁两次或者两次以上。如果没有问题，没有产生bug，就是可重入锁。如果不能正常的运行，就是不可重入的锁了。

## synchronized的用法： ##

1、synchronized修饰普通方法：

public synchronized void increase(){
            sum++;
        }

此处的锁对象是this

2、 synchronized修饰静态方法

public class SynchronizedDemo1 {
        private int sum=0;
    
        public synchronized static void fun(int a){
            a++;
        }
        
    }

此处的锁对象是SynchronizedDemo1的类的对象。

3、synchronized修饰代码块

public  void increase(){
            synchronized(this){
                sum++;
            }
    
        }

此时的锁对象依然是this。

**注意：在使用synchronized的时候一定要注意锁的对象是谁，一般有this，类名.class（类对象）和普通对象变量。**

## volatile ： ##

方案二：volatile关键字

首先我们需要明确：volatile是为了解决内存可见性问题用到的关键字，其中文意思就是易变的，这是在提醒编译器，遇到这个关键字就不要擅作主张了。

## volatile的用法： ##

修饰变量。

比如：

volatile public int flag=0;

这里举个例子：还是前面总结内存可见性的例子：

package MySynchronized;
    
    import java.util.Scanner;
    
    class MyCount{
        volatile public int flag=0;
    }
    
    public class SynchronizedDemo2 {
        public static void main(String[] args) {
    
            MyCount myCount=new MyCount();
    
            Thread t1=new Thread(()->{
                while(myCount.flag==0){
    
                }
                System.out.println("循环结束！");
    
            });
    
            Thread t2=new Thread(()->{
                Scanner scan=new Scanner(System.in);
                System.out.println("输入你要输入的数字：");
                int result=scan.nextInt();
                myCount.flag=result;
    
            });
            t1.start();
            t2.start();
        }
    }

如果我们不加上述的volatile，就会出现这个情况：

![6b420c59f03746f9bc33f7a42c0d53db.png][]

只有加上volatile才会正常的显示我们想要的结果：

![5501bbba89a04116ad8f6ac26f79364f.png][]

## volatile和synchronized的区别： ##

synchronized保证原子性，volatile不保证原子性，保证的是内存可见性

## wait和notify: ##

**方案三：wait和notify**

首先我们要知道线程在执行的过程中是随机调度的，抢占式执行的，所以我们是不知道它们执行的顺序的。但是我们在实际的开发中有些时候我们希望各个线程按照一定的顺序来进行执行，此时我们就需要用到我们的wait和notify了。

wait要做的事情：使当前执行代码的线程阻塞等待，释放锁，等待唤醒后重新获取这个锁。

notify要做的事情：唤醒等待的线程

wait被唤醒的条件：

1、其他线程调用该对象的notify方法

2、wait等待时间超时

3、wait抛出InterruptedException异常（别的线程调用了该等待线程的interrupted方法）

这里我们举一个如何使用3个线程，按照顺序打印ABC的例子：

package MySynchronized;
    
    public class SynchronizedDemo3 {
        public static void main(String[] args) {
    
            Object loker1=new Object();
            Object loker2=new Object();
            Thread t1=new Thread(()->{
                System.out.println("A");
                //A打印完进行通知t2
                synchronized (loker1){
                    loker1.notify();
                }
            });
    
            Thread t2=new Thread(()->{
                //B在A前面，所以让t2阻塞等待
                synchronized (loker1){
                    try {
                        loker1.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                System.out.println("B");
                //打印B之后，进行通知
                synchronized (loker2){
                    loker2.notify();
                }
            });
            //为保证ABC的顺序，所以我们要保证C要在B的后面
            //所以我们在打印C之前，要让它阻塞等待
            Thread t3=new Thread(()->{
                //阻塞等待，等待t2线程的通知
                synchronized (loker2){
                    try {
                        loker2.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                System.out.println("C");
                System.out.println("打印正确！");
            });
            //这里有个细节要注意：如果t1比t2先执行了，那么t1中的通知就失去了作用，也就是说t2还没有排队等待呢，t1已经通知了，这个时候通知就没有用了
            //等到t2等待的时候，t1就没有等二次通知的机会了，所以要让t2先执行。
            t2.start();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            t1.start();
            t3.start();
        }
    }

特别要注意：wait和notify的对象要要一致！

![9e803d4a55a5434d9bb8cbe674d7affa.png][]

notifyAll方法：

与notify功能类似，都是通知同对象的线程。但是略有区别的是，notify是随机唤醒一个同对象所在的阻塞线程（假设有多个线程），notifyAll是唤醒所有的，剩下的进行所竞争。（风险大，不咋用，上面的**wait和notify是重点！！！！**）

## wait和sleep的区别（面试）： ##

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

区别：1、wait需要搭配synchronized使用 sleep不需要  
2、wait是Object的方法sleep是Thread 的静态方法

[6b420c59f03746f9bc33f7a42c0d53db.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/acd154c89c844306b92abfdab5ea8e2c.png
[5501bbba89a04116ad8f6ac26f79364f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/0908cf6eba6c43158ebeb8730b249d08.png
[9e803d4a55a5434d9bb8cbe674d7affa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/02543fa395a747a19d15e11c2e2d4657.png