haoranhaoshi的博客

ReentrantLock实现了Lock，初始化时可选择FairSync、NonfairSync。Sync继承了AbstractQueuedSynchronizer。AbstractQueuedSynchronizer的state：0表示未持有锁、>=1表示持有锁、>1表示锁被重入。AbstractQueuedSynchronizer用双向链表存储抢占锁的Node（AbstractQueuedSynchronizer的静态内部类，存有前驱Node、后继Node、线程）。 // Reentran

delay时长后执行一次任务。TimeUnit是时间单位枚举。 public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);delay时长后执行一次有返回值的任务。 public <V> ScheduledFuture<V> schedule(Callable<V

线程池的目标是线程复用。public ThreadPoolExecutor(int corePoolSize, //核心线程数量 int maximumPoolSize, //最大线程数 long keepAliveTime, //空闲线程的存活时间，超过空闲时间上限就销毁线程,默认是针对临时线程，allowCoreThreadTimeOut(true)时也控制核心线程 TimeUnit unit, //存活时间单位 BlockingQueue<Runnable> workQueu

import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;import java.util.concurrent.TimeUnit;import java.util.concurrent.TimeoutException;/** * @Author: ZhangHao * @Description: FutureTask测试 * @Date: 2020/11/6 15:44 .

先上实例：/** * @Author: ZhangHao * @Description: RetryTest * @Date: 2020/11/4 20:11 * @Version: 1.0 */public class RetryTest { public static void main(String[] args) { // retry:后必须紧跟for循环 retry: for(int l = 0;l < 3;l++)

Semaphore（信号量）初始化时设置许可证数量，还可以设置是否使用公平锁，默认使用非公平锁。acquire()申请许可证，没有许可证可用就等待。release()释放许可证。release(int permits)释放permits个许可证。下面以占车位为例展示Semaphore：public class SemaphoreDemo { public static void main(String[] args) { // 10个司机，5个车位 Se.

CountDownLatch初始化时设置等待数量，countDown()可以减1，await()在等待数量大于0时会使线程等待。下面以跑步比赛为例展示CountDownLatch：public class CountDownLatchDemo { /** * 运动员数量 */ private static int athleteCount = 10; /** * 所有运动员准备起跑，同一把发令枪 */ private s.

阻塞队列（BlockingQueue）是一个支持阻塞操作的队列。在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列能存储元素。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。阻塞队列提供了四种处理方法（Queue接口中没有一直阻塞和超时退出对应的方法）:方法\处理方式 抛出异常 返回特殊值 一直阻塞 超时退出 插入方法 a

消费者：public class Consumer implements Runnable{ private Queue<String> messageQueue; private Lock lock; private Condition condition; public Consumer(Queue<String> messageQueue, Lock lock, Condition condition) { this.me

Java内存模型（Java Memory Model，JMM）涉及JVM主内存（Main Memory）和线程本地内存（Thread Local Memory）或者称线程工作内存。JMM用来屏蔽Java程序在不同的硬件和操作系统上访问内存的差异，定义Java程序中变量的访问规则。JVM的堆内存在主内存中。方法区在持久代实践时在主内存中；在元空间实践时不在主内存中，在直接内存或者称堆外内存中，被操作系统直接管理。JVM的栈或者称虚拟机栈、本地方法栈、程序计数器是线程私有的，对应内存在线程工作内存中。

死锁、活锁、饥饿、无锁针对线程或进程。以下以线程为例。死锁：线程相互等待锁释放。举例：（1）A、B锁是独占锁。甲线程已获取A锁，想获取B锁后释放A锁；乙线程已获取B锁，想获取A锁后释放B锁。二者等待对方释放自己想获取的锁，自己却不释放对方想获取的锁，就会造成死锁，甲乙线程皆会一直阻塞。预防：（1）有序资源分配算法：规定锁获取顺序，必须获取A锁后才能去获取B锁。（2）银行家算法：独占锁不被占有时，才能去尝试获取。活锁：线程获取锁后不执行后续逻辑就释放锁。举例：（1）甲线程获取锁后总会执

Object：wait()相当于wait(0)，无超时时间。wait(long timeout)，timeout单位毫秒。wait(long timeout, int nanos)，timeout单位毫秒，nanos为增加的纳秒。Thread：sleep(long millis)，timeout单位毫秒。sleep(long millis, int nanos)，timeout单位毫秒，nanos为增加的纳秒。join(long millis)join(long millis, int n

可重入锁：获取锁后再次请求获取同一把锁，不再抢占锁，而是只增加获得锁的次数。synchronized、ReentrantLock是可重入锁。公平锁：按照线程抢占锁的顺序使线程获得锁。非公平锁：不按照线程抢占锁的顺序使线程获得锁。线程是否能抢占锁和线程抢占锁的顺序无关，随机抢占。ReentrantLock默认是非公平锁。 /** * Creates an instance of {@code ReentrantLock}. * This is equivalent

import org.junit.jupiter.api.Test;import java.util.concurrent.atomic.AtomicInteger;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * @Author: ZhangHao * @Description: ReentrantLock测试相关 * @Date: 2020/10/1.

public class VolatileTest { private static boolean stop = false; public static void main(String[] args) { Thread thread = new Thread(() -> { System.out.println("start"); long i = 0; System.out.pr...

消费者：public class Consumer implements Runnable { private Queue<String> messageQueue; public Consumer(Queue<String> messageQueue) { this.messageQueue = messageQueue; } @Override public void run() { while (

例1：java.util.concurrent.LinkedBlockingQueue将队列头取出数据和队尾插入数据分离成两个锁，而不是取出数据和插入数据抢占同一个锁。锁分离可以提升性能。private final ReentrantLock takeLock = new ReentrantLock();private final ReentrantLock putLock = new ReentrantLock();例2：java.util.concurrent.ConcurrentH

jvm源码(biasedLocking.cpp)解析的偏向锁升级流程(忽略一些细节)。示例中:线程1当前拥有偏向锁对象,线程2是需要竞争到偏向锁。线程2来竞争锁对象; 判断当前对象头是否是偏向锁; 判断拥有偏向锁的线程1是否还存在; 线程1不存在,直接设置偏向锁标识为0(线程1执行完毕后,不会主动去释放偏向锁); 使用cas替换偏向锁线程ID为线程2,锁不升级，仍为偏向锁; 线程1仍然存在,暂停线程1； 设置锁标志位为00(变为轻量级锁),偏向锁为0; 从线程1的空闲monitor..

锁升级：偏向锁、轻量级锁、重量级锁的过渡。https://blog.youkuaiyun.com/haoranhaoshi/article/details/92388612优先尝试低级锁，不能适用，就升级锁。线程获取到不被其他线程获取的监视类或对象，监视类或对象头部记录线程ID，线程退出对监视类或对象的获取时直接退出，是偏向锁。如果有其他线程来获取监视类或对象，发现头部记录的线程ID不是自己的ID（https://blog.youkuaiyun.com/haoranhaoshi/article/details/10850.

锁粗化：JIT编译时扩大锁定区域，避免对同一个类或对象频繁加锁、释放锁。例1：public void doMethod(){ synchronized(lock){ //do 1 } synchronized(lock){ //do 2 } synchronized(lock){ //do 3 }}public void doMethod(){ synchronized(lock){

CAS是英文单词Compare And Swap的缩写，翻译过来就是比较并替换。CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。更新一个变量的时候，只有当变量的预期值A和内存地址V当中的实际值相同时，才会将内存地址V对应的值修改为B。这样说或许有些抽象，我们来看一个例子：1.在内存地址V当中，存储着值为10的变量。image2.此时线程1想要把变量的值增加1。对线程1来说，旧的预期值A=10，要修改的新值B=11。image3.在线程1要

指令重排序，包括编译器重排序和处理器重排序（指令级并行技术或缓存）（https://blog.youkuaiyun.com/yjp198713/article/details/78839698）。单例模式中的双重校验锁方式（https://www.runoob.com/design-pattern/singleton-pattern.html）加了volatile关键字防止private volatile static Singleton singleton; 和new Singleton()的内存分配指令重.

/** * @Author: ZhangHao * @Description: join测试 * @Date: 2020/7/27 8:45 * @Version: 1.0 */public class JoinTest { public static void main(String[] args) throws InterruptedException { TestThread testThread1 = new TestThread("1"); T.

上源码：public static final int MIN_PRIORITY = 1;public static final int NORM_PRIORITY = 5;public static final int MAX_PRIORITY = 10;private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContex

/** * @Author: ZhangHao * @Description: ThreadTest * @Date: 2020/3/30 14:14 * @Version: 1.0 */public class ThreadTest { static Thread thread; public static void main(String[] args) { ...

转载自：http://blog.sina.com.cn/s/blog_68f262210100j61q.html通俗的解释一个系统运行着很多进程，可以比喻为一条马路上有很多马车不同的进程可以理解为不同的马车而同一辆马车可以有很多匹马来拉----这些马就是线程假设道路的宽度恰好可以通过一辆马车道路可以认为是临界资源那么马车成为分配资源的最小单位（进程）而同一个马车被很...

重量级锁如果你学过多线程，那么你肯定知道锁这个东西，至于为什么需要锁，我就不给你普及了，就当做你是已经懂的了。我们知道，我们要进入一个同步、线程安全的方法时，是需要先获得这个方法的锁的，退出这个方法时，则会释放锁。如果获取不到这个锁的话，意味着有别的线程在执行这个方法，这时我们就会马上进入阻塞的状态，等待那个持有锁的线程释放锁，然后再把我们从阻塞的状态唤醒，我们再去获取这个方法的锁。这...

同步容器在 Java 中，同步容器主要包括 2 类：Vector、Stack、HashTable Vector 实现了 List 接口，Vector 实际上就是一个数组，和 ArrayList 类似，但是 Vector 中的方法都是 synchronized 方法，即进行了同步措施。 Stack 也是一个同步容器，它的方法也用 synchronized 进行了同步，它实际上是继承于 V...

包括如下：常规的误区同步和异步阻塞和非阻塞阻塞和等待两两组合I/O阻塞IO和非阻塞IO同步IO和同步阻塞IO异步IO和异步阻塞/非阻塞IO常规的误区：假设有一个展示用户详情的需求，分两步，先调用一个HTTP接口拿到详情数据，然后使用适合的视图展示详情数据。如果网速很慢，代码发起一个HTTP请求后，就卡住不动了，直到十几秒后才拿到HTTP响应，然后继续...