首页  思维导图  详情

多线程并发

2017-07-10 16:02:17   150  举报





AI智能生成

java多线程基础和进阶。。。。。。。。。。。。。。。。。。。。。。

java 多线程

后端开发

作者其他创作

大纲/内容

高级部分

CompletionService

作用

是以异步的方式一边生产新的任务，一边处理已完成任务的结果，这样可以将执行任务与处理任务分离开来进行处理。使用 submit 执行任务，使用 take 取得已完成的任务，并按照完成这些任务的时间顺序处理它们的结果。

实现类

ExecutorCompletionService

方法

方法 take（）取得最先完成任务的 Future 对象，谁执行时间最短谁最先返回。

方法 poll（）的作用是获取并移除表示下一个已完成任务的 Future，如果不存在这样的任务，则返回 null，方法 poll（）无阻塞的效果。

方法 Future< V> poll（ long timeout， TimeUnit unit）的作用是等待指定的 timeout 时间，在 timeout 时间之内获取到值时立即向下继续执行，如果超时也立即向下执行。

总结

接口 CompletionService 完全可以避免 FutureTask 类阻塞的缺点，可更加有效地处理 Future 的返回值，也就是哪个任务先执行完， CompletionService 就先取得这个任务的返回值再处理。

CountDownLatch&CyclicBarrier

CountDownLatch

作用

门闩，也就是有“ 门锁” 的功能，所以当门没有打开时， N 个人是不能进入屋内的，也就是 N 个线程是不能继续向下运行的，支持这样的特性可以控制线程执行任务的时机，使线程以“ 组团” 的方式一起执行任务。类 CountDownLatch 所提供的功能是判断 count 计数不为 0 时则当前线程呈 wait 状态，也就是在屏障处等待

基本用法

定一个计数，当使用这个 CountDownLatch 类的线程判断计数不为 0 时，则呈 wait 状态，如果为 0 时则继续运行。实现等待与继续运行的效果分别需要使用 await（）和 countDown（）方法来进行。调用 await（）方法时判断计数是否为 0，如果不为 0 则呈等待状态。其他线程可以调用 count- Down（）方法将计数减 1，当计数减到为 0 时，呈等待的线程继续运行。而方法 getCount（）就是获得当前的计数个数。

代码 new CountDownLatch（ 1）的作用是创建 1 个计数的 CountDownLatch 类的对象，当线程执行 down. await（）代码时呈等待状态，程序不向下继续运行。程序执行 down. countDown（）代码时计数由 1 变成 0，以前呈等待状态的线程继续向下运行。

其他概念

方法 await（ long timeout， TimeUnit unit）的作用使线程在指定的最大时间单位内进入 WAITING 状态，如果超过这个时间则自动唤醒，程序继续向下运行。参数 timeout 是等待的时间，而 unit 参数是时间的单位。

方法 getCount（）获取当前计数的值。

我的理解

门上一共有10把锁，10个人有10把钥匙，当锁全部打开，10个人才可以进入下一步操作

调用countdownlatch.awati的线程处于阻塞状态，当countdownlatch调用countdownf方法将count计数减为0的时候，await的线程从阻塞状态变为可运行状态

CyclicBarrier

作用

类 CyclicBarrier 不仅有 CountDownLatch 所具有的功能，还可以实现屏障等待的功能，也就是阶段性同步，它在使用上的意义在于可以循环地实现线程要一起做任务的目标，而不是像类 CountDownLatch 一样，仅仅支持一次线程与同步点阻塞的特性，

它允许一组线程互相等待，直到到达某个公共屏障这些线程必须实时地互相等待，这种情况下就可以使用 CyclicBarrier 类来方便地实现这样的功能。 CyclicBarrier 类的公共屏障点可以重用，所以类的名称中有“ cyclic 循环” 的单词。

CountDownLatch 类的使用情况是两个角色之间互相等待，而 Cyclic- Barrier 的使用情况是同类互相等待。和 CountDownLatch 类不同，类 CyclicBarrier 的计数是加法操作。

类 CyclicBarrier 具有屏障重置性，这句话的意思就是如果全部线程await的个数都到达了屏障数，那屏障就会被重置为0，然后在从0开始累加到屏障数

基本用法

一组线程中每个线程调用CyclicBarrier.awati()方法等待其他线程到达一个公共屏障点

new CyclicBarrier(5,Runnable),设置最大为 5 个的 parties 同行者，也就是 5 个线程都执行了 cbRef 对象的 await（）方法后程序才可以继续向下运行，否则这些线程彼此互相等待，一直呈阻塞状态。

其他概念

getNumberWaiting（），该方法的作用是获得有几个线程已经到达屏障点。

方法 isBroken（）查询此屏障是否处于损坏状态。

方法 isBroken（）查询此屏障是否处于损坏状态。由于中断或者超时提前离开了屏障点，其他所有在屏障点等待的线程也会抛出 BrokenBarrierException 或者 InterruptedException 异常，并且离开屏障点。

方法 await（ long timeout， TimeUnit unit）的功能是如果在指定的时间内达到 parties 的数量，则程序继续向下运行，否则如果出现超时，则抛出 TimeoutException 异常。

方法 getParties（）的作用是取得 parties 个数。

reset（）的作用是重置屏障。

Semaphore&Exchanger

Semaphore

作用

控制线程并发的数量

主要用法

semaphore.acquire();

System.out.println(Thread.currentThread().getName() + "，begin timer=" + System.currentTimeMillis());

Thread.sleep(1000);

System.out.println(Thread.currentThread().getName() + "，end timer=" + System.currentTimeMillis());

semaphore.release();

其他概念

有参方法 acquire（int permits）的功能是每调用 1 次此方法，就使用 x 个许可。说白了就是一共有10把锁，没进来一个人就消耗掉2把锁，所以一共只能进来5次

构造参数 new Semaphore（5）；中的 5 并不是最终的许可数量，仅仅是初始的状态值。比如初始是5，如果release(5)，那avaliablePermits=10

方法 acquireUninterruptibly（）的作用是使等待进入 acquire（）方法的线程，不允许被中断。也就是正常执行不抛出异常

availablePermits（）返回此 Semaphore 对象中当前可用的许可数，此方法通常用于调试，因为许可的数量有可能实时在改变，并不是固定的数量。

drainPermits（）可获取并返回立即可用的所有许可个数，并且将可用许可置 0。

方法 getQueueLength（）的作用是取得等待许可的线程个数。

方法 hasQueuedThreads（）的作用是判断有没有线程在等待这个许可。

Semaphore semaphore = new Semaphore( 1, isFair);

获得许可的顺序与线程启动的顺序有关，这时信号量就要分为公平与非公平的。所谓的公平信号量是获得锁的顺序与线程启动的顺序有关，但不代表 100% 地获得信号量，仅仅是在概率上能得到保证。而非公平信号量就是无关的了。

无参方法 tryAcquire（）的作用是尝试地获得 1 个许可，如果获取不到则返回 false，此方法通常与 if 语句结合使用，其具有无阻塞的特点。无阻塞的特点可以使线程不至于在同步处一直持续等待的状态，如果 if 语句判断不成立则线程会继续走 else 语句，

有参方法 tryAcquire（ int permits）的作用是尝试地获得 x 个许可，如果获取不到则返回 false。

有参方法 tryAcquire（ int long timeout， TimeUnit unit）的作用是在指定的时间内尝试地获得 1 个许可，如果获取不到则返回 false。

有参方法 tryAcquire（ int permits， long timeout， TimeUnit unit）的作用是在指定的时间内尝试地获得 x 个许可，如果获取不到则返回 false。

Exchanger

作用

类 Exchanger 中的 exchange（）方法具有阻塞的特色，也就是此方法被调用后等待其他线程来取得数据，如果没有其他线程取得数据，则一直阻塞等待。

基本用法

System.out.println("ex1=" + ex.exchange("hello world"));两个线程分别调用ex.exchange(Object obj)方法，互相阻塞，互相得到exchange方法的返回值

其他概念

调用 exchange（ V x， long timeout， TimeUnit unit）方法后在指定的时间内没有其他线程获取数据，则出现超时异常。

并发集合框架

继承关系

Iterable

Collection

List

ArrayList

非线程安全

Vector

线程安全

当多个线程分别调用该类的 iterator（）方法返回 Iterator 对象后，再调用 remove（）时会出现 ConcurrentModificationException 异常，也就是并不支持 Iterator 并发的删除

子类Stack

后进先出（ LIFO）的对象堆栈

Queue

可以方便地操作列头，poll，add，remove等方法

PriorityQueue

它是一个基于优先级的无界优先级队列

Deque(接口)

双端队列，表头表尾都可以操作

ArrayDeque

队列两端获取数据

LinkedList

队列两端获取数据，还可以根据索引的位置操作数据

Set

具有的默认特点是内容不允许重复，排序方式为自然排序，防止元素重复的原理是元素需要重写 hashCode（）和 equals（）方法

HashSet

非线程安全，无序

LinkedHashSet

非线程安全，有序

TreeSet

它不仅实现了 Set 接口，而且还实现了 SortedSet 和 NavigableSet 接口

SortedSet 和 NavigableSet 接口在功能上得到了扩展，比如可以获取 Set 中内容的子集，以比较范围进行获得子集，支持对表头与表尾的数据进行获取等，

Map

AbstractMap

HashMap

非线程安全

HashTable

线程安全

不支持并发操作

LinkedHashMap

非阻塞队列

Map相关

ConcurrentHashMap

线程安全

支持并发操作

ConcurrentSkipListMap

线程安全

支持排序

支持并发操作

Set相关

ConcurrentSkipListSet

支持并发操作

支持排序

支持并发操作

不允许重复

CopyOnWriteArraySet

Queue相关

ConcurrentLinkedQueue

方法 poll（）当没有获得数据时返回为 null，如果有数据时则移除表头，并将表头进行返回。

方法 element（）当没有获得数据时出现 NoSuchElementException 异常，如果有数据时则返回表头项。

方法 peek（）当没有获得数据时返回为 null，如果有数据时则不移除表头，并将表头进行返回。

ConcurrentLinkedDeque

双端队列

pollFirst()

pollLast()

List相关

CopyOnWriteArrayList

阻塞队列

概念

阻塞队列 BlockingQueue，其实就是如果 BlockQueue 是空的，从 BlockingQueue 取东西的操作将会被阻塞进入等待状态，直到 BlockingQueue 添加进了元素才会被唤醒。同样，如果 BlockingQueue 是满的，也就是没有空余空间时，试图往队列中存放元素的操作也会被阻塞进入等待状态，直到 BlockingQueue 里有剩余空间才会被唤醒继续操作。

分类

List相关

Set相关

Queue相关

ArrayBlockingQueue

有界

PriorityBlockingQueue

LinkedBlockingQueue

无界

类似ArrayBlockingQueue

LinkedBlockingDeque

双端操作

SynchronousQueue

一种阻塞队列，其中每个插入操作必须等待另一个线程的对应移除操作，反之亦然。同步队列没有任何内部容量，甚至连一个队列的容量都没有。不能在同步队列上进行 peek，因为仅在试图要移除元素时，该元素才存在；除非另一个线程试图移除某个元素，否则也不能（使用任何方法）插入元素；也不能迭代队列，因为其中没有元素可用于迭代。类 SynchronousQueue 经常在多个线程之间传输数据时使用。

DelayQueue

LinkedTransferQueue

作用和SynchronousQueue一样

Future&Callable

作用

在默认情况下，线程 Thread 对象不具有返回值的功能，如果在需要取得返回值的情况下是极为不方便的，但在 Java1. 5 的并发包中可以使用 Future 和 Callable 来使线程具有返回值的功能。

与Runnable接口的区别

1） Callable 接口的 call（）方法可以有返回值，而 Runnable 接口的 run（）方法没有返回值。

2） Callable 接口的 call（）方法可以声明抛出异常，而 Runnable 接口的 run（）方法不可以声明抛出异常。

执行完 Callable 接口中的任务后，返回值是通过 Future 接口进行获得的。

用法

ExecutorService executorService = Executors.newSingleThreadExecutor();

Future<String> feture = executorService.submit(new MyThread());

System.out.println(feture.get());

ExecutorService 接口中的方法 submit（ Runnable，T result），第 2 个参数 result 可以作为执行结果的返回值，而不需要使用 get（）方法来进行获得。

接口 Future 的实现类是 FutureTask. java

Future.get()方法是阻塞的

isDone（）方法无阻塞特性。

方法 cancel（ boolean mayInterruptIfRunning）的参数 mayInterruptIfRunning 的作用是：如果线程正在运行则是否中断正在运行的线程，在代码中需要使用 if（ Thread. currentThread（）. isInterrupted（））进行配合。

任务在没有运行完成之前执行了 cancel（）方法返回为 true，代表成功发送取消的命令。

方法 get（ long timeout， TimeUnit unit）的作用是在指定的最大时间内等待获得返回值。

RejectedExecutionHandler

ExecutorService的execute()与submit()区别

返回值

方法 execute（）没有返回值

而 submit（）方法可以有返回值。

异常

方法 execute（）在默认的情况下异常直接抛出，不能捕获，但可以通过自定义 Thread- Factory 的方式进行捕获

submit（）方法在默认的情况下，可以 catch Execution- Exception 捕获异常。

Executor

继承关系

Executor（接口）

ExecutorService（接口）

AbstractExecutorService(抽象类)

ThreadPoolExecutor(类)

ForkJoinPool(类)

ScheduledExcutorService(抽象类)

ScheduledThreadPoolExcutor

线程池

Executors工具类

newCachedThreadPool()

使用 Executors 类的 newCachedThreadPool（）方法创建的是无界线程池，可以进行线程自动回收。所谓的“ 无界线程池” 就是池中存放线程个数是理论上的 Integer. MAX_ VALUE 最大值。

newCachedThreadPool(ThreadFactory)

定制线程工厂

MyThreadFactory implements ThreadFactory,复写newThread方法

newFixedThreadPool（int）

newFixedThreadPool（ int）创建的是有界线程池，也就是池中的线程个数可以指定最大数量。

newFixedThreadPool（ int， ThreadFactory）

newSingleThreadExecutor()

创建单一线程池

newSingleThreadExecutor（ThreadFactory）

ThreadPoolExecutor

ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue)

·corePoolSize：池中所保存的线程数，包括空闲线程，也就是核心池的大小。

maximumPoolSize：池中允许的最大线程数。

keepAliveTime：当线程数量大于 corePoolSize 值时，在没有超过指定的时间内是不从线程池中将空闲线程删除的，如果超过此时间单位，则删除。

unit： keepAliveTime 参数的时间单位。

·workQueue：执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。

shutdown()

方法 shutdown（）的作用是使当前未执行完的线程继续执行，而不再添加新的任务 Task，还有 shutdown（）方法不会阻塞，调用 shutdown（）方法后，主线程 main 就马上结束了，而线程池会继续运行直到所有任务执行完才会停止。如果不调用 shutdown（）方法，那么线程池会一直保持下去，以便随时执行被添加的新 Task 任务。

以上的文字一句话，已经接下的客人继续服务完，但是停止接客

当线程池调用 shutdown（）方法时，线程池的状态则立刻变成 SHUTDOWN 状态，此时不能再往线程池中添加任何任务，否则将会抛出 RejectedExecutionException 异常。但是，此时线程池不会立刻退出，直到线程池中的任务都已经处理完成，才会退出。

shutdownNow()

方法 shutdownNow（）的作用是中断所有的任务 Task，并且抛出 InterruptedException 异常，前提是在 Runnable 中使用 if（if（ Thread. currentThread（）. isInterrupted（）== true）语句来判断当前线程的中断状态，而未执行的线程不再执行，也就是从执行队列中清除。如果没有 if（ Thread. currentThread（）. isInterrupted（）== true）语句及抛出异常的代码，则池中正在运行的线程直到执行完毕，而未执行的线程不再执行，也从执行队列中清除。

以上文字一句话，接下的客，判断是否服务完，如果告知人家服务完，则全部清除，否则等待服务完已结客人，但不接待未接的客人

而 shutdownNow（）方法是使线程池的状态立刻变成 STOP 状态，并试图停止所有正在执行的线程（如果有 if 判断则人为地抛出异常），不再处理还在池队列中等待的任务，当然，它会返回那些未执行的任务。

isShutdown()

方法 isShutdown（）的作用是判断线程池是否已经关闭。

只要调用了 shutdown（）方法， isShutdown（）方法的返回值就是 true。

Phaser

基础部分

实现方式

继承自thread，实现run方法

实现runnable接口，实现run方法

启动

调用start方法

线程的启动具有随机性

常用API

currentThread()

获得当前线程，如果在main中调用，当前线程是main而不是被start的线程

isAlive()

判断当前线程是否处于活动状态

线程处于正在运行或准备开始运行的状态，就认为线程是“ 存活” 的。

sleep()

方法 sleep（）的作用是在指定的毫秒数内让当前“ 正在执行的线程” 休眠（暂停执行）。这个“ 正在执行的线程” 是指 this. currentThread（）返回的线程。

getId()

getId（）方法的作用是取得线程的唯一标识。

停止线程

使用退出标志，使线程正常退出，也就是当 run 方法完成后线程终止。

stop()

这个方法是不安全的（ unsafe），而且是已被弃用作废的（ deprecated）

调用 stop（）方法时会抛出 java. lang. ThreadDeath 异常，但在通常的情况下，此异常不需要显式地捕捉。

使用 interrupt() 方法中断线程。

调用 interrupt（）方法仅仅是在当前线程中打了一个停止的标记，并不是真的停止线程。

interrupt()

测试当前线程是否已经中断。线程的中断状态由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

isInterrupt()

测试线程 Thread 对象是否已经是中断状态，但不清除状态标志。

抛出InterruptedException

if (this. interrupted()) { System. out. println(" 已经是停止状态了! 我要退出了!"); throw new InterruptedException(); }

使用 return 停止线程

建议使用“ 抛异常” 的方法来实现线程的停止，因为在 catch 块中还可以将异常向上抛，使线程停止的事件得以传播。

暂停/恢复线程

suspend()

废弃的方法

缺点

此方法是独占的，如果拿到锁并且调用了线程的suspend()方法，那其他线程就再也拿不到锁，无法执行了

容易出现因为线程的暂停而导致数据不同步的情况。

resume()

yield()

放弃当前的 CPU 资源，将它让给其他的任务去占用 CPU 执行时间。但放弃的时间不确定，有可能刚刚放弃，马上又获得 CPU 时间片。

线程的优先级

setPriority()

线程的优先级分为 1~ 10 这 10 个等级，如果小于 1 或大于 10，则 JDK 抛出异常 throw new IllegalArgumentException（）。

JDK 中使用 3 个常量来预置定义优先级的值，

public final static int MIN_ PRIORITY = 1;

public final static int NORM_ PRIORITY = 5;

public final static int MAX_ PRIORITY = 10;

特性

继承特性

规律性：高优先级的线程总是先执行完

随机性：高优先级的线程不一定每一次都先执行完

线程的分类

用户线程

守护线程

守护线程是一种特殊的线程，它的特性有“ 陪伴”的含义，当进程中不存在非守护线程了，则守护线程自动销毁。

典型的守护线程就是垃圾回收线程，当进程中没有非守护线程了，则垃圾回收线程也就没有存在的必要了，自动销毁。

但是在主线程中调用守护线程.join(),那就守护不了了

对象及变量的并发访问

synchronized同步方法

方法内的变量为线程安全

实例变量非线程安全

两个线程访问同一个对象中的同步方法时一定是线程安全的

java中的锁是对象锁：如果拿到锁，则其他线程是不能调用对象中的所有synchronized方法的

synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到一个对象锁后，再次请求此对象锁时是可以再次得到该对象的锁的。这也证明在一个synchronized方法/块的内部调用本类的其他synchronized方法/块时，是永远可以得到锁的。

出现异常，锁自动释放

同步不具有继承性

synchronized同步语句块

同步方法的弊端，方法中不需要同步的代码也做了同步，增加了方法的执行时间

并发线程访问同一个对象object中的synchronized（this）同步代码块时，一段时间内只能有一个线程被执行，另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

不在synchronized块中就是异步执行，在synchronized块中就是同步执行。

当一个线程访问object的一个synchronized（this）同步代码块时，其他线程对同一个object中所有其他synchronized（this）同步代码块的访问将被阻塞，这说明synchronized使用的“对象监视器”是一个。

多个线程调用同一个对象中的不同名称的synchronized同步方法或synchronized（this）同步代码块时，调用的效果就是按顺序执行，也就是同步的，阻塞的。

synchronized同步方法

对其他synchronized同步方法或synchronized（this）同步代码块调用呈阻塞状态。

同一时间只有一个线程可以执行synchronized同步方法中的代码。

synchronized（this）同步代码块

对其他synchronized同步方法或synchronized（this）同步代码块调用呈阻塞状态。

同一时间只有一个线程可以执行synchronized（this）同步代码块中的代码。

锁非this对象

如果在一个类中有很多个synchronized方法，这时虽然能实现同步，但会受到阻塞，所以影响运行效率；但如果使用同步代码块锁非this对象，则synchronized（非this）代码块中的程序与同步方法是异步的，不与其他锁this同步方法争抢this锁，则可大大提高运行效率。

使用“synchronized（非this对象x）同步代码块”格式进行同步操作时，对象监视器必须是同一个对象。如果不是同一个对象监视器，运行的结果就是异步调用了，就会交叉运行。

同步代码块放在非同步synchronized方法中进行声明，并不能保证调用方法的线程的执行同步/顺序性，也就是线程调用方法的顺序是无序的，虽然在同步块中执行的顺序是同步的，这样极易出现“脏读”问题。

所得几种类型

对象锁

添加在方法上和代码块上的锁都是对象锁

Class锁

synchronized还可以应用在static静态方法上，如果这样写，那是对当前的*.java文件对应的Class类进行持锁

Class锁可以对类的所有对象实例起作用

在静态方法上加Synchronized 等同于 Synchoronized(this.getClass())

死锁

JAVA_HOME下执行jps列出java进程

执行jstack 进程id

volatile

关键字volatile的主要作用是使变量在多个线程间可见。

volatile的作用是强制从公共堆栈中取得变量的值，而不是从线程私有数据栈中取得变量的值。

类的成员变量存在于公共堆栈及线程的私有堆栈中。在JVM被设置为-server模式时为了线程运行的效率，线程一直在私有堆栈中取值

线程的私有堆栈

读取公共内存

关键字volatile虽然增加了实例变量在多个线程之间的可见性，但它却不具备同步性，那么也就不具备原子性。

变量在内存中的工作过程

使用原子类进行i++操作

AtomicInteger

synchronized代码块有volatile同步的功能

线程间通信

等待/通知

wait()

方法wait（）的作用是使当前执行代码的线程进行等待，wait（）方法是Object类的方法，该方法用来将当前线程置入“预执行队列”中，并且在wait（）所在的代码行处停止执行，直到接到通知或被中断为止。在调用wait（）之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait（）方法。在执行wait（）方法后，当前线程释放锁。在从wait（）返回前，线程与其他线程竞争重新获得锁。如果调用wait（）时没有持有适当的锁，则抛出IllegalMonitorStateException，它是RuntimeException的一个子类，因此，不需要try-catch语句进行捕捉异常。

wait()方法被执行后，锁立即释放

线程呈wait（）状态时，调用线程对象的interrupt（）方法会出现InterruptedException异常。

wait(1000)，等待1s，超过1s自动唤醒

当多个执行相同任务的线程，条件判断wait()的时候要用while而不能用if

当线程wait之后，又被唤醒的时候，是从wait后面开始执行，而不是又从头开始执行的，所以如果用if的话，被唤醒之后就不会在判断if中的条件，而是继续往下执行了

notify()

notify（）也要在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的对象级别锁。如果调用notify（）时没有持有适当的锁，也会抛出IllegalMonitorStateException。该方法用来通知那些可能等待该对象的对象锁的其他线程，如果有多个线程等待，则由线程规划器随机挑选出其中一个呈wait状态的线程对其发出通知notify，并使它等待获取该对象的对象锁。

需要说明的是，在执行notify（）方法后，当前线程不会马上释放该对象锁，呈wait状态的线程也并不能马上获取该对象锁，要等到执行notify（）方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才会释放锁，而呈wait状态所在的线程才可以获取该对象锁。

notify()方法执行后，不自动释放，必须执行完notify()方法所在的同步synchronized代码块后才释放锁。

notifyAll()唤醒所有线程

线程状态切换图

两个队列

就绪队列

存储将要获得锁的线程

被notify()并且拿到锁的线程

阻塞队列

存储被阻塞的线程

调用wait()的线程

不同线程间直接传送数据

字节流

PipedInputStream

PipedOutputStream

字符流

PipedReader

PipedWriter

join

作用：创建子线程的主线程，必须等待子线程执行完毕，或销毁后后，才能够提前执行完成

thread.join()

join（long）中的参数是设定等待的时间

方法join（long）的功能在内部是使用wait（long）方法来实现的，所以join（long）方法具有释放锁的特点。

ThreadLocal

作用：解决的就是每个线程绑定自己的值，可以将ThreadLocal类比喻成全局存放数据的盒子，盒子中可以存储每个线程的私有数据。

ThreadLocal threadLocal = new ThreadLocal(); threadLocal.set("tes value"); threadLocal.get();

解决threadLocal初始化get()为null的问题

继承自ThreadLocal类，复写initialValue()方法

InheritableThreadLocal

以在子线程中取得父线程继承下来的值。

Lock的使用

ReentrantLock

调用ReentrantLock对象的lock（）方法获取锁，调用unlock（）方法释放锁。

基本用法

ReentrantLock lock = new ReentrantLock();

lock.lock();

//do something else.

lock.unlock();

Condition

Condition类是在JDK5中出现的技术，使用它有更好的灵活性，比如可以实现多路通知功能，也就是在一个Lock对象里面可以创建多个Condition（即对象监视器）实例，线程对象可以注册在指定的Condition中，从而可以有选择性地进行线程通知，在调度线程上更加灵活。

Condition condition = lock.newCondition();

condition.wait()

Object类中的wait（）方法相当于Condition类中的await（）方法。

Object类中的wait（longtimeout）方法相当于Condition类中的await（longtime，TimeUnitunit）方法。

condition.signal()

Object类中的notify（）方法相当于Condition类中的signal（）方法。

Object类中的notifyAll（）方法相当于Condition类中的signalAll（）方法。

公平锁和非公平锁

公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序。

非公平锁就是一种获取锁的抢占机制，是随机获得锁的，和公平锁不一样的就是先来的不一定先得到锁，这个方式可能造成某些线程一直拿不到锁，结果也就是不公平的了。

new ReentrantLock（isFair）

ReentrantReadWriteLock

共享锁

关系

读操作相关的锁

读锁之间不互斥

读锁与写锁互斥

使用

ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

lock.readLock().lock();

// do something else.

lock.readLock().unlock();

排它锁

关系

写操作相关的锁

写锁与写锁互斥

使用

ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

lock.writeLock().lock();

// do something else.

lock.writeLock().unlock();