一、wait/notify原理
1、锁的拥有者发现条件不满足，调用wait方法，进入WaitSet中变为Wating状态；
2、blocked与waiting的线程都处于阻塞状态，不占用cpu时间片；
3、blocked线程会在owner线程释放锁时唤醒；
4、waiting线程会在owner线程调用notify或notifyAll时唤醒，但唤醒后并不是立即获得锁，仍然需要进入EntryList中重新竞争；
注意：wait、notify、notifyAll都属于Object对象的方法，必须获得此对象的锁，才能调用这几个方法；
二、sleep(long n) 与 wait(long n)的区别
1、sleep是Thread方法，而wait是Object的方法；
2、sleep不需要强制和synchronized配合使用，但wait需要和synchronized一起用；
3、sleep在睡眠的同时，不会释放对象锁，但wait会释放对象锁；
相同点：状态都为Timed_waiting;
虚假唤醒：
有多个线程在等待，notify方法随机挑一个唤醒，可能唤醒了不该唤醒的线程（可通过whille解决）。
三、同步模式之保护性暂停模式
即 Guarded Suspension, 用在一个线程等待另一个线程执行结果。
要点：
1、有一个结果需要从一个线程传递到另一个线程，让他们关联同一个GuardedObject；
2、如果有结果不断从一个线程到另一个线程，那么可以可以使用消息队列(生产者/消费者)；
3、JDK中，join的实现，Future的实现，采用的就是此模式；
4、因为要等待另一方的结果，因此归类到同步模式；
示例代码如下：
// 增加超时效果
class GuardedObject{
// 标识Garded Object
private int id;
public GuardedObject(int id) {
this.id = id;
}
public int getId(){
return id;
}
// 结果
private Object response;
// 获取结果
public Object get(long timeout){
synchronized (this){
// 开始时间
long begin = System.currentTimeMillis();
// 经历的时间
long passedTime = 0;
// 没有结果
while(response == null){
// 这一轮循环应该等待的时间
long waitTime = timeout - passedTime;
// 经历的时间>超时时间，退出循环
if(waitTime <= 0){
break;
}
try{
this.wait(waitTime); // 存在虚假唤醒
}catch (Exception e){
e.printStackTrace();
}
// 求得经历时间
passedTime = System.currentTimeMillis() - begin;
}
}
return response;
}
// 产生结果
public void complete(Object response){
synchronized (this){
// 给结果成员变量赋值
this.response = response;
this.notifyAll();
}
}
}
四、join原理
底层调用wait方法，应用保护暂停模式；
源码如下：
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) {
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
五、生产者消费者模式
要点：
1、与前面的保护性暂停中GuardObject不同，不需要产生结果和消费结果的线程一一对应；
2、消费队列可以用来平衡生产和消费的线程资源；
3、生产者仅仅负责产生结果数据，不关心数据该如何处理，而消费者专心处理结果数据；
4、消息队列是有容量限制的，满时不会再加入数据，空时不会再消耗数据；
5、JDK中各种阻塞队列，采用的就是这种模式；
代码如下：
package com.concurrent.test;
import java.util.LinkedList;
public class Test12 {
public static void main(String[] args) {
MessageQueue queue = new MessageQueue(2);
for (int i = 0; i < 3; i++) {
int id = i;
new Thread(() -> {
queue.put(new Message(id, "值"+id));
}, "生产者" + i).start();
}
new Thread(() -> {
while(true) {
try {
Thread.sleep(1000);
Message message = queue.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "消费者").start();
}
}
// 消息队列类，java线程之间通信
class MessageQueue{
// 消息队列集合
private LinkedList<Message> list = new LinkedList<>();
// 消息队列容量
private int capcity;
public MessageQueue(int capcity) {
this.capcity = capcity;
}
// 获取消息
public Message take() {
// 检查队列是否为空
synchronized (list){
while(list.isEmpty()){
try {
System.out.println("队列为空，消费者线程等待");
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 从队列的头部获取消息返回
Message message = list.removeFirst();
list.notifyAll();
return message;
}
}
// 存入消息
public void put(Message message) {
synchronized (list){
// 检查队列是否已满
while(list.size() == capcity){
try {
System.out.println("队列已满，生产者线程等待");
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 将消息加入队列尾部
list.addLast(message);
list.notifyAll();
}
}
}
final class Message{
private int id;
private Object value;
public Message(int id, Object value) {
this.id = id;
this.value = value;
}
public int getId() {
return id;
}
public Object getValue() {
return value;
}
@Override
public String toString() {
return "Message{" +
"id=" + id +
", value=" + value +
'}';
}
}
六、LockSupport的park()与unPark()
与Object的wait¬ify相比
1、wait,notify,notifyAll必须配合Object Monitor一起使用(必须要获得锁)，而park,unpark不必；
2、park & unpark是以线程为单位来“阻塞”和“唤醒”线程的，而notify只能随机唤醒一个等待线程，notifyAll是唤醒所有等待线程，就不那么“精确”；
3、park & unpark可以先unpark,而wait & notify 不能先notify；
原理 park & unpark
每个线程都有一个自己的Parker对象，由3部分组成_counter,_cond和mutex。
1、当线程先调用park,再调用unpark
1、当前线程调用Unsafe.park()方法
2、检查_counter, 本情况为0,这时,获得_mutex互斥锁
3、线程进入_cond条件变量阻塞
4、设置_counter = 0
1、当前线程调用Unsafe.unpark()方法,设置_counter为1
2、唤醒_cond条件变量中Thread
3、Thread恢复运行
4、设置_counter为0
2、当线程先调用unpark,再调用park
1、调用Unsafe.unpark(),设置_counter为1
2、当前线程调用Unsafe.park()
3、检查_counter,本情况为1,这时线程无需阻塞，继续运行
4、设置_counter为0
七、java线程状态转换
情况1 new --> runnable
当调用了t.start()方法
情况2 runnable --> waiting
t线程调用synchronized(obj)获取了对象锁后：
调用obj.wait()方法，t线程从runnable --> waiting
调用obj.notify(), obj.notifyAll(),t.interrupt()时
竞争锁成功，t线程从 waiting --> runnable
竞争锁失败，t线程从 waiting --> blocked
情况3 runnable --> waiting
当前线程调用t.join()方法时，当前线程从runnable --> waiting
注意是当前线程在t线程对象的监视器上等待
t线程运行结束，或调用了当前线程的interrupt()时，当前线程从waiting–>runnable
情况4 runnable --> waiting
当前线程调用LockSupport.park()方法会让当前线程从runnable --> waiting
调用LockSupport.unpark()或调用了线程的interrupt(), 会让目标线程从 waiting --> runnable
情况5 runnable --> timed_waiting
t线程用syncronized(obj)获取了对象锁之后
调用obj.wait(long n)方法时，t线程从 runnable --> timed_waiting
t线程等待时间超过了n毫秒，或调用了obj.notify(), obj.notifyAll(), t.interrupt()时
竞争锁成功，t线程从 timed_waiting --> runnable
竞争锁失败，t线程从 timed_waiting --> blocked
情况6 runnable --> timed_waiting
当前线程调用t.join(long n) 方法时，当前线程从runnable–>timed_waiting
注意是当前线程在t线程对象的监视器上等待
当前线程等待时间超过了n毫秒，或t线程运行结束，或调用了当前线程的interrupt(),当前线程从timed_waiting --> runnable
情况7 runnable --> timed_waiting
当前线程调用Thread.sleep(long n), 当前线程从 runnable --> timed_waiting
当前线程等待时间超过了n毫秒，当前线程从timed_waiting --> runnable
情况8 runnable --> timed_waiting
当前线程调用LockSupport.parkNanos(long nanos)或LockSupport.parkUntil(long millis)时，当前线程从 runnable --> timed_waiting
调用LockSupport.unpark(目标线程)或调用了线程的interrupt(), 或是等待超时，会让目标线程从timed_waiting --> runnable
情况9 runnable --> blocked
t线程用synchronized(obj)获取对象锁时，如果竞争失败，从runnable --> blocked
持obj锁线程的同步代码块执行完毕，会唤醒该对象上所有blocked的线程重新竞争，如果其中t线程竞争成功，从blocked–>runnable,其它失败的线程仍然blocked
情况10 runnable --> terminated
当前线程所有代码运行完毕，进入terminated
八、死锁与活锁
定位死锁
可以使用jconsole工具，或者使用jps定位进程id, 再用jstack定位死锁；
活锁
多个线程，同时对同一个变量做操作(例如一个+，一个-)，导致程序不能结束；
可以错开两个线程的执行，sleep一会；
九、ReentrantLock
相对于synchronized，它具备以下特点：
1、可中断(lock.lockInterruptibly(), 使用interrupt()打断)
2、可以设置超时时间(lock.tryLock(2, TimeUnit.SECONDS)；（注意：带参数的tryLock可以被中断)
3、可以设置为公平锁
4、支持多个条件变量
5、与synchronized一样，都支持可重入
基本语法：
// 获取锁
reentrantLock.lock();
try{
// 临界区
} finally {
// 释放锁
reentrantLock.unlock();
}
条件变量
synchronized中也有条件变量，就是waitSet，当条件不满足时进入waitSet等待；
ReentrantLock的条件变量比synchronized强大之处在于，它是支持多个条件变量的，这就好比synchronized是那些不满足条件的线程都在同一间休息室休息。而ReentrantLock支持多间休息室，唤醒时也是按照休息室来唤醒。
使用流程
1、await前需要获取锁；
2、await执行后，会释放锁，进入conditionObject等待；
3、await的线程被唤醒(或打断，或超时)去重新竞争lock锁；
4、竞争lock锁成功后，从wait后继续执行；
(注意：waitSet中的线程状态是waiting, 而EntryList中的线程状态是blocked)
十、固定顺序输入
顺序输出 abc，输出5次：
// 方法一：使用synchronized
public class Test16 {
private static String flag = "a";
public static void main(String[] args) {
Test16 test = new Test16();
new Thread(() -> {test.print(5, "a", "b");}).start();
new Thread(() -> {test.print(5, "b", "c");}).start();
new Thread(() -> {test.print(5, "c", "a");}).start();
}
public void print(int loopNumber, String cur, String next){
for(int i = 0; i < loopNumber; i++){
synchronized (this){
while(!flag.equals(cur)){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print(cur);
flag = next;
this.notifyAll();
}
}
}
}
---------------------------------------------------------------------------------------
// 方法二：使用ReentrantLock
package com.concurrent.test;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class Test17 {
public static void main(String[] args) throws InterruptedException {
AwaitSingle awaitSingle = new AwaitSingle(5);
Condition condition1 = awaitSingle.newCondition();
Condition condition2 = awaitSingle.newCondition();
Condition condition3 = awaitSingle.newCondition();
new Thread(() -> {awaitSingle.print(condition1, condition2, "a");}).start();
new Thread(() -> {awaitSingle.print(condition2, condition3, "b");}).start();
new Thread(() -> {awaitSingle.print(condition3, condition1, "c");}).start();
TimeUnit.SECONDS.sleep(1);
awaitSingle.lock();
try{
System.out.println("开始打印：");
condition1.signal();
}finally {
awaitSingle.unlock();
}
}
}
class AwaitSingle extends ReentrantLock {
private int loopNumber;
public AwaitSingle(int loopNumber) {
this.loopNumber = loopNumber;
}
public void print(Condition cur, Condition next, String curString){
for (int i = 0; i < loopNumber; i++) {
lock();
try {
cur.await();
System.out.print(curString);
next.signal();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
unlock();
}
}
}
}
---------------------------------------------------------------------------------------
// 方法三：使用park & unpark
package com.concurrent.test;
import java.util.concurrent.locks.LockSupport;
public class Test18 {
static Thread t1 = null;
static Thread t2 = null;
static Thread t3 = null;
public static void main(String[] args) {
ParkUnPark parkUnPark = new ParkUnPark(5);
t1 = new Thread(() -> {parkUnPark.print("a", t2);}, "t1");
t2 = new Thread(() -> {parkUnPark.print("b", t3);}, "t2");
t3 = new Thread(() -> {parkUnPark.print("c", t1);}, "t3");
t1.start();
t2.start();
t3.start();
LockSupport.unpark(t1);
}
}
class ParkUnPark{
private int loopNumber;
public ParkUnPark(int loopNumber) {
this.loopNumber = loopNumber;
}
public void print(String curString, Thread next){
for (int i = 0; i < loopNumber; i++) {
LockSupport.park();
System.out.print(curString);
LockSupport.unpark(next);
}
}
}
扫一扫
511
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
