线程调度与单例模式：wait、notify与懒汉模式解析

风吹落叶3257

已于 2025-05-19 15:25:24 修改

阅读量1.1k

点赞数 31

文章标签： java 开发语言 java-ee

于 2025-05-19 15:24:51 首次发布

本文链接：https://blog.csdn.net/2402_87239469/article/details/148058488

版权

一.wait 和 notify（等待和通知）

引入 wait notify 就是为了能够从应用层面，干预到多个不同线程代码的执行顺序，可以让后执行的线程主动放弃被调度的机会，等先执行的线程完成后通知放弃调度的线程重新执行。

自助取款机

当取款机没有钱的时候，要想去取钱只能等别人进去存钱或者等银行的人过来放钱，否则他永远拿不到钱，他在出去之后又会进去取款，刚刚释放了锁，就又会参与到锁竞争，并且大概率他会一直拿到锁，这叫“线程饿死“，这种情况只是概率性事件，但还是会极大影响到其他线程运行，这个时候他为了不影响到其他人就会等待（wait），然后让后面如果存钱的人存了钱了，通知（notify）自己一声，自己就可以重新排队取钱，在没通知的这段时间，他就会一直在旁边等，不会去排队了。

join 和 wait

join 是等待另一个线程执行完，才继续执行

wait 则是等待另一个线程通过 notify 进行通知（不要求另一个线程必须执行完）

wait进入阻塞，只能说明自己释放锁了，至于是否有其他线程拿到锁，这是不能确定的

public class ThreadDemo25 {
    public static void main(String[] args) {
        //需要有一个统一的对象进行加锁，wait，nitify
        Object locker = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (locker){
                System.out.println("t1 wait 之前");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(" t1 wait 之后");
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(5000);

                synchronized (locker){
                    System.out.println(" t2 notify 之前");
                    locker.notify();
                    System.out.println("t2 notify 之后");
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        t1.start();
        t2.start();
    }
}

我们发现阻塞等待的原因是19行的wait

wait方法放到synchronized是因为要释放锁，前提是先加上锁

java特别约定要把notify放到synchronized中

由于线程的随机调度我们并不知道要先调用谁，如果先调用t2就没有线程去给t1唤醒了，所以要保证t1先执行，我们给t2加上了sleep

需要注意的是t2在notify之后并没有释放锁，而t1唤醒后会尝试加锁，所以会产生小小的阻塞。

notifyAll 唤醒这个对象所有等待的线程

假设有很多个线程，都使用同一个对象wait，针对这个对象进行notifyAll，此时就会全都唤醒

需要注意的是，这些线程在wait返回的时候，需要重新获取锁，就会因为锁竞争，是这些线程串行执行

wait 和 sleep

wait 提供了一个带有超时时间的版本

sleep 也是能指定时间

都是时间到了，就继续执行，解除阻塞了

wait 和 sleep 都可以被提前唤醒（虽然时间还没到），wait通过notify唤醒，sleep通过interrupt唤醒

使用wait 最主要的目标一定是不知道多少时间的前提下使用的，超时时间是为了兜底

使用sleep，一定是知道了多少时间的前提下使用的，虽然能提前唤醒，但是通过异常唤醒一般是程序出现一些特殊情况了

二.单例模式

单例模式是一种设计模式，遵守设计模式下限就有了兜底

1.饿汉模式

单例 == 单个实例（对象）

static 这个引用就是我们期望创建出唯一的实例的引用，static 静态的指的是“类属性”

instance 就是当前类对象里面持有的属性

每个类的类对象，只存在一个，类对象中的static属性，自然也是只有一个了

这时instance所指向的对象就是唯一的一个对象，其他代码要想使用这个类的实例，就需要通过这个方法来进行获取，而不是直接new一个出来。

这直接从根本上让其他人想new都new不了了

Sington内部代码早就把唯一的实例安排好了

class Singleton{
     private static Singleton instance = new Singleton();


     public static Singleton getInstance(){
         return instance;
     }

    private Singleton() {

    }
}
public class ThreadDemo26 {
    public static void main(String[] args) {
   Singleton s = Singleton.getInstance();

    }
}

上述代码成为“饿汉模式”单例模式一种简单的写法，在程序启动时，实例就创建了，所以就是用饿汉，创建实例非常早。

2.懒汉模式

创建实例的时机不一样了，创建实例的时机更晚，直到第一次使用的时候，才会创建实例

class SingletonLazy{
    //这个引用指向唯一实例，这个引用先初始化null，而不是立即创建实例
    private volatile static SingletonLazy instance = null;
    private static Object locker = new Object();
    public static SingletonLazy getInstance(){
        if(instance == null){
            //如果 Instance 为 NULL，就说明时首次调用，首次调用就需要考虑线程安全问题，就要加锁
            //如果非空的话就说明时后续调用就不必加锁
            synchronized (locker){
                if(instance == null) instance = new SingletonLazy();
            }
        }
        return instance;
    }
    private SingletonLazy(){}
}
public class ThreadDemo27 {
    public static void main(String[] args) {
       
        SingletonLazy s1 = SingletonLazy.getInstance();
        SingletonLazy s2 = SingletonLazy.getInstance();
        System.out.println(s1 == s2);
    }
}

如果是首次调用 getinstance，那么instance 引用为null，进入if语句创建实例出来，后续再次调用返回的就已经是创建好的引用了。