1. `killall` already nice (SIGTERM)

killall by default sends SIGTERM. This is already the nice approach that leaves applications the chance to clean up after themselves. The "go die already, right now!" approach is to send a SIGKILL signal, which requires specifying that as an option to killall. From The GNU C Library: Termination Signals:

Macro: int SIGTERM

[...] It is the normal way to politely ask a program to terminate.

2. System Monitor's "End process" equally nice (SIGTERM, too)

You link to a question about GNOME System Monitor. That does use SIGTERM for its "End process" action too (and I realise I am contradicting the answer to that question). You can find it in the source code to verify yourself:

data/menus.ui:

<item>
  <attribute name="label" translatable="yes">_End</attribute>
  <attribute name="action">win.send-signal-end</attribute>
  <attribute name="accel">&lt;Primary&gt;e</attribute>
  <attribute name="target" type="i">15</attribute>
</item>

The 15 here is the signal number. Signal 15 is SIGTERM. And System Monitor has used SIGTERM well before that other question was asked and answered.

Technical addendum (in response to a comment)

_{Looking through the Github representation of git blame, here are the changes that have been made to how the signals are spelt out in the source code of GNOME System Monitor:}

_{383007f2 24 Jul 2013 Replaced duplicated code for sending signals with GAction parameters
0e766b2d 18 Jul 2013 Port process popup menu to GAction
97674c79 3 Oct 2012 Get rid of ProcData structure
38c5296c 3 Jul 2011 Make indentation uniform across source files.}

_{None of these changed from SIGQUIT to SIGTERM, and that last one was from before the linked question was asked.}

The answer by @hvd is basically correct. To back that up even more, the init process will first send SIGTERM to processes when your are shutting down your computer, then after a delay will send SIGKILL if they have not already exited. Processes can't handle/ignore SIGKILL.

To give a bit more detail though, the real answer is that you have no way of knowing for sure that the program handles it. SIGTERM is the most usual signal to use for politely asking a program to quit, but all signal handling depends on the program doing something with the signal.

To put it a different way, based on the other answers, if you had a program written by @Jos or by @AlexGreg then they would presumably be handling SIGQUIT but possibly not SIGTERM, and hence sending SIGTERM would be less "soft" than SIGQUIT.

I've written some code so you can play around with it yourself. Save the below as signal-test.c, then compile with

gcc -o signal-test signal-test.c

You can then run it ./signal-test, and see what happens when you send different signals with killall -s <signal>.

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

int flag = 0;

void handle_signal(int s)
{
    flag = s;
}

int main(int argc, char *argv[])
{
    signal(SIGTERM, handle_signal);
    signal(SIGQUIT, handle_signal);

    while(flag == 0){
        sleep(1);
    }
    printf("flag is %d\n", flag);
    return flag;
}

As it stands, the code handles both SIGTERM and SIGQUIT gracefully. You could try commenting out the lines signal(SIG... (using a // at the start of the line) to remove the signal handler, then run and send the signals again. You should be able to see these different outputs:

$ ./signal-test
Terminated

$ ./signal-test
Quit (core dumped)

$ ./signal-test
flag is 15

$ ./signal-test
flag is 3

depending on whether you handle the signals or not.

You could also try ignoring the signals:

signal(SIGTERM, SIG_IGN);

If you do that then sending SIGTERM will do nothing, you'll have to use SIGKILL to end the process.

More details in man 7 signal. Note that using signal() in this way is considered non-portable - it's lots easier than the alternative though!

One other minor footnote - on Solaris killall attempts to kill all processes. All of them. If you run it as root then you may be surprised :)

"End all" would be killall -s SIGQUIT [process name]. If you want a fancy solution, define alias endall='killall -s SIGQUIT'.