Determine if only one instance is running: Difference between revisions

 

=={{header|Ada}}==

The following solution tries to open a file for reading. If the file does ''not'' exist, a 'Name_Error' is raised. The exception handler creates that file, allows the program to perform its task, and, eventually, makes sure the file is deleted. If no exception is raised, the file exists, so another instance is running, and the program stops. It also stops if the wrong exception is raised, i.e., any exception other than 'Name_Error'.

 

 

procedure Single_Instance is

exception

when others => IO.Delete(Lock_File);

 

Note that there is a race condition: If another instance tries to open the file for reading, before the first one has created it, then more than one instance will actually run.

AutoHotkey has a #SingleInstance command. If you run two scripts that don't have it at the same time, it alerts the user. #SingleInstance FORCE closes the older instance when a newer one is run, and #SingleInstance IGNORE does nothing when you try to open a new instance of an already-running script.

 

Using advisory locks from libc.

OPTION DEVICE O_NONBLOCK

 

SLEEP 5000

 

 

=={{header|Bash Shell}}==

Using flock, exits 0 if you got the lock, otherwise exits 1, below is a simplified example:

 

local fd=${2:-200}

 

&& # do something if you got the lock \

|| # do something if you did not get the lock

 

There's a nice program called singleton that wraps this in an easy to use package : https://github.com/krezreb/singleton

{{works with|BBC BASIC for Windows}}

Change 'UniqueLockName' to something more likely to be unique, such as a GUID.

SYS "GetLastError" TO lerr%

IF lerr% = 183 THEN

SYS "ReleaseMutex", Mutex%

SYS "CloseHandle", Mutex%

 

=={{header|C}}==

 

{{libheader|POSIX}}

#include <stdlib.h> /* atexit, getenv, malloc */

#include <stdio.h> /* fputs, printf, puts, snprintf */

puts("Fin!");

return 0;

 

=== POSIX with file creation ===

 

{{libheader|POSIX}}

#include <signal.h>

#include <stdio.h>

unlink("/tmp/MyUniqueName"); close(myfd);

return 0;

 

=={{header|C sharp|C#}}==

===Using a TCP Port===

 

using System.Net;

using System.Net.Sockets;

}

}

 

===Using a mutex===

// Use this class in your process to guard against multiple instances

//

}

}

 

=={{header|C++}}==

{{works with|Windows|2000 or later}}

This line needs to be near the top of the file (or in stdafx.h, if you use one.)

 

You need a variable of type HANDLE with the same lifetime as your program. Perhaps as a member of your CWinApp object.

 

At the earliest possible point in your program, you need to initialize it and perform your check. "MyApp" should be a string unique to your application. See [http://msdn2.microsoft.com/en-us/library/ms682411.aspx here] for full details.

 

if ( GetLastError() == ERROR_ALREADY_EXISTS )

{

// There's another instance running. What do you do?

 

Finally, near the end of your program, you need to close the mutex.

 

=={{header|Clojure}}==

{{trans|Java}}

 

(def *port* 12345) ; random large port number

(try (new ServerSocket *port* 10 (. InetAddress getLocalHost))

 

=={{header|D}}==

All we need is to generate a unique name for our program and pass it as the address when calling bind(). The trick is that instead of specifying a file path as the address, we pass a null byte followed by the name of our choosing (e.g. "\0my-unique-name"). The initial null byte is what distinguishes abstract socket names from conventional Unix domain socket path names, which consist of a string of one or more non-null bytes terminated by a null byte.

Read more here: [https://blog.petrzemek.net/2017/07/24/ensuring-that-a-linux-program-is-running-at-most-once-by-using-abstract-sockets/]

bool is_unique_instance()

{

}

}

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

end;

end;

 

=={{header|Erlang}}==

called as register(aname,<0.42.0>)

</pre>

 

=={{header|Go}}==

Recommended over file based solutions. It has the advantage that the port is always released

when the process ends.

 

import (

fmt.Println("single instance started")

time.Sleep(10 * time.Second)

===File===

Solution using O_CREATE|O_EXCL. This solution has the problem that if anything terminates the

program early, the lock file remains.

 

import (

time.Sleep(10 * time.Second)

os.Remove(lfn)

Here's a fluffier version that stores the PID in the lock file to provide better messages.

It has the same problem of the lock file remaining if anything terminates the program early.

 

import (

fmt.Println(os.Getpid(), "running...")

time.Sleep(1e10)

 

=={{header|Haskell}}==

Simple implementation using a lock file. Two threads are launched, but the second cannot start because the first has created a lock file which is deleted when it has finished.

import System.Directory (doesFileExist, getAppUserDataDirectory,

removeFile)

-- thus will exit immediately

forkIO oneInstance

 

=={{header|Icon}} and {{header|Unicon}}==

The following only works in Unicon. The program uses a socket as a flag.

 

if not open(":"||54321,"na") then stop("Already running")

repeat {} # busy loop

 

Sample run:

 

=={{header|Java}}==

import java.net.InetAddress;

import java.net.ServerSocket;

}

}

 

=={{header|Jsish}}==

Using a socket on a fixed port number.

var sock;

 

puts('Applicaion already running');

exit(1);

 

{{out}}

 

=={{header|Julia}}==

using Sockets

 

 

canopen()

 

=={{header|Kotlin}}==

 

import java.io.IOException

SingleInstance.close()

}

 

{{out}}

 

=={{header|Lasso}}==

 

local(lockfile = file('/tmp/myprocess.lockfile'))

sleep(10000)

 

 

Output Window 1:

 

=={{header|Liberty BASIC}}==

CallDLL #kernel32, "CreateMutexA", 0 as Long, 1 as Long, "Global\My Program" as ptr, mutex as ulong

CallDLL #kernel32, "GetLastError", LastError as Long

calldll #kernel32, "ReleaseMutex", mutex as ulong, ret as ulong

calldll #kernel32, "CloseHandle", mutex as ulong, ret as ulong

 

=={{header|M2000 Interpreter}}==

We can lock a file in user folder. Only one instance can lock a file.

 

Module Checkit {

Try {

}

}

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

$Epilog is the action performed upon session exit.

Running the following code before any other code will prevent 2 instances from concurrent execution.

If[Attributes[Global`Mutex] == {Protected},

Exit[],

Global`Mutex[x_] := Locked; Protect[Global`Mutex];

 

=={{header|Nim}}==

===fcntl based===

 

 

let fn = getHomeDir() & "rosetta-code-lock"

echo i

sleep 1000

 

===Unix Domain Socket based===

 

from net import newSocket, bindUnix

from nativesockets import AF_UNIX, SOCK_DGRAM, IPPROTO_IP

server()

else:

 

=={{header|OCaml}}==

Replicates the '''C''' example, with the library [http://ocaml-sem.sourceforge.net/ ocaml-sem].

 

let () =

(* end of the app *)

sem_unlink "MyUniqueName";

 

The standard library of OCaml also provides a [http://caml.inria.fr/pub/docs/manual-ocaml/libref/Mutex.html Mutex] module.

 

=={{header|Oz}}==

import Application Open System

define

{{New Open.file init(name:stdin)} read(list:_ size:1)}

{Application.exit 0}

 

=={{header|Perl}}==

 

Then it tries to get a lock to its own file, from where the script was called.

 

INIT

}

 

 

=={{header|Phix}}==

{{libheader|Phix/pGUI}}

 

=={{header|PicoLisp}}==

<pre>$ ./myScript & # Start in the background

[1] 26438</pre>

: (call "killall" "-0" "-q" "myScript")

 

===Using a mutex===

Another possibility is to 'acquire' a mutex on program start, and never release

it.

A second application trying to acquire the same mutex would receive 'NIL'

 

=={{header|PowerShell}}==

if (Get-Process -Name "notepad" -ErrorAction SilentlyContinue)

{

Start-Process -FilePath C:\Windows\notepad.exe

}

No output because notepad.exe was not running, so it was started.

{{Out}}

</pre>

Run it again.

if (Get-Process -Name "notepad" -ErrorAction SilentlyContinue)

{

Start-Process -FilePath C:\Windows\notepad.exe

}

Since it is running a warning message is output.

{{Out}}

 

=={{header|PureBasic}}==

Mutex=CreateMutex_(0,1,#MyApp)

If GetLastError_()=#ERROR_ALREADY_EXISTS

 

ReleaseMutex_(Mutex)

 

=={{header|Python}}==

Must be run from an application, not the interpreter.

 

 

def isOnlyInstance():

return os.system("(( $(ps -ef | grep python | grep '[" +

__main__.__file__[0] + "]" + __main__.__file__[1:] +

 

This is not a solution - one can run the same app by copying the code to another location. A solution may be a lock file or lock directory created by the first instance and hold while the first instance is running.

=={{header|Racket}}==

{{trans|Java}}

#lang racket

(define *port* 12345) ; random large port number

(printf "Working...\n")

(sleep 10)

 

=={{header|Raku}}==

{{works with|rakudo|2018.03}}

An old-school Unix solution, none the worse for the wear:

my $pid = $*PID;

 

}

note "Got lock!";

 

=={{header|REXX}}==

{{works with|ARexx}}

Solutions using a temporary file as a semaphore aren't very clean; if the program ends abruptly, the file isn't cleaned up. In this solution, we will instead open an ARexx port of our own. Ports are automatically closed by the interpreter if the program is ABENDed.

IF Show('PORTS','ROSETTA') THEN DO /* Port is already open; exit */

SAY 'This program may only be run in a single instance at a time.'

END

 

 

=={{header|Ring}}==

# Project : Determine if only one instance is running

 

end

return sum

Output:

<pre>

=={{header|Ruby}}==

Uses file locking on the program file

puts "first instance"

sleep 20

end

 

 

=={{header|Run BASIC}}==

 

=={{header|Rust}}==

Using TCP socket

 

fn create_app_lock(port: u16) -> TcpListener {

// ...

remove_app_lock(lock_socket);

 

=={{header|Scala}}==

===Java Interoperability===

{{Out}}Best seen running in your browser [https://scastie.scala-lang.org/ja0sMzt5SGKHSu3w8qnlQQ Scastie (remote JVM)].

import java.net.{InetAddress, ServerSocket}

 

sys.exit(0)

 

 

=={{header|Sidef}}==

# store the returned fh inside a variable.

var fh = File(__FILE__).open_r

say "Running..."

Sys.sleep(20)

 

=={{header|Swift}}==

Uses NSDistributedNotificationCenter. Works with Swift 1.2.

 

let globalCenter = NSDistributedNotificationCenter.defaultCenter()

 

send()

 

=={{header|Tcl}}==

{{trans|Java}}

{{works with|Tcl|8.6}}

try {

# Pick a port number based on the name of the main script executing

puts stderr "Application $::argv0 already running?"

exit 1

 

=={{header|TXR}}==

==== Microsoft Windows ====

 

(typedef HANDLE cptr)

(typedef LPSECURITY_ATTRIBUTES cptr)

)

 

=={{header|UNIX Shell}}==

{{works with|Bourne Shell}}

{{works with|Bourne Again SHell}}

# (c) Copyright 2005 Mark Hobley

#

fi

}

 

=={{header|Visual Basic}}==

{{works with|Visual Basic|5}}

{{works with|Visual Basic|6}}

 

{{omit from|ACL2}}