Garbage Collection issue with infinite ImageViews

My code is creating ImageViews (image of a target) at a set rate that are displayed on the UI and will be removed from the main layout after 3 seconds or once it has been clicked on. The problem is the garbage collection causes delay when I create these ImageViews, which delays the creation of further ImageViews

Here I spawn call for the ImageView to be created in a while loop:

//for each multiple of the spawn rate value, a target will be spawned
                    while (currentTimeOfGame % spawnRate == 0) {
                        createTarget(context);
                        //update the time of game relative to the game's start time
                        currentTimeOfGame = ((new Date().getTime()) - startTime);
                    }

And then in createTarget() I create an instance of the Target class which extends ImageView.

    //method for creating the targets
    public void createTarget(Context context) {
        //dimensions of the main relative layout
        int width = getWidth();
        int height = getHeight();

        //instantiate a target to spawn
        final Target target = new Target(context);
        target.setParams(width, height);

Here it is removed from the layout once it is clicked. This removes the targets fine but after a few of them, it causes delays caused by the garbage collector, which only delays the next spawn.

        Runnable thread = () -> target.setOnClickListener(v -> {
            Handler subMainHandler = new Handler(context.getMainLooper());
            Runnable subThread = new Runnable() {
                @Override
                public void run() {
                    target.setVisibility(View.INVISIBLE);
                    removeView(target);
                    target.setImageDrawable(null);
//            Log.d("target clicked", String.valueOf(currentTimeOfGame));
//            Interrupting the thread that tracks the target's timer
                    spawnTarget.interrupt();
                }
            };
            subMainHandler.post(subThread);

        });

This is the class for the Target.

public class Target extends androidx.appcompat.widget.AppCompatImageView {

    public long spawnTime = new Date().getTime();

    public Target(Context context) {
        super(context);
        this.setBackgroundResource(R.drawable.target_shape);
        this.setVisibility(View.VISIBLE);
    }

    public void setParams(int width, int height) {
        RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
        Random r = new Random();

        this.setLayoutParams(params);
        int randomLeftMargin = r.nextInt(width);
        int randomTopMargin = r.nextInt(height);
        params.leftMargin = randomLeftMargin;
        params.topMargin = randomTopMargin;
        this.setLayoutParams(params);
    }

}

This is the XML file of the target

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="oval">
    <solid android:color="@color/PrimaryBlue" />
    <stroke
        android:width="1dp"
        android:color="@color/LightGrey" />
    <size
        android:width="30dp"
        android:height="30dp" />
</shape>

How do I prevent the garbage collector from causing delays up to 300 milliseconds? Is this to do with creating a new instance of the Target class every time I create a new Target?

EDIT:

Code for handling the 3 second timer for each targets life span. a target is removed whenever a target isn't clicked within 3 seconds, after 3 seconds. a life is deducted each time, and once there are 0 lives, no more targets are spawned. The issue with the delay is caused by this block of code where the player still has lives and the target is removed with a click, so this thread is interrupted by the onClickListener.

       Thread handleTarget = new Thread() {
            public void run() {

                //updating the location of the target to ensure it doesn't overlap with the edge
                Runnable setTargetParamsThread = () -> {
                    int targetWidth = target.getMeasuredWidth();
                    int targetHeight = target.getMeasuredHeight();
                    if (targetHeight != 0 && targetWidth != 0) {
                        target.setParams(width, height, targetWidth, targetHeight);
                        target.setVisibility(View.VISIBLE);
                    }
                };
                mainHandler.post(setTargetParamsThread);


                while (true) {
                    //check if the target has reached 3 seconds without being tapped
                    if (new Date().getTime() > target.spawnTime + 3000) {

                        if (lives == 0) {
                            gameOver = true;
                            //discontinue of the number of lives = 0 as the game is over
                            target.setClickable(false);

                            //fade out animation for target on end of game for remaining targets
                            Animation fadeOut = new AlphaAnimation(1, 0);
                            fadeOut.setDuration(250);
                            AnimationSet animFadeOut = new AnimationSet(true);
                            animFadeOut.addAnimation(fadeOut);
                            target.setAnimation(animFadeOut);

                            Handler mainHandler = new Handler(context.getMainLooper());
                            Runnable thread = () -> removeView(target);
                            mainHandler.post(thread);

                            Thread.currentThread().interrupt();
                        }

                        //if the target is visible remove it and deduct a life.
                        else if (target.getVisibility() == View.VISIBLE) {
                            //remove the target and deduct a life
                            target.setImageDrawable(null);
                            Handler mainHandler2 = new Handler(context.getMainLooper());
                            Runnable thread = () -> removeView(target);
                            mainHandler2.post(thread);

//                            Log.d("target removed", String.valueOf(currentTimeOfGame));
                            lives--;
//                            Log.v("lives", String.valueOf(gameOver));
                            //discontinue the thread for this target once it has been removed as it no longer needs to be referenced
                            Thread.currentThread().interrupt();
                        }
                        break;
                    }
                }
            }
        };

Replacing anonymous inner classes and handling Thread interruptions resolved the issue.