Java内存模型，是一个概念，不存在的东西，概念、约定
规则：
是Java虚拟机提供的轻量级的同步机制
保证可见性，线程A对主存中变量的修改，线程B会知道，给变量加上volatile
不保证原子性，原子性是不可分割。
/*private static volatile int num = 0;// volatile 不保证原子性的
public static void add(){
num++;// 不具有原子性
}
*/
//java.util.concurrent.atomic.AtomicInteger;
private static volatile AtomicInteger num =new AtomicInteger();
public static void add(){
num.getAndIncrement(); //用的是CAS，效率比synchronized高
}
public static void main(String[] args) {
// 按道理结果应该是20000，但是
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while (Thread.activeCount() > 2){
Thread.yield();
}
System.out.println(Thread.currentThread().getName() + " "+num);
}
如果不加lock和synchronized，怎么保证原子性，java.util.concurrent.atomic
//java.util.concurrent.atomic.AtomicInteger;
private static volatile AtomicInteger num =new AtomicInteger();
public static void add(){
num.getAndIncrement(); //用的是CAS，效率比synchronized高, 在内存中修改值，UnSafe类是特殊的存在
}
禁止指令重排
a,b,x,y=0
| 线程A | 线程B |
|---|---|
| x=a | y=b |
| b=1 | a=2 |
正常结果：x=0，y=0
| 线程A | 线程B |
|---|---|
| b=1 | a=2 |
| x=a | y=b |
指令重排之后：x=2, y=1
Volatile可以避免指令重排：
内存屏障（禁止上面和下面指令顺序交换），CPU指令：
饿汉式
package com.clay.single;
// 饿汉式单例
public class Hungry {
private Hungry(){
}
//饿汉式，一上来就加载了一个对象，可能会浪费空间
private final static Hungry HUNGRY = new Hungry();
public static Hungry getInstance(){
return HUNGRY;
}
public static void main(String[] args) {
}
}
懒汉式
package com.clay.single;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
// 懒汉式单例
public class LazyMan {
private static boolean flag = false;
private LazyMan(){
// synchronized (LazyMan.class){
// // 防止通过反射来破坏单例，但是
// // 多个反射同时创建还是会出问题
// if(lazyMan != null){
// throw new RuntimeException("不要试图通过反射来破坏");
// }
// }
synchronized (LazyMan.class){
if(flag == false){
flag = true;
}else {
throw new RuntimeException("不要试图通过反射来破坏");
}
}
}
private volatile static LazyMan lazyMan;
public static LazyMan getInstance(){
if (lazyMan == null){
synchronized (LazyMan.class){
if(lazyMan==null){
lazyMan = new LazyMan();//不是原子性操作
// 分配内存空间、执行构造方法初始化对象、对象指向空间
// 如果发生指令重排，先执行了对象指向空间，有可能别的线程进来了
//判断不等于null，就直接返回，空指针，因此应加上volatile
}
}
}//并发下有问题，加双重锁
return lazyMan;
}
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
LazyMan instance = LazyMan.getInstance();
//通过反射来破坏单例
Constructor<LazyMan> constructor = LazyMan.class.getConstructor(null);
constructor.setAccessible(true);//无视私有构造器
LazyMan lazyMan = constructor.newInstance();
}
}
静态内部类
package com.clay.single;
public class Holder {
private Holder(){
}
public static Holder getInstance(){
return InnerClass.HOLDER;
}
//静态内部类
public static class InnerClass{
private static final Holder HOLDER = new Holder();
}
}
枚举
反射无法破坏枚举的单例
比较当前工作内存中的值和主内存的值，如果这个值是期望的，则执行操作，如果不是则继续循环（自旋锁），CAS是CPU原语，速度很快。
缺点：循环会耗时、一次性只能保证一个共享变量的原子性、存在ABA问题。
compareAndSet源码：（compareAndSwap）
//Atomically sets the value to the given updated value if the current value == the expected value
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
//CAS compareAndSet比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2021);
// 如果期望值相同，更新
atomicInteger.compareAndSet(2021,2022);
System.out.println(atomicInteger.get());
}
ABA问题：A换成B又换成A
AtomicReference 和AtomicStampReference
乐观锁原理，每一次改变操作，版本号加1
公平锁和非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}//默认是非公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}//可以更改为公平锁
可重入锁
可重入锁(递归锁)：拿到了外层的锁，自动也就获取了内部的锁
class Phone{ Lock lock = new ReentrantLock(); //有两把锁，获取了我外层锁，就获得了内部锁，一因此会一个线程先执行完两个函数，再换下一个线程执行 public void send(){ lock.lock(); try { System.out.println(Thread.currentThread().getName() + "hi"); call(); } catch (Exception e) { e.printStackTrace(); } finally { lock.unlock(); } } public void call(){ lock.lock(); try { System.out.println(Thread.currentThread().getName() + "call"); } catch (Exception e) { e.printStackTrace(); } finally { lock.unlock(); } }}
自旋锁
不断尝试，直到成功，是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。
public class SpinLock {
//原子引用
AtomicReference<Thread> atomicReference = new AtomicReference<>();
// 加锁
public void myLock(){
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName()+"mylock");
// 自旋锁
while (!atomicReference.compareAndSet(null,thread)){
}
}
//解锁
public void unMyLock(){
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName()+"unmylock");
atomicReference.compareAndSet(thread,null);
}
}
死锁
两个线程互相抢夺对方手里的资源
死锁长生的四个必要条件：
package com.clay.lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
//死锁
public class DeadLock {
public static void main(String[] args) {
String LockA = "LockA";
String LockB = "LockB";
new Thread(new MyThread(LockA,LockB)).start();
new Thread(new MyThread(LockB,LockA)).start();
}
}
class MyThread implements Runnable{
private String LockA;
private String LockB;
public MyThread(String lockA, String lockB) {
LockA = lockA;
LockB = lockB;
}
@Override
public void run() {
synchronized (LockA){
System.out.println(Thread.currentThread().getName()+"拿到"+LockA+"想要"+LockB);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (LockB){
System.out.println(Thread.currentThread().getName()+"拿到"+LockB+"想要"+LockA);
}
}
}
}
通过jps -l定位进程号
通过jstak 进程号来找到死锁。