In general this should be fine to do it this way.
When you click the "X" to close the terminal window, that is sending a "signal" from your desktop (GNOME, KDE, etc.) to the terminal application, telling it to shut itself down. Since you're running MATLAB in this shell it's considered a child process to the terminal application.
So part of the responsibilities of being a parent process, is that you in turn send this same close "signal" to your children.
Now if you understand conceptually what I just explained then let's substitute in a bit more of the real terminology.
signals
First with the "signal", there are actually a whole family of different signals that you can send to Unix processes. To keep it simple there are 4 that you'll often see, SIGHUP
, SIGTERM
, SIGINT
, and SIGKILL
.
SIGHUP
The SIGHUP signal is sent to a process when its controlling terminal
is closed. It was originally designed to notify the process of a
serial line drop. In modern systems, this signal usually means that
controlling pseudo or virtual terminal has been closed.
SIGTERM
The SIGTERM signal is a generic signal used to cause program
termination. Unlike SIGKILL, this signal can be blocked, handled, and
ignored. It is the normal way to politely ask a program to terminate.
SIGINT
The SIGINT (“program interrupt”) signal is sent when the user types
the INTR character (normally C-c).
SIGKILL
The SIGKILL signal is used to cause immediate program termination. It
cannot be handled or ignored, and is therefore always fatal. It is
also not possible to block this signal.
NOTE: SIGINT
is what gets sent when you use Ctrl+C to "break" a program from the command line while it's in the middle of running.
which one is getting used?
Most likely the SIGTERM
is being called by your windowing environment and being passed down to your terminal. Your terminal is then most likely then sending SIGHUP
down to MATLAB. This signal gives all the processes the opportunity to do any local clean-up (closing files, ending processes, etc.) themselves.
kill command
You can send signals yourself using the poorly named command, kill
. So to send the SIGTERM
signal to your terminal or the SIGHUP to MATLAB, you could determine their PID using
ps` and then run this command to send them the signal:
$ kill -SIGTERM <PID>
or this:
$ kill -SIGHUP <PID>
You can get a complete list of the signals using this command:
$ kill -l
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP
6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
...
...
Notice that the signals have numbers? You'll often times see them used like that instead of by their names:
$ kill -15 <PID>
Or the infamous -9
, which can kill pretty much any process.
The reason why cannot interrupt that with Ctrl-c etc... is that the shell isn't running any command at that point. It's busy expanding {1..999999}
to compute what the command line arguments will eventually be once it gets to the point of running the command.
While external commands respond to termination signals like SIGINT
(which is emitted by default when you press Ctrl-c), shells themselves ignore them. If they didn't, then, when you pressed Ctrl-c, then in addition to killing whatever command happened to be running, you'd also kill the shell itself! (This is not quite true because of tty job control and foreground and background process groups, but close enough for the purpose of that explanation.)
If you need to interrupt it, there is unfortunately nothing you can do but kill the shell itself. Killing the shell itself will cause your session to terminate. In that sense it's largely equivalent to closing the terminal window or terminating the SSH connection.
Best Answer
The application is connected in two ways: to bash, and to the terminal.
The connection to the terminal is that the standard streams (stdin, stdout and stderr) of the application are connected to the terminal. Typical GUI applications don't use stdin or stdout, but they might emit error messages to stderr.
The connection to the shell is that if you started the application with
foo &
, it remains known to the shell as a job, as explained in Difference between nohup, disown and &. When you close the terminal, the shell receives aSIGHUP
, which it propagates to its jobs. When you typeexit
in the shell, it disowns the jobs beforehand (this is configurable to some extent).You can sever the shell connection with the
disown
built-in. You can't sever the terminal connection, at least not without underhand methods (using a debugger) that could crash the program.