六)、共享模型之无锁1.问题提出(1).为什么不安全?(2).安全实现_使用锁(3).安全实现_使用CAS

2.CAS与volatile(1).CAS_原理介绍(2).CAS_Debug分析(3).volatile(4).为什么无锁效率高(5).CAS的特点

3.原子整形(1).原子整数类型_

原子引用类型(1).不安全的实现(2).安全实现_使用锁(3).安全实现_使用

CAS

问题(5).ABA问题解决1_AtomicStampedReference(6).ABA问题解决2_AtomicMarkableReference

使用CAS

6.字段更新器(1).未使用voliatile修饰的时候会报异常(2).使用voliatile修饰后(3).存在问题ABA问题

7.原子累加器(1).运用累加器类性能更高(2).为什么性能高呢?(4).源码之

LongAdder(5).cas

8.UnSafe(1).概述(2).获取UnSafe实列(3).UnSafe的Case操作(4).模拟原子整数

(七)、共享模型之不可变1.日期转换的问题(1).问题提出(2).思路

同步锁(3).思路

{account.withdraw(10);}));}ts.forEach(Thread::start);ts.forEach(t

{try

System.nanoTime();System.out.println(account.getBalance()

cost:

cn/itcast/AccountUnsafe.balance

Ljava/lang/Integer;

cn/itcast/AccountUnsafe.balance

Ljava/lang/Integer;

cn/itcast/AccountUnsafe.balance

thread-0

cn/itcast/AccountUnsafe.balance

thread-0

cn/itcast/AccountUnsafe.balance

thread-1

cn/itcast/AccountUnsafe.balance

thread-1

java.util.concurrent.atomic.AtomicInteger;/***

Author

的解决方法内部并没有用锁来保护共享变量的线程安全。

那么它是如何实现的呢

public

比如说线程1先获取余额为100然后减去10结果为90此时还没有来得及进行cas的操作线程2已经把原来100的值修改为了90。

经比较线程2的将prev90更新到主存主存prev为90与线程1获取的prev值100是不相等那么返回fasle线程1再次进行重新-10操作.

CAS

会让总线锁住当这个核把此指令执行完毕再开启总线。

这个过程中不会被线程的调度机制所打断保证了多个线程对内存操作的准确性是原子的。

(2).CAS_Debug分析

3.获取最新值再次比较如果其他线程没有再次改变那么就返回true

(3).volatile

它可以用来修饰成员变量和静态成员变量他可以避免线程从自己的工作缓存中查找变量的值必须到主存中获取它的值线程操作

volatile

仅仅保证了共享变量的可见性让其它线程能够看到最新值也能保证程序的有序性但不能解决指令交错问题不能保证原子性

CAS

会让线程在没有获得锁的时候发生上下文切换进入阻塞。

打个比喻线程就好像高速跑道上的赛车高速运行时速度超快一旦发生上下文切换就好比赛车要减速、熄火等被唤醒又得重新打火、启动、加速…

恢复到高速运行代价比较大但无锁情况下因为线程要保持运行需要额外

CPU

在这里就好比高速跑道没有额外的跑道线程想高速运行也无从谈起虽然不会进入阻塞但由于没有分到时间片仍然会进入可运行状态还是会导致上下文切换。

线程数不超过CPU的核定线程数都很高效假如超过了效率就会大幅降低。

CAS

是基于乐观锁的思想最乐观的估计不怕别的线程来修改共享变量就算改了也没关系我吃亏点再重试呗。

synchronized

是基于悲观锁的思想最悲观的估计得防着其它线程来修改共享变量我上了锁你们都别想改我改完了解开锁你们才有机会。

CAS

因为没有使用

synchronized所以线程不会陷入阻塞这是效率提升的因素之一。

但如果竞争激烈可以想到重试必然频繁发生反而效率会受影响。

3.原子整形

AtomicBooleanAtomicIntegerAtomicLong

AtomicInteger

原子类的所有方法都是线程安全的都具有原子性且CAS自旋的操作。

所以刚才的取账问题我们可以用

addAndGet()

java.util.concurrent.atomic.AtomicInteger;/***

Author

AtomicInteger(1);System.out.println(先获取再自增的操作

iSystem.out.println(先自减再获取的操作:integer.decrementAndGet());

--iSystem.out.println(先获取再自检的操作:integer.getAndDecrement());

i--System.out.println(最终得值为:integer);System.out.println();System.out.println(自定义后增加:integer.getAndAdd(4));

先获取再4System.out.println(最终得值为:integer);System.out.println(自定义先增加:integer.addAndGet(4));

先自增4

在获取System.out.println(最终得值为:integer);System.out.println();}

(2).原子整数类型_乘除模

java.util.concurrent.atomic.AtomicInteger;/***

Author

会发生CAS自旋的操作System.out.println(integer.updateAndGet((value)-{return

value*10;}));

先修改在获取之System.out.println(integer.getAndUpdate((value)-{return

value*10;}));

AtomicReferenceAtomicMarkableReferenceAtomicStampedReference

有如下方法

{account.withdraw(BigDecimal.TEN);}));}ts.forEach(Thread::start);ts.forEach(t

{try

{e.printStackTrace();}});System.out.println(account.getBalance());}

package

DecimalAccountUnsafe(BigDecimal

balance)

balance.subtract(amount);}public

static

DecimalAccountSafeLock(BigDecimal

balance)

balance.subtract(amount);}}public

static

java.util.concurrent.atomic.AtomicReference;/***

Author

DecimalAccountSafeCas(BigDecimal

balance)

AtomicReference(balance);}Overridepublic

BigDecimal

主存与新值进行比较一样则false。

break;}}}public

static

lombok.extern.slf4j.Slf4j;import

java.util.concurrent.atomic.AtomicReference;/***

Author

ref.get();Thread.sleep(1000);//

尝试改为

lombok.extern.slf4j.Slf4j;import

java.util.concurrent.atomic.AtomicReference;/***

Author

ref.get();other();Thread.sleep(1000);//

尝试改为

t1).start();Thread.sleep(500);new

Thread(()

lombok.extern.slf4j.Slf4j;import

java.util.concurrent.atomic.AtomicReference;/***

Author

ref.get();other();Thread.sleep(1000);//

尝试改为

t1).start();Thread.sleep(500);new

Thread(()

(5).ABA问题解决1_AtomicStampedReference

cas

lombok.extern.slf4j.Slf4j;import

java.util.concurrent.atomic.AtomicReference;

import

java.util.concurrent.atomic.AtomicStampedReference;/***

Author

现象other();Thread.sleep(1000);//

尝试改为

判断stamp当前版本号与主存中的版本号是否一致}private

static

ref.compareAndSet(ref.getReference(),

B,ref.getStamp(),

t1).start();Thread.sleep(500);new

Thread(()

ref.compareAndSet(ref.getReference(),

A,ref.getStamp(),

通过AtomicStampedReference我们可以知道引用变量中途被更改了几次。

(6).ABA问题解决2_AtomicMarkableReference

但是有时候并不关心引用变量更改了几次只是单纯的关心是否更改过所以就有了AtomicMarkableReference.

package

lombok.extern.slf4j.Slf4j;import

java.util.concurrent.atomic.AtomicMarkableReference;/***

Author

TestABAAtomicMarkableReference*

Description:

⭐AtomicMarkableReferenceGarbageBag

ref

ref.getReference();log.debug(prev.toString());//

2.保洁阿姨打扫卫生...new

{}log.debug(bag.toString());}).start();Thread.sleep(1000);log.debug(主线程想换一只新垃圾袋);boolean

success

success);log.debug(ref.getReference().toString());}

5.原子数组

AtomicIntegerArrayAtomicLongArrayAtomicReferenceArray

package

java.util.function.Supplier;/***

Author

⭐非原子数组的创建(array)-array.length,(array,index)-array[index],(array)-

System.out.println(Arrays.toString(array)));}/***

参数3自增方法回传

等所有线程结束printConsumer.accept(array);}

}(2).安全实现_

java.util.concurrent.atomic.AtomicIntegerArray;

import

java.util.function.Supplier;/***

Author

提供长度(array,index)-array.getAndIncrement(index),

System.out.println(array));}/***

参数3自增方法回传

等所有线程结束printConsumer.accept(array);}

}6.字段更新器

字段AtomicIntegerFieldUpdaterAtomicLongFieldUpdater

利用字段更新器可以针对对象的某个域Field进行原子操作只能配合

volatile

lombok.extern.slf4j.Slf4j;import

java.util.concurrent.atomic.AtomicReferenceFieldUpdater;/***

Author

AtomicReferenceFieldUpdater.newUpdater(Student.class,String.class,name);//

1.第一个参数:

修改成什么值updater.compareAndSet(student,null,张三);}

}class

lombok.extern.slf4j.Slf4j;import

java.util.concurrent.atomic.AtomicReferenceFieldUpdater;/***

Author

AtomicReferenceFieldUpdater.newUpdater(Student.class,String.class,name);//

1.第一个参数:

修改成什么值updater.compareAndSet(student,null,张三);System.out.println(student.toString());}

}class

lombok.extern.slf4j.Slf4j;import

java.util.concurrent.atomic.AtomicReferenceFieldUpdater;/***

Author

AtomicReferenceFieldUpdater.newUpdater(Student.class,String.class,name);//

2.第一个参数:

⭐⭐updater.compareAndSet(student,null,张三);System.out.println(student.toString());//

3.原始值指的正确那么会成功。

⭐⭐⭐updater.compareAndSet(student,张三,张四);System.out.println(student.toString());//

⭐⭐⭐⭐updater.compareAndSet(student,张三,张五);System.out.println(student.toString());}

}class

lombok.extern.slf4j.Slf4j;import

java.util.ArrayList;

java.util.concurrent.atomic.AtomicLong;

import

java.util.concurrent.atomic.LongAdder;

import

java.util.function.Supplier;/***

Author

1.设置我们的原子长整型(adder)-adder.getAndIncrement()

//2.进行自增的操作);System.out.println(上面是原子长整型类下面是长整型累加器);demo(()-new

LongAdder(),(adder)-adder.increment());}/****

param

{action.accept(adder);}}));}ts.forEach(t

{try

System.nanoTime();System.out.println(adder

cost:

性能提升的原因很简单就是在有竞争时设置多个累加单元Therad-0

Cell[0]而

重试失败从而提高性能。

相当于不共享一个累加单元每一个线程都有一个自己的累加单元!!!

(4).源码之

CAS锁的源码实践但是实际开发中我们不用用下面这样的代码进行开发

package

lombok.extern.slf4j.Slf4j;import

java.util.concurrent.atomic.AtomicInteger;/***

Author

{log.debug(unlock...);state.set(0);}public

static

{log.debug(begin...);lock.lock();try

catch

{log.debug(begin...);lock.lock();try

finally

UNSAFE.compareAndSwapLong(this,

valueOffset,

缓存的加入会造成数据副本的产生即同一份数据会缓存在不同核心的缓存行中。

CPU

用来解决这个问题它的原理是在使用此注解的对象或字段的前后各增加

128

将对象预读至缓存时占用不同的缓存行这样不会造成对方缓存行的失效。

(7).add源码

Unsafe.class.getDeclaredField(theUnsafe);//

2.因为是私有的成员变量所以我们需要先设置Accessibleunsafe.setAccessible(true);//

(Unsafe)unsafe.get(null);System.out.println(o);}

package

Unsafe.class.getDeclaredField(theUnsafe);//

2.因为是私有的成员变量所以我们需要先设置Accessibleo.setAccessible(true);//

unsafe

(Unsafe)o.get(null);System.out.println(o);//

idOffset

unsafe.objectFieldOffset(Student1.class.getDeclaredField(id));long

nameOffset

unsafe.objectFieldOffset(Student1.class.getDeclaredField(name));Student1

student1

操作unsafe.compareAndSwapInt(student1,idOffset,0,1);

第一个:

新值unsafe.compareAndSwapObject(student1,nameOffset,null,张三);

第一个:

每次取10块钱account.withdraw(10);}));}ts.forEach(Thread::start);ts.forEach(t

{try

System.nanoTime();System.out.println(account.getBalance()

cost:

Unsafe.class.getDeclaredField(theUnsafe);theUnsafe.setAccessible(true);unsafe

(Unsafe)

2.获取我们偏移域valueOffsetunsafe.objectFieldOffset(MyAtomicInteger.class.getDeclaredField(value));}

catch

(unsafe.compareAndSwapInt(this,valueOffset,prev,next)){break;}}}Overridepublic

Integer

lombok.extern.slf4j.Slf4j;import

java.text.SimpleDateFormat;/***

Author

SimpleDateFormat(yyyy-MM-dd);//

2.开启十个线程进行解析for

java.lang.NumberFormatException

(数字类型错误)

lombok.extern.slf4j.Slf4j;import

java.text.SimpleDateFormat;/***

Author

SimpleDateFormat(yyyy-MM-dd);//

2.开启十个线程进行解析for

如果一个对象在不能够修改其内部状态属性那么它就是线程安全的因为不存在并发修改啊这样的对象在Java

中有很多例如在

lombok.extern.slf4j.Slf4j;import

import

java.time.format.DateTimeFormatter;/***

Author

DateTimeFormatter.ofPattern(yyyy-MM-dd);for

(int

StringIndexOutOfBoundsException(beginIndex);}int

subLen

StringIndexOutOfBoundsException(subLen);}return

(beginIndex

StringIndexOutOfBoundsException(offset);}if

(count

StringIndexOutOfBoundsException(count);}if

(offset

StringIndexOutOfBoundsException(offset

count);}this.value

。

这种通过创建副本对象来避免共享的手段称之为【保护性拷贝defensive

3.享元模式

BooleanByteShortIntegerLongCharacter

valueOf

-Djava.lang.Integer.IntegerCache.high

来改变

达到数千如果每次都重新创建和关闭数据库连接性能会受到极大影响。

这时预先创建好一批连接放入连接池。

一次请求到达后从连接池获取连接使用完毕后再还回连接池这样既节约了连接的创建和关闭时间也实现了连接的重用不至于让庞大的连接数压垮数据库。

class

Connection[poolSize];this.states

new

{log.debug(wait...);this.wait();}

catch

conn);this.notifyAll();}break;}}}}class

MockConnection

指令来完成同样在这条指令之后也会加入写屏障保证在其它线程读到它的值时不会出现为

(2).获取final

因为成员变量保存的数据也可以称为状态信息因此没有成员变量就称之为【无状态】