a particular lock" is different between different lock types. A common idiom The common idiom, as in the examples presented above, is that the selection of the appropriate algorithm is based on the call's argument types at runtime. The call is therefore subject to all the usual additional performance costs that are associated with dynamic resolution of calls, usually more than in a language supporting only single method dispatch. In C++, for example, a dynamic function call is usually resolved by a single offset calculation - which is possible because the compiler knows the location of the function in the object's method table and so can statically calculate the offset. In a language supporting double dispatch, this is slightly more costly, because the compiler must generate code to calculate the method's offset in the method table at runtime, thereby increasing the overall instruction path length (by an amount that is likely to be no more than the total number of calls to the function, which may not be very significant). Example in Ruby A common use case is displaying an object on a display port which can be a screen or a printer, or something else entirely that doesn't exist yet. This is a naive implementation of how to deal with those different media. class Rectangle def display_on(port) # selects the right code based on the object class case port when DisplayPort # code for displaying on DisplayPort when PrinterPort # code for displaying on PrinterPort when RemotePort # code for displaying on RemotePort end end end The same would need to be written for Oval, Triangle and any other object that wants to display itself on a medium, and all would need to be rewritten if a new type of port were to be created. The problem is that more than one degree of polymorphism exist: one for dispatching the display_on method to an object and another for selecting the right code (or method) for displaying. A much cleaner and more maintainable solution is then to do a second dispatch, this time for selecting the right method for displaying the object on the medium: class Rectangle def display_on(port) # second dispatch port.display_rectangle(self) end end class Oval def display_on(port) # second dispatch port.display_oval(self) end end class DisplayPort def display_rectangle(object) # code for displaying a rectangle on a DisplayPort end def display_oval(object) # code for displaying an oval on a DisplayPort