java多线程讲解_Java多线程详解

基本概念

多线程：

指的是这个程序(一个进程)运行时产生了不止一个线程

并行：

多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。

并发：

通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。

线程安全：

指在并发的情况之下，该代码经过多线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，cpu是不是够用即可。反过来，线程不安全就意味着线程的调度顺序会影响最终结果。

同步：

通过人为的控制和调度，保证共享资源的多线程访问成为线程安全，来保证结果的准确。

线程的状态

NEW(新建状态)

当一个线程创建以后，就处于新建状态。那什么时候这个状态会改变呢？只要它调用的start()方法，线程就进入了锁池状态。

BLOCKED(锁池)

进入锁池以后就会参与锁的竞争，当它获得锁以后还不能马上运行，因为一个单核CPU在某一时刻，只能执行一个线程，所以他需要操作系统分配给它时间片，才能执行。

RUNNABLE(运行状态)

当一个持有对象锁的线程获得CPU时间片以后，开始执行这个线程，此时叫做运行状态。

TIMED_WAITING(定时等待)、WAITING(等待)

处于运行状态的线程还可能调用wait()方法、或者带时间参数的wait(long milli)方法。这时候线程就会将对象锁释放，进入等待队列里面(如果是调用wait()方法则进入等待状态，如果是调用带时间参数的则进入定时等待状态)

TERMINATED(终止、结束)

当一个线程正常执行完，那么就进入终止(死亡)状态。系统就会回收这个线程占用的资源。

线程状态.png

注意：1.当线程调用sleep()方法或当前线程中有其他线程调用了带时间参数的join()方法的时候进入了定时等待状态(TIMED_WAITING)

2.当其他线程调用了不带时间参数的join()(join内部调用的是sleep，所以可看成sleep的一种)方法时进入等待状态(WAITING)。

3.当线程遇到I/O的时候还是运行状态(RUNNABLE)

4.当一个线程调用了suspend()方法挂起的时候它还是运行状态(RUNNABLE)。

synchronized、Lock

他们是应用于同步问题的人工线程调度工具，wait/notify必须存在于synchronized块中。并且，这三个关键字针对的是同一个监视器(某对象的监视器)。这意味着wait之后，其他线程可以进入同步块执行。

同步原理

JVM规范规定JVM基于进入和退出Monitor对象来实现方法同步和代码块同步，但两者的实现细节不一样。代码块同步是使用monitorenter和monitorexit指令实现，而方法同步是使用另外一种方式实现的，细节在JVM规范里并没有详细说明，但是方法的同步同样可以使用这两个指令来实现。monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结束处和异常处， JVM要保证每个monitorenter必须有对应的monitorexit与之配对。任何对象都有一个 monitor 与之关联，当且一个monitor 被持有后，它将处于锁定状态。线程执行到 monitorenter 指令时，将会尝试获取对象所对应的 monitor 的所有权，即尝试获得对象的锁。

synchronized的使用

锁的本质是对象实例，对于非静态方法来说，Synchronized 有两种呈现形式，Synchronized方法体和Synchronized语句块。两种呈现形式本质上的锁都是对象实例。

1.锁定实例

public class SynchronizeDemo {

public void doSth1() {

/**

* 锁对象实例 synchronizeDemo

*/

synchronized (synchronizeDemo){

try {

System.out.println("正在执行方法");

Thread.sleep(10000);

System.out.println("正在退出方法");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public void doSth2() {

/**

* 锁对象实例 this 等同于 synchronizeDemo

*/

synchronized (this){

try {

System.out.println("正在执行方法");

Thread.sleep(10000);

System.out.println("正在退出方法");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

synchronized块中的方法获取了lock实例的monitor，如果实例相同，那么只有一个线程能执行该块内容

2.直接用于方法

public synchronized void doSth3() {

/**

* 表面呈现是锁方法体，实际上是synchronized (this) ，等价于上面

*/

try {

System.out.println("正在执行方法");

Thread.sleep(10000);

System.out.println("正在退出方法");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

相当于上面代码中用lock来锁定的效果，实际获取的是Thread1类的monitor。更进一步，如果修饰的是static方法，则锁定Synchronized 的Class对象

Lock的使用

lock: 在java.util.concurrent包内。共有三个实现：

1.ReentrantLock

2.ReentrantReadWriteLock.ReadLock

3.ReentrantReadWriteLock.WriteLock

lock的主要目的是和synchronized一样,但是lock更灵活

公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序依次获得锁；而非公平锁则不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁。Sychronized的锁是非公平的，ReentrantLock默认情况下也是非公平的，但可以通过带boolean值的构造函数要求使用公平锁；

锁绑定多个条件是指一个ReentrantLock对象可以同时绑定多个Condition对象，而在Synchronized中，锁对象的wait()和notify()或notifyAll()方法可以实现一个隐含的条件，如果要多于一个条件关联的时候，就不得不额外添加一个锁，而ReentrantLock无需这样做，只需要多次调用newCondition()方法即可。

ReentrantLock

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

/**

* 有界阻塞队列

* 当队列为空,队列将会阻塞删除并获取操作的线程,直到队列中有新元素;

* 当队列已满,队列将会阻塞添加操作的线程，直到队列有空位置；

*

* Created by LeonWong on 16/4/29.

*/

public class BoundedQueue {

private Object[] items;

// 添加的下标,删除的下标和数组当前数量

private int addIndex, removeIndex, count;

private Lock lock = new ReentrantLock();

private Condition notEmpty = lock.newCondition();

private Condition notFull = lock.newCondition();

public BoundedQueue() {

items = new Object[5];

}

public BoundedQueue(int size) {

items = new Object[size];

}

/**

* 添加一个元素,数组满则添加线程进入等待状态

*

* @param t

* @throws InterruptedException

*/

public void add(T t) throws InterruptedException {

lock.lock();

try {

while (items.length == count) {

System.out.println("添加队列--陷入等待");

notFull.await();

}

items[addIndex] = t;

addIndex = ++addIndex == items.length ? 0 : addIndex;

count++;

notEmpty.signal();

} finally {

lock.unlock();

}

}

/**

* 删除并获取一个元素,数组空则进入等待

*

* @return

* @throws InterruptedException

*/

public T remove() throws InterruptedException {

lock.lock();

try {

while (count == 0) {

System.out.println("删除队列--陷入等待");

notEmpty.await();

}

Object tmp = items[removeIndex];

items[removeIndex] = null;// 这一步可以有可无

removeIndex = ++removeIndex == items.length ? 0 : removeIndex;

count--;

notFull.signal();

return (T) tmp;

} finally {

lock.unlock();

}

}

public Object[] getItems() {

return items;

}

public void setItems(Object[] items) {

this.items = items;

}

public int getAddIndex() {

return addIndex;

}

public void setAddIndex(int addIndex) {

this.addIndex = addIndex;

}

public int getRemoveIndex() {

return removeIndex;

}

public void setRemoveIndex(int removeIndex) {

this.removeIndex = removeIndex;

}

public int getCount() {

return count;

}

public void setCount(int count) {

this.count = count;

}

}

ReentrantReadWriteLock

允许多个读线程同时访问，但不允许写线程和读线程、写线程和写线程同时访问。相对于排他锁，提高了并发性。在实际应用中，大部分情况下对共享数据(如缓存)的访问都是读操作远多于写操作，这时ReentrantReadWriteLock能够提供比排他锁更好的并发性和吞吐量。

进程切换导致的系统开销

Java的线程是直接映射到操作系统线程之上的，线程的挂起、阻塞、唤醒等都需要操作系统的参与，因此在线程切换的过程中是有一定的系统开销的。在多线程环境下调用Synchronized方法，有可能需要多次线程状态切换，因此可以说Synchronized是在Java语言中一个重量级操作。

虽然如此，JDK1.6版本后还是对Synchronized关键字做了相关优化，加入锁自旋特性减少系统线程切换导致的开销，几乎与ReentrantLock的性能不相上下，因此建议在能满足业务需求的前提下，优先使用Sychronized。

volatile

多线程的内存模型：main memory(主存)、working memory(线程栈)，在处理数据时，线程会把值从主存load到本地栈，完成操作后再save回去(volatile关键词的作用：每次针对该变量的操作都激发一次load and save)。

使用volatile关键字仅能实现对原始变量(如boolen、 short 、int 、long等)操作的原子性，但需要特别注意， volatile不能保证复合操作的原子性，即使只是i++，实际上也是由多个原子操作组成：read i; inc; write i，假如多个线程同时执行i++，volatile只能保证他们操作的i是同一块内存，但依然可能出现写入脏数据的情况。

volatile和synchronized的区别

1.volatile本质是在告诉jvm当前变量在寄存器(工作内存)中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。

2.volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的

3.volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性

4.volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。

5.volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化

常用方法

Thread.yield()

当前线程可转让cpu控制权，让别的就绪状态线程运行(切换)

Thread.sleep()

暂停一段时间

join()

在一个线程中调用other.join(),将等待other执行完后才继续本线程。

interrupte()

中断线程

中断是一个状态！interrupt()方法只是将这个状态置为true而已。所以说正常运行的程序不去检测状态，就不会终止，而wait等阻塞方法会去检查并抛出异常。如果在正常运行的程序中添加while(!Thread.interrupted()) ，则同样可以在中断后离开代码体

future模式

使用步骤

(1)创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。

(2)创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。

(3)使用FutureTask对象作为Thread对象的target创建并启动新线程。

(4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

多线程控制类

1.ThreadLocal类

2.原子类(AtomicInteger、AtomicBoolean……)

3.容器类

BlockingQueue

阻塞队列。该类是java.util.concurrent包下的重要类，通过对Queue的学习可以得知，这个queue是单向队列，可以在队列头添加元素和在队尾删除或取出元素

除了传统的queue功能(表格左边的两列)之外，还提供了阻塞接口put和take，带超时功能的阻塞接口offer和poll。put会在队列满的时候阻塞，直到有空间时被唤醒；take在队　列空的时候阻塞，直到有东西拿的时候才被唤醒。用于生产者-消费者模型尤其好用

常见的阻塞队列有：

ArrayListBlockingQueue

LinkedListBlockingQueue

DelayQueue

SynchronousQueue

ConcurrentHashMap

高效的线程安全哈希map

4.线程池

5. 信号量(Semaphore)

信号量是一个非负整数(车位数)，所有通过它的线程(车辆)都会将该整数减一(通过它当然是为了使用资源)，当该整数值为零时，所有试图通过它的线程都将处于等待状态。在信号量上我们定义两种操作： Wait(等待) 和 Release(释放)。 当一个线程调用Wait(等待)操作时，它要么通过然后将信号量减一，要么一直等下去，直到信号量大于一或超时。Release(释放)实际上是在信号量上执行加操作，对应于车辆离开停车场，该操作之所以叫做“释放”是因为加操作实际上是释放了由信号量守护的资源。