Architecturally, i.e., with respect to what software sees, modern processors use the serial von Neumann model. However, most high-performance processors use out-of-order execution, which allows operations to be executed in a non-serial manner but their effects are committed in program order.
(Some earlier, in-order processors had imprecise exceptions caused by operations beginning execution in-order but the results being committed as they became available. This means that a shorter latency operation, such as an integer addition, coming after a longer latency operation, such as a floating point multiplication, can write its result to a register before the longer latency operation completes. If an interrupt or exception occurred before the longer latency operation completed, the program state would be inconsistent.)
A dataflow architecture does not execute programs serially, but scaling the dependency handling hardware is problematic (even modern high-performance out-of-order processors have execution windows from which candidate operations are scheduled of less than 100 operations) and ensuring correctness (particularly for software, where formal methods are less common) is also difficult. To get a feel for the design, each operation is treated like a separate thread that can begin execution as soon as its source operands are available and can commit its result as soon as the operation completes (allowing operations waiting for only that result to begin execution). At the machine language level, this could be viewed as the ultimate multithreaded spaghetti code.
Processors that use out-of-order execution are like dataflow architectures in operation but with limited execution windows and guaranteed in-order visibility of results within the same thread of execution. (Weaker memory consistency models will allow results to become visible to other processors in an order that is not strictly sequential.)