享元模式

戏子无情 提交于 2020-03-10 00:53:28

享元模式:
        又称轻量级模式, 是对象池的一种实现。类似于线程池, 线程池可以避免不停的创建和销毁多个对象, 消耗新能。提供了减少对象数量从而改善应用所需的对象结构的方式
        特征: 共享细粒度对象, 将多个对同一对象的访问集中起来。属于结构型模式

使用场景:
        1、常常应用于系统底层的开发,以便解决系统的性能问题
        2、系统有大量相似对象、需要缓冲池的场景

public interface ITicket {

    void showInfo(String bunk);
}
public class TrainTicket implements ITicket{

    private String from;

    private String to;

    private int price;

    public TrainTicket(String from, String to) {
        this.from = from;
        this.to = to;
    }

    @Override
    public void showInfo(String bunk) {
        this.price = new Random().nextInt(2000) ;
        System.out.println(from + "->" + to + ": " + bunk + "价格: " + this.price);
    }
}
public class TicketFactory {

    private static Map<String, ITicket> pool = new HashMap<>();


    public static ITicket queryTicket(String from, String to) {
        String key = from + "->" + to;
        if (pool.containsKey(key)) {
            System.out.println("使用缓存: " + key);
            return pool.get(key);
        }
        System.out.println("首次查询, 创建对象: " + key);
        ITicket ticket = new TrainTicket(from, to);
        pool.put(key, ticket);
        return ticket;
    }
}
public static void main(String[] args) {
    ITicket ticket = TicketFactory.queryTicket("成都东", "北京西");
    ticket.showInfo("商务座");
    ticket = TicketFactory.queryTicket("成都东", "北京西");
    ticket.showInfo("软卧");
    ticket = TicketFactory.queryTicket("成都东", "厦门");
    ticket.showInfo("软卧");
}

=====================================================================================================

public class ConnectionPool {

    private Vector<Connection> pool;

    private String url = "jdbc:mysql://localhost:3306/test";

    private String username = "root";
    private String password = "123456";
    private String driverClassName = "com.mysql.jdbc.Driver";
    private int poolSize = 100;

    public ConnectionPool() {

        pool = new Vector<>(poolSize);

        try {
            Class.forName(driverClassName);
            for (int i = 0; i < poolSize; i++) {

                Connection conn = DriverManager.getConnection(url, username, password);
                pool.add(conn);
            }
        } catch (Exception e) {

        }
    }


    public synchronized Connection getConnection() {

        if (pool.size() > 0) {
            Connection conn = pool.get(0);
            pool.remove(conn);
            return conn;
        }

        return null;
    }

    public synchronized void relese(Connection conn) {

        pool.add(conn);

    }
}
public static void main(String[] args) {
    ConnectionPool pool = new ConnectionPool();
    Connection conn = pool.getConnection();
    System.out.println(conn);
}

在源码中的应用String、Integer

public static void main(String[] args) {
    /**
     * 字符串如果是变量,先开空间,再拼接
     * 如果是常量,先拼接,再在常量池里找,如果有就直接返回,否则,就创建
     *
     * String s=new String("string")String s="string"的区别;
     *   有,前者创建两个对象(或者一个对象,如果字符串常量池里已经存在,就只创建一个对象),后者创建一个对象
     * ==:比较引用类型比较的是地址值是否相同
     * equals:比较引用类型默认比较的也是地址值是否相同
     * string类重写了equals()方法,比较的是内容是否相同
     */
    String s1 = "hello";
    String s2 = "hello";
    String s3 = "he" + "llo";
    String s4 = "hel" + new String("lo");
    String s5 = new String("hello");
    String s6 = s5.intern();
    String s7 = "h";
    String s8 = "ello";
    String s9 = s7 + s8;
    // true
    System.out.println(s1 == s2);
    // false;s5new出来的对象,“==”比较的是地址值
    System.out.println(s1 == s5);
    // true
    System.out.println(s1 == s3);
    // false
    System.out.println(s1 == s4);
    // false
    System.out.println(s1 == s5);
    // false
    System.out.println(s4 == s5);
    // true
    System.out.println(s1 == s6);
    // false
    System.out.println(s5 == s6);
    // false
    System.out.println(s4 == s6);
    // false
    System.out.println(s1 == s9);
}
public static void main(String[] args) {
    Integer a = Integer.valueOf(100);
    Integer b = 100;

    Integer c = Integer.valueOf(1000);
    Integer d = 1000;
    // true
    System.out.println("a==b:" + (a == b));
    // false
    System.out.println("c==d:" + (c == d));
}

Long

优点:
    1、减少对象的创建, 降低内存中对象的数量, 降低系统的内存, 提高效率
    2、减少内存之外的其他资源占用
缺点:
    1、关注内、外部状态、关注线程安全问题
    2、使系统、程序的逻辑复杂化

 

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!