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.

=={{header|AutoHotkey}}==

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.

 

=={{header|BBC BASIC}}==

{{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

using System;

using System.Threading;

}

}

 

=={{header|Clojure}}==

{{trans|Java}}

 

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

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

=={{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;

import java.net.UnknownHostException;

public class SingletonApp

{

 

 

 

 

=={{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|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}}==

 

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

var fd = getFileHandle fn.open fmReadWrite

if fcntl(fd, F_SETLK, addr fl) < 0:

quit 1

addQuitProc ooiUnlink

echo i

sleep 1000

 

=={{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}}==

 

=={{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|REXX}}==

{{works with|ARexx}}

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|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|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|UNIX Shell}}==

{{works with|Bourne Shell}}

{{works with|Bourne Again SHell}}

# (c) Copyright 2005 Mark Hobley

#

fi

}

 

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

{{works with|Visual Basic|4}} <!-- previous versions possible but unlikely; no way to test right now -->

 

{{omit from|ACL2}}