Java编程--单例模式(饿汉模式/懒汉模式)/阻塞队列

       前言 

        逆水行舟，不进则退！！！     

---

       目录

       单例模式

        饿汉模式：       

        懒汉模式：

       什么是阻塞队列

        什么是高内聚 低耦合

       阻塞队列的实现

---

       单例模式

        单例模式（Singleton Pattern）是一种常见的设计模式，主要应用于创建型模式。它确保一个类只有一个实例，并且自行负责实例化并向整个系统提供这个唯一实例。此外，这种模式属于创建型模式，通过这种方式创建的类在当前进程中只存在一个实例。

        在计算机系统中，诸如线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例，因为它们在整个应用程序中只需要一个实例。然而，尽管单例模式是应用最广的设计模式之一，也是程序员非常熟悉的一种设计模式，但它仍然存在一些需要注意的问题。

        饿汉模式：       

			
//饿汉模式单例模式
//此处保证Singleton这个类只能创建出一个实例
class Singleton{
    //在此处，先把这个实例给创建出来
    private static Singleton instance = new Singleton();
			
    //获取这个唯一实例
    public static SingletongetInstance() {
        return instance;
    }
			
    //为了避免Singleton类不小心被复制出多份来，
    //把构造方法设为private，在类外面，就无法通过new的方式来创建这个Singleton实例了
    private Singleton() {  }
			
}
			
public class ThreadDemo6 {
			
    public static void main (String[] args) {
        Singletons1 = Singleton.getInstance();
        Singletons2 = Singleton.getInstance();
        System.out.println(s1==s2);
	}
}

        懒汉模式：

//懒汉模式
class SingletonLazy{
    // 饿汉 与 懒汉 的 根本区别在这里
	private static SingletonLazy instance = null;
			
	public static SingletonLazygetInstance() {
		if (instance == null) {
		    instance = new SingletonLazy ();
		}
		return instance;
	}
			
	private SingletonLazy() {};
		}
			
public class ThreadDemo7 {
	public static void main (String[] args) {
		SingletonLazys1 = SingletonLazy.getInstance();
		SingletonLazys2 = SingletonLazy.getInstance();
		System.out.println(s1==s2);
	}
}

      

        懒汉模式中有一个new的操作，这里就可能造成线程安全问题，而饿汉模式中只有读的操作，所以是线程安全的。

         懒汉模式的线程不安全 是因为读操作、比较、写操作不是原子性的。解决的办法就是将这三个操作上锁，使其变成原子性的。

        在懒汉模式中，实例化对象这个步骤可分为下图中的三步：

        不过，也是有办法解决的：volatile，volatile有两个功能：1，解决内存可见性；2，禁止指令重排序。

        或者使用 synchronized 来解决指令重排序问题。

//懒汉模式
classSingletonLazy{
	private volatile static SingletonLazy instance = null;
						
	public static SingletonLazy getInstance () {
		if (instance == null ) {        //外层这个if 是判断是否加锁
			synchronized (SingletonLazy.class) {
				if (instance == null) {      // 内层这个if  是判断是否实例化对象
				instance = new SingletonLazy();
		        }
	        }
	    }
    return instance;
						
    }
						
	private SingletonLazy () {};
}
						
public class ThreadDemo7 {
	public static void main (String[] args) {
		SingletonLazys1 = SingletonLazy.getInstance();
		SingletonLazys2 = SingletonLazy.getInstance();
		System.out.println(s1 == s2);
	}
}

针对上面代码中提一个问题：既然外层的if已经判断为null了， 又有加锁操作，是否可以将内存的判断删掉呢？

        答：假设有t1、t2两个线程，两个线程都执行到了外层的if语句，并且判断都为null，但是呢，t1线程比t2线程略微快那么一点儿，t1线程先申请到了锁，所以t2线程就只能线程阻塞了，等到t1线程执行完毕后，已经实例化了对象，此时t2线程再去执行，这时的内层if语句就会将t2线程拦下。所以说，两个判断语句，一个都不能少。

        

这里还是有一个问题： 比如t1线程通过synchronized已经对实例化操作进行加锁了，其他线程又如何将执行到一半的t1线程给切换走呢？

        答：线程加锁，并不是说这个线程就一直占用cpu，只是其他线程执行被上锁的代码时会阻塞，但是线程的切换调度还是照常进行的，并不会因为加锁而改变。（意思就是，已经上锁了，你的就是你的，别人拿不走，但是你先别着急，我的这个任务优先级更高，急需执行，所以你就先阻塞一下）。然而问题就是出现在这里，我t1线程执行到一半了，instance已经是非null了，但是还没有构造出对象。结果阻塞了，然后其他线程刚好在t1阻塞这个期间执行到了第一个if语句，发现instance不为null，结果就直接返回了instance，这个就导致了instance引用指向的对象不完整，引发后续问题。

---

       什么是阻塞队列

        什么是高内聚 低耦合

                答：高内聚，这是一个软件工程中的重要概念，它是判断软件设计优劣的标准之一。具体来说，高内聚是指模块内部的元素关联性非常强，以至于模块的单一性非常显著。理想情况下，一个模块应尽可能独立地完成某个特定的功能。

                在面向对象的设计中，高内聚低耦合是一个重要的设计原则，其主要目标是增强程序模块的可重用性和移植性。如果一个模块的内部实现过于复杂，可能会影响其可重用性和移植性。例如，如果一个模块需要被各种场景引用，那么代码的质量可能会变得非常脆弱，这种情况下建议将该模块拆分为多个独立的模块。

                总的来说，高内聚是强调模块功能的独立性和完整性，而低耦合则是强调模块之间的相互独立性，它们共同构成了软件设计的重要原则。

        阻塞队列是一种在多线程编程中经常使用的线程同步工具，它的主要功能是控制生产者和消费者之间的数据流量。阻塞队列的“阻塞”特性带来了几个显著的优点：

                1. 内存消耗可控：当队列容量有限时，内存消耗也会受到限制，防止过度消耗系统资源。

                2. 平衡生产者和消费者速度：阻塞功能使得生产者和消费者两端的能力得以平衡。当有任何一端速度过快时，阻塞队列便会把过快的速度限制下来。

                3. 自动线程阻塞与唤醒：在队列中没有数据的情况下，消费者端的所有线程都会被自动阻塞（挂起），直到有数据放入队列。这样的机制减少了手动管理线程的复杂性。

                4. 指定超时等待：在获取元素时，如果队列为空，线程可以等待特定的超时时间。如果在超时时间内有数据加入队列，线程将继续执行；否则，可以选择放弃等待或采取其他补救措施。

                5. 缓冲区长度可调节：一般的队列只能是有限长度的缓冲区，一旦超出缓冲长度，就无法保留了。当阻塞队列满时，阻塞队列会通过阻塞保留住当前想要继续入队的任务。

        总体而言，阻塞队列通过其阻塞特性，不仅使线程间的通信更加高效，而且减少了程序员需要处理的并发问题，大大提高了程序的稳定性和可靠性。

阻塞队列为生产者消费者模型 带来了两个好处：

        1）解耦合；

                简单理解：就是现在有AB两个程序，其中任何一个程序崩了，都会导致另一个程序的崩溃，这种就是高耦合现象，处处受其他程序掣肘。

                阻塞队列的出现就是来降低两个程序之间的耦合，将AB程序之间的信息交流通过阻塞队列来实现，这样的话，任何一个程序挂了，但是阻塞队列还好着，另一个程序还是可以从队里中拿到其的请求。

        2）削峰填谷

                "阻塞队列的削峰填谷"是一个在多线程编程中常用的术语，主要用于描述阻塞队列在处理并发任务时的一种重要功能。

                1. 削峰：这是指当并发任务的数量过多，以至于系统无法及时处理时，阻塞队列可以起到缓冲的作用，避免系统因为瞬时的大量任务而崩溃。阻塞队列相当于一个缓冲区，平衡了生产者和消费者的处理能力。

                2. 填谷：当并发任务的数量较少时，阻塞队列还可以存储这些暂时没有处理的任务，等到后续有新的任务到来时，再一起处理。这样可以避免系统的空闲资源浪费，提高了系统的处理效率。

---

       阻塞队列的实现

//自己实现阻塞队列
//此处不考虑泛型， 直接使用 int 来表示

class MyBlockingQueue {
    private int[] items = new int[1000];
    private int head = 0;   // 头指针
    private int tail = 0;   // 尾指针
    private int size = 0;   // 记录阻塞队列中元素的个数

    //入队列
    public void put(int value) throws InterruptedException {
        synchronized(this) {
            //在这里进行循环等待，因为 wait 可能被打断。
            while (size == items.length) {
                //队列满了，不能继续插入

                this.wait();
                // 自动阻塞，等待出队列代码（消费者）的 唤醒
            }
            //数组实现循环队列的处理
            items[tail] = value;
            tail++;
            //求余数 是一种解决循环数组的方法
            //tail = tail % items.length;
            //也可以进行一个判断 来解决
            //相比求余数，判断语句的解决方式更容易看懂。 并且这种代码的效率可能更高。
            if (tail >= items.length) {
                tail = 0;
            }
            size++;
            
            // 当前队列不为空了，唤醒 正在阻塞等待 的出队列程序（消费者线程）
            this.notify();
            
        }



    }


    // 出队列
    public Integer take() throws InterruptedException {
        int result = 0;
        synchronized(this) {
            //这里也是循环等待，做同样的处理
            while (size == 0) {
                //队列为空， 无法取出数值
                // 自动阻塞，等待入队列程序（生产者线程）的唤醒
                this.wait();
            }
            result = items[head];
            head++;
            if (head >= items.length) {
                head = 0;
            }
            size--;
            // 此时队列中 不是满着的， 唤醒 入队列程序（生产者线程）
            this.notify();
        }
        
        return result;
    }

    //1， 先要保证线程安全


}



public class ThreadDemo9 {
    public static void main(String[] args) {
        MyBlockingQueue queue = new MyBlockingQueue();

        //消费者线程
        Thread customer = new Thread(() -> {
            while(true) {
                Integer result = null;
                try {
                    result = queue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费元素：" + result);
            }
        });

        //生产者线程
        Thread producter = new Thread(() -> {
            int count = 0;
            while(true) {
                try {
                    queue.put(count);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("生产元素：  " + count);
                count++;
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        customer.start();
        producter.start();
    }
}

---

        我是专注学习的章鱼哥~