Ideal way to single-instance apps on the Mac

Question

On Windows, it's common practice to create a named mutex and use the presence of that to determine that an instance of a given app is already running. This has its drawbacks, but mostly works.

I can think of a ways to do this on the Mac:

1. named pthread mutexes
2. enumerate running processes and look for one that matches
3. create and lock a file

Is there something built into Cocoa/Carbon that's easier than the options above? If not, which of the three are most used on the mac? I would assume 2 or 3...

Colpitis

just looking at how apps are launched and interacted with I didn't think it was possible to have multiple instances... At least not with apps bundled up into a nice .app – Opalescent

Ok I cheated a little in my question... I really wanted to run a test app that did a bunch of validation but launching it while the application is running caused false positives. In order to not waste time chasing down useless issues, I wanted the test app to bail with an error if the app is running. On windows, I solved it using the single-instancing approach and assumed I want to do the same for the mac. – Colpitis

[used NSRunningApplication detect if application with same bundleID is running, activate it and close what starts.][1] [1]: #685411 – Plexiglas

Answer 1

Macs do not have instances in the same way as Windows does. Generally speaking you want the application running twice you physically need to copy the binary and then double click on the copied version as well.

If you need two instances of an application running then you are not thinking like a Mac user :).

Edit: This is technically not true. Check the comments.

Catarrhine

In other words, there's no need if we're talking about GUI apps. It already works that way. – Henebry

That's not true. If you start the application from the terminal, for example, you can launch N instances simultaneously. The fact that it is uncommon do not mean that the case should not be taken into account. – Unbalance

Right. I even will give you a simple example, which I believe is a pretty common one: starting an app from postinstall of an installer. If you search the app and launch from Spotlight, second instance lights up. – Glottology

Answer 2

To elaborate further on using NSWorkspace. Try using launchedApplications in NSWorkspace. This returns an NSArray containing a dictionary for each launched application. You can loop through the array to see if the app you are looking for is already running. I would advise that you use the value with the key NSApplicationBundleIdentifier which will have a value like "com.mycompany.myapp" rather than looking for the name. If you need to find the bundle identifier for an app you can look at its info.plist file in the app package.

Indicia

This is kinda what I want to do, but my test app isn't a Cocoa app (see updated comment in my Q above). I found GetNextProcess() in Carbon that might help.. any other suggestions? – Colpitis

That would be the way to do it if you are a Carbon app. Are you already linked against the Carbon library? However, the same single instance feature applies to Carbon apps as well. It sounds like you might be building a unix command line program, is that correct? It might be helpful to describe what you are building in more detail. – Indicia

Note that NSWorkspace -launchedApplications was depreciated in Mac OS X 10.7. Apple recommends that you now use NSWorkspace -runningApplications instead (10.6+): developer.apple.com/library/mac/#documentation/Cocoa/Reference/… – Delwin

Answer 3

Mapping process management among disparate operating systems doesn't work. Or doesn't work well. By default and without particular effort, you get one copy and only one copy of the application.

Here's a previous similar question that goes a step further than this current question, and with some replies that discuss interlocking when there are multiple copies of an image, or multiple applications that need coordination.

How to detect whether an OS X application is already launched

For an introduction to the run-time context and particularly around Mac OS X daemons and agents (and for those cases when you do need to have multiple copies of an executable running, as a pool or such and akin to Apache), see:

http://developer.apple.com/technotes/tn2005/tn2083.html

Oaks

Answer 4

If you're writing a Cocoa application, you can use NSWorkspace to see if another process is running with your bundle identifier. I've seen a few apps that present a dialog and say: "An instance of this app is already running" - I think Firefox does it, actually.

It's not a very "mac-ish" approach, but it will get the job done.

Pleadings

This is kinda what I want to do, but my test app isn't a Cocoa app (see updated comment in my Q above). I found GetNextProcess() in Carbon that might help.. any other suggestions? – Colpitis

Answer 5

If you were to deploy your application with Java Web Start (JWS), you could use javax.jnlp.SingleInstanceService. JWS provisioning would also provide automatic program updates.

Angeliqueangelis

Answer 6

The following code can be used the quit applications with the same bundle identifier that are already running.

It also displays an alert after doing so.

AppDelegate.applicationDidFinishLaunching

let runningApp =
    NSWorkspace.shared.runningApplications
        .filter { item in item.bundleIdentifier == Bundle.main.bundleIdentifier }
        .first { item in item.processIdentifier != getpid() }

if let running = runningApp {
    running.forceTerminate()
    
    let alert = NSAlert()
    alert.messageText = "App was alreday running"
    alert.informativeText = "App was terminated."
    alert.alertStyle = NSAlert.Style.informational
    alert.addButton(withTitle: "OK")
    alert.runModal()
}

note: This assumes that there only can be one already running app. Should be trivial to adapt for other scenarios.

Roussillon

Answer 7

Here's the Swift 5 code for quitting current application if one is already running. Just put it in applicationDidFinishLaunching

let bundleIdentifier = Bundle.main.bundleIdentifier

if NSWorkspace.shared.runningApplications.filter { $0.bundleIdentifier == bundleIdentifier }.count > 1 {
    print("App already running.")
    exit(0)
}

Melamine