2021.11.10

最新推荐文章于 2024-07-10 14:24:24 发布

shu__shu

最新推荐文章于 2024-07-10 14:24:24 发布

阅读量259

点赞数

分类专栏：每日练习文章标签： git redis 数据库

本文链接：https://blog.csdn.net/shu__shu/article/details/121590477

版权

每日练习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

线程安全单例模式

单例模式的实现方式

单例模式属于创建型模式,提供了一种创建对象的最佳方式.

特点:

一个单例类只能有一个实例
单例类必须自己创建自己的唯一实例
在提供这个唯一实例的时候必须保证唯一性

使用场景:

创建某些对象要消耗的资源太多,重复创建效率非常低,比如,I/O和数据库连接池,线程池等
要求生产唯一序列号
WEB中的计数器,可以先使用单例存储

设计要求:

一个私有的构造函数确保只能由单例类自己创建实例
一个公有的静态方法用于提供给使用者内部实例的方法
一个私有静态变量保证实例的唯一性

实现方式:

懒汉式(线程不安全):

class Singleton_hunger{
    private static Singleton_hunger instance;
    private Singleton_hunger(){
        
    }

    public static Singleton_hunger getInstance() {
        if(instance==null){
           instance = new Singleton_hunger();
        }
        return instance;
    }
}

说明:因为只有在第一次调用getInsrance方法的时候才会创建实例,所以被叫做懒汉式

**优点:**在不使用这个类的时候,这个资源不会被实例化,节省了资源,

**缺点:**线程不安全,当有多个线程同时调用getInstance()方法,进入if(insrance==null)语句,那么在此时instance确实没有被创建.那么会有多个线程对这个资源进行实例化,造成了资源的浪费

懒汉式(线程安全):

public class Singleton {
    private static Singleton uniqueInstance;

    private static singleton() {
    }
//加了synchronized同步锁
    private static synchronized Singleton getUinqueInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }

}

**说明:**加入了synchronized同步锁关键字,锁大小为getUinqueInstance()方法,保证同时只有一个线程能进入,从而解决了多个线程同时实例化的问题

但是在后续使用中,因为资源并不会发生改变.不存在线程安全问题.此时这个同步锁会成为性能的桎梏.

**优点:**延迟实例化，节约了资源，并且是线程安全的。

**缺点:**性能的降低

饿汉式(线程安全)

public class Singleton {

    private static Singleton uniqueInstance = new Singleton();

    private Singleton() {
    }

    public static Singleton getUniqueInstance() {
        return uniqueInstance;
    }

}

**说明:**顾名思义,他比较饥渴,哈哈哈.在创建这个类的时候就将这个资源实例化好

**优点:**线程安全

**缺点:**如果不使用这个资源的话,会造成资源的浪费

静态内部类实现（线程安全)

public class Singleton {

    private Singleton() {
    }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getUniqueInstance() {
        return SingletonHolder.INSTANCE;
    }

}

**说明:**在外部类Singleton加载的时候,内部SingletonHolder类不会被加载进内存,

当调用getUniqueInstance()方法的时候,此时会运行 return SingletonHolder.INSTANCE;语句,此时静态内部类才会被加载进内存,并且初始化这个实例的时候,JVM机制因为会保证类只被加载一次,所以这个资源也只会被实例化一次.

优点: 延迟实例化，节约了资源；且线程安全；性能也提高了。

缺点:无?

双重校验锁DCL(线程安全，效率高)

class Singleton_double {
    //一个私有静态变量
    private static volatile Singleton_double instance;
    
    //一个私有构造方法
    private Singleton_double (){
    }
    
    //一个提供给外接的共有方法获取实例
    public static Singleton_double getInstance(){
          if(instance == null){
              synchronized(Subgleton_double.class){
                  if(instance == null){
                      instance = new Singleton_double();
                  }
              }
          }
        return instance;
    }
    
}

volatile关键字添加的原因

在 instance = new Singleton_double();执行过程中可能会分为三步

先为instance实例分配内存空间
对instance进行初始化
返回instance对象

但是JVM是具有指令重排序的优化的,此时在多线程的情况下,可能导致未进行初始化的时候,就将instance对象返回.导致程序出错.

volatile关键字会使得JVM进行指令重排序

**缺点:**volatile对性能有一定影响

枚举类线程安全

public enum Singleton {

    INSTANCE;

    //添加自己需要的操作
    public void doSomeThing() {

    }

}

枚举类默认就是线程安全的

构造方法

初始化Employee类的时候,Person作为父类要先进行初始化,但是因为有有参构造没有无参构造(没有构造方法会默认有一个)

所以在子类初始化的时候,如果没有使用super.构造方法来进行父类构造方法的指定,那么就会调用父类无参构造,当父类没有无参构造方法,需要子类显式调用父类的构造函数.

可以使用super.(nm);加在低8行

剑指 Offer 25. 合并两个排序的链表 - 力扣（LeetCode） (leetcode-cn.com)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode head = new ListNode(0);
ListNode tail = head;
        while(l1!=null && l2!=null){
            if(l1.val<l2.val){
              tail.next = l1;
              l1 = l1.next;
            }else{
                tail.next = l2;
                l2 = l2.next;
            } 
            tail = tail.next;
        }
        tail.next = l1==null?l2:l1;
        return head.next;
    }
}

剑指 Offer 27. 二叉树的镜像 - 力扣（LeetCode） (leetcode-cn.com)

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if(root == null){
            return null;
        }
        mirrorTree(root.left);
        mirrorTree(root.right);
        exchange(root);
        return root;
    }
    public static void exchange(TreeNode root){
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

剑指 Offer 28. 对称的二叉树 - 力扣（LeetCode） (leetcode-cn.com)

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.*;
class Solution {
    public boolean isSymmetric(TreeNode root) {
        //递归搜索
        //当两个子节点都为null,到了叶子结点
        //当一个子节点为空返回false不对称
        if(root==null){
            return true;
        }
        return check(root.left,root.right);
    }
    public boolean check(TreeNode left,TreeNode right){
        if(left==null && right==null){
            return true;
        }
        if(left==null || right==null || left.val != right.val ){
            return false;
        }
        return check(left.left,right.right)&&check(left.right,right.left);
    }
}

shu__shu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021.11.10

线程安全单例模式单例模式的实现方式单例模式属于创建型模式,提供了一种创建对象的最佳方式.特点:一个单例类只能有一个实例单例类必须自己创建自己的唯一实例在提供这个唯一实例的时候必须保证唯一性使用场景:创建某些对象要消耗的资源太多,重复创建效率非常低,比如,I/O和数据库连接池,线程池等要求生产唯一序列号WEB中的计数器,可以先使用单例存储设计要求:一个私有的构造函数确保只能由单例类自己创建实例一个公有的静态方法用于提供给使用者内部实例的方法一个私有静态变
复制链接

扫一扫