When should I use object pool?

I am doing a 2D game that generate at every second a game object.
And the game object is different every time, for that I am using like 12 prefabs, but 9 of then are pretty the same, the only difference is the sprite. So there are 3 very different prefabs with different children, diffrent scripts , and different polygon collider and size.
So to do a object pool for them I need to change the size , the sprite , the child and the polygon collider.
for that and need every time to destroy some components and adding them.

So should I use the object pooling or just instantiate and destroy them?

Well because you want to generate every second a game object, object pooling is far better in terms of performance (most specifically CPU and memory), than instantiating and destroying.
Also, I assume that because you make a 2d game you may want to target for web or mobile, where the community widely suggests using object pooling.

So even in case, where pooling objects concerning performance may not have too much difference in your game I highly suggest you learn how to do it because some day you might want to use it.
I recently created a generic object pooling class based on the unity tutorials, which you can use for any object you want :

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ObjectPooler : MonoBehaviour {

	public static ObjectPooler current;
	public GameObject pooledObject;
	public int pooledAmount = 11;

	//list used for object pooling
	List<GameObject> pooledObjects;

        //reference this game object
	void Awake() {
		current = this;
	}

	// Use this for initialization
	void Start () {
		
		pooledObjects = new List<GameObject>();
		for(int i =0; i < pooledAmount; i++){
			GameObject obj = (GameObject) Instantiate(pooledObject);
			obj.SetActive(false);
			pooledObjects.Add(obj);
		}
	
	}

	
	public GameObject GetPooledObject(){
		for(int i=0; i < pooledObjects.Count ; i++)
		{
			if(!pooledObjects*.activeInHierarchy)*
  •  	{*
    

_ return pooledObjects*;_
_
}_
_
}*_

* return null;*
* }*
}

This is more of a judgement call. It depends on the complexity of your code, the frequency you’re creating objects, the platform you’re targeting, so I can’t say you definitively should or shouldn’t based on the information you’ve given. However, there is a resource I use that is free and has some guidelines. I’d suggest reading it:
http://gameprogrammingpatterns.com/object-pool.html

Here is a snippet about when to use object pools:

This pattern is used widely in games for obvious things like game entities and visual effects, but it is also used for less visible data structures such as currently playing sounds. Use Object Pool when:

You need to frequently create and destroy objects.

Objects are similar in size.

Allocating objects on the heap is slow or could lead to memory fragmentation.

Each object encapsulates a resource such as a database or network connection that is expensive to acquire and could be reused.