复习-JavaGuide-并发 on 随记

Atomic预备知识

Fri, 03 Feb 2023 11:04:33 +0000

Java实现CAS的原理[非javaguide]#

i是非线程安全的，因为**i不是原子操作；可以使用synchronized和CAS实现加锁**

synchronized是悲观锁，一旦获得锁，其他线程进入后就会阻塞等待锁；而CAS是乐观锁，执行时不会加锁，假设没有冲突，如果因为冲突失败了就重试，直到成功

乐观锁和悲观锁
- 这是一种分类方式
- 悲观锁，总是认为每次访问共享资源会发生冲突，所以必须对每次数据操作加锁，以保证临界区的程序同一时间只能有一个线程在执行
- 乐观锁，又称**“无锁”**，假设对共享资源访问没有冲突，线程可以不停的执行，无需加锁无需等待；一旦发生冲突，通常是使用一种称为CAS的技术保证线程执行安全
  - 无锁没有锁的存在，因此不可能发生死锁，即乐观锁天生免疫死锁
  - 乐观锁用于**“读多写少”的环境，避免加锁频繁影响性能；悲观锁用于“写多读少”，避免频繁失败及重试**影响性能
CAS概念，即CompareAndSwap ，比较和交换，CAS中，有三个值（概念上）
V：要更新的变量(var)；E：期望值（expected）；N：新值（new）判断V是否等于E，如果等于，将V的值设置为N；如果不等，说明已经有其它线程更新了V，则当前线程放弃更新，什么都不做。一般来说，预期值E本质上指的是“旧值”（判断是否修改了）
1. 如果有一个多个线程共享的变量i原本等于5，我现在在线程A中，想把它设置为新的值6;
2. 我们使用CAS来做这个事情；
3. （首先要把原来的值5在线程中保存起来）
4. 接下来是原子操作：首先我们用（现在的i）去与5对比，发现它等于5，说明没有被其它线程改过，那我就把它设置为新的值6，此次CAS成功，i的值被设置成了6；
5. 如果不等于5，说明i被其它线程改过了（比如现在i的值为2），那么我就什么也不做，此次CAS失败，i的值仍然为2。

其中i为V，5为E，6为N

CAS是一种原子操作，它是一种系统原语，是一条CPU原子指令，从CPU层面保证它的原子性（不可能出现说，判断了对比了i为5之后，正准备更新它的值，此时该值被其他线程改了）

当多个线程同时使用CAS操作一个变量时，只有一个会胜出，并成功更新，其余均会失败，但失败的线程并不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作。

Java实现CAS的原理 - Unsafe类

在Java中，如果一个方法是native的，那Java就不负责具体实现它，而是交给底层的JVM使用c或者c++去实现

Java中有一个Unsafe类，在sun.misc包中，里面有一些native方法，其中包括：

boolean compareAndSwapObject(Object o, long offset,Object expected, Object x);
boolean compareAndSwapInt(Object o, long offset,int expected,int x);
boolean compareAndSwapLong(Object o, long offset,long expected,long x);


//------>AtomicInteger.class

public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;

// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

static {
 try {
 valueOffset = unsafe.objectFieldOffset
 (AtomicInteger.class.getDeclaredField("value"));
 } catch (Exception ex) { throw new Error(ex); }
}

private volatile int value;
public final int getAndIncrement() {
	return unsafe.getAndAddInt(this, valueOffset, 1);

}

memory-area

Wed, 07 Dec 2022 13:49:39 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

如果没有特殊说明，针对的都是HotSpot虚拟机

前言#

对于Java程序员，虚拟机自动管理机制，不需要像C/C++程序员为每一个new 操作去写对应的delete/free 操作，不容易出现内存泄漏 和 内存溢出问题
但由于内存控制权交给Java虚拟机，一旦出现内存泄漏和溢出方面问题，如果不了解虚拟机是怎么样使用内存，那么很难排查任务

运行时数据区域#

Java虚拟机在执行Java程序的过程中，会把它管理的内存，划分成若干个不同的数据区域

JDK1.8之前：

线程共享堆，方法区【永久代】(包括运行时常量池)
线程私有虚拟机栈、本地方法栈、程序计数器
本地内存(包括直接内存)

JDK1.8之后：
1.8之后整个永久代改名叫"元空间"，且移到了本地内存中

规范（概括）：
线程私有：程序计数器，虚拟机栈，本地方法栈

线程共享：堆，方法区，直接内存（非运行时数据区的一部分）

Java虚拟机规范对于运行时数据区域的规定是相当宽松的，以堆为例：

堆可以是连续，也可以不连续

大小可以固定，也可以运行时按需扩展

虚拟机实现者可以使用任何垃圾回收算法管理堆，设置不进行垃圾收集

程序计数器#

是一块较小内存空间，看作是当前线程所执行的字节码的行号指示器
java程序流程
字节码解释器，工作时通过改变这个计数器的值来选取下一条需要执行的字节码指令

分支、循环、跳转、异常处理、线程恢复等功能都需要依赖这个计数器
而且，为了线程切换后恢复到正确执行位置，每条线程需要一个独立程序计数器，各线程计数器互不影响，独立存储，我们称这类内存区域为**“线程私有”**的内存
总结，程序计数器的作用
- 字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制
- 多线程情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切回来的时候能够知道该线程上次运行到哪
程序计数器是唯一一个不会出现OutOfMemoryError的内存区域，它的生命周期随线程创建而创建，线程结束而死亡

Java虚拟机栈#

Java虚拟机栈，简称"栈"，也是线程私有的，生命周期和线程相同，随线程创建而创建，线程死亡而死亡
除了Native方法调用的是通过本地方法栈实现的，其他所有的Java方法调用都是通过栈来实现的（需要和其他运行时数据区域比如程序计数器配合）
方法调用的数据需要通过栈进行传递，每一次方法调用都会有一个对应的栈帧被压入栈，每一个方法调用结束后，都会有一个栈帧被弹出。
栈由一个个栈帧组成，每个栈帧包括局部变量表、操作数栈、动态链接、方法返回地址。栈为先进后出，且只支持出栈和入栈

局部变量表：存放编译器可知的各种数据类型(boolean、byte、char、short、int、float、long、double)、对象引用(reference 类型，不同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是一个指向一个代表对象的句柄或其他与此对象相关的位置)
操作数栈作为方法调用的中转站使用，用于存放方法执行过程中产生的中间计算结果。计算过程中产生的临时变量也放在操作数栈中
动态链接主要服务一个方法需要调用其他方法的场景。

在 Java 源文件被编译成字节码文件时，所有的变量和方法引用都作为符号引用（Symbilic Reference）保存在 Class 文件的常量池里。当一个方法要调用其他方法，需要将常量池中指向方法的符号引用转化为其在内存地址中的直接引用。动态链接的作用就是为了将符号引用转换为调用方法的直接引用。

completablefuture-intro

Tue, 06 Dec 2022 17:13:41 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

Java8被引入的一个非常有用的用于异步编程的类【没看】

简单介绍#

CompletableFuture同时实现了Future和CompletionStage接口

public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
}

CompletableFuture 除了提供了更为好用和强大的 Future 特性之外，还提供了函数式编程的能力。

Future接口有5个方法：

boolean cancel(boolean mayInterruptIfRunning) ：尝试取消执行任务。
boolean isCancelled() ：判断任务是否被取消。
boolean isDone() ：判断任务是否已经被执行完成。
get() ：等待任务执行完成并获取运算结果。
get(long timeout, TimeUnit unit) ：多了一个超时时间。

CompletionStage<T> 接口中的方法比较多，CompoletableFuture的函数式能力就是这个接口赋予的，大量使用Java8引入的函数式编程

常见操作#

创建CompletableFuture#

两种方法：new关键字或 CompletableFuture自带的静态工厂方法 runAysnc()或supplyAsync()

通过new关键字这个方式，可以看作是将CompletableFuture当作Future来使用，如下：
我们通过创建了一个结果值类型为 RpcResponse<Object> 的 CompletableFuture，你可以把 resultFuture 看作是异步运算结果的载体
```
CompletableFuture<RpcResponse<Object>> resultFuture = new CompletableFuture<>();
```
如果后面某个时刻，得到了最终结果，可以调用complete()方法传入结果，表示resultFuture已经被完成：
```
// complete() 方法只能调用一次，后续调用将被忽略。
resultFuture.complete(rpcResponse);
```
通过isDone()检查是否完成：
```
public boolean isDone() {
 return result != null;
}
```
获取异步结果，使用get() ，调用get()方法的线程会阻塞直到CompletableFuture完成运算： rpcResponse = completableFuture.get();

ThreadLocal详解

Mon, 05 Dec 2022 17:31:52 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

本文来自一枝花算不算浪漫投稿，原文地址： https://juejin.cn/post/6844904151567040519open in new window。感谢作者!

思维导图

目录#

ThreadLocal代码演示#

简单使用

public class ThreadLocalTest {
 private List<String> messages = Lists.newArrayList();

 public static final ThreadLocal<ThreadLocalTest> holder = ThreadLocal.withInitial(ThreadLocalTest::new);

 public static void add(String message) {
 holder.get().messages.add(message);
 }

 public static List<String> clear() {
 List<String> messages = holder.get().messages;
 holder.remove();

 System.out.println("size: " + holder.get().messages.size());
 return messages;
 }

 public static void main(String[] args) {
 ThreadLocalTest.add("一枝花算不算浪漫");
 System.out.println(holder.get().messages);
 ThreadLocalTest.clear();
 }
}
/* 结果 
[一枝花算不算浪漫]
size: 0
*/

简单使用2

Atomic原子类介绍

Mon, 05 Dec 2022 09:24:36 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

文章开头先用例子介绍几种类型的api使用

package com.aqs;

import lombok.*;

import java.util.concurrent.atomic.*;

@Data
@Getter
@Setter
@AllArgsConstructor
@ToString
class User {
 private String name;
 //如果要为atomicReferenceFieldUpdater服务,必须加上volatile修饰
 public volatile Integer age;
}

public class AtomicTest {
 public static void main(String[] args) {
 System.out.println("原子更新数值---------------");
 AtomicInteger atomicInteger = new AtomicInteger();
 int i1 = atomicInteger.incrementAndGet();
 System.out.println("原子增加后为" + i1);
 System.out.println("原子更新数组---------------");

 int[] a = new int[3];
 AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(a);

 int i = atomicIntegerArray.addAndGet(1, 3);
 System.out.println("数组元素[" + 1 + "]增加后为" + i);
 System.out.println("数组为" + atomicIntegerArray);
 System.out.println("原子更新对象---------------");
 User user1 = new User("ly1", 10);
 User user2 = new User("ly2", 20);
 User user3 = new User("ly3", 30);
 AtomicReference<User> atomicReference = new AtomicReference<>(user1);
 boolean b = atomicReference.compareAndSet(user2, user3);
 System.out.println("更新" + (b ? "成功" : "失败"));
 System.out.println("引用里值为"+atomicReference.get());
 boolean b1 = atomicReference.compareAndSet(user1, user3);
 System.out.println("更新" + (b1 ? "成功" : "失败"));
 System.out.println("引用里值为"+atomicReference.get());
 System.out.println("原子更新对象属性---------------");
 User user4=new User("ly4",40);
 AtomicReferenceFieldUpdater<User, Integer> atomicReferenceFieldUpdater = AtomicReferenceFieldUpdater.newUpdater(User.class, Integer.class, "age");
 boolean b2 = atomicReferenceFieldUpdater.compareAndSet(user4, 41, 400);
 System.out.println("更新"+(b2?"成功":"失败"));
 System.out.println("引用里user4值为"+atomicReferenceFieldUpdater.get(user4));
 boolean b3 = atomicReferenceFieldUpdater.compareAndSet(user4, 40, 400);
 System.out.println("更新"+(b3?"成功":"失败"));
 System.out.println("引用里user4值为"+atomicReferenceFieldUpdater.get(user4));
 System.out.println("其他使用---------------");
 User user5=new User("ly5",50);
 User user6=new User("ly6",60);
 User user7=new User("ly7",70);
 AtomicMarkableReference<User> userAtomicMarkableReference=new AtomicMarkableReference<>(user5,true);
 boolean b4 = userAtomicMarkableReference.weakCompareAndSet(user6, user7, true, false);
 System.out.println("更新"+(b4?"成功":"失败"));
 System.out.println("引用里值为"+userAtomicMarkableReference.getReference());
 boolean b5 = userAtomicMarkableReference.weakCompareAndSet(user5, user7, false, true);
 System.out.println("更新"+(b5?"成功":"失败"));
 System.out.println("引用里值为"+userAtomicMarkableReference.getReference());
 boolean b6 = userAtomicMarkableReference.weakCompareAndSet(user5, user7, true, false);
 System.out.println("更新"+(b6?"成功":"失败"));
 System.out.println("引用里值为"+userAtomicMarkableReference.getReference());
 System.out.println("AtomicStampedReference使用---------------");
 User user80=new User("ly8",80);
 User user90=new User("ly9",90);
 User user100=new User("ly10",100);
 AtomicStampedReference<User> userAtomicStampedReference=new AtomicStampedReference<>(user80,80);//版本80
 //...每次更改stamp都加1
 //这里假设中途被改成81了
 boolean b7 = userAtomicStampedReference.compareAndSet(user80, user100,81,90);
 System.out.println("更新"+(b7?"成功":"失败"));
 System.out.println("引用里值为"+userAtomicStampedReference.getReference());
 boolean b8 = userAtomicStampedReference.compareAndSet(user80, user100,80,90);
 System.out.println("更新"+(b8?"成功":"失败"));
 System.out.println("引用里值为"+userAtomicStampedReference.getReference());
 }
}
/*
原子更新数值---------------
原子增加后为1
原子更新数组---------------
数组元素[1]增加后为3
数组为[0, 3, 0]
原子更新对象---------------
更新失败
引用里值为User(name=ly1, age=10)
更新成功
引用里值为User(name=ly3, age=30)
原子更新对象属性---------------
更新失败
引用里user4值为40
更新成功
引用里user4值为400
其他使用---------------
更新失败
引用里值为User(name=ly5, age=50)
更新失败
引用里值为User(name=ly5, age=50)
更新成功
引用里值为User(name=ly7, age=70)
AtomicStampedReference使用---------------
更新失败
引用里值为User(name=ly8, age=80)
更新成功
引用里值为User(name=ly10, age=100)

Process finished with exit code 0

*/

原子类介绍#

在化学上，原子是构成一般物质的最小单位，化学反应中是不可分割的，Atomic指一个操作是不可中断的，即使在多个线程一起执行时，一个操作一旦开始就不会被其他线程干扰
原子类–>具有原子/原子操作特征的类
并发包java.util.concurrent 的原子类都放着java.util.concurrent.atomic中
根据操作的数据类型，可以将JUC包中的原子类分为4类（基本类型、数组类型、引用类型、对象的属性修改类型）
- 基本类型使用原子方式更新基本类型，包括AtomicInteger 整型原子类，AtomicLong 长整型原子类，AtomicBoolean 布尔型原子类

aqs详解

Wed, 30 Nov 2022 14:48:01 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

Semaphore [ˈseməfɔː(r)]

何为 AQS？AQS 原理了解吗？

CountDownLatch 和 CyclicBarrier 了解吗？两者的区别是什么？

用过 Semaphore 吗？应用场景了解吗？

……

AQS简单介绍#

AQS,AbstractQueueSyschronizer，即抽象队列同步器，这个类在java.util.concurrent.locks包下面

AQS是一个抽象类，主要用来构建锁和同步器

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
}

AQS 为构建锁和同步器提供了一些通用功能的实现，因此，使用 AQS 能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的 ReentrantLock，Semaphore，其他的诸如 ReentrantReadWriteLock，SynchronousQueue，FutureTask(jdk1.7) 等等皆是基于 AQS 的。

AQS原理#

AQS核心思想#

面试不是背题，大家一定要加入自己的思想，即使加入不了自己的思想也要保证自己能够通俗的讲出来而不是背出来

AQS 核心思想是，如果被请求的共享资源（AQS内部）空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制 AQS 是用 CLH 队列锁实现的，即将暂时获取不到锁的线程加入到队列中。

CLH(Craig,Landin and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS 是将每条请求共享资源的线程封装成一个 CLH 锁队列的一个结点（Node）来实现锁的分配。
[ 搜索了一下，CLH好像是人名 ] 在 CLH 同步队列中，一个节点表示一个线程，它保存着线程的引用（thread）、当前节点在队列中的状态（waitStatus）、前驱节点（prev）、后继节点（next）。
CLH队列结构

AQS（AbstractQueuedSynchronized）原理图

AQS使用一个int成员变量来表示同步状态，通过内置的线程等待队列来获取资源线程的排队工作。
state 变量由 volatile 修饰，用于展示当前临界资源的获锁情况。
```
private volatile int state;//共享变量，使用volatile修饰保证线程可见性
```
状态信息的操作

java常见并发容器

Tue, 29 Nov 2022 16:58:59 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

JDK提供的容器，大部分在java.util.concurrent包中

ConcurrentHashMap：线程安全的HashMap
CopyOnWriteArrayList：线程安全的List，在读多写少的场合性能非常好，远好于Vector
ConcurrentLinkedQueue：高效的并发队列，使用链表实现，可以看作一个线程安全的LinkedList，是一个非阻塞队列
BlockingQueue：这是一个接口，JDK内部通过链表、数组等方式实现了该接口。表示阻塞队列，非常适合用于作为数据共享的通道
ConcorrentSkipListMap：跳表的实现，是一个Map，使用跳表的数据结构进行快速查找

ConcurrentHashMap#

HashMap是线程不安全的，并发场景下要保证线程安全，可以使用Collections.synchronizedMap()方法来包装HashMap，但这是通过使用一个全局的锁来同步不同线程间的并发访问，因此会带来性能问题
建议使用ConcurrentHashMap，不论是读操作还是写操作都能保证高性能：读操作（几乎）不需要加锁，而写操作时通过锁分段(这里说的是JDK1.7？)技术，只对所操作的段加锁而不影响客户端对其他段的访问

CopyOnWriteArrayList#

//源码
public class CopyOnWriteArrayList<E>
extends Object
implements List<E>, RandomAccess, Cloneable, Serializable

在很多应用场景中，读操作可能会远远大于写操作
我们应该允许多个线程同时访问List内部数据（针对读）
与ReentrantReadWriteLock读写锁思想非常类似，即读读共享、写写互斥、读写互斥、写读互斥
不一样的是，CopyOnWriteArrayList读取时完全不需要加锁，且写入也不会阻塞读取操作，只有写入和写入之间需要同步等待。

CopyOnWriteArrayList是如何做到的#

CopyOnWriteArrayList 类的所有可变操作（add，set 等等）都是通过创建底层数组的新副本来实现的。当 List 需要被修改的时候，并不修改原有内容，而是对原有数据进行一次复制，将修改的内容写入副本。写完之后，再将修改完的副本替换原来的数据，这样就可以保证写操作不会影响读操作了。
从 CopyOnWriteArrayList 的名字就能看出 CopyOnWriteArrayList 是满足 CopyOnWrite 的
在计算机，如果你想要对一块内存进行修改时，我们不在原有内存块中进行写操作，而是将内存拷贝一份，在新的内存中进行写操作，写完之后呢，就将指向原来内存指针指向新的内存(注意，是指向，而不是重新拷贝★重要★)，原来的内存就可以被回收掉了

CopyOnWriteArrayList 读取和写入源码简单分析#

CopyOnWriteArrayList读取操作的实现 读取操作没有任何同步控制和锁操作，理由就是内部数组array不会发生修改，只会被另一个array替换，因此可以保证数据安全

 /** The array, accessed only via getArray/setArray. */
 private transient volatile Object[] array;
 public E get(int index) {
 return get(getArray(), index);
 }
 @SuppressWarnings("unchecked")
 private E get(Object[] a, int index) {
 return (E) a[index];
 }
 final Object[] getArray() {
 return array;
 }

CopyOnWriteArrayList写入操作的实现在添加集合的时候加了锁，保证同步，避免多线程写的时候会copy出多个副本

线程池最佳实践

Tue, 29 Nov 2022 11:31:20 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

线程池知识回顾#

1. 为什么要使用线程池#

池化技术的思想，主要是为了减少每次获取资源（线程资源）的消耗，提高对资源的利用率
线程池提供了一种限制和管理资源（包括执行一个任务）的方法，每个线程池还维护一些基本统计信息，例如已完成任务的数量

好处：

降低资源消耗
提高响应速度
提高线程的可管理性

2. 线程池在实际项目的使用场景#

线程池一般用于执行多个不相关联的耗时任务，没有多线程的情况下，任务顺序执行，使用了线程池的话可让多个不相关联的任务同时执行。

3. 如何使用线程池#

一般是通过 ThreadPoolExecutor 的构造函数来创建线程池，然后提交任务给线程池执行就可以了。构造函数如下：

 /**
 * 用给定的初始参数创建一个新的ThreadPoolExecutor。
 */
 public ThreadPoolExecutor(int corePoolSize,//线程池的核心线程数量
 int maximumPoolSize,//线程池的最大线程数
 long keepAliveTime,//当线程数大于核心线程数时，多余的空闲线程存活的最长时间
 TimeUnit unit,//时间单位
 BlockingQueue<Runnable> workQueue,//任务队列，用来储存等待执行任务的队列
 ThreadFactory threadFactory,//线程工厂，用来创建线程，一般默认即可
 RejectedExecutionHandler handler//拒绝策略，当提交的任务过多而不能及时处理时，我们可以定制策略来处理任务
 ) {
 if (corePoolSize < 0 ||
 maximumPoolSize <= 0 ||
 maximumPoolSize < corePoolSize ||
 keepAliveTime < 0)
 throw new IllegalArgumentException();
 if (workQueue == null || threadFactory == null || handler == null)
 throw new NullPointerException();
 this.corePoolSize = corePoolSize;
 this.maximumPoolSize = maximumPoolSize;
 this.workQueue = workQueue;
 this.keepAliveTime = unit.toNanos(keepAliveTime);
 this.threadFactory = threadFactory;
 this.handler = handler;
 }

使用代码：

java线程池详解

Wed, 23 Nov 2022 14:40:41 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

一使用线程池的好处#

池化技术：减少每次获取资源的消耗，提高对资源的利用率
线程池提供一种限制和管理资源（包括执行一个任务）的方式，每个线程池还维护一些基本统计信息，例如已完成任务的数量
线程池的好处
- 降低资源消耗（重复利用，降低线程创建和销毁造成的消耗）
- 提高响应速度（任务到达直接执行，无需等待线程创建）
- 提高线程可管理性（避免无休止创建，使用线程池统一分配、调优、监控）

二 Executor框架#

Java5之后，通过Executor启动线程，比使用Thread的start方法更好，更易于管理，效率高，还能有助于避免this逃逸的问题

this逃逸，指的是构造函数返回之前，其他线程就持有该对象的引用，会导致调用尚未构造完全的对象
例子：

public class ThisEscape { 
 public ThisEscape() { 
 new Thread(new EscapeRunnable()).start(); 
 // ... 
 } 
 
 private class EscapeRunnable implements Runnable { 
 @Override
 public void run() { 
 // 通过ThisEscape.this就可以引用外围类对象, 但是此时外围类对象可能还没有构造完成, 即发生了外围类的this引用的逃逸 
 } 
 } 
}

处理办法 //不要在构造函数中运行线程

public class ThisEscape { 
 private Thread t; 
 public ThisEscape() { 
 t = new Thread(new EscapeRunnable()); 
 // ... 
 } 
 
 public void init() { 
 //也就是说对象没有构造完成前，不要调用ThisEscape.this即可
 t.start(); 
 } 
 
 private class EscapeRunnable implements Runnable { 
 @Override
 public void run() { 
 // 通过ThisEscape.this就可以引用外围类对象, 此时可以保证外围类对象已经构造完成 
 } 
 } 
}

Executor框架不仅包括线程池的管理，提供线程工厂、队列以及拒绝策略。

java内存模型

Mon, 21 Nov 2022 10:57:24 +0000

引用自https://github.com/Snailclimb/JavaGuide

从CPU缓存模型说起#

redis是为了解决程序处理速度和访问常规关系型数据库速度不对等的问题，CPU缓存则是为了解决CPU处理速度和内存处理速度不对等的问题

我们把内存看作外存的高速缓存，程序运行时把外存的数据复制到内存，由于内存的处理速度远高于外存，这样提高了处理速度
总结，CPU Cache缓存的是内存数据，用于解决CPU处理速度和内存不匹配的问题，内存缓存的是硬盘数据用于解决硬盘访问速度过慢的问题 CPU Cache示意图：

CPU Cache通常分为三层，分别叫L1，L2，L3 Cache 工作方式： 先复制一份数据到CPUCache中，当CPU需要用的时候就可以从CPUCache中读取数据，运算完成后，将运算得到的数据，写回MainMemory中，此时，会出现内存缓存不一致的问题，例子：执行了i++，如果两个线程同时执行，假设两个线程从CPUCach中读取的i=1，两个线程做了1++运算完之后再写回MainMemory，此时i=2 而正确结果为3
CPU为了解决内存缓存不一致问题，可以通过制定缓存一致协议（比如MESI协议）或其他手段。这个缓存一致协议，指的是在 CPU 高速缓存与主内存交互的时候需要遵守的原则和规范 操作系统，通过内存模型MemoryModel定义一系列规范来解决这个问题

Java内存模型#

指令重排序#

什么是指令重排序？ 简单来说就是系统在执行代码的时候并不一定是按照你写的代码的顺序依次执行
指令重排有下面2种
- 编译器优化重排：编译器（包括 JVM、JIT 编译器等）在不改变单线程程序语义的前提下，重新安排语句的执行顺序。
- 指令并行重排：现代处理器采用了指令级并行技术(Instruction-Level Parallelism，ILP)来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序

另外，内存系统也会有“重排序”，但又不是真正意义上的重排序。在 JMM 里表现为主存和本地内存的内容可能不一致，进而导致程序在多线程下执行可能出现问题。

即Java源代码会经历 编译器优化重排—>指令并行重排—>内存系统重排，最终编程操作系统可执行的指令序列

极其重要★：指令重排序可以保证串行语义一致，但是没有义务保证多线程间的语义也一致，所以在多线程下指令重排可能导致一些问题

编译器和处理器的指令重排序的处理方式不一样。对于编译器，通过禁止特定类型的编译器重排序的方式来禁止重排序。对于处理器，通过插入内存屏障（Memory Barrier，或有时叫做内存栅栏，Memory Fence）的方式来禁止特定类型的处理器重排序。指令并行重排和内存系统重排都属于是处理器级别的指令重排序。

内存屏障（Memory Barrier，或有时叫做内存栅栏，Memory Fence）是一种 CPU 指令，用来禁止处理器指令发生重排序（像屏障一样），从而保障指令执行的有序性。另外，为了达到屏障的效果，它也会使处理器写入、读取值之前，将主内存的值写入高速缓存，清空无效队列，从而保障变量的可见性。

JMM（JavaMemoryMode）#

什么是 JMM？为什么需要 JMM？#

一般来说，编程语言也可以直接复用操作系统层面的内存模型。不过，不同的操作系统内存模型不同。如果直接复用操作系统层面的内存模型，就可能会导致同样一套代码换了一个操作系统就无法执行了。Java 语言是跨平台的，它需要自己提供一套内存模型以屏蔽系统差异。

实际上，对于Java来说，可以把JMM看作是Java定义的并发编程相关的一组规范，除了抽象了线程和主内存之间的关系之外，还规定了从Java源代码到CPU可执行指令的转化过程要遵守哪些和并发相关的原则和规范，主要目的是为了简化多线程编程，增强程序可移植性。

为什么要遵守这些并发相关的原则和规范呢？因为在并发编程下，CPU多级缓存和指令重排这类设计会导致程序运行出问题，比如指令重排，为此JMM抽象了happens-before原则

JMM 说白了就是定义了一些规范来解决这些问题，开发者可以利用这些规范更方便地开发多线程程序。对于 Java 开发者说，你不需要了解底层原理，直接使用并发相关的一些关键字和类（比如 volatile、synchronized、各种 Lock）即可开发出并发安全的程序。

JMM 是如何抽象线程和主内存之间的关系？#

Java内存模型(JMM)，抽象了线程和主内存之间的关系，比如线程之间的共享变量必须存储在主内存中

并发03

Mon, 07 Nov 2022 16:04:33 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

线程池#

为什么要使用线程池
- 池化技术：线程池、数据库连接池、Http连接池
- 池化技术思想意义：为了减少每次获取资源的消耗，提高对资源的利用率
- 线程池提供了限制和管理资源(包括执行一个任务)的方式
- 每个线程池还维护基本统计信息，例如已完成任务的数量
- 好处：
  1. 降低资源消耗 重复利用已创建线程降低线程创建和销毁造成的消耗
  2. 提高响应速度任务到达时，任务可以不需等到线程创建就能继续执行
  3. 提高线程的可管理性 线程是稀缺资源，如果无限制创建，不仅消耗系统资源，还会降低系统的稳定性，使用线程池统一管理分配、调优和监控。

实现Runnable接口和Callable接口的区别

//Callable的用法 
public class TestLy {

 //如果加上volatile,就能保证可见性，线程1 才能停止
 boolean stop = false;//对象属性

 public static void main(String[] args) throws InterruptedException, ExecutionException {
 FutureTask<String> futureTask=new FutureTask<>(new Callable<String>() {
 @Override
 public String call() throws Exception {
 System.out.println("等3s再把结果给你");
 TimeUnit.SECONDS.sleep(3);
 return "hello world";
 }
 });
 new Thread(futureTask).start();
 String s = futureTask.get();
 System.out.println("3s后获取到了结果"+s);

 new Thread(new Runnable() {
 @Override
 public void run() {
 System.out.println("abc");
 }
 }).start();
 }
}
/*
等3s再把结果给你
3s后获取到了结果hello world
abc
*/

Runnable接口不会返回结果或抛出检查异常，Callable接口可以

锁升级

Sun, 06 Nov 2022 12:31:02 +0000

以下内容均转自 https://www.cnblogs.com/wuqinglong/p/9945618.html，部分疑惑参考自另一作者 https://github.com/farmerjohngit/myblog/issues/12 ，感谢原作者。

【目前还是存有部分疑虑（轻量级锁那块），可能需要详细看源码才能释疑】

概述#

传统的synchronized为重量级锁（使用操作系统互斥量（mutex）来实现的传统锁），但是随着JavaSE1.6对synchronized优化后，部分情况下他就没有那么重了。本文介绍了JavaSE1.6为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁，以及锁结构、及锁升级过程

实现同步的基础#

Java中每个对象都可以作为锁，具体变现形式

对于普通同步方法，锁是当前实例对象
对于静态同步方法，锁是当前类的Class对象
对于同步方法块，锁是synchronized括号里配置的对象

一个线程试图访问同步代码块时，必须获取锁；在退出或者抛出异常时，必须释放锁

实现方式#

JVM 基于进入和退出 Monitor 对象来实现方法同步和代码块同步，但是两者的实现细节不一样

代码块同步：通过使用 monitorenter 和 monitorexit 指令实现的
同步方法：ACC_SYNCHRONIZED 修饰

monitorenter 指令是在编译后插入到同步代码块的开始位置，而 monitorexit 指令是在编译后插入到同步代码块的结束处或异常处

对于同步方法，进入方法前添加一个 monitorenter 指令，退出方法后添加一个 monitorexit 指令。

demo：

public class Demo {

 public void f1() {
 synchronized (Demo.class) {
 System.out.println("Hello World.");
 }
 }

 public synchronized void f2() {
 System.out.println("Hello World.");
 }

}

编译之后的字节码（使用 javap )

public void f1();
 descriptor: ()V
 flags: ACC_PUBLIC
 Code:
 stack=2, locals=3, args_size=1
 0: ldc #2 // class me/snail/base/Demo
 2: dup
 3: astore_1
 4: monitorenter
 5: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
 8: ldc #4 // String Hello World.
 10: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
 13: aload_1
 14: monitorexit
 15: goto 23
 18: astore_2
 19: aload_1
 20: monitorexit
 21: aload_2
 22: athrow
 23: return
 Exception table:
 from to target type
 5 15 18 any
 18 21 18 any
 LineNumberTable:
 line 6: 0
 line 7: 5
 line 8: 13
 line 9: 23
 StackMapTable: number_of_entries = 2
 frame_type = 255 /* full_frame */
 offset_delta = 18
 locals = [ class me/snail/base/Demo, class java/lang/Object ]
 stack = [ class java/lang/Throwable ]
 frame_type = 250 /* chop */
 offset_delta = 4

public synchronized void f2();
 descriptor: ()V
 flags: ACC_PUBLIC, ACC_SYNCHRONIZED
 Code:
 stack=2, locals=1, args_size=1
 0: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
 3: ldc #4 // String Hello World.
 5: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
 8: return
 LineNumberTable:
 line 12: 0
 line 13: 8

先说 f1() 方法，发现其中一个 monitorenter 对应了两个 monitorexit，这是不对的。但是仔细看 #15: goto 语句，直接跳转到了 #23: return 处，再看 #22: athrow 语句发现，原来第二个 monitorexit 是保证同步代码块抛出异常时锁能得到正确的释放而存在的，这就理解了。

(该文弃用)锁升级

Thu, 03 Nov 2022 11:08:59 +0000

本文主要讲解synchronized原理和偏向锁、轻量级锁、重量级锁的升级过程，基本都转自

https://blog.csdn.net/MariaOzawa/article/details/107665689 原作者: MariaOzawa

简介#

为什么需要锁
并发编程中，多个线程访问同一共享资源时，必须考虑如何维护数据的原子性
历史
- JDK1.5之前，Java依靠Synchronized关键字实现锁功能，Synchronized是Jvm实现的内置锁，锁的获取与释放由JVM隐式实现
- JDK1.5，并发包新增Lock接口实现锁功能，提供同步功能，使用时显式获取和释放锁
区别
- Lock同步锁基于Java实现，Synchronized基于底层操作系统的MutexLock实现 /ˈmjuːtɛks/ ，每次获取和释放锁都会带来用户态和内核态的切换，从而增加系统性能开销，性能糟糕，又称重量级锁
- JDK1.6之后，对Synchronized同步锁做了充分优化

Synchronized同步锁实现原理#

Synchronized实现同步锁的两种方式：修饰方法；修饰方法块

 // 关键字在实例方法上，锁为当前实例
 public synchronized void method1() {
 // code
 }

 // 关键字在代码块上，锁为括号里面的对象
 public void method2() {
 Object o = new Object();
 synchronized (o) {
 // code
 }
 }

这里使用编译–及javap 打印字节文件

javac -encoding UTF-8 SyncTest.java //先运行编译class文件命令

javap -v SyncTest.class //再通过javap打印出字节文件

结果如下，Synchronized修饰代码块时，由monitorenter和monitorexist指令实现同步。进入monitorenter指令后线程持有Monitor对象；退出monitorenter指令后，线程释放该Monitor对象

 public void method2();
 descriptor: ()V
 flags: ACC_PUBLIC
 Code:
 stack=2, locals=4, args_size=1
 0: new #2 
 3: dup
 4: invokespecial #1 
 7: astore_1
 8: aload_1
 9: dup
 10: astore_2
 11: monitorenter //monitorenter 指令
 12: aload_2
 13: monitorexit //monitorexit 指令
 14: goto 22
 17: astore_3
 18: aload_2
 19: monitorexit
 20: aload_3
 21: athrow
 22: return
 Exception table:
 from to target type
 12 14 17 any
 17 20 17 any
 LineNumberTable:
 line 18: 0
 line 19: 8
 line 21: 12
 line 22: 22
 StackMapTable: number_of_entries = 2
 frame_type = 255 /* full_frame */
 offset_delta = 17
 locals = [ class com/demo/io/SyncTest, class java/lang/Object, class java/lang/Object ]
 stack = [ class java/lang/Throwable ]
 frame_type = 250 /* chop */
 offset_delta = 4

如果Synchronized修饰同步方法，代替monitorenter和monitorexit的是 ACC_SYNCHRONIZED标志，即：JVM使用该访问标志区分方法是否为同步方法。方法调用时，调用指令检查是否设置ACC_SYNCHRONIZED标志，如有，则执行线程先持有该Monitor对象，再执行该方法；运行期间，其他线程无法获取到该Monitor对象；方法执行完成后，释放该Monitor对象 javap -v xx.class 字节文件查看

(该文弃用)锁升级

Mon, 31 Oct 2022 11:08:59 +0000

简介#

无锁 => 偏向锁 => 轻量锁 => 重量锁

复习Class类锁和实例对象锁，说明Class类锁和实例对象锁不是同一把锁，互相不影响

public static void main(String[] args) throws InterruptedException { 
 Object object=new Object();
 new Thread(()->{
 synchronized (Customer.class){
 System.out.println(Thread.currentThread().getName()+"Object.class类锁");
 try {
 TimeUnit.SECONDS.sleep(5);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 System.out.println(Thread.currentThread().getName()+"结束并释放锁");
 },"线程1").start();
 //保证线程1已经获得类锁
 try {
 TimeUnit.SECONDS.sleep(2);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 new Thread(()->{
 synchronized (object){
 System.out.println(Thread.currentThread().getName()+"获得object实例对象锁");
 }
 System.out.println(Thread.currentThread().getName()+"结束并释放锁");
 },"线程2").start();

 }

/* 输出
线程1Object.class类锁
线程2获得object实例对象锁
线程2结束并释放锁
线程1结束并释放锁
*/

总结图 , 00 , 01 , 10 ，没有11

对象内存布局和对象头

Sun, 30 Oct 2022 16:56:16 +0000

对象布局#

heap （where）: new (eden ,s0 ,s1) ,old, metaspace
对象的构成元素（what） HotSpot虚拟机里，对象在堆内存中的存储布局分为三个部分
- 对象头（Header）
  - 对象标记 MarkWord
  - 类元信息（类型指针 Class Pointer，指向方法区的地址）
  - 对象头多大 length（数组才有）
- 实例数据（Instance Data）
- 对其填充（Padding，保证整个对象大小，是8个字节的倍数）

对象头#

对象标记
1. Object o= new Object(); //new一个对象，占内存多少
2. o.hashCode() //hashCode存在对象哪个地方
3. synchronized(o){ } //对象被锁了多少次（可重入锁）
4. System.gc(); //躲过了几次gc（次数）
上面这些，哈希码、gc标记、gc次数、同步锁标记、偏向锁持有者，都保存在对象标记里面
1. 如果在64位系统中，对象头中，**mark word（对象标记）**占用8个字节（64位）；**class pointer（类元信息）**占用8个字节，总共16字节（忽略压缩指针）
2. 无锁的时候，
类型指针注意下图，指向方法区中（模板）的地址

实例数据和对齐填充#

实例数据
用来存放类的属性（Filed）数据信息，包括父类的属性信息
对齐填充
填充到长度为8字节，因为虚拟机要求对象起始地址必须是8字节的整数倍（对齐填充不一定存在）

示例

class Customer{
 int id;//4字节
 boolean flag=false; //1字节
}
//Customer customer=new Customer();
//该对象大小：对象头（对象标记8+类型指针8）+实例数据（4+1）=21字节 ===> 为了对齐填充，则为24字节

源码查看#

具体的（64位虚拟机为主）#

并发02

Fri, 28 Oct 2022 14:15:06 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

JMM（JavaMemoryModel)#

详见-知识点

volatile关键字#

保证变量可见性

使用volatile关键字保证变量可见性，如果将变量声明为volatile则指示JVM该变量是共享且不稳定的，每次使用它都到主存中读取

volatile关键字并非Java语言特有，在C语言里也有，它最原始的意义就是禁用CPU缓存。
volatile关键字只能保证数据可见性，不能保证数据原子性。synchronized关键字两者都能保证

不可见的例子

package com.concurrent; 
import java.util.concurrent.TimeUnit;

public class TestLy {

 //如果加上volatile,就能保证可见性，线程1 才能停止
 boolean stop = false;//对象属性

 public static void main(String[] args) throws InterruptedException {
 TestLy atomicTest = new TestLy();
 new Thread(() -> {
 while (!atomicTest.stop) {
 //这里不能加System.out.println ,因为这个方法内部用了synchronized修饰,会导致获取主内存的值，
 //就没法展示效果了
 /*System.out.println("1还没有停止");*/
 }
 System.out.println(Thread.currentThread().getName()+"停止了");
 },"线程1").start();

 new Thread(() -> {
 try {
 TimeUnit.SECONDS.sleep(1);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 atomicTest.stop= true;
 System.out.println(Thread.currentThread().getName()+"让线程1停止");
 },"线程2").start();
 while (true){}
 }


}

如何禁止指令重排使用volatile关键字，除了可以保证变量的可见性，还能防止JVM指令重排。当我们对这个变量进行读写操作的时候，-会通过插入特定的内存屏障来禁止指令重排

并发01

Wed, 26 Oct 2022 16:46:32 +0000

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

什么是进程和线程

进程：是程序的一次执行过程，是系统运行程序的基本单位 系统运行一个程序，即一个进程从创建、运行到消亡的过程
- 启动main函数则启动了一个JVM进程，main函数所在线程为进程中的一个线程，也称主线程
- 以下为一个个的进程
  - 查看java进程
```
jps -l
32 org.jetbrains.jps.cmdline.Launcher
10084
16244 com.Test
17400 sun.tools.jps.Jps
```
  - 杀死进程
```
 taskkill /f /pid 16244
```

何为线程

线程，比进程更小的执行单位
同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈、本地方法栈，又被称为轻量级进程

Java天生就是多线程程序，如：

public class MultiThread {
	public static void main(String[] args) {
		// 获取 Java 线程管理 MXBean
	ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
		// 不需要获取同步的 monitor 和 synchronizer 信息，仅获取线程和线程堆栈信息
		ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
		// 遍历线程信息，仅打印线程 ID 和线程名称信息
		for (ThreadInfo threadInfo : threadInfos) {
			System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
		}
	}
}
//输出
[5] Attach Listener //添加事件
[4] Signal Dispatcher // 分发处理给 JVM 信号的线程
[3] Finalizer //调用对象 finalize 方法的线程
[2] Reference Handler //清除 reference 线程
[1] main //main 线程,程序入口

也就是说，一个Java程序的运行，是main线程和多个其他线程同时运行

复习-JavaGuide-并发 on 随记

Atomic预备知识

Java实现CAS的原理[非javaguide]#

memory-area

前言#

运行时数据区域#

程序计数器#

Java虚拟机栈#

completablefuture-intro

简单介绍#

常见操作#

创建CompletableFuture#

ThreadLocal详解

目录#

ThreadLocal代码演示#

Atomic原子类介绍

原子类介绍#

aqs详解

AQS简单介绍#

AQS原理#

AQS核心思想#

java常见并发容器

ConcurrentHashMap#

CopyOnWriteArrayList#

CopyOnWriteArrayList是如何做到的#

CopyOnWriteArrayList 读取和写入源码简单分析#

线程池最佳实践

线程池知识回顾#

1. 为什么要使用线程池#

2. 线程池在实际项目的使用场景#

3. 如何使用线程池#

java线程池详解

一 使用线程池的好处#

二 Executor框架#

java内存模型

从CPU缓存模型说起#

Java内存模型#

指令重排序#

JMM（JavaMemoryMode）#

什么是 JMM？为什么需要 JMM？#

JMM 是如何抽象线程和主内存之间的关系？#

并发03

线程池#

锁升级

概述#

实现同步的基础#

实现方式#

(该文弃用)锁升级

简介#

Synchronized同步锁实现原理#

(该文弃用)锁升级

简介#

对象内存布局和对象头

对象布局#

对象头#

实例数据和对齐填充#

源码查看#

具体的（64位虚拟机为主）#

并发02

JMM（JavaMemoryModel)#

volatile关键字#

并发01

一使用线程池的好处#