享元模式（Flyweight Pattern）

享元模式（Flyweight Pattern）

享元模式是对象池的一种体现。类似于线程池，可以避免不停地创建和销毁多个对象。实际上就是将多个同一个对象的访问集中起来，类似于数据库连接池。

To illustrate with  a scene of  ticket-grabbing

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

    private String from;
    private String destination;
    private int price;
    TrainTicket(String from, String destination) {
        this.from = from;
        this.destination = destination;
    }


    // get information from website of 12306 or someone else
    @Override
    public void showInfo(String bunk) {
        this.price= new Random().nextInt(500);
        System.out.println(from+"->"+destination+":"+bunk+" price:"+this.price);
    }
}

the duty of Method named showInfo is to get infromation of ticket form other places,whcih will consume many performance of computer and  time.when we get a information we will  assemble them into an instance,we should make a same instance just be cerate once.

public class TicketFactory {
    static Map<String, ITicket> pool = new ConcurrentHashMap();
    static ITicket query(String from,String destination){
        String key=from+"->"+destination;
        if (pool.containsKey(key)){
            System.out.println("use cache ");
            return pool.get(key);
        }
        System.out.println("first query and create instance: "+key);
        ITicket iTicket=new TrainTicket(from,destination);
        pool.put(key,iTicket);
        return iTicket;
    }
}

 To test

public class Test {
    public static void main(String[] args) {
        ITicket query = TicketFactory.query("beijing", "xian");
        query.showInfo("hard seat");
        query = TicketFactory.query("beijing", "xian");
        query.showInfo("soft seat");

    }
}

 

 To expalin

we query the same place of departure and destination,the first time we go to website named 12306 to get infromation ,but the second time we just get message from cache, so that we do not have to spent much time and consume performance of computer

 

tips:

you may have a question of that is it similiar with pattern of register singleton!you can see it again,actually, it bit like that but the dimension of  Register Singleton is Class but the dimension of pattern of flyweight is different  key of hash(you can assign key whatever you want)

 How is the pattern of flyweight applied into source of code

in String we use it

s1==s2((in fact when the code compiled the 'hello' has been assign into pool of constant,as a result s1 and s2 are assign a same address of constant ,so that they are equal) )

s1==s3 (like s1==s2)

s1==s4 (in s4 actually there where 3 space the  first is 'hel' and second is 'new String' and 'lo' also,therefore they are not equal) so on

 sum up: in base class of String has a pool of constant if two constant are equal it will be assign the same address(like pattern of pattern)

 public static void main(String[] args) {
        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;
        System.out.println(s1==s2);//true
        System.out.println(s1==s3);//true
        System.out.println(s1==s4);//false
        System.out.println(s1==s9);//false
        System.out.println(s4==s5);//false
        System.out.println(s1==s6);//true
    }

in interger（java.lang.Integer#valueOf(int)）

       Integer a = Integer.valueOf(100);
        Integer b = 100;

        Integer c = Integer.valueOf(1000);
        Integer d = 1000;

        System.out.println("a==b:" + (a == b));
        System.out.println("c==d:" + (c == d));

 To explain:

why do we pass on 100 and 1000 result the different consequence->(the low of cache is -128 and the high of its is 127 if the number we pass on is included in the area. it will create a new instance )

 Sum up:

advantage：

It can extremely reduce number of  instances,so that the same instances are kept in memory

disadvantage:

make sysmtem more complex, as the interger you should not know key you pass on  numbers greater than 127 will create a new instances ,if you did not looking up sorce of code