Complex distributed object-oriented systems often need complex concurrency features, which may go beyond the traditional concurrency control associated with separate method calls. A transaction groups together a sequence of operations, and can therefore encapsulate complex behavior and method calls. Transactions are able to hide the effects of concurrency and at the same time prevent the propagation of errors, making them appropriate building blocks for structuring reliable distributed systems. The open multithreaded transaction model, introduced by Prof. J. Kienzle, in his PhD thesis, 2001, provides features for controlling and structuring not only accesses to objects, as usual in transaction systems, but also threads taking part in transactions. The model allows several threads to enter the same transaction in order to perform a joint activity. It provides a flexible way of manipulating threads executing inside a transaction by allowing them to be forked and terminated, but it restricts their behavior in order to guarantee correctness of transaction nesting and isolation among transactions. The model also incorporates disciplined exception handling adapted to nested transactions. When ending an open multithreaded transaction, synchronization on exit is needed to assure consistence and isolation of transactions. This limitation is described and a possible improvement is exposed, introducing look-ahead threads. Look-ahead threads are threads that speculate on the outcome of a transaction, leaving it to execute operations in advance. This thesis proposes different models that allow looking-ahead in open multithreaded transactions, covering every concern, from typical read/write concurrency control problems to exception handling. Some models can even be used complementary, depending on the system context. Every model proposed is discussed in terms of implement complexity, execution speed, and exception handling granularity.