javaaqs

② 并发编程解惑之线程

主要内容：

进程是资源分配的最小单位，每个进程都有独立的代码和数据空间，一个进程包含 1 到 n 个线程。线程是 CPU 调度的最小单位，每个线程有独立的运行栈和程序计数器，线程切换开销小。

Java 程序总是从主类的 main 方法开始执行，main 方法就是 Java 程序默认的主线程，而在 main 方法中再创建的线程就是其他线程。在 Java 中，每次程序启动至少启动 2 个线程。一个是 main 线程，一个是垃圾收集线程。每次使用 Java 命令启动一个 Java 程序，就相当于启动一个 JVM 实例，而每个 JVM 实例就是在操作系统中启动的一个进程。

多线程可以通过继承或实现接口的方式创建。

Thread 类是 JDK 中定义的用于控制线程对象的类，该类中封装了线程执行体 run() 方法。需要强调的一点是，线程执行先后与创建顺序无关。

通过 Runnable 方式创建线程相比通过继承 Thread 类创建线程的优势是避免了单继承的局限性。若一个 boy 类继承了 person 类，boy 类就无法通过继承 Thread 类的方式来实现多线程。

使用 Runnable 接口创建线程的过程：先是创建对象实例 MyRunnable，然后将对象 My Runnable 作为 Thread 构造方法的入参，来构造出线程。对于 new Thread(Runnable target) 创建的使用同一入参目标对象的线程，可以共享该入参目标对象 MyRunnable 的成员变量和方法，但 run() 方法中的局部变量相互独立，互不干扰。

上面代码是 new 了三个不同的 My Runnable 对象，如果只想使用同一个对象，可以只 new 一个 MyRunnable 对象给三个 new Thread 使用。

实现 Runnable 接口比继承 Thread 类所具有的优势：

线程有新建、可运行、阻塞、等待、定时等待、死亡 6 种状态。一个具有生命的线程，总是处于这 6 种状态之一。 每个线程可以独立于其他线程运行，也可和其他线程协同运行。线程被创建后，调用 start() 方法启动线程，该线程便从新建态进入就绪状态。

NEW 状态（新建状态） 实例化一个线程之后，并且这个线程没有开始执行，这个时候的状态就是 NEW 状态：

RUNNABLE 状态（就绪状敬春则态）：

阻塞状态有 3 种：

如果一个线程调用了一个对象的 wait 方法， 那么这个线程就会处于等待状态（waiting 状态）直到另外一个线程调用这个对象的 notify 或者 notifyAll 方法后才会解除这个状态。

run() 里的代码执行完毕后，线程进入终结状态（TERMINATED 状态）。

线程状态有 6 种：新建、可运行、阻塞、等待、定时等待、死亡。

我们看下 join 方法的使用：

运行结果：

我们来看下 yield 方法的使用：

运行结果：

线程与线程之间是无法直接通信的，A 线程无法直接通知 B 线程，Java 中线程之间交换信息是通过共享的内存来实现的，控制共享资源的读写的访问，使得多个线程轮流执行对共享数据的操作，线程之间通信是通过对共享资源上锁或释放锁来实现的。线程排队轮流执行共享资源，这称为线程的同步。

Java 提供了很多同森历步操作（也就是线程间的通信方式），同步可使用 synchronized 关键字、Object 类的 wait/notifyAll 方法、ReentrantLock 锁、无锁同步 CAS 等方式来实现。

ReentrantLock 是 JDK 内置的一个锁对象，用于线程同步（线程通信），需要用户手动释放锁。

运行结果：

这表明同一时间段只能有 1 个线程执行 work 方法，因为 work 方法里的代码需要获取到锁才能执行，这就实现了多个线程间的通信，线程 0 获取锁，先执行，线程 1 等待，线程 0 释放锁，线程 1 继续执行。

synchronized 是一亮棚种语法级别的同步方式，称为内置锁。该锁会在代码执行完毕后由 JVM 释放。

输出结果跟 ReentrantLock 一样。

Java 中的 Object 类默认是所有类的父类，该类拥有 wait、 notify、notifyAll 方法，其他对象会自动继承 Object 类，可调用 Object 类的这些方法实现线程间的通信。

除了可以通过锁的方式来实现通信，还可通过无锁的方式来实现，无锁同 CAS（Compare-and-Swap，比较和交换）的实现，需要有 3 个操作数：内存地址 V，旧的预期值 A，即将要更新的目标值 B，当且仅当内存地址 V 的值与预期值 A 相等时，将内存地址 V 的值修改为目标值 B，否则就什么都不做。

我们通过计算器的案例来演示无锁同步 CAS 的实现方式，非线程安全的计数方式如下：

线程安全的计数方式如下：

运行结果：

线程安全累加的结果才是正确的，非线程安全会出现少计算值的情况。JDK 1.5 开始，并发包里提供了原子操作的类，AtomicBoolean 用原子方式更新的 boolean 值，AtomicInteger 用原子方式更新 int 值，AtomicLong 用原子方式更新 long 值。 AtomicInteger 和 AtomicLong 还提供了用原子方式将当前值自增 1 或自减 1 的方法，在多线程程序中，诸如 ++i 或 i++ 等运算不具有原子性，是不安全的线程操作之一。 通常我们使用 synchronized 将该操作变成一个原子操作，但 JVM 为此种操作提供了原子操作的同步类 Atomic，使用 AtomicInteger 做自增运算的性能是 ReentantLock 的好几倍。

上面我们都是使用底层的方式实现线程间的通信的，但在实际的开发中，我们应该尽量远离底层结构，使用封装好的 API，例如 J.U.C 包（java.util.concurrent，又称并发包）下的工具类 CountDownLath、CyclicBarrier、Semaphore，来实现线程通信，协调线程执行。

CountDownLatch 能够实现线程之间的等待，CountDownLatch 用于某一个线程等待若干个其他线程执行完任务之后，它才开始执行。

CountDownLatch 类只提供了一个构造器：

CountDownLatch 类中常用的 3 个方法：

运行结果：

CyclicBarrier 字面意思循环栅栏，通过它可以让一组线程等待至某个状态之后再全部同时执行。当所有等待线程都被释放以后，CyclicBarrier 可以被重复使用，所以有循环之意。

相比 CountDownLatch，CyclicBarrier 可以被循环使用，而且如果遇到线程中断等情况时，可以利用 reset() 方法，重置计数器，CyclicBarrier 会比 CountDownLatch 更加灵活。

CyclicBarrier 提供 2 个构造器：

上面的方法中，参数 parties 指让多少个线程或者任务等待至 barrier 状态；参数 barrierAction 为当这些线程都达到 barrier 状态时会执行的内容。

CyclicBarrier 中最重要的方法 await 方法，它有 2 个重载版本。下面方法用来挂起当前线程，直至所有线程都到达 barrier 状态再同时执行后续任务。

而下面的方法则是让这些线程等待至一定的时间，如果还有线程没有到达 barrier 状态就直接让到达 barrier 的线程执行任务。

运行结果：

CyclicBarrier 用于一组线程互相等待至某个状态，然后这一组线程再同时执行，CountDownLatch 是不能重用的，而 CyclicBarrier 可以重用。

Semaphore 类是一个计数信号量，它可以设定一个阈值，多个线程竞争获取许可信号，执行完任务后归还，超过阈值后，线程申请许可信号时将会被阻塞。Semaphore 可以用来 构建对象池，资源池，比如数据库连接池。

假如在服务器上运行着若干个客户端请求的线程。这些线程需要连接到同一数据库，但任一时刻只能获得一定数目的数据库连接。要怎样才能够有效地将这些固定数目的数据库连接分配给大量的线程呢？

给方法加同步锁，保证同一时刻只能有一个线程去调用此方法，其他所有线程排队等待，但若有 10 个数据库连接，也只有一个能被使用，效率太低。另外一种方法，使用信号量，让信号量许可与数据库可用连接数为相同数量，10 个数据库连接都能被使用，大大提高性能。

上面三个工具类是 J.U.C 包的核心类，J.U.C 包的全景图就比较复杂了：

J.U.C 包（java.util.concurrent）中的高层类（Lock、同步器、阻塞队列、Executor、并发容器）依赖基础类（AQS、非阻塞数据结构、原子变量类），而基础类是通过 CAS 和 volatile 来实现的。我们尽量使用顶层的类，避免使用基础类 CAS 和 volatile 来协调线程的执行。J.U.C 包其他的内容，在其他的篇章会有相应的讲解。

Future 是一种异步执行的设计模式，类似 ajax 异步请求，不需要同步等待返回结果，可继续执行代码。使 Runnable（无返回值不支持上报异常）或 Callable（有返回值支持上报异常）均可开启线程执行任务。但是如果需要异步获取线程的返回结果，就需要通过 Future 来实现了。

Future 是位于 java.util.concurrent 包下的一个接口，Future 接口封装了取消任务，获取任务结果的方法。

在 Java 中，一般是通过继承 Thread 类或者实现 Runnable 接口来创建多线程， Runnable 接口不能返回结果，JDK 1.5 之后，Java 提供了 Callable 接口来封装子任务，Callable 接口可以获取返回结果。我们使用线程池提交 Callable 接口任务，将返回 Future 接口添加进 ArrayList 数组，最后遍历 FutureList，实现异步获取返回值。

运行结果：

上面就是异步线程执行的调用过程，实际开发中用得更多的是使用现成的异步框架来实现异步编程，如 RxJava，有兴趣的可以继续去了解，通常异步框架都是结合远程 HTTP 调用 Retrofit 框架来使用的，两者结合起来用，可以避免调用远程接口时，花费过多的时间在等待接口返回上。

线程封闭是通过本地线程 ThreadLocal 来实现的，ThreadLocal 是线程局部变量（local vari able），它为每个线程都提供一个变量值的副本，每个线程对该变量副本的修改相互不影响。

在 JVM 虚拟机中，堆内存用于存储共享的数据（实例对象），也就是主内存。Thread Local .set()、ThreadLocal.get() 方法直接在本地内存（工作内存）中写和读共享变量的副本，而不需要同步数据，不用像 synchronized 那样保证数据可见性，修改主内存数据后还要同步更新到工作内存。

Myabatis、hibernate 是通过 threadlocal 来存储 session 的，每一个线程都维护着一个 session，对线程独享的资源操作很方便，也避免了线程阻塞。

ThreadLocal 类位于 Thread 线程类内部，我们分析下它的源码：

ThreadLocal 和 Synchonized 都用于解决多线程并发访问的问题，访问多线程共享的资源时，Synchronized 同步机制采用了以时间换空间的方式，提供一份变量让多个线程排队访问，而 ThreadLocal 采用了以空间换时间的方式，提供每个线程一个变量，实现数据隔离。

ThreadLocal 可用于数据库连接 Connection 对象的隔离，使得每个请求线程都可以复用连接而又相互不影响。

在 Java 里面，存在强引用、弱引用、软引用、虚引用。我们主要来了解下强引用和弱引用：

上面 a、b 对实例 A、B 都是强引用

而上面这种情况就不一样了，即使 b 被置为 null，但是 c 仍然持有对 C 对象实例的引用，而间接的保持着对 b 的强引用，所以 GC 不会回收分配给 b 的空间，导致 b 无法回收也没有被使用，造成了内存泄漏。这时可以通过 c = null; 来使得 c 被回收，但也可以通过弱引用来达到同样目的：

从源码中可以看出 Entry 里的 key 对 ThreadLocal 实例是弱引用：

Entry 里的 key 对 ThreadLocal 实例是弱引用，将 key 值置为 null，堆中的 ThreadLocal 实例是可以被垃圾收集器（GC）回收的。但是 value 却存在一条从 Current Thread 过来的强引用链，只有当当前线程 Current Thread 销毁时，value 才能被回收。在 threadLocal 被设为 null 以及线程结束之前，Entry 的键值对都不会被回收，出现内存泄漏。为了避免泄漏，在 ThreadLocalMap 中的 set/get Entry 方法里，会对 key 为 null 的情况进行判断，如果为 null 的话，就会对 value 置为 null。也可以通过 ThreadLocal 的 remove 方法（类似加锁和解锁，最后 remove 一下，解锁对象的引用）直接清除，释放内存空间。

总结来说，利用 ThreadLocal 来访问共享数据时，JVM 通过设置 ThreadLocalMap 的 Key 为弱引用，来避免内存泄露，同时通过调用 remove、get、set 方法的时候，回收弱引用（Key 为 null 的 Entry）。当使用 static ThreadLocal 的时候（如上面的 Spring 多数据源），static 变量在类未加载的时候，它就已经加载，当线程结束的时候，static 变量不一定会被回收，比起普通成员变量使用的时候才加载，static 的生命周期变长了，若没有及时回收，容易产生内存泄漏。

使用线程池，可以重用存在的线程，减少对象创建、消亡的开销，可控制最大并发线程数，避免资源竞争过度，还能实现线程定时执行、单线程执行、固定线程数执行等功能。

Java 把线程的调用封装成了一个 Executor 接口，Executor 接口中定义了一个 execute 方法，用来提交线程的执行。Executor 接口的子接口是 ExecutorService，负责管理线程的执行。通过 Executors 类的静态方法可以初始化

ExecutorService 线程池。Executors 类的静态方法可创建不同类型的线程池：

但是，不建议使用 Executors 去创建线程池，而是通过 ThreadPoolExecutor 的方式，明确给出线程池的参数去创建，规避资源耗尽的风险。

如果使用 Executors 去创建线程池：

最佳的实践是通过 ThreadPoolExecutor 手动地去创建线程池，选取合适的队列存储任务，并指定线程池线程大小。通过线程池实现类 ThreadPoolExecutor 可构造出线程池的，构造函数有下面几个重要的参数：

参数 1：corePoolSize

线程池核心线程数。

参数 2：workQueue

阻塞队列，用于保存执行任务的线程，有 4 种阻塞队列可选：

参数 3：maximunPoolSize

线程池最大线程数。如果阻塞队列满了（有界的阻塞队列），来了一个新的任务，若线程池当前线程数小于最大线程数，则创建新的线程执行任务，否则交给饱和策略处理。如果是无界队列就不存在这种情况，任务都在无界队列里存储着。

参数 4：RejectedExecutionHandler

拒绝策略，当队列满了，而且线程达到了最大线程数后，对新任务采取的处理策略。

有 4 种策略可选：

最后，还可以自定义处理策略。

参数 5：ThreadFactory

创建线程的工厂。

参数 6：keeyAliveTime

线程没有任务执行时最多保持多久时间终止。当线程池中的线程数大于 corePoolSize 时，线程池中所有线程中的某一个线程的空闲时间若达到 keepAliveTime，则会终止，直到线程池中的线程数不超过 corePoolSize。但如果调用了 allowCoreThread TimeOut(boolean value) 方法，线程池中的线程数就算不超过 corePoolSize，keepAlive Time 参数也会起作用，直到线程池中的线程数量变为 0。

参数 7：TimeUnit

配合第 6 个参数使用，表示存活时间的时间单位最佳的实践是通过 ThreadPoolExecutor 手动地去创建线程池，选取合适的队列存储任务，并指定线程池线程大小。

运行结果：

线程池创建线程时，会将线程封装成工作线程 Worker，Worker 在执行完任务后，还会不断的去获取队列里的任务来执行。Worker 的加锁解锁机制是继承 AQS 实现的。

我们来看下 Worker 线程的运行过程：

总结来说，如果当前运行的线程数小于 corePoolSize 线程数，则获取全局锁，然后创建新的线程来执行任务如果运行的线程数大于等于 corePoolSize 线程数，则将任务加入阻塞队列 BlockingQueue 如果阻塞队列已满，无法将任务加入 BlockingQueue，则获取全局所，再创建新的线程来执行任务

如果新创建线程后使得线程数超过了 maximumPoolSize 线程数，则调用 Rejected ExecutionHandler.rejectedExecution() 方法根据对应的拒绝策略处理任务。

CPU 密集型任务，线程执行任务占用 CPU 时间会比较长，应该配置相对少的线程数，避免过度争抢资源，可配置 N 个 CPU+1 个线程的线程池；但 IO 密集型任务则由于需要等待 IO 操作，线程经常处于等待状态，应该配置相对多的线程如 2*N 个 CPU 个线程，A 线程阻塞后，B 线程能马上执行，线程多竞争激烈，能饱和的执行任务。线程提交 SQL 后等待数据库返回结果时间较长的情况，CPU 空闲会较多，线程数应设置大些，让更多线程争取 CPU 的调度。

③ Java AQS如何清除垃圾节点

根据清除算法，整理算法，复制算法，分代算法进行清除。
清除算法为标记无用对象，然后进行清除回收，缺点为效率不高，无法清除垃圾碎片。
整理算法是标记无用对象，让所有存活的对象都向一端移动，然后直接清除掉端边界以外的内存。
复制算法是按照容量划分二个慧喊大小相等的内存区域，当一块用完的时候将活着的对象复制到另一块上，然后再把已使用的内存空间一次清理掉。缺点是内存使用率不高，只有原来的一半。
分代算法是根据对象存活周期的不同将内存划分为几块，一般是新生代和前罩野老年代，新生代基本采用复制算法，老年代采用标记整闷弊理算法。

④ 什么是重入锁和AQS

什么是重入锁

java.util.concurrent.locks.ReentrantLock

ReenTrantLock独有的能力：

1.      ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。

2.      ReenTrantLock提供了一个Condition（条件）类，用来实现分组唤醒需要唤醒的线程们，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。

3.      ReenTrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。

非重入锁

当A方法获取锁去锁住一段需要做原子性操作的B方法时，如果这段B方法又需要锁去做原子性操作，那么A方法就必定要与B方法出现死锁。这种会出现问题的重入一把锁的情况，叫不可重入锁。

lock的过程：

   首先尝试获取资源，如果当前状态为0，表示没有线程占有锁，设置该线程为独占模式，使用CAS设置状态，否则如果当前线程和独占线程是一个线程，修改状态值，否则返回false。

  若获取资源失败，则通过addWaiter <-(aqs)方法创建一个节点并放在CLH队列的尾部。head tail未初始化会创建虚拟节点同时指向

为什么 AQS 需要一个虚拟 head 节点

每个节点都需要设置前置Node 的 waitStatus  状态（这个状态为是为了保证数据一致性），防止重复释放操作。而第一个节点是没有前置节点的尘行，所以需要创建一个虚拟节点。

  逐步去执行CLH队列中的线程，当前线程会公平性的阻塞一直到获取锁为止，返回线程在等待的过程中还是否中断过。

unlock的过程

一次unlock操作需要修改状态位，然后唤醒节点。整个释放操作也是使用unpark()来唤醒队列最前面的节点。其实lock中比较重要的也就是lock和release，它们又和AQS联系紧密，下面会单独谈谈AQS的重要方法。

Condition的await和signal

wait和notify/notify VS await和signal

Condition能够支持不响应中断，而通过使用Object方式不支持；

Condition能够支持多个等待队列（new 多个Condition对象），而Object方式只能支持一个；

Condition能够支持超时时间的设置，而Object不支持

对标Object的wait方法

void await() throws InterruptedException:当前线程进入等待状态，如果其他线程调用condition的signal或者signalAll方法并且当前线程获取Lock从await方法返回，如果在等待状态中被中断会抛出被中断异常；

long awaitNanos(long nanosTimeout)：当前线程进入等待状态直到被通知，中断或者超时；

boolean await(long time, TimeUnit unit)throws InterruptedException：同第二种，支持自定义时间单位

boolean awaitUntil(Date deadline) throws InterruptedException：当前线程进入等待状态直到被通知，中断或高兄孝者到了某个时间

对标Object的notify/notifyAll方法

void signal()：唤醒一个等待在condition上的线程，将该线程从等待队列中转移到同步队列中，如果在同步队列中能够竞争到Lock则可以从等待方法中返回。

void signalAll()：戚稿与1的区别在于能够唤醒所有等待在condition上的线程

如图所示，ConditionObject是AQS的内部类，因此每个ConditionObject能够访问到AQS提供的方法，相当于每个Condition都拥有所属同步器的引用。

调用condition.await方法的线程必须是已经获得了lock，也就是当前线程是同步队列中的头结点。调用该方法后会使得当前线程所封装的Node尾插入到等待队列中。

如图，线程awaitThread先通过lock.lock()方法获取锁成功后调用了condition.await方法进入等待队列，而另一个线程signalThread通过lock.lock()方法获取锁成功后调用了condition.signal或者signalAll方法，使得线程awaitThread能够有机会移入到同步队列中，当其他线程释放lock后使得线程awaitThread能够有机会获取lock，从而使得线程awaitThread能够从await方法中退出执行后续操作。如果awaitThread获取lock失败会直接进入到同步队列。

// 线程已被取消

    static final int CANCELLED =  1;

    // 当前线程的后继线程需要被unpark(唤醒)

    // 一般发生情况是：当前线程的后继线程处于阻塞状态，而当前线程被release或cancel掉，因此需要唤醒当前线程的后继线程。

    static final int SIGNAL    = -1;

    // 在Condition休眠状态，在等待Condition唤醒

    static final int CONDITION = -2;

    // (共享锁)其它线程获取到“共享锁”，对应的waitStatus的值

    static final int PROPAGATE = -3;

volatile int waitStatus;

---------------------

/**

    * 这个方法也就是lock（）方法的关键方法。tryAcquire获得资源，返回true，直接结束。若未获取资源，新建一个节点插入队尾，

*addWaiter用于添加节点,也就是把当前线程对应的节点插入CLH队列的尾部。

    * @param arg the acquire argument.  This value is conveyed to

    *        {@link #tryAcquire} but is otherwise uninterpreted and

    *        can represent anything you like.

    */

    public final void acquire(int arg) {

        if (!tryAcquire(arg) &&//获取资源立刻结束

            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))//没有被中断过，也结束

            selfInterrupt();

    }

---------------------

protected final boolean tryAcquire(int acquires) {

            final Thread current = Thread.currentThread();

            int c = getState();

            if (c == 0) {

                if (!hasQueuedPredecessors() &&

                    compareAndSetState(0, acquires)) {

                    setExclusiveOwnerThread(current);

                    return true;

                }

            }

            else if (current == getExclusiveOwnerThread()) { //判断是否持有锁的是自己,重入

                int nextc = c + acquires;

                if (nextc < 0)

                    throw new Error("Maximum lock count exceeded");

                setState(nextc);

                return true;

            }

            return false;

        }

---------------------

  * 非公平锁

    */

    static final class NonfairSync extends Sync {

        private static final long serialVersionUID = 7316153563782823691L;

        /**

        * Performs lock.  Try immediate barge, backing up to normal

        * acquire on failure.

        */

        final void lock() {

            if (compareAndSetState(0, 1))//CAS设置当前为0 的时候上锁

                setExclusiveOwnerThread(Thread.currentThread());

            else

                acquire(1);//否则尝试获得锁。

        }

        protected final boolean tryAcquire(int acquires) {

            return nonfairTryAcquire(acquires);

        }

    }

    /**

    * 公平锁

    */

    static final class FairSync extends Sync {

        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {

            acquire(1);

        }

        /**

        *

        */

        protected final boolean tryAcquire(int acquires) {

            final Thread current = Thread.currentThread();

            int c = getState();

            if (c == 0) {

                if (!hasQueuedPredecessors() &&

                    compareAndSetState(0, acquires)) {//没有前驱节点并且CAS设置成功

                    setExclusiveOwnerThread(current);//设置当前线程为独占线程

                    return true;

                }

            }

            else if (current == getExclusiveOwnerThread()) {//这里和非公平锁类似

                int nextc = c + acquires;

                if (nextc < 0)

                    throw new Error("Maximum lock count exceeded");

                setState(nextc);

                return true;

            }

            return false;

        }

    }

⑤ JAVA锁有哪些种类，以及区别

常见的Java锁有下面这些：

• 公平锁/非公平锁

• 可重入锁

• 独享锁/共享锁

• 互斥锁/读写锁

• 乐观锁/悲观锁

• 分段锁

• 偏向锁/轻量级锁/重量级锁

• 自旋锁

这些分类并不是全是指锁的状态，有的指锁的特性，有的指锁的设计，下面总结的内容是对每个锁的名词进行一定的解释。

公平锁/非公平锁

公平锁是指多个线程按照申请锁的顺序来获取锁。
非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象。
对于JavaReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。
对于Synchronized而言，也是一种非公平锁。由于其并不像ReentrantLock是通过AQS的来实现线程调度，所以并没有任何办法使其变成公平锁。

可重入锁

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。说的有点抽象，下面会有一个代码的示例。
对于JavaReentrantLock而言, 他的名字就可以看出是一个可重入锁，其名字是Re entrant Lock重新进入锁。
对于Synchronized而言,也是一个可重入锁。可重入锁的一个好处是可一定程度避免死锁。

• synchronized void setA() throws Exception{


• Thread.sleep(1000);


• setB();


• }synchronized void setB() throws Exception{


• Thread.sleep(1000);


• }



上面的代码就是一个可重入锁的一个特点，如果不是可重入锁的话，setB可能不会被当前线程执行，可能造成死锁。

独享锁/共享锁

独享锁是指该锁一次只能被一个线程所持有。
共享锁是指该锁可被多个线程所持有。

对于JavaReentrantLock而言，其是独享锁。但是对于Lock的另一个实现类ReadWriteLock，其读锁是共享锁，其写锁是独享锁。
读锁的共享锁可保证并发读是非常高效的，读写，写读 ，写写的过程是互斥的。
独享锁与共享锁也是通过AQS来实现的，通过实现不同的方法，来实现独享或者共享。
对于Synchronized而言，当然是独享锁。

互斥锁/读写锁

上面讲的独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。
互斥锁在Java中的具体实现就是ReentrantLock
读写锁在Java中的具体实现就是ReadWriteLock

乐观锁/悲观锁

乐观锁与悲观锁不是指具体的什么类型的锁，而是指看待并发同步的角度。
悲观锁认为对于同一个数据的并发操作，一定是会发生修改的，哪怕没有修改，也会认为修改。因此对于同一个数据的并发操作，悲观锁采取加锁的形式。悲观的认为，不加锁的并发操作一定会出问题。
乐观锁则认为对于同一个数据的并发操作，是不会发生修改的。在更新数据的时候，会采用尝试更新，不断重新的方式更新数据。乐观的认为，不加锁的并发操作是没有事情的。

从上面的描述我们可以看出，悲观锁适合写操作非常多的场景，乐观锁适合读操作非常多的场景，不加锁会带来大量的性能提升。
悲观锁在Java中的使用，就是利用各种锁。
乐观锁在Java中的使用，是无锁编程，常常采用的是CAS算法，典型的例子就是原子类，通过CAS自旋实现原子操作的更新。

分段锁

分段锁其实是一种锁的设计，并不是具体的一种锁，对于ConcurrentHashMap而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。
我们以ConcurrentHashMap来说一下分段锁的含义以及设计思想，ConcurrentHashMap中的分段锁称为Segment，它即类似于HashMap（JDK7与JDK8中HashMap的实现）的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表；同时又是一个ReentrantLock（Segment继承了ReentrantLock)。
当需要put元素的时候，并不是对整个hashmap进行加锁，而是先通过hashcode来知道他要放在那一个分段中，然后对这个分段进行加锁，所以当多线程put的时候，只要不是放在一个分段中，就实现了真正的并行的插入。
但是，在统计size的时候，可就是获取hashmap全局信息的时候，就需要获取所有的分段锁才能统计。
分段锁的设计目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。

偏向锁/轻量级锁/重量级锁

这三种锁是指锁的状态，并且是针对Synchronized。在Java 5通过引入锁升级的机制来实现高效Synchronized。这三种锁的状态是通过对象监视器在对象头中的字段来表明的。
偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。

轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。
重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。

自旋锁

在Java中，自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

⑥ 有没有关于java深入一点的书推荐

学习的最好途径就是看书“，这是我自己学习并且小有了一定的积累之后的第一体会。个人认为看书有两点好处：

1.能出版出来的书一定是经过反复的思考、雕琢和审核的，因此从专业性的角度来说，一本好书的价值远超其他资料。

2.对着书上的代码自己敲的时候方便。

“看完书之后再次提升自我的最好途径是看一些相关的好博文“，我个人认为这是学习的第二步，因为一本书往往有好几百页，好的博文是自己看书学习之后的一些总结和提炼，对于梳理学习的游蠢扮内容很有好处，当然这里不是说自己的学习方法，就不再扯下去了。

很多程序员们往往有看书的冲动，但不知道看哪些书，下面我就给各位Java程序猿们推荐一些好书（每本书的作者会加粗标红），其中绝大多数都是我自己平时在看的书，也算是我对于平时读的书做一个小总结和读后感吧。

首先推荐的不是一本书，而是一个博客，也是我们博客园另外一位博友java_my_life。

目前市面上讲解设计模式的书很多，虽然我前面讲了看书是最好的，但是对设计模式感兴趣的朋友们，我推荐的是这个博客。这位博友的设计模式讲得非常非常好，我认为90%的内容都是没有问题且很值得学习的，其讲解设计模式的大体路线是：

随便开篇点明该设计模式的定义

图文并茂讲解该设计模式中的结构

以详细的代码形式写一下该种设计模式的实现

补充内容

讲解该设计模式的优缺点

对于一个设计模式我们关注、学习的知识点，不就是上面这些吗？

不过我要重点提醒一下网友们，同一种设计档衫模式的写法有多种，并不是说只有按某种写法来写才是这种设计模式。比方说适配器模式，我们关注适配器模式一定要关注的是什么是适配器模式不是怎么写适配器模式，不要认为某段代码不是按照适配器模式的写法写下来的它就不是适配器模式了，记住这一点，你在学习设计模式的时候一定会对代码中用到的设计模式有更深入的理解。

1、深入理解Java虚拟机：JVM高级特性与最佳实践

如果你不满足于做一个只会写ifelse的Java程序员，而是希望更进一步，我随便举几个例子吧：

了解Java代码的底层运行机制

定位性能问题

对整个系统进行性能调优

解决各种奇奇怪怪的线上线下问题

更加高级别的，为自己的项目量身定做一款适合自己项目的虚拟机

那么Java虚拟机是你必学的一门技术。《深入理解Java虚拟机：JVM高级特性与最佳实践》作者是周志明，这本书可以说是国内写得最好的有关Java虚拟机的书籍，近半年，前前后后这本书我起码看了有5遍。国内写虚拟机的书除了这本，其实还有一些其他的，我也买过，不过粗略看下来，很多内容也是《深入理解Java虚拟机：JVM高神灶级特性与最佳实践》此书里面的。

另外值得一提的是，《深入理解Java虚拟机：JVM高级特性与最佳实践》这本书，有电子版的，网上搜一下就能下载到了。不过建议有兴趣的朋友还是去买书看，电子版本下载到的一般是比较老的版本，相比最新修订版的《深入理解Java虚拟机：JVM高级特性与最佳实践》，有很多作者新补充的知识点是没有的。

2、HotSpot实战

所有的Java虚拟机都是遵循着Java虚拟机规范来的，市面上的Java虚拟机几十款，《深入理解Java虚拟机：JVM高级特性与最佳实践》一书里面讲的虚拟机并不针对某种特定的虚拟机，而是从Java虚拟机规范的角度来讲解Java虚拟机。

我们平时使用的乃至商用的大多数Java虚拟机都是Sun公司的HotSpot，大家cmd进入命令行，使用”java-version”命令就可以看到了。如果希望在Java虚拟机规范的基础上更加深入地去理解虚拟机的一些细节是怎么实现的，就可以看一下《HotSpot实战》一书，作者是陈涛。不过由于HotSpot的源码都是C/C++写的，所以要求读者有非常好的C/C++基础，如果对这两门语言不是很熟悉的朋友，看这本书可能对你帮助不是很大。

最后提一句，如果有兴趣的朋友，不妨先去网上下载一个openJDK，HotSpot的源码就在里面。

3、Java并发编程实战

这本书常常被列入Java程序员必读十大书籍排行榜前几位，不过个人不是很推荐这本书。

《Java并发编程实战》作者是BrianGoetz，怎么说呢，这本书前前后后我也看了两遍左右，个人感受是：

文字多代码少

讲解多实践少

我觉得这可能就是老外写书的特点吧，因为Java是北美国家（加拿大、美国）开发和维护的，所以老外对Java方方面面的理论知识体系都掌握得是非常清楚和透彻的。翻开这本书看，多线程什么用、什么是死锁、什么是竞争、什么是线程安全等等，方方面面的知识点都用大量的文字篇幅讲解，不免让人感觉十分枯燥，也难让读者有实质性的进步。我这本书看了两遍也属于一目十行意思，有兴趣的地方就重点看一下。

无论如何，作为一本常常位于Jva程序员必读十大书籍排行榜前几名的书，还是一定要推荐给大家的。

4、java多线程编程核心技术

《Java多线程编程核心技术》作者高洪岩。想要学习多线程的朋友，这本书是我大力推荐的，我的个人博客里面二十多篇的多线程博文都是基于此书，并且在这本书的基础上进行提炼和总结而写出来的。

此书和《Java并发编程实战》相反，这本书的特点是大篇幅的代码+小篇幅的精讲解，可能这和中国人写的书比较偏向实用主义的风格有关。本书关于线程安全、synchronized、Reentrant、Timer等等都用详细的代码进行了讲解，而且每个大知识点下的多个小知识点都会详细讲解到，非常有实践价值。

有兴趣的朋友们，我相信只要你们跟着这本书里面的代码敲、运行、思考，三步走，对于多线程的使用与理解一定会进几大步。

不过这本书的缺点就是对于Java并发包下的一些类像CountDownLatch、Semphore、CyclicBarrier、Future、Callable等都没有讲到，重点的CAS和AQS也没有触及，重点类的实现原理也没有提。当然，这很深入了，在学习了这本书之后如果能再去对这些知识进行一些学习、研究的话，你一定会慢慢成长为一个很厉害的多线程高手。

5、EffectiveJava中文版

这是唯一一本我没有买的书。初识这本书，是在我的博文Java代码优化（长期更新）里面，底下评论的时候有朋友提到了这本书，当时我说要去买，不过这两个月一直都没时间去逛书店，甚是遗憾，之后肯定会找时间去买这本书的。

《EffectiveJava中文版》的作者是JoshuaBloch，这个人就很厉害了，他是谷歌的首席架构师，属于超级技术大牛级别了吧，呵呵。由于没有看过这本书，所以我不好发表评论，但是从这本书的知名度以及其作者的来头来看（多提一句，这本书也是Java之父JamesGosling博士推崇的一本书），我相信这一定是一本值得一看的好书。

好的代码是每个Java程序员都应该去追求的，不是说我今天写一段好代码相比写一段烂代码对性能会有多大的提升，更多的应该是提升了代码的可读性以及可以规避许多潜在的、未知的问题，避免代码上线之后出问题而花时间去维护—-无论从时间成本、人力成本还是风险成本来说，这都是非常高的。

6、深入分析JavaWeb技术内幕

《深入分析JavaWeb技术内幕》，作者许令波，淘宝工程师。

这本书我用一个字概括就是：全。真的非常全，HTTP、DNS、CDN、静态化、Jetty、Tomcat、Servlet、Spring、MyBatis等等，什么都有，涉及知识面非常广，但又不像专门精讲某个知识点的书籍一样讲得非常深入，感觉这本书就是尽量去用短的篇幅讲清楚一些JavaWeb使用到的技术的内幕，让读者对这些知识点的技术内幕有一个理性的认识。

不过，尽管每个知识点的篇幅都不多，但是重点都基本讲到了，是一本让人真正有收获的书。如果想进一步了解这些技术的技术内幕，就要自己去买相关书籍或者自己上网查资料了，有种抛砖引玉，或者说师傅领进门、修行在个人的感觉。

7、大型网站技术架构核心原理与案例分析

一个字评价这本书，_；两个字评价这本书，很_；三个字评价这本书，非常_。呵呵，好了，再说下去可能别人以为我是水军了。

《大型网站技术架构核心原理与案例分析》的作者是李智慧，原阿里巴巴技术专家。

Java的大多数应用都是用在Web上的，现在只要稍微大型一点的Web应用，都一定是一个分布式系统，那么一个分布式系统用到了哪些技术？一个大型网站是如何从一个小型网站成长起来的？如何保证你的网站安全？分布式系统使用到了缓存，有哪些缓存？缓存的使用有哪些值得注意的事项？

关于分布式的知识点，都在这本书里面有体现，只有你想不到，没有他写不到，而且写得非常易懂，基本属于看一两遍，再记一些笔记就知道是怎么一回事儿了。多看几遍，对分布式的理解一定会加深不少。而且里面不仅仅是分布式的知识，还非常接地气地写了如何做一个好的架构师，其实我认为这不仅仅是写给想做架构师的读者看的，就是给读者一些建议，如何更好地提出意见、如何更让别人关注你的声音、如何看到他人的优点，入木三分，让人获益匪浅。

8、大型网站系统与Java中间件实践

《大型网站系统与Java中间件实践》作者曾宪杰，是淘宝的技术总监，算起来应该在阿里有至少P8的级别了吧。

这本书的部分内容和上面一本李智慧的《大型网站技术架构核心原理与案例分析》有所重合，像分布式系统的演化、CDN、CAP理论和BASE理论等等，这也更说明这些都是分布式系统或者说是一个大型网站重点关注的内容，当作一次再学习也不错。

本书要突出的重点是中间件三个字，中间件是分布式系统中一个非常重要的东西，其最重要的作用应该就是解耦，降低模块与模块之间的强依赖，不同的模块之间的依赖度降低，便可以各自独立地开发自己的功能，这也可以说是软件工程发展的目标和驱动力。

因此，本书有一部分的内容就是基于中间件，详细讲解了中间件与JMS的各种知识，适合对分布式系统比较熟悉并且想要往中间件方面有一定研究的读者。

9、从Paxos到ZooKeeper分布式一致性原理与实践

《从Paxos到ZooKeeper分布式一致性原理与实践》，作者倪超，阿里巴巴工程师。

这本书是我最近在研读的一本书，和上面的《大型网站系统与Java中间件实践》一样，属于分布式组件的范畴，属于有些深入的内容，当然也是我自己的个人兴趣。当然，如果有志向做一个出色的大型网站架构师、公司的技术总监之类，这些知识当然是必须掌握的。

本书从分布式系统基本理论开始讲起，讲到Paxos算法，最后慢慢引入到Zookeeper，循序渐进。当然，更多的我目前还不方便发表什么看法，因为这本书的第二张Paxos算法我都还没有弄懂（Paxos算法确实有些难以理解和不太易懂），接下来的章节还没有看下去。

如果网友们所在的公司在使用Zookeeper，并且你又对Zookeeper感兴趣想要研究一下它的原理的，这本书将是不二之选。

10、MySQL5.6从零开始学

《MySQL5.6从零开始学》，作者刘增杰和李坤。

作为一名Java程序员，我认为我们千万不要觉得数据库是DBA的事情，数据库对一个Java程序员来说也是必须掌握的一门知识，丰富的数据库性能优化经验是一个顶尖程序员必备技能。

目前主流的数据库有Oracle和MySQL，当然推荐大家的是MySQL，主要原因我认为有两点：

1、MySQL相比Oracle更轻量级、更小、安装和卸载更方便，SQL其实都是差不多的，如果想学数据库，学MySQL就可以了，在家里面可以自己方便地研究，如果你的公司使用Oracle，只要再用对比学习法，关注一下Oracle和MySQL的差别即可

2、随着2009年阿里巴巴去IOE的运动的进行，目前国内的很多互联网公司都会选择MySQL作为它们使用的数据库，因为MySQL免费，所以既省钱又不需要出了问题就依赖甲骨文公司

MySQL学习我推荐的是这本我自己学习看的《MySQL5.6从零开始学》，我是觉得挺好的这本书，书里面的知识点很细致、很全面，读者选择书籍的标准大多不就是这两点吗？

11、Spring源码深度解析

《Spring源码深度解析》，作者郝佳。

Spring这个框架做得太好了，功能太强大了，以至于很多开发者都只知Spring，不知什么是工厂、什么是单例、什么是代理（我面试别人的真实体会）。这种功能强大的框架内部一定是很复杂的实现，这就导致一旦你的程序使用Spring，出了问题，可能是Error、可能是Exception、可能是程序运行结果不是你的预期的，出现诸如此类问题的时候，将会让你感到困惑，除了上网查资料或者问别人似乎没有更好的解决办法。

研读Spring的源代码不失为一种很好的学习方法，我个人认为这有很多好处：

理解框架内部的实现之后，可以主动去解决问题，而不需要依赖别人

Spring框架内部实现用到了很多设计模式，很好的代码设计思路，这将会对你写代码、对你理解设计模式有很大的提高

研究Spring框架将会大大增强你读代码的能力，我相信只要你能研究清楚Spring内部是如何实现的，其他任何一个框架的源代码都难不倒你

总而言之，我认为读代码的能力是一个普通的程序员和一个好的程序员之间最大的差别之一，前者只会把别人写好的东西拿来用，后者不仅能用好，还清楚知道别人写好的东西底层是如何实现的，在出现问题的时候可以轻松解决。

Spring源代码，个人推荐《Spring源码深度解析》一书，真要研究透并且写清楚Spring源代码，恐怕三四本书都不够，作者在近400页的篇幅中尽量去讲解Spring源代码是如何实现的，殊为不易，尽管无法讲得完全，但是相信作者的讲解配合上读者自己的研究，一定可以对Spring的实现有更深度的理解。

以上就是我对Java高级部分应该看的书籍的推荐，希望可以对你有所帮助。说一点我的建议，我们学Java技术更重要的还是看视频教程，我们只有看更多的视频教程，不断的练习，在脑海当中产生深刻的记忆。我永远坚信我的一句话：书籍能诠释的东西毕竟有限。

最后在这里推荐大家关注一下我的微信公众号：Java新手学习，给你准备了一套最新的Java基础精讲视频教程和Java系统学习路线，关注即可观看。

⑦ 实战Java高并发程序设计读后感10篇_读后感_名着读后感

《实战Java高并发程序设计》是一本由葛一鸣 / 郭超着作，电子工业出版社出版的平装图书，本书定价：69.00元，页数：352，文章吧我精心整理的一些读者的读后感，希望对大家能有帮助。

《实战Java高并发程序设计》读后感(一)：是本入门书籍

这是一本Java并发基础以及conCurrent包的类的简介，虽然书名是实战，但是例子挺多都是属于helloWorld级别的，所以是比较适合入门。同时也会夹着一些对源码和数据机构的分析，也会有Java8带来一些新特性（比如函数式编程等）的讲解，所以还可以吧。

还有一点就是这本书的图会比较新颖和奇葩，例如下面这样的：

有时候会觉得挺形象的，更多的时候是不想吐槽（有些字一下子还看不出来是什么字o(╯□╰)o），还是希望用专业的画图软件画吧.

再去找一个并发的书籍看看加强~并发真的需要好好学学

《实战Java高并发程序设计》读后感(二)：全面了解Java并发编程的好书

1.这本书的章节编排是比较清晰的，而且是由浅入深、由理论到实战，阅读的时候感觉特别流畅；

2.如果你翻过这本书，你一定会对书中的插图印象“深刻”，很难想象现代出版的书里的插图是这种质量；

3.关于Java并发的知识可以说是介绍得比较全面了，当前全面的话可能就没法真正的深入，比如ConcurrentHashMap基本上并发编程中最常用最经典的设计，但是书上介绍的非常少；同样的，Java 8中引入的CompletableFuture也是一个很重要的工具但是介咐顷绍的篇幅也非常有限；

4.对于Akka这一块，说实话我读了两遍，还是没有看得很懂，通过阅读官方的文档才比较清晰，感觉这一块写得有点混乱，条理不够清晰；

5.最终我还是给这本书四星，因为读后自己确实对并发这一块有了比较完整的认识，读后结合《深入理解Java虚拟机（第2版）》，从项目中的代码找到并相关部分并予以改进，梳理并发重点的知识（显式锁控制、并发容器、并发流），收获还是挺多的。

《实战Java高并发程序设计》读后感(三)：Java并发编程和高并发解决方案视频课程

Java并发编程和高并发解决方案视频课程

网盘地址：//pan./s/19tUBliZIYy2HQ0LiVfCw-A 密码: d9fb

备用地址（腾讯微云）：//share.weiyun/5grRNnM 密码：e324w9

学会高并发处理思路与手段，让跳槽面试从容不迫，并发与高并发是面试的重要考察点，常问面试问题与答案都在这里了！

无论面试还是实际开发，几乎都会涉及并发相关知识及高并发相关场景处理，如果你想系统的学习一下并发编程

并了解一下实际的高并发场景及应对方案，那这门课就是为你准备的。

第1章 课程准备衡好陆

第2章 并发基础

第3章 项目准备

第4章 线程安全性

第5章 安全发布对象

第6章 线程安全策略

第7章 J.U.C之AQS

第8章 J.U.C组件拓展

第9章 线程调度-线程池

第10章 多线程并发拓展

第11章 高并发之扩容思路

第12章 高并发之缓存思路

第13章 高并发之消息队列思路

第14章 高并发之应用拆分思路

第15章 高并发之应用限流思路

第16章 高并发之服务降级与服务熔断思路

第17章 高并发之数据库切库分库分表思路

第18章 高并发之高可用手段介绍

第19章 课程总结

《实战Java高并发程序设计》读后感(四)：实战Java高并发程序设计书评

说实话，在当当上找了很多有关java并发编程的书籍，最后也不知道是什么原因买了这本书（好像是这本书有优惠。。。）买来之后看了，简直后悔得不行！

这本书的作者是葛一鸣和郭超，出版社是电子工业出版社！

首先，这本书的作者的写作态度值得怀疑，书中的配图完全是手画的，而且画的质量实在不敢恭维，写过的论文都应该知道，画图应该袜烂用Visio。实在纳闷那么多专业的图，作者为何不用Visio或其他专业画图软件，选择用手画是几个意思，关键画的质量还不咋地，歪七八糟的，看都看不清楚！作为一个专业的出版社，编辑也能审核通过，我是佩服出版社的编辑的审稿能力！

其次，关于java并发这块，这本书连入门书籍都算不上，只能算是科普下，书中涉及到的并发知识，比如java内存模型，volatile，锁等，作者都没有深入原理的讲，基本上都是简单带过，远不如网络来的讲得好，其中讲volatile的一段：“和原子性问题一样，我们只要简单地使用volatile来声明ready变量，告诉java虚拟机，这个变量可能会在不同的线程中修改，这样就可以顺利的解决这个问题了。” 不知道大家觉得怎么样，反正我看完想说脏话，作者你就是这么讲解技术的吗？用volatile来告诉虚拟机变量会在不同线程中修改？？我只能说呵呵

还有一点，其他豆瓣网友也提到过，很多内容以及代码都是从其他博客、文章过来，作者原创的有价值的东西，几乎为零。

书中还有其他一些低级错误，就不一一指出了，最后，如果有幸能够被作者看到此评论，真心希望作者好好反思下，请你为写出的书负责，确保产出原创的有意义的内容，不是随意几段文字和代码，整理下就能出书的，请你对得起买书的读者！