JVM系列之java虚拟机与线程

引言

“少年读书，如隙中窥月；中年读书，如庭中望月；老年读书，如台上玩月。皆以阅历之深浅，为所得之深浅耳”

参考书籍：“深入理解Java虚拟机”

个人java知识分享项目——gitee地址

个人java知识分享项目——github地址

java虚拟机与线程

线程出现的场合一般都会有数据并发安全，而如何保证数据并发安全又是java程序员必备的一项技能，今天这篇文章我们就从java虚拟机的角度去了解线程的底层原理。let’s go!!

线程的实现

我们知道，线程是比进程更轻量级的调度执行单位，线程的引入，可以把一个进程的资源分配和执行调度分开，各个线程既可以共享进程资源(内存地址、文件I/O等)，又可以独立调度(线程是CPU调度的基本单位)。

主流的操作系统都提供了线程实现，Java语言则提供了在不同硬件和操作系统平台下对线程操作的统一处理，每个已经执行start()且还未结束的java.lang.Thread类的实例就代表了一个线程。
我们注意到Thread类与大部分的Java API有显著的差别，它的所有关键方法都是声明为Native的。在Java API中，一个Native方法往往意味着这个方法没有使用或无法使用平台无关的手段来实现(当然也可能是为了执行效率而使用Native方法，不过，通常最高效率的手段也就是平台相关的手段)

实现线程主要有3种方式:使用内核线程实现、使用用户线程实现和使用用户线程加轻量级进程混合实现

1. 使用内核线程实现

   内核线程(Kernel-Level Thread,KLT)就是直接由操作系统内核(Kernel，下称内核)支持的线程，这种线程由内核来完成线程切换，内核通过操纵调度器(Scheduler)对线程进行调度，并负责将线程的任务映射到各个处理器上。每个内核线程可以视为内核的一个分身, 这样操作系统就有能力同时处理多件事情，支持多线程的内核就叫做多线程内核(Multi- Threads Kernel)

   程序一般不会直接去使用内核线程，而是去使用内核线程的一种高级接口——轻量级进程(Light Weight Process,LWP)，轻量级进程就是我们通常意义上所讲的线程，由于每个轻量级进程都由一个内核线程支持，因此只有先支持内核线程，才能有轻量级进程。这种轻量级进程与内核线程之间1:1的关系称为一对一的线程模型

   

   由于内核线程的支持，每个轻量级进程都成为一个独立的调度单元，即使有一个轻量级进程在系统调用中阻塞了，也不会影响整个进程继续工作，但是轻量级进程具有它的局限性:首先，由于是基于内核线程实现的，所以各种线程操作，如创建、析构及同步，都需要进行系统调用。而系统调用的代价相对较高，需要在用户态(User Mode)和内核态(Kernel Mode)中来回切换。其次，每个轻量级进程都需要有一个内核线程的支持，因此轻量级进程要消耗一定的内核资源(如内核线程的栈空间)，因此一个系统支持轻量级进程的数量是有限的

2. 使用用户线程实现

   从广义上来讲，一个线程只要不是内核线程，就可以认为是用户线程(User Thread,UT)，因此，从这个定义上来讲，轻量级进程也属于用户线程，但轻量级进程的实 现始终是建立在内核之上的，许多操作都要进行系统调用，效率会受到限制

   而狭义上的用户线程指的是完全建立在用户空间的线程库上，系统内核不能感知线程存在的实现。用户线程的建立、同步、销毁和调度完全在用户态中完成，不需要内核的帮助。 如果程序实现得当，这种线程不需要切换到内核态，因此操作可以是非常快速且低消耗的， 也可以支持规模更大的线程数量，部分高性能数据库中的多线程就是由用户线程实现的。这种进程与用户线程之间1:N的关系称为一对多的线程模型

   

   使用用户线程的优势在于不需要系统内核支援，劣势也在于没有系统内核的支援，所有的线程操作都需要用户程序自己处理。线程的创建、切换和调度都是需要考虑的问题，而且由于操作系统只把处理器资源分配到进程，那诸如“阻塞如何处理”、“多处理器系统中如何 将线程映射到其他处理器上”这类问题解决起来将会异常困难，甚至不可能完成。因而使用用户线程实现的程序一般都比较复杂(此处所讲的“复杂”与“程序自己完成线程操作”，并不限制程序中必须编写了复杂的实现用户线程的代码，使用用户线程的程序，很多都依赖特定的线程库来完成基本的线程操作，这些复杂性都封装在线程库之中)，除了以前在不支持多线程的操作系统中(如DOS) 的多线程程序与少数有特殊需求的程序外，现在使用用户线程的程序越来越少了，Java、 Ruby等语言都曾经使用过用户线程，最终又都放弃使用它

3. 使用用户线程加轻量级进程混合实现

   线程除了依赖内核线程实现和完全由用户程序自己实现之外，还有一种将内核线程与用户线程一起使用的实现方式。在这种混合实现下，既存在用户线程，也存在轻量级进程。用户线程还是完全建立在用户空间中，因此用户线程的创建、切换、析构等操作依然廉价，并且可以支持大规模的用户线程并发。而操作系统提供支持的轻量级进程则作为用户线程和内核线程之间的桥梁，这样可以使用内核提供的线程调度功能及处理器映射，并且用户线程的系统调用要通过轻量级线程来完成，大大降低了整个进程被完全阻塞的风险。在这种混合模式中，用户线程与轻量级进程的数量比是不定的，即为N:M的关系

   

对于Sun JDK来说，它的Windows版与Linux版都是使用一对一的线程模型实现的，一条 Java线程就映射到一条轻量级进程之中，因为Windows和Linux系统提供的线程模型就是一对一的。

线程的调度

线程调度是指系统为线程分配处理器使用权的过程，主要调度方式有两种，分别是协同式线程调度(Cooperative Threads-Scheduling)和抢占式线程调度(Preemptive Threads- Scheduling)

如果使用协同式调度的多线程系统，线程的执行时间由线程本身来控制，线程把自己的工作执行完了之后，要主动通知系统切换到另外一个线程上。协同式多线程的最大好处是实现简单，而且由于线程要把自己的事情干完后才会进行线程切换，切换操作对线程自己是可知的，所以没有什么线程同步的问题。Lua语言中的“协同例程”就是这类实现。它的坏处也很明显:线程执行时间不可控制，甚至如果一个线程编写有问题，一直不告知系统进行线程切换，那么程序就会一直阻塞在那里。很久以前的Windows 3.x系统就是使用协同式来实现多进程多任务的，相当不稳定，一个进程坚持不让出CPU执行时间就可能会导致整个系统崩溃

如果使用抢占式调度的多线程系统，那么每个线程将由系统来分配执行时间，线程的切换不由线程本身来决定(在Java中，Thread.yield()可以让出执行时间，但是要获取执行时间的话，线程本身是没有什么办法的)。在这种实现线程调度的方式下，线程的执行时间是系统可控的，也不会有一个线程导致整个进程阻塞的问题，Java使用的线程调度方式就是抢占式调度[。与前面所说的Windows 3.x的例子相对，在Windows 9x/NT内核中就是使用抢占 式来实现多进程的，当一个进程出了问题，我们还可以使用任务管理器把这个进程“杀掉”， 而不至于导致系统崩溃。

虽然Java线程调度是系统自动完成的，但是我们还是可以“建议”系统给某些线程多分配 一点执行时间，另外的一些线程则可以少分配一点——这项操作可以通过设置线程优先级来完成。Java语言一共设置了10个级别的线程优先级(Thread.MIN_PRIORITY至 Thread.MAX_PRIORITY)，在两个线程同时处于Ready状态时，优先级越高的线程越容易被系统选择执行

不过，线程优先级并不是太靠谱，原因是Java的线程是通过映射到系统的原生线程上来实现的，所以线程调度最终还是取决于操作系统，虽然现在很多操作系统都提供线程优先级的概念，但是并不见得能与Java线程的优先级一一对应，如Solaris中有2147483648(232)种 优先级，但Windows中就只有7种，比Java线程优先级多的系统还好说，中间留下一点空位就可以了，但比Java线程优先级少的系统，就不得不出现几个优先级相同的情况了，表12-1显 示了Java线程优先级与Windows线程优先级之间的对应关系，Windows平台的JDK中使用了除 THREAD_PRIORITY_IDLE之外的其余6种线程优先级

上面说到“线程优先级并不是太靠谱”，不仅仅是说在一些平台上不同的优先级实际会变得相同这一点，还有其他情况让我们不能太依赖优先级:优先级可能会被系统自行改变。例 如，在Windows系统中存在一个称为“优先级推进器”(Priority Boosting，当然它可以被关闭 掉)的功能，它的大致作用就是当系统发现一个线程执行得特别“勤奋努力”的话，可能会越过线程优先级去为它分配执行时间。因此，我们不能在程序中通过优先级来完全准确地判断 一组状态都为Ready的线程将会先执行哪一个

线程的状态

Java语言定义了5种线程状态，在任意一个时间点，一个线程只能有且只有其中的一种状态，这5种状态分别如下：

• 新建(New):创建后尚未启动的线程处于这种状态
• 运行(Runable):Runable包括了操作系统线程状态中的Running和Ready，也就是处于此 状态的线程有可能正在执行，也有可能正在等待着CPU为它分配执行时间
• 无限期等待(Waiting):处于这种状态的线程不会被分配CPU执行时间，它们要等待被 其他线程显式地唤醒。以下方法会让线程陷入无限期的等待状态：
• 限期等待(Timed Waiting):处于这种状态的线程也不会被分配CPU执行时间，不过无 须等待被其他线程显式地唤醒，在一定时间之后它们会由系统自动唤醒。以下方法会让线程进入限期等待状态：
  • 没有设置Timeout参数的Object.wait()方法。
  • 没有设置Timeout参数的Thread.join()方法
  • LockSupport.park()方法
• 阻塞(Blocked):线程被阻塞了，“阻塞状态”与“等待状态”的区别是:“阻塞状态”在等 待着获取到一个排他锁，这个事件将在另外一个线程放弃这个锁的时候发生;而“等待状 态”则是在等待一段时间，或者唤醒动作的发生。在程序等待进入同步区域的时候，线程将 进入这种状态
  • Thread.sleep()方法
  • 设置了Timeout参数的Object.wait()方法
  • 设置了Timeout参数的Thread.join()方法
  • LockSupport.parkNanos()方法
  • LockSupport.parkUntil()方法
• 结束(Terminated):已终止线程的线程状态，线程已经结束执行

上述5种状态在遇到特定事件发生的时候将会互相转换，它们的转换关系如图所示：

线程安全

线程安全：“当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交 替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象 的行为都可以获得正确的结果，那这个对象是线程安全的”

按照线程安全的“安全程度”由强至弱来排序，可以将Java语言中各种操作共享的数据分为以下5类:
不可变、绝对线程安全、相对线程安全、线程兼容和线程对立

1.不可变

在Java语言中(特指JDK 1.5以后，即Java内存模型被修正之后的Java语言)，不可变 (Immutable)的对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再采取任何的线程安全保障措施，之前的文章中有提到，只要一个不可变的对象被正确地构建出来(没有发生this引用逃逸的情况)，那其外部的可见状态永远也不会改变，永远也不会看到它在多个线程之中处于不一致的状态。 “不可变”带来的安全性是最简单和最纯粹的，如：java.lang.String类的对象，它是一个典型的不可变对象，我们调用它的substring()、replace()和concat()这些 方法都不会影响它原来的值，只会返回一个新构造的字符串对象。

2. 绝对线程安全

满足“当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交 替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象是线程安全的”这句话的线程的即使绝对线程安全的，但是这个定义其实是很严格的，一个类要达到“不管运行时环境如何，调用者都不需要任何额外的同步措施”通常需要付出很大的，甚至有时候是不切实际的代价。

在Java API中标注自己是线程安全的类，大多数都不是绝对的线程安全。我们可以通过Java API中一个不是“绝对线程安全”的线程安全类来看看这里的“绝对”是什么意思。

import java.util.Vector;

public class VectorTest {
    private static Vector<Integer> vector = new Vector();

    public static void main(String[] args) {
        while (true) {
            for (int i = 0; i < 10; i++) {
                vector.add(i);
            }
            Thread removedThread = new Thread(() -> {
                for (int i = 0; i < vector.size(); i++) {
                    vector.remove(i);
                }
            });

            Thread printThread = new Thread(() -> {
                for (int i = 0; i < vector.size(); i++) {
                    System.out.println((vector.get(i)));
                }
            });
            removedThread.start();
            printThread.start();
            while (Thread.activeCount() > 30) ;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

大家可以去运行一下这个案例，在终端会打印ArrayIndexOutOfBoundsExce的异常信息，但是不会停止程序。

出现这种情况是因为，尽管这里使用到的Vector的get()、remove()和size()方法都是同步的， 但是在多线程的环境中，如果不在方法调用端做额外的同步措施的话，使用这段代码仍然是不安全的，因为如果另一个线程恰好在错误的时间里删除了一个元素，导致序号i已经不再可用的话，再用i访问数组就会抛出一个ArrayIndexOutOfBoundsException。如果要保证这段代 码能正确执行下去，我们不得不把removeThread和printThread的定义改成如下面代码所示：

import java.util.Vector;

public class VectorTest {
    private static Vector<Integer> vector = new Vector();

    public static void main(String[] args) {
        while (true) {
            for (int i = 0; i < 10; i++) {
                vector.add(i);
            }
            Thread removedThread = new Thread(() -> {
                synchronized (vector) {
                    for (int i = 0; i < vector.size(); i++) {
                        vector.remove(i);
                    }
                }
            });

            Thread printThread = new Thread(() -> {
                synchronized (vector) {
                    for (int i = 0; i < vector.size(); i++) {
                        System.out.println((vector.get(i)));
                    }
                }
            });
            removedThread.start();
            printThread.start();
            while (Thread.activeCount() > 30) ;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

3.相对线程安全

相对的线程安全就是我们通常意义上所讲的线程安全，它需要保证对这个对象单独的操作是线程安全的，我们在调用的时候不需要做额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性.

在Java语言中，大部分的线程安全类都属于这种类型，例如Vector、HashTable、 Collections的synchronizedCollection()方法包装的集合等。

4.线程兼容

线程兼容是指对象本身并不是线程安全的，但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用，我们平常说一个类不是线程安全的，绝大多数时候指的是这一种情况。Java API中大部分的类都是属于线程兼容的，如与前面的Vector和 HashTable相对应的集合类ArrayList和HashMap等。

5.线程对立

线程对立是指无论调用端是否采取了同步措施，都无法在多线程环境中并发使用的代码。由于Java语言天生就具备多线程特性，线程对立这种排斥多线程的代码是很少出现的， 而且通常都是有害的，应当尽量避免。

一个线程对立的例子是Thread类的suspend()和resume()方法，如果有两个线程同时 持有一个线程对象，一个尝试去中断线程，另一个尝试去恢复线程，如果并发进行的话，无 论调用时是否进行了同步，目标线程都是存在死锁风险的，如果suspend()中断的线程就是 即将要执行resume()的那个线程，那就肯定要产生死锁了。也正是由于这个原因，suspend()和resume()方法已经被JDK声明废弃(@Deprecated)了。常见的线程对立 的操作还有System.setIn()、Sytem.setOut()和System.runFinalizersOnExit()等

线程安全的实现方法

互斥同步

互斥同步(Mutual Exclusion&Synchronization)是常见的一种并发正确性保障手段。同步是指在多个线程并发访问共享数据时，保证共享数据在同一个时刻只被一个(或者是一些， 使用信号量的时候)线程使用。而互斥是实现同步的一种手段，临界区(Critical Section)、互斥量(Mutex)和信号量(Semaphore)都是主要的互斥实现方式。因此，在这 4个字里面，互斥是因，同步是果;互斥是方法，同步是目的

在Java中，最基本的互斥同步手段就是synchronized关键字，synchronized关键字经过编译之后，会在同步块的前后分别形成monitorenter和monitorexit这两个字节码指令，这两个字节码都需要一个reference类型的参数来指明要锁定和解锁的对象。如果Java程序中的 synchronized明确指定了对象参数，那就是这个对象的reference;如果没有明确指定，那就根据synchronized修饰的是实例方法还是类方法，去取对应的对象实例或Class对象来作为锁对象

根据虚拟机规范的要求，在执行monitorenter指令时，首先要尝试获取对象的锁。如果这 个对象没被锁定，或者当前线程已经拥有了那个对象的锁，把锁的计数器加1，相应的，在 执行monitorexit指令时会将锁计数器减1，当计数器为0时，锁就被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到对象锁被另外一个线程释放为止。

在虚拟机规范对monitorenter和monitorexit的行为描述中，有两点是需要特别注意的。首 先，synchronized同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题。其 次，同步块在已进入的线程执行完之前，会阻塞后面其他线程的进入

除了synchronized之外，我们还可以使用java.util.concurrent(下文称J.U.C)包中的重入锁 (ReentrantLock)来实现同步，在基本用法上，ReentrantLock与synchronized很相似，他们都 具备一样的线程重入特性，只是代码写法上有点区别，一个表现为API层面的互斥锁 (lock()和unlock()方法配合try/finally语句块来完成)，另一个表现为原生语法层面的互斥锁。不过，相比synchronized,ReentrantLock增加了一些高级功能，主要有以下3项:等待可中断、可实现公平锁，以及锁可以绑定多个条件

1. 等待可中断是指当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情，可中断特性对处理执行时间非常长的同步块很有帮助
2. 公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁;而 非公平锁则不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁。 synchronized中的锁是非公平的，ReentrantLock默认情况下也是非公平的，但可以通过带布尔 值的构造函数要求使用公平锁
3. 锁绑定多个条件是指一个ReentrantLock对象可以同时绑定多个Condition对象，而在 synchronized中，锁对象的wait()和notify()或notifyAll()方法可以实现一个隐含的条 件，如果要和多于一个的条件关联的时候，就不得不额外地添加一个锁，而ReentrantLock则 无须这样做，只需要多次调用newCondition()方法即可

使用synchronized和ReentrantLock都能实现互斥同步，如果你的jdk版本是1.6之前的版本则推荐使用ReentrantLock，如果是1.6或之后的版本则推荐使用synchronized。至于为什么要这么选是因为在jdk1.6之前的synchronized在多线程环境下的吞吐量表现比ReentrantLock要差，但在jdk1.6就针对锁的进行了一系列的优化措施（这是后面的文章需要去讲解的内容）两者的性能基本是一致的，性能因素就不再是选择ReentrantLock的理由了，虚拟机在未来的性能改进中肯定也会更加偏向于原生的synchronized，所以还是提倡在synchronized能实现需求 的情况下，优先考虑使用synchronized来进行同步。

非阻塞同步

互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也称为阻塞同步(Blocking Synchronization)。从处理问题的方式上说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确的同步措施(例如加锁)，那就肯定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁(这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁)、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。随着硬件指令集的发展，我们有了另外一个选择:基于冲突检测的乐观并发策略，通俗地说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了;如果共享数据有争用，产生了冲突，那就再采取其他的补偿措施(最常见的补偿措施 就是不断地重试，直到成功为止)，这种乐观的并发策略的许多实现都不需要把线程挂起， 因此这种同步操作称为非阻塞同步(Non-Blocking Synchronization)。

为什么说使用乐观并发策略需要“硬件指令集的发展”才能进行呢?因为我们需要操作和冲突检测这两个步骤具备原子性，靠什么来保证呢?如果这里再使用互斥同步来保证就失去意义了，所以我们只能靠硬件来完成这件事情，硬件保证一个从语义上看起来需要多次操作的行为只通过一条处理器指令就能完成，这类指令常用的有：

1. 测试并设置(Test-and-Set)
2. 获取并增加(Fetch-and-Increment)
3. 交换(Swap)
4. 比较并交换(Compare-and-Swap，下文称CAS) — 高频面试点
5. 加载链接/条件存储(Load-Linked/Store-Conditional，下文称LL/SC)

其中，前面的3条是20世纪就已经存在于大多数指令集之中的处理器指令，后面的两条 是现代处理器新增的，而且这两条指令的目的和功能是类似的。在IA64、x86指令集中有cmpxchg指令完成CAS功能，在sparc-TSO也有casa指令实现，而在ARM和PowerPC架构下， 则需要使用一对ldrex/strex指令来完成LL/SC的功能。

CAS指令需要有3个操作数，分别是内存位置(在Java中可以简单理解为变量的内存地 址，用V表示)、旧的预期值(用A表示)和新值(用B表示)。CAS指令执行时，当且仅当 V符合旧预期值A时，处理器用新值B更新V的值，否则它就不执行更新，但是无论是否更新 了V的值，都会返回V的旧值，上述的处理过程是一个原子操作

在JDK 1.5之后，Java程序中才可以使用CAS操作，该操作由sun.misc.Unsafe类里面的 compareAndSwapInt()和compareAndSwapLong()等几个方法包装提供，虚拟机在内部对这些方法做了特殊处理，即时编译出来的结果就是一条平台相关的处理器CAS指令，没有方法调用的过程，或者可以认为是无条件内联进去了

由于Unsafe类不是提供给用户程序调用的类(Unsafe.getUnsafe()的代码中限制了只有 启动类加载器(Bootstrap ClassLoader)加载的Class才能访问它)，因此，如果不采用反射手段，我们只能通过其他的Java API来间接使用它，如J.U.C包里面的整数原子类，其中的 compareAndSet()和getAndIncrement()等方法都使用了Unsafe类的CAS操作。

通过AtomicInteger#incrementAndGet去加深一下印象：

尽管CAS看起来很美，但显然这种操作无法涵盖互斥同步的所有使用场景，并且CAS从 语义上来说并不是完美的，存在这样的一个逻辑漏洞:如果一个变量V初次读取的时候是A 值，并且在准备赋值的时候检查到它仍然为A值，那我们就能说它的值没有被其他线程改变 过了吗?如果在这段期间它的值曾经被改成了B，后来又被改回为A，那CAS操作就会误认 为它从来没有被改变过。这个漏洞称为CAS操作的“ABA”问题。J.U.C包为了解决这个问题， 提供了一个带有标记的原子引用类“AtomicStampedReference”，它可以通过控制变量值的版本 来保证CAS的正确性。不过目前来说这个类比较“鸡肋”，大部分情况下ABA问题不会影响程 序并发的正确性，如果需要解决ABA问题，改用传统的互斥同步可能会比原子类更高效

无同步方案

要保证线程安全，并不是一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性，因此会有一些代码天生就是线程安全的，简单地介绍其中的两类：

1. 可重入代码(Reentrant Code):这种代码也叫做纯代码(Pure Code)，可以在代码执 行的任何时刻中断它，转而去执行另外一段代码(包括递归调用它本身)，而在控制权返回后，原来的程序不会出现任何错误。相对线程安全来说，可重入性是更基本的特性，它可以保证线程安全，即所有的可重入的代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。我们可以通过一个简单的原则来判断代码是否具备可重入性:如果一个方法，它的返回结果是可以预测的，只要输入了相同的数据，就都能返回相同的结果，那它就满足可重入性的要求，当然也就是线程安全的
2. 线程本地存储(Thread Local Storage):如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行?如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题（经典例子就是ThreadLocal在保证web服务器的线程安全）

本来想着用自己的语言去讲解这块的知识点，但是在尝试了几次后，发现没办法讲的简洁明了，因此这篇文章大篇幅的内容都是摘抄自“深入理解java虚拟机”一书中，其中我个人觉得有些琐碎无关紧要的内容我进行了删除，一些重要的地方做了标记，希望各位能在这篇文章有所获。