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的操作,这里就可能造成线程安全问题,而饿汉模式中只有读的操作,所以是线程安全的。

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

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

Java编程--单例模式(饿汉模式/懒汉模式)/阻塞队列_第1张图片

        不过,也是有办法解决的: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线程拦下。所以说,两个判断语句,一个都不能少。

Java编程--单例模式(饿汉模式/懒汉模式)/阻塞队列_第2张图片

        

这里还是有一个问题: 比如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();
    }
}


        我是专注学习的章鱼哥~

你可能感兴趣的:(Java多线程编程,java,单例模式,开发语言)