whether a shell script can be executed if another instance of the same script is already running

When writing scripts like the one you describe, I take one of two approaches.

First, you can use a pid file to indicate that a second copy should not run. For example:

#!/bin/sh

pidfile=/var/run/$(0##*/).pid

# remove pid if we exit normally or are terminated
trap "rm -f $pidfile" 0 1 3 15

# Write the pid as a symlink
if ! ln -s "pid=$$" "$pidfile"; then
  echo "Already running. Exiting." >&2
  exit 0
fi

# Do your stuff

I like using symlinks to store pid because writing a symlink is an atomic operation; two processes can't conflict with each other. You don't even need to check for the existence of the pid symlink, because a failure of ln clearly indicates that a pid cannot be set. That's either a permission or path problem, or it's due to the symlink already being there.

Second option is to make it possible .. nay, preferable .. not to block additional instances, and instead configure whatever it is that this script does to permit multiple servers to run at the same time on different queue entries. "Single-queue-single-server" is never as good as "single-queue-multi-server". Since you haven't included code in your question, I have no way to know whether this approach would be useful for you, but here's some explanatory meta bash:

#!/usr/bin/env bash

workdir=/var/tmp   # Set a better $workdir than this.

a=( $(get_list_of_queue_ids) )  # A command? A function? Up to you.

for qid in "${a[@]}"; do

  # Set a "lock" for this item .. or don't, and move on.
  if ! ln -s "pid=$$" $workdir/$qid.working; then
    continue
  fi

  # Do your stuff with just this $qid.
  ...

  # And finally, clean up after ourselves
  remove_qid_from_queue $qid
  rm $workdir/$qid.working

done

The effect of this is to transfer the idea of "one at a time" from the handler to the data. If you have a multi-CPU system, you probably have enough capacity to handle multiple queue entries at the same time.

ghoti's answer shows some helpful techniques, if modifying the script is an option.

Generally speaking, for an existing script:

Unless you know with certainty that:

• the script has no side effects other than to output to the terminal or to write to files with shell-instance specific names (such as incorporating $$, the current shell's PID, into filenames) or some other instance-specific location,

• OR that the script was explicitly designed for parallel execution,

I would assume that you cannot safely run multiple copies of the script simultaneously.

It is not reasonable to expect the average shell script to be designed for concurrent use.

From the viewpoint of the operating system, several processes may of course execute the same program in parallel. No need to worry about this.

However, it is conceivable, that a (careless) programmer wrote the program in such a way that it produces incorrect results, when two copies are executed in parallel.