linearizable concurrent objects  technological advances are making multiprocessors more readily available, but despite impressive progress at the hardware level, it is still difficult to realize these machines' potential for parallelism. in the sequential domain, "object-oriented" programming methodologies based on data abstraction are widely recognized as an effective means of enhancing modularity, expressibility, and correctness. our paper describes the foundations for a new approach to extending object- oriented methodologies to highly-concurrent shared-memory multiprocessors.  the basic idea is the following: rather than communicating through low-level machine constructs such as bytes, words, registers, etc., processes communicate through abstract data structures called concurrens objects. for example, in a real-time system consisting of a pool of sensor and actuator processes, the processes might communicate via a first-in-first-out (fifo) queue object in shared memory. when a sensor process detects a condition requiring a response, it records the condition by enqueuing a record in the queue. whenever an actuator process becomes idle, it dequeues the next item from the queue and takes appropriate action. while the correct behavior of objects such as fifo queues is well-understood in the sequential domain, it is not so obvious how a fifo queue should behave when manipulated by concurrent processes. we advocate a new correctness condition, linearizability, for implementing and reasoning about concurrent objects.  we view a concurrent system as a collection of sequential processes that communicate through shared objects. each object has a type, which defines a set of possible values and a set of primitive operations that provide the only means to create and manipulate that object. in the absence of concurrency, operations are executed one at a time, and their meanings can be captured by simple pre- and postconditions. in a concurrent program, however, operations can be executed concurrently, thus it is necessary to find a new meaning for operations that may overlap in time. two requirements seem to make intuitive sense: first, each operation should appear to "take effect" instantaneously, and second, the order of non-concurrent operations should be preserved. we define a concurrent computation to be linearizable2 if it is "equivalent" to a legal sequential computation that satisfies these two requirements.  informally, linearizability provides the illusion that each operation applied by concurrent processes takes effect instantaneously at some point between its invocation and its response. this property implies that the effects of a concurrent object's operations can still be specified using pre- and post- conditions; however, we interpret a data type's sequential specification as permitting only linearizable interleavings. thus, instead of treating data as a mass of hardware registers or single large database whose entities are uninterpreted, linearizability exploits the semantics of abstract data types. it permits a high degree of concurrency, yet it permits programmers to specify and reason about concurrent objects using known techniques from the sequential domain.  using axiomatic specifications and our notion of linearizability, we can reason about two kinds of problems: (1) the correctness of linearizable object implementations by using new techniques that generalize the sequential notions of representation invariant and abstraction function to the concurrent domain; and (2) the correctness of computations that use linearizable objects by transforming assertions about concurrent computations into simpler assertions about their sequential counterparts.  m. p. herlihy j. m. wing