池模式和原型模式有什么区别？

Question

I've just read the chapter on Creational patterns in the book Design Patterns in golang. These are:

• factory
• abstract factory
• prototype
• singleton
• builder

I've created a repository on github to list all of them. I've looked for other repositories like mine:

• tmrts/go-patterns
• yksz/go-design-patterns
• jeanphorn/go-design-patterns

Some list object-pool as a pattern, others simple-factory and factory-method. Does there exist an official list of creational patterns in go? Is it important to know the list, or is it more important to know what is possible and be able to use right code in right context? With or without know all the patterns in the world?

And, ... what is the difference between prototype and object pool patterns? They look very similar to me.

Answer 1

A Pool helps limit the number of new objects allocated; a Prototype is a way of specifying how a new object is created.

Object pools are concerned with caching created instances of objects that can be accessed later. Golang has an implementation (https://golang.org/pkg/sync/#Pool) which is mainly used for relieving pressure on the garbage collector. The usual way of using a pool follows something like:

1. ask the pool for an instance
2. The pool will either give you back an unused object, or it will allocate a new object, and give the new instance back to you
3. You use the object to do whatever you need
4. You give the object back to the pool so that another "client" can use it.

In the Pool implementation, you'll notice that you can pass a "creation" function to specify how the pool should create an instance in Step 2.

New func() interface{}

This function could simply allocate an empty struct, or it could use a Prototype pattern to clone new instances if the creation logic was complicated.

The Prototype pattern is more focused on abstracting how you can create many "copies" of an object from a prototype object. You mainly use this pattern when you want to try and avoid the use of the new keyword.