重量级锁竞争的时候,还可以使用自旋来进行优化,如果当前线程自旋成功(即这时候持锁线程已经退出了同步块,释放了锁),这时当前线程就可以避免阻塞。 自旋重试成功的情况
自旋重试失败的情况
轻量级锁在没有竞争时(就自己这个线程),每次重入任然需要执行CAS操作。 Java6中引入了偏向锁来做进一步优化 :只有第一次使用CAS将线程ID设置到对象的Mark Word头,之后发现这个线程ID是自己的就表示没有竞争,不用重新CAS。以后只要不发生竞争,这个对象就归该线程所有 例如 :
偏向状态 回忆一下对象头格式
一个对象创建时 :
输出
注意 处于偏向锁的对象解锁后,线程id任存储于对象头中 3)测试禁用 在上面测试代码运行时在添加VM参数 -xx: -UseBiasedLocking禁用偏向锁 输出
4)测试hashcode 调用hashcode以后,会禁用偏向锁,因为对象头中没有地方存储偏向锁的线程id了。(hashcode为31位,thread为54位) 调用了对象的hashCode,但偏向锁的对象MarkWord中存储的是线程id,如果调用hashCode会导致偏向锁被撤销
输出
当有其它线程使用偏向锁对象时,会将偏向锁升级为轻量级锁
如果对象虽然被多个线程访问,但没有竞争,这时偏向了线程T1的对象仍有机会重新偏向T2,重新偏向重置对象的Thread ID 当撤销偏向锁阈值超过20次后,jvm会这样觉得,我是不是偏向错了,于是会在给这些对象加锁时重新偏向至加锁线程
当撤销偏向锁阀值超过40次后,jvm会这样觉得,自己确实偏向错了,根本就不该偏向。于是整个类的所有对象都会变为不可偏向的,新建的对象也是不可偏向的
锁消除
sleep(long n)和wait(long n)的区别 1)sleep是Thread方法,而wait是Object的方法 2)sleep不需要强制和synchronized配合使用,但wait需要和synchronized一起用 3)sleep在睡眠的同时,不会释放对象锁的,但wait在等待的时候会释放对象锁 4)它们状态都是TIMED_WAITING
wait和notify正确使用姿势
即Guarded Suspension,用在一个线程待得另一个线程的执行结果 要点
要点
package com.example.demo;
import lombok.extern.slf4j.Slf4j;
import java.util.LinkedList;
@Slf4j()
public class Test1 {
public static void main(String[] args) {
MessageQueue messageQueue = new MessageQueue(2);
for (int i = 0; i < 3; i++) {
int id = i;
new Thread(() -> {
messageQueue.put(new Message(id, "值" + id));
}, "生产者" + i).start();
}
new Thread(() -> {
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Message take = messageQueue.take();
}
}, "消费者").start();
}
}
/**
* 消息队列类,java线程之间通信
*/
@Slf4j(topic = "cn.Message")
class MessageQueue {
/**
* 消息的队列集合
*/
private LinkedList<Message> linkedList = new LinkedList<>();
/**
* 队列容量
*/
private int capcity;
public MessageQueue(int capcity) {
this.capcity = capcity;
}
/**
* 获取消息
*/
public Message take() {
// 检查对象是否为空
synchronized (linkedList) {
while (linkedList.isEmpty()) {
try {
log.info("队列为空,消费者线程等待");
linkedList.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 从队列头部获取消息并返回
Message message = linkedList.removeFirst();
log.info("已消费消息 : {}", message);
linkedList.notifyAll();
return message;
}
}
/**
* 存入消息
*/
public void put(Message message) {
synchronized (linkedList) {
// 检查对象是否已满
while (linkedList.size() == capcity) {
try {
log.info("队列已满,生产者线程等待");
linkedList.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 将消息添加到队列的尾部
linkedList.addLast(message);
log.info("已生产消息 : {}", message);
linkedList.notifyAll();
}
}
}
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相比
每个线程都有自己的一个Parker对象,由三部分组成_counter,_cond和_mutex打个比喻
假设有线程Thread t
情况1 New --》RUNNABLE
情况2 RUNNABLE < – > WAITING t 线程用synchronized(obj)获取了对象锁后
情况3 RUNNABLE < – > WAITING
情况4 RUNNABLE < – > WAITING
情况5 RUNNABLE < – > TIMED_WAITING t线程用synchronized(obj)获取了对象锁后
情况6 RUNNABLE < – > TIMED_WAITING
情况7 RUNABLE < – > TIMED_WAITING
情况8 RUNNABLE < – > TIMED_WAITING
情况9 RUNNABLE <–>BLOCKED
情况10 RUNNABLE < – > TERMINATED 当前线程所有代码运行完毕,进入TERMINATED