juc并发编程
线程上下文
概念
我们都知道,jvm由堆、栈、方法区组成,其中栈内存就是给线程用的,每个线程启动后,虚拟机就会为其分
配一块栈内存。而每个栈又由多个栈帧组成,对应着每次方法调用时所占用的内存。每个线程只能有一个
活动栈帧,对应着当前正在执行的那个方法。而线程上下文就是由于一些原因导致cpu不再执行当前线程,
转而执行另一个线程的代码。
产生的原因
- 线程的cpu时间片运行完
- 垃圾回收
- 有更高优先级的线程需要运行
- 线程自己调用了sleep、yield、wait、join、park、synchronized、lock等方法
当出现了上下文切换,在java中,java会使用程序计数器来保存当前线程的状态,是是线程私有的。
上下文切换频繁发生会影响性能
join方法
首先先看一个图
如果想让main线程等待t执行完再执行,就需要用到join方法。
join方法的作用就是等待线程的执行,要等待谁执行,就用谁.join()!
join的再理解
join限时同步
interrupt
打断阻塞
打断正常(不会直接打断程序的运行,只会把打断标识置为true)
守护线程
概念
默认情况下,java进程需要等待所有的线程运行完才结束，如下图:
当有守护线程，即使是守护线程的代码没有执行完,也会强制结束(垃圾回收就是守护线程的体现)
线程安全-局部变量
局部变量存放于在jvm栈中,在多线程情况下,会为每一个线程开辟一块栈内存,因此不存在线程安全的问题。
但是局部变量引用的对象未必,如果对象没有逃离方法的作用范围,它是线程安全的,如果逃离了,则需要考虑线程安全。
线程安全问题-暴露引用
线程安全-组合调用
虽然有一些线程安全的集合,提供了一些线程安全的方法,但是又的组合调用会出现线程不安全的问题,如图:
此时key的值成为了1，发生了这样的问题,其实主要是第一个线程在执行get方法完后,释放锁，还没 开始执行put方法的时候,第二个线程拿到了cpu分到的时间片,开始执行get方法,在释放锁后,可能 cpu分配的时间片用完了,第一个线程拿到执行权,进行put操作，在执行完put操作后,第二个线程拿到 执行权,执行put方法将第一个线程的值覆盖了。
Monitor
Java 对象头（以 32 位虚拟机为例）
普通对象
|--------------------------------------------------------------|
Object Header (64 bits)
|------------------------------------|-------------------------|
Mark Word (32 bits) Klass Word (32 bits)
|------------------------------------|-------------------------|
数组对象
|---------------------------------------------------------------------------------|
| Object Header (96 bits)
|--------------------------------|-----------------------|------------------------|
| Mark Word(32bits) | Klass Word(32bits) |array length(32bits)
|--------------------------------|-----------------------|------------------------|
其中 Mark Word 结构为
|-------------------------------------------------------|--------------------|
| Mark Word (32 bits) | State
|-------------------------------------------------------|--------------------|
| hashcode:25 | age:4 | biased_lock:0 | 01 | Normal
|-------------------------------------------------------|--------------------|
| thread:23 | epoch:2 | age:4 | biased_lock:1 | 01 | Biased
|-------------------------------------------------------|--------------------|
| ptr_to_lock_record:30 | 00 | Lightweight Locked
|-------------------------------------------------------|--------------------|
| ptr_to_heavyweight_monitor:30 | 10 | Heavyweight Locked
|-------------------------------------------------------|--------------------|
| |11 | Marked for GC
|-------------------------------------------------------|--------------------|
64 位虚拟机 Mark Word
Monitor的工作原理
synchronized-Monitor（监视器）
在jdk6以前,在多线程的情况下,我们在使用synchronized的时候,对象头里面的的MarkWord会存储指向
Monitor的指针,从而获取Monitor,线程1成为monitor的主人,此时线程2来了,尝试获取monitor锁,但是
发现minitor已经有主人了,于是在EntityList（阻塞队列）中等待,等待线程1执行完。
1synchronized-Lightweight Locked(轻量级锁)
static final Object obj = new Object();
public static void method1() {
synchronized( obj ) {
// 同步块 A
method2();
}
}
public static void method2() {
synchronized( obj ) {
// 同步块 B
}
}
- 创建锁记录（Lock Record）对象，每个线程都的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的Mark Word
- 让锁记录中 Object reference 指向锁对象，并尝试用 cas 替换 Object 的 Mark Word，将 Mark Word 的值存入锁记录
- 如果 cas 替换成功，对象头中存储了 锁记录地址和状态 00 ，表示由该线程给对象加锁，这时图示如下
- 如果 cas 失败，有两种情况
- 如果是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程
- 如果是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数
- 当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重入计数减一
- 当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas 将 Mark Word 的值恢复给对象头
- 成功，则解锁成功
- 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程
8.2锁膨胀
概念
如果在尝试加轻量级锁的过程中，CAS 操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量
级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。
如以下代码:
static Object obj = new Object();
public static void method1() {
synchronized( obj ) {
// 同步块
}
}
- 当 Thread-1 进行轻量级加锁时，Thread-0 已经对该对象加了轻量级锁
- 这时 Thread-1 加轻量级锁失败，进入锁膨胀流程
- `即为 Object 对象申请 Monitor 锁，让 Object 指向重量级锁地址
- 然后自己进入 Monitor 的 EntryList BLOCKED
- 当 Thread-0 退出同步块解锁时，使用 cas 将 Mark Word 的值恢复给对象头，失败。这时会进入重量级解锁流程，即按照 Monitor 地址找到 Monitor 对象，设置 Owner 为 null，唤醒 EntryList 中 BLOCKED 线程
8.3 自旋优化
重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出
了同步块，释放了锁），这时当前线程就可以避免阻塞。
- 自旋重试成功的情况:在自旋的某一次,当持有锁的线程解锁了,这个时候,就可以得到锁并成功上锁
- 自旋重试失败的情况:在自旋的过程中,持有锁的线程一直不释放锁,于是竞争的线程就会进入到
EntiryList中阻塞
注意:
- 自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势。
- 在 Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会
- 高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能。
- Java 7 之后不能控制是否开启自旋功能
偏向锁
- 轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。
- Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现这个线程 ID 是自己的就表示没有竞争，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有
例如：
static final Object obj = new Object();
public static void m1() {
synchronized( obj ) {
// 同步块 A
m2();
}
}
public static void m2() {
synchronized( obj ) {
// 同步块 B
m3();
}
}
public static void m3() {
synchronized( obj ) {
}
}
如图解释偏向锁:
偏向锁的状态
一个对象创建时：
- 如果开启了偏向锁（默认开启），那么对象创建后，markword 值为 0x05 即最后 3 位为 101，这时它的thread、epoch、age 都为 0
- 偏向锁是默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加 VM 参数
-XX:BiasedLockingStartupDelay=0来禁用延迟 - 如果没有开启偏向锁，那么对象创建后，markword 值为 0x01 即最后 3 位为 001，这时它的 hashcode、age 都为 0，第一次用到 hashcode 时才会赋值
-在上面测试代码运行时在添加 VM 参数-XX:-UseBiasedLocking禁用偏向锁
偏向锁的撤销
调用对象的hascode:调用对象的hascode后,因为此对象的对象头的markword此时存储的是线程的ThreadId,所以调用hacode会导致偏向锁被撤销。- 调用 wait/notify
wait/notify
-
Owner 线程发现条件不满足，调用 wait 方法，即可进入 WaitSet 变为 WAITING 状态
-
BLOCKED 和 WAITING 的线程都处于阻塞状态，不占用 CPU 时间片
-
BLOCKED 线程会在 Owner 线程释放锁时唤醒
-
WAITING 线程会在 Owner 线程调用 notify 或 notifyAll 时唤醒，但唤醒后并不意味者立刻获得锁，仍需进入EntryList 重新竞争
-
obj.wait(): 让进入 object 监视器的线程到 waitSet 等待 -
obj.notify(): 在 object 上正在 waitSet 等待的线程中挑一个唤醒 -
obj.notifyAll(): 让 object 上正在 waitSet 等待的线程全部唤醒
必须获得锁对象,成为monitor的owner 才可以调用以上三个方法。`虚假唤醒
有两个正在waitSet中等待的线程,我们想要唤醒一个线程,为了防止随机性,使用notifyAll()唤醒,但是产生了一个弊端,就是第二个不想唤醒的线程也被唤醒被执行了。解决方法就是换成while循环,循环判断条件
10.设计模式-保护性暂停模式
1. 定义
即 Guarded Suspension，用在一个线程等待另一个线程的执行结果
要点 -
有一个结果需要从一个线程传递到另一个线程，让他们关联同一个 GuardedObject
-
如果有结果不断从一个线程到另一个线程那么可以使用消息队列（见生产者/消费者）
-
JDK 中，join 的实现、Future 的实现，采用的就是此模式因为要等待另一方的结果，因此归类到同步模式
线程的活跃性-死锁
ReentranLock锁
锁的超时
JMM（Java Memory Model)
JMM 即 Java Memory Model，它定义了主存(共享信息存储的位置)、工作内存(私有信息存储的位置)抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、
CPU 指令优化等。
JMM 体现在以下几个方面
原子性 - 保证指令不会受到线程上下文切换的影响
可见性 - 保证指令不会受 cpu 缓存的影响
有序性 - 保证指令不会受 cpu 指令并行优化的影响
可见性
1. 初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存。
2.因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，减少对主存中 run 的访问，提高效率
3.1秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读取这个变量的值，结果永远是旧值
voliate关键字
禁止指令重排
保证可见性
不保证原子性
无锁实现保护共享资源
package com.wl.Juc.Mehod;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
public class RunTest11 {
public static void main(String[] args) {
// 加锁的方式实现
Account accountUnsafe = new AccountUnsafe(10000);
Account.demo(accountUnsafe);
// 不加锁的方式实现(使用cas)
Account accountCas = new AccountCas(10000);
Account.demo(accountCas);
}
}
// 无锁实现保护共享资源
class AccountCas implements Account {
private AtomicInteger balance;
public AccountCas(Integer balance) {
this.balance =new AtomicInteger(balance);
}
@Override
public void withdraw(Integer money) {
while (true) {
int prev = balance.get();
int next = prev - money;
if (balance.compareAndSet(prev, next)) {
break;
}
}
// 可以简化为下面的方法
// balance.addAndGet(-1 * amount);
}
@Override
public Integer getBalance() {
return balance.get();
}
}
class AccountUnsafe implements Account {
private Integer balance;
public AccountUnsafe(Integer balance) {
this.balance = balance;
}
@Override
public void withdraw(Integer money) {
synchronized (this) {
this.balance -= money;
}
}
@Override
public Integer getBalance() {
synchronized (this) {
return balance;
}
}
}
// 账户接口
interface Account {
void withdraw(Integer money);
Integer getBalance();
static void demo(Account account) {
List<Thread> ts = new ArrayList<>();
long start = System.nanoTime();
for (int i = 0; i < 1000; i++) {
ts.add(new Thread(() -> {
account.withdraw(10);
}));
}
ts.forEach(Thread::start);
ts.forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
long end = System.nanoTime();
System.out.println(account.getBalance()
+ " cost: " + (end - start) / 1000_000 + " ms");
}
}
CAS
在保护共享资源,我们使用最多的方式是加锁。但是加锁有的时候会使程序的运行效率比较低,这个时候我们可以使用CAS来实现对共享资源的保护。
其中的关键是 compareAndSet，它的简称就是 CAS （也有 Compare And Swap 的说法），它必须是原子操作。
CAS和Synchronized
- CAS是基于乐观锁的实现,它认为别人不会修改数据,它会在每次修改数据前判断是否有人修改了当前数据,如果修改了,会下次再尝试。它的执行效率比synchronized高的原因是,他不会陷入阻塞,会一直持续执行。
- synchronized是基于悲观锁的实现,它认为别人会修改数据,于是在每次操作数据的时候上锁,直到自己操作完成释放锁,才会让别人修改数据。这样会发生上下文切换,进入阻塞
原子整数(是java提供的线程安全的操作)
AtomicInteger ac = new AtomicInteger(100);
System.out.println(ac.incrementAndGet()); // ++i
System.out.println(ac.getAndIncrement()); // i++
System.out.println(ac.addAndGet(-10)); //负数代表减,正数代表+
System.out.println(ac.get()); //获取最新值
System.out.println(ac.updateAndGet(s->s*10));//可以自己选择运算
原子引用
package com.wl.Juc.Mehod;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
public class RunTest12 {
public static void main(String[] args) {
DecimalAccountCas decimalAccountCas = new DecimalAccountCas(new BigDecimal("10000"));
DecimalAccount.demo(decimalAccountCas);
}
}
interface DecimalAccount {
// 获取余额
BigDecimal getBalance();
// 取款
void withdraw(BigDecimal amount);
/**
* 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
* 如果初始余额为 10000 那么正确的结果应当是 0
*/
static void demo(DecimalAccount account) {
List<Thread> ts = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
ts.add(new Thread(() -> {
account.withdraw(BigDecimal.TEN);
}));
}
ts.forEach(Thread::start);
ts.forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println(account.getBalance());
}
}
class DecimalAccountCas implements DecimalAccount {
AtomicReference<BigDecimal> ref;
public DecimalAccountCas(BigDecimal ref) {
this.ref = new AtomicReference<BigDecimal>(ref);
}
@Override
public BigDecimal getBalance() {
return ref.get();
}
@Override
public void withdraw(BigDecimal amount) {
while (true) {
// 获取最新值
BigDecimal pre = ref.get();
// 获取修改后的值
BigDecimal next = pre.subtract(amount);
if (ref.compareAndSet(pre, next)) {
break;
}
}
}
}
原子引用ABA问题
在执行CAS操作的时候,只能比较并更新值,无法判断在此期间,别人是否修改过共享变量值。于是就存在线程1修改共享变量的值A->B，线程2修改共享变量的值B->A。
package com.wl.Juc.Mehod;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.atomic.AtomicReference;
@Slf4j
public class RunTest13 {
static AtomicReference<String> arf=new AtomicReference<>("A");
public static void main(String[] args) throws InterruptedException {
RunTest13.other();
Thread.sleep(1000);
arf.compareAndSet(arf.get(),"C");
log.debug("change A->C");
}
public static void other() throws InterruptedException {
new Thread(
()->{
log.debug("change A->B", arf.compareAndSet(arf.get(),"B"));
},"t1"
).start();
Thread.sleep(500);
new Thread(
()->{
log.debug("change B->A", arf.compareAndSet(arf.get(),"A"));
},"t2"
).start();
}
}
解决ABA问题-AtomicStampedReference
主线程仅能判断出共享变量的值与最初值 A 是否相同，不能感知到这种从 A 改为 B 又 改回 A 的情况，如果主线程希望：
- 只要有其它线程【动过了】共享变量，那么自己的 cas 就算失败，这时，仅比较值是不够的，需要再一个版本号
- 解决ABA问题主要是加版本号,每次修改让版本号加1
static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);
public static void main(String[] args) throws InterruptedException {
log.debug("main start...");
// 获取值 A
String prev = ref.getReference();
// 获取版本号
int stamp = ref.getStamp();
log.debug("版本 {}", stamp);
// 如果中间有其它线程干扰，发生了 ABA 现象
other();
sleep(1);
// 尝试改为 C
log.debug("change A->C {}", ref.compareAndSet(prev, "C", stamp, stamp + 1));
}
private static void other() {
new Thread(() -> {
log.debug("change A->B {}", ref.compareAndSet(ref.getReference(), "B",
ref.getStamp(), ref.getStamp() + 1));
log.debug("更新版本为 {}", ref.getStamp());
}, "t1").start();
sleep(0.5);
new Thread(() -> {
log.debug("change B->A {}", ref.compareAndSet(ref.getReference(), "A",
ref.getStamp(), ref.getStamp() + 1));
log.debug("更新版本为 {}", ref.getStamp());
}, "t2").start();
}
原子数组
| AtomicIntegerArray | 原子整型数组 |
|---|---|
| AtomicLongArray | 原子长整型数组 |
| AtomicReferenceArray | 原子引用数组 |
| #####案例如下 |
package com.wl.Juc.Mehod;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
public class RunTest15 {
public static void main(String[] args) {
// 原始数组
demo(
()->new int[10],
(arr)->arr.length,
(arr,index)->arr[index]++,
(arr)-> System.out.println(Arrays.toString(arr))
);
// 使用原子数租
demo(
()->new AtomicIntegerArray(10),
(arr)->arr.length(),
(arr,index)->arr.getAndIncrement(index),
(arr)-> System.out.println(arr)
);
}
/**
参数1，提供数组、可以是线程不安全数组或线程安全数组
参数2，获取数组长度的方法
参数3，自增方法，回传 array, index
参数4，打印数组的方法
*/
// supplier 提供者 无中生有 ()->结果
// function 函数 一个参数一个结果 (参数)->结果 , BiFunction (参数1,参数2)->结果
// consumer 消费者 一个参数没结果 (参数)->void, BiConsumer (参数1,参数2)->
private static <T> void demo(
Supplier<T> arraySupplier,
Function<T, Integer> lengthFun,
BiConsumer<T, Integer> putConsumer,
Consumer<T> printConsumer ) {
List< Thread> ts = new ArrayList<>();
T array = arraySupplier.get();
int length = lengthFun.apply(array);
for (int i = 0; i < length; i++) {
// 每个线程对数组作 10000 次操作
ts.add(new Thread(() -> {
for (int j = 0; j < 10000; j++) {
putConsumer.accept(array, j%length);
}
}));
}
ts.forEach(t -> t.start()); // 启动所有线程
ts.forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}); // 等所有线程结束
printConsumer.accept(array);
}
}
原子更新器
| AtomicReferenceFieldUpdater | 原子引用类型字段更新 |
|---|---|
| AtomicIntegerFieldUpdater | 原子整数类型字段更新 |
| AtomicLongFieldUpdater | 原子长整型字段更新 |
| #####代码如下 |
package com.wl.Juc.Mehod;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
public class RunTest16 {
public static void main(String[] args) {
Student stu = new Student();
// 字段更新器
AtomicReferenceFieldUpdater updater=AtomicReferenceFieldUpdater.newUpdater(Student.class,String.class,"name");
System.out.println(updater.compareAndSet(stu,null,"李四"));
System.out.println(stu);
}
}
class Student{
volatile String name;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
}
UnSafe类
UnSafe类是不可以直接获取的,只能通过反射来进行操作。
import lombok.Data;
import sun.misc.Unsafe;
import java.lang.reflect.Field;
public class RunTest17 {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
// Unsafe是可以直接操作内存的一个类,不是不安全的类。
Field theUnsafe= Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
Unsafe unsafe = (Unsafe) theUnsafe.get(null);
// 求出People中 id和name的偏移值
long idOffset = unsafe.objectFieldOffset(People.class.getDeclaredField("id"));
long nameOffset = unsafe.objectFieldOffset(People.class.getDeclaredField("name"));
// 修改People对象中的值
People people = new People();
unsafe.compareAndSwapInt(people,idOffset,0,10);
unsafe.compareAndSwapObject(people,nameOffset,null,"张三");
// 输出people对象
System.out.println(people);
}
}
@Data
class People{
volatile int id;
volatile String name;
}
自己模仿写出AtomicInteger
package com.wl.Juc.Mehod;
import sun.misc.Unsafe;
public class RunTest18 {
public static void main(String[] args) {
Account.demo(new MyAtomicInteger(10000));
}
}
class MyAtomicInteger implements Account{
private volatile int value;
// Unsafe类
private static final Unsafe unsafe;
// 偏移值
private static long offsetValue;
public MyAtomicInteger(int value) {
this.value = value;
}
static {
// 初始化UnSafe类
unsafe = UnSafeUtils.getUnsafe();
try {
// 获取value的偏移值
offsetValue=unsafe.objectFieldOffset(MyAtomicInteger.class.getDeclaredField("value"));
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
public int getValue() {
return value;
}
public void decrement(int amount){
while (true){
int pre=this.value;
int next=pre-amount;
if (unsafe.compareAndSwapInt(this,offsetValue,pre,next)){
break;
}
}
}
@Override
public void withdraw(Integer money) {
this.decrement(money);
}
@Override
public Integer getBalance() {
return getValue();
}
}
工具类
package com.wl.Juc.Mehod;
import sun.misc.Unsafe;
import java.lang.reflect.Field;
public class UnSafeUtils {
private static Unsafe unsafe;
private UnSafeUtils(){}
static {
try {
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
unsafe= (Unsafe) theUnsafe.get(null);
} catch (NoSuchFieldException | IllegalAccessException e) {
e.printStackTrace();
}
}
public static Unsafe getUnsafe(){
return unsafe;
}
}
Account接口
// 账户接口
interface Account {
void withdraw(Integer money);
Integer getBalance();
static void demo(Account account) {
List<Thread> ts = new ArrayList<>();
long start = System.nanoTime();
for (int i = 0; i < 1000; i++) {
ts.add(new Thread(() -> {
account.withdraw(10);
}));
}
ts.forEach(Thread::start);
ts.forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
long end = System.nanoTime();
System.out.println(account.getBalance()
+ " cost: " + (end - start) / 1000_000 + " ms");
}
}
不可变对象
我们在操作共享资源的时候,可以使用加锁或者CAS无锁保证线程安全,还有一种就是使用不可变的对象保证线程安全。
以下是不可变时间日期保证线程安全:
package com.wl.Juc.Mehod;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAccessor;
import java.util.Date;
/**
* 不可变类的使用
*/
public class RunTest20 {
public static void main(String[] args) {
// 使用不可变类保证线程安全
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd");
for (int i = 0; i < 10; i++) {
new Thread(
() -> {
try {
TemporalAccessor parse = dtf.parse("2021-01-09");
System.out.println(parse);
} catch (Exception e) {
e.printStackTrace();
}
}
).start();
}
}
/**
* 加锁实现
*/
private static void Lock () {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (int i = 0; i < 10; i++) {
new Thread(
() -> {
try {
synchronized (sdf) {
Date parse = sdf.parse("2021-01-09");
System.out.println(parse);
}
} catch (ParseException e) {
e.printStackTrace();
}
}
).start();
}
}
}
线程池
Executor线程连接池
4. 线程池的7大参数
public ThreadPoolExecutor(
int corePoolSize, // 核心线程池大小
int maximumPoolSize, // 最大核心线程池大小
long keepAliveTime, // 超时了没有人会调用就会释放
TimeUnit unit, // 超时单位
BlockingQueue<Runnable> workQueue, // 阻塞队列
ThreadFactory threadFactory, // 线程工厂,创建线程的,一般不用动
RejectedExecutionHandler handler) // 拒绝策略
5.四大策略
AbortPolicy() 抛出异常 不处理
CallerRunsPolicy 不抛出异常 哪里来的去哪里
DiscardOldestPolicy 队列满了,尝试和最早的竞争,如果竞争成功则执行，否则被抛弃,不会抛出异常
DiscardPolicy 队列满了,丢掉任务,不会抛出异常
常见的线程池
FixedThreadPool(固定线程池)
- 这种线程池的特点就是一个线程池中的线程数量是固定的。如果此线程池数量过少,当线程池任务过多时,会导致大量线程等待,如果过少,会浪费资源。
- 使用的是 LinkedBlockingQueue(双向链表),阻塞队列是无界的。
SingleThreadPool(单线程池)
- 这种线程池的特点就是一个线程池里只有一个线程。当线程任务过多,会造成大量线程等待。
- 使用的是 LinkedBlockingQueue(双向链表),阻塞队列是无界的。
CachedThreadPool(弹性缓存线程池)
-这种线程池的特点是线程池在创建的时候是一个线程都没有的,当来了线程任务的时候,会自动新建线程,如果线程池有空余线程,则不会新建,这种线程池一般可以容纳几万个线程,线程空余60s会被回收,但是这样的写法也会带来一个缺点,一旦线程无限增长,到导致内存OOM。
- 使用的是 SynchronousQueue(同步队列),它没有容量，没有线程来取是放不进去的
Fork/Join
- Fork/Join 是 JDK 1.7 加入的新的线程池实现，它体现的是一种分治思想，适用于能够进行任务拆分的 cpu 密集型
运算 - 所谓的任务拆分，是将一个大任务拆分为算法上相同的小任务，直至不能拆分可以直接求解。跟递归相关的一些计算，如归并排序、斐波那契数列、都可以用分治思想进行求解
- Fork/Join 在分治的基础上加入了多线程，可以把每个任务的分解和合并交给不同的线程来完成，进一步提升了运
算效率 - Fork/Join 默认会创建与 cpu 核心数大小相同的线程池
13.AQS原理
全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的同步器工具的框架
特点：
- 用 state 属性来表示资源的状态（分独占模式和共享模式），子类需要定义如何维护这个状态，控制如何获取锁和释放锁
- getState - 获取 state 状态
- setState - 设置 state 状态
- compareAndSetState - cas 机制设置 state 状态
- 独占模式是只有一个线程能够访问资源，而共享模式可以允许多个线程访问资源
- 提供了基于 FIFO 的等待队列，类似于 Monitor 的 EntryList
- 条件变量来实现等待、唤醒机制，支持多个条件变量，类似于 Monitor 的 WaitSet
子类主要实现这样一些方法（默认抛出 UnsupportedOperationException）
- tryAcquire
- tryRelease
- tryAcquireShared
- tryReleaseShared
- isHeldExclusively
ReentrantLock底层也用到了AQS，在ReentrantLock中有一个Sync（同步器）,他继承了AQS。
