jianjun200607的专栏

重入锁死是跟死锁和嵌套的监控程序锁死相似的一个场景。重入锁死也在读写锁中提到过了。重入锁死可能会发生在如果一个线程重入一个锁中，ReadWriteLock或者一些其他的同步器不是可重入的。可重入的意味着已经持有一个锁的线程可以再一次持有它。Java的同步块是可重入的，因此下面的代码将会没有问题的工作：public class Reentrant{ public synchronized ou...

一个锁是一个线程同步机制，像同步块除了锁可以是更复杂的比java的同步块。锁（以及其他的更先进的同步机制）都是使用同步块被创建的。从Java 5开始这个java.util.concurrent.locks包包含了几个锁的实现，以至于翻译地址：http://tutorials.jenkov.com/java-concurrency/locks.html

一个读写锁是一个比在上一篇文章中的Lock实现来说更加复杂的锁。想想下你有一个应用读写一些资源，但是写没有和读一样完成。两个线程读相同的资源不会互相引起问题，以至于想读这个资源的多个线程同时授予访问权限。但是，如果一个线程想写这个资源，那么读和写都必须不能同时在进行中。为了解决这个允许多个读一个写的问题，你需要一个读写锁。Java 5在java.util.concurrent包中提供了读写锁的实现...

滑倒的条件是什么？滑倒的条件意味着，那个来自于特定的时间的一个线程检查一个特定的条件直到这个条件作用于它之上，但是这个条件已经被另外一个线程改变了以至于对于第一个线程是错误的。这里有一个简单的例子：public class Lock { private boolean isLocked = true; public void lock(){ synchron

嵌套的监控程序锁死是怎么样发生的嵌套的监控程序锁死跟死锁的问题类似。一个嵌套的监控程序锁死像下面这样发生：Thread 1 synchronizes on AThread 1 synchronizes on B (while synchronized on A)Thread 1 decides to wait for a signal from another thread befor

如果一个线程没有被授予CPU时间，因为其他的线程全部获取到了，它称之为“饥饿”。这个线程“会饿死的”，因为其他的线程被允许这个CPU时间代替他。饥饿的解决方案就是公平----那就是所有的线程公平的获取一个机会去执行。在Java中的饥饿的原因下面三个公共的原因将会导致在Java中的线程的饥饿：翻译地址：http://tutorials.jenkov.com/java-concur

在一些场景中，去预防死锁是可能的。在这个内容中我将会描述三种技术：

线程死锁一个死锁是当正在等待获取锁的两个或者更多的线程被锁住的时候，在死锁中的其他线程也持有了这个锁。翻译地址：http://tutorials.jenkov.com/java-concurrency/deadlock.html

线程信号的目的是使得线程彼此之间可以互相发送信号。另外，线程信号可以使得线程去等待来自其他线程的信号。例如，一个线程B可能等待来自一个线程A的信号，说明数据准备处理了。经由共享变量的信号对于线程发送信号的一个简单方式就是翻译地址：http://tutorials.jenkov.com/java-concurrency/thread-signaling.html

这个在Java中的ThreadLocal类可以保证使你创建的变量只能被相同的线程读和写。因此，甚至如果两个线程正在执行相同的代码，并且这个代码有一个对于ThreadLocal变量的引用，然后这两个线程就不能看到彼此的ThreadLocal变量。创建一个ThreadLocal这里有一个代码现实如何创建一个ThreadLocal：private ThreadLocal myThreadLo

翻译地址：http://tutorials.jenkov.com/java-concurrency/volatile.html

翻译地址：http://tutorials.jenkov.com/java-concurrency/synchronized.html

这个Java内存模型指定的是Java虚拟机如何跟计算机内存（RAM）一起工作。这个Java虚拟机是整个计算机的模型，以至于这个模型自然的包括的一个内存模型----也叫作Java内存模型。理解Java内存模型是很重要的，如果你想正确的设计并发程序。这个Java内存模型指的是如何以及什么时间不同的线程可以看到被其他线程写入的共享变量的值，以及如何同步的访问共享变量。最初的Java内存模型是不足

竞态条件的发生只是在如果两个线程同时访问相同的资源，以及一个或者更多的线程写这个资源。如果多个线程读这个相同的资源，竞态条件不会发生。我们可以确定，在线程之间共享的对象通过使得这个共享的对象不可变，不会被任何的线程更新，从而是线程安全的。这里有一个例子：public class ImmutableValue{ private int value = 0; public Immu

代码被多线程同时的调用是安全的称之为线程安全。如果一段代码是线程安全的，那么它就不包含竞态条件。竞态条件只是发生在多线程更新共享资源的时候。因此知道Java线程什么时间执行共享的资源是重要的。局部变量局部变量存储在每一个线程自己的栈中。那就意味着局部变量在线程之间不会共享。那也意味着所有的局部原始变量是线程安全的。这里有一个例子：public void someMethod(){

一个竞态条件是一个特殊的条件，可能发生在一个临界部分的内部（critical section）。一个临界部分是一段正在被多线程执行的代码，翻译地址：http://tutorials.jenkov.com/java-concurrency/race-conditions-and-critical-sections.html

Java线程是一个类似其他任何对象的一个对象类型。线程是java.lang.Thread类的实例，或者这个类的子类的实例。除了作为对象类型之外，java线程也可以执行代码。创建和启动一个线程创建一个线程可以像下面这样：Thread thread = new Thread();为了启动Java线程，你需要调用start方法，像下面这样：thread.start();这个例子没

翻译地址：http://tutorials.jenkov.com/java-concurrency/concurrency-vs-parallelism.html

相同线程是一个并发模型，这种并发模型的含义是一个单线程的系统向外扩展成为N个单线程的系统。这个结果就是N个单线程的系统并行运行。一个相同线程的系统不是一个纯粹的单线程系统，因为它包含了多个线程。但是这些线程中的每一个就像是一个单线程系统运行一样。为什么是单线程的系统今天你可能想知道为什么每一个都被设计成单线程系统呢。单线程系统已经得到普及，因为他们的并发模型比多线程更加简单。单线程系统

并发系统可以使用不同的并发模型去实现。一个并发模型指定着线程在系统协作中是如何完成被给与的任务。翻译地址：http://tutorials.jenkov.com/java-concurrency/concurrency-models.html

从单线程转换成多线程不只是提供了益处。它也有一些代价。不要在应用中因为你可以用就去使用多线程。你应该有一个好的想法通过这样做能得到什么好处，好处要比代价大。当处在怀疑中的时候，尝试着测试衡量应用的性能或者响应速度，代替只是猜测。更加复杂的设计虽然多线程的一些部分比单线程的简单，但是其他的部分更加复杂。通过多线程执行的代码访问共享的数据需要特殊的注意。线程交互总是原理简单。来自于不正确的线程

不管多线程的挑战仍然被使用的原因，是因为多线程仍然有几个益处，这些益处中的一些是：更好的资源利用在一些场景下简单的程序设计更快响应的程序更好的资源利用想象一个应用读取和处理来自于本地文件系统的文件。让我们说从磁盘中读取一个文件花费5秒钟，处理它花费2秒钟，执行两个文件将会花费： 5 seconds reading file A 2 seconds processing

想当年一台计算机只有一个CPU，并且一次只能处理一个程序的能力。后来多任务处理出现了，这就意味着计算机可以同时处理多个程序了。虽然它不是真正的“同时”。单独的CPU在程序之间被共享。操作系统将会在运行中的程序进行切换，在切换之前执行一会他们中的一个。伴随着多任务处理的到来，对于软件开发者来说是一个新的挑战。程序不能去假设所有的CPU一直都是可用的了，或者所有的内存以及其他的计算机资源。一个好的