JUC并发编程学习（二）

JUC并发编程学习（二） 15、异步回调（同ajax）

拒绝阻塞，与主线程同步执行（个人理解）

package com.huang.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //runAsync 没有返回值
//        CompletableFuture future =  CompletableFuture.runAsync(()->{
//            try{
//                TimeUnit.SECONDS.sleep(2);
//            }catch (InterruptedException e){
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()+"runAsync=》void");
//        });
//        System.out.println(111);
//        future.get();
        //有返回值的SupplyAsync（）
        CompletableFuture uCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName()+"uCompletableFuture=>()");
            return 1024/0;
        });
        System.out.println(uCompletableFuture.whenComplete((t, u) -> {
            System.out.println("t=>" + t); //正确结果
            System.out.println("u=>" + u); //错误结果
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 233;
        }).get());

    }

}

16、JMM

谈谈你对volatile的理解

Volatile是java虚拟机提供轻量级的同步机制

1、保证可见性

2、不保证原子性

3、禁止指令重排

什么是JMM

JMM：java内存模型，是一种约定不存在！

关于JMM的一些同步约定：

1、线程解锁前，必须把共享变量立刻刷回主存。

2、线程加锁前，必须读取主存中最新的值到工作内存中！

3、加锁和解锁是同一把锁

线程 工作内存和主内存

八种 *** 作：

17、Volatile

1、保证可见性：

package com.huang.VolatileDemo;

import java.util.concurrent.TimeUnit;

public class Test01 {
    private volatile static int num=0;//加了volatile分线程可以实时监测主线程中num的变化
    public static void main(String[] args) {
        new Thread(()->{
            while (num==0){//对主内存变化不知道
//                System.out.println(num);
            }
        }).start();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num = 1;
        System.out.println(num);
    }
}

2、不保证原子性：

原子性：不可分割！

如何实现原子性：加入 synochronized 和lock锁！另外还有利用原子类（利用 *** 作系统底层代码）

package com.huang.VolatileDemo;
import java.util.concurrent.atomic.AtomicInteger;

public class AutomicTest {
    private volatile static AtomicInteger num=new AtomicInteger();
    public static void  add(){
        num.getAndIncrement();
    }
    public static void main(String[] args) {
        for (int i = 1; i <=20 ; i++) {
            new Thread(()->{
                for (int j = 1; j <=1000 ; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(num);
    }
}****

while (Thread.activeCount()>2){
Thread.yield();
}
System.out.println(num);
}
}****