是也不是。

线程安全不仅仅是确保共享数据一次只能被一个线程访问。您必须确保对共享数据的顺序访问，同时避免竞争条件、死锁、活动锁和资源短缺。

当多个线程同时运行时，不可预知的结果并不是线程安全代码的必要条件，但这通常是一种副产品。例如，您可以使用一个共享队列、一个生产者线程和几个消费者线程来设置生产者-消费者方案，并且数据流可能完全可预测。如果你开始引入更多的消费者，你会看到更多随机的结果。

正如其他人所指出的，线程安全意味着如果一段代码同时被多个线程使用，那么它将正常工作。

值得注意的是，这有时是有代价的，计算机时间和更复杂的编码，所以它并不总是可取的。如果一个类只能安全地在一个线程上使用，那么这样做可能会更好。

例如，Java有两个几乎相同的类:StringBuffer和StringBuilder。不同之处在于StringBuffer是线程安全的，因此StringBuffer的单个实例可以同时被多个线程使用。StringBuilder不是线程安全的，它被设计为仅由一个线程构建String的情况下(绝大多数情况下)的高性能替代品。

一个更容易理解的方法是，是什么使代码不是线程安全的。有两个主要问题会使线程应用程序产生不需要的行为。

Accessing shared variable without locking This variable could be modified by another thread while executing the function. You want to prevent it with a locking mechanism to be sure of the behavior of your function. General rule of thumb is to keep the lock for the shortest time possible. Deadlock caused by mutual dependency on shared variable If you have two shared variable A and B. In one function, you lock A first then later you lock B. In another function, you start locking B and after a while, you lock A. This is a potential deadlock where first function will wait for B to be unlocked when second function will wait for A to be unlocked. This issue will probably not occur in your development environment and only from time to time. To avoid it, all locks must always be in the same order.

与其认为代码或类是线程安全的，我认为将操作视为线程安全的更有帮助。如果两个操作在从任意线程上下文运行时按照指定的方式运行，那么它们就是线程安全的。在许多情况下，类将以线程安全的方式支持一些操作组合，而其他则不支持。

例如，许多像数组列表和散列集这样的集合可以保证，如果它们最初只由一个线程访问，并且在引用对任何其他线程可见后永远不会被修改，那么它们可以被任何线程组合以任意方式读取而不受干扰。

More interestingly, some hash-set collections such as the original non-generic one in .NET, may offer a guarantee that as long as no item is ever removed, and provided that only one thread ever writes to them, any thread that tries to read the collection will behave as though accessing a collection where updates might be delayed and occur in arbitrary order, but which will otherwise behave normally. If thread #1 adds X and then Y, and thread #2 looks for and sees Y and then X, it would be possible for thread #2 to see that Y exists but X doesn't; whether or not such behavior is "thread-safe" would depend upon whether thread #2 is prepared to deal with that possibility.

As a final note, some classes--especially blocking communications libraries--may have a "close" or "Dispose" method which is thread-safe with respect to all other methods, but no other methods that are thread-safe with respect to each other. If a thread performs a blocking read request and a user of the program clicks "cancel", there would be no way for a close request to be issued by the thread that's attempting to perform the read. The close/dispose request, however, may asynchronously set a flag which will cause the read request to be canceled as soon as possible. Once close is performed on any thread, the object would become useless, and all attempts at future actions would fail immediately, but being able to asynchronously terminate any attempted I/O operations is better than require that the close request be synchronized with the read (since if the read blocks forever, the synchronization request would be likewise blocked).

线程安全代码按照指定的方式工作，即使由不同的线程同时输入。这通常意味着，应该不间断地运行的内部数据结构或操作受到保护，不会同时进行不同的修改。

不要将线程安全性与决定论混淆。线程安全代码也可以是非确定性的。考虑到使用线程代码调试问题的难度，这可能是正常的情况。: -)

线程安全只是确保当一个线程修改或读取共享数据时，没有其他线程可以以改变数据的方式访问它。如果代码依赖于特定的执行顺序来确保正确性，那么除了线程安全所需的同步机制之外，还需要其他同步机制来确保这一点。