1、什么是JUC?
java.util工具包、包、分类
2、线程和进程
进程:一个程序,如,QQ.exe Music.exe 程序的集合
一个进程往往可以包含多个线程,至少包含一个
Java默认有几个进程?2个—> main线程、GC线程
对于Java而言:Thread、Runnable、Callable
Java真的可以开启线程吗?开不了
并发编程:并发、并行
并发(多线程操作同一个资源)
CPU一核,模拟出来多条线程,天下武功,唯快不破,快速交替
并行(多个人一起行走)
CPU多核,多个线程可以同时执行,线程池
public class Test1 {
public static void main(String[] args) {
//获取CPU的核数
//CPU密集型,IO密集型
System.out.println(Runtime.getRuntime().availableProcessors());
}
}
并发编程的本质:充分利用CPU资源
线程的状态:6个
public enum State {
//新生(创建)
NEW,
//运行
RUNNABLE,
//阻塞
BLOCKED,
//等待(死死地等)
WAITING,
//超时等待
TIMED_WAITING,
//终止
TERMINATED;
}
wait和sleep的区别?
1、来自不同的类
wait来自Object
sleep来自Thread
2、关于锁的释放
wait会释放锁,sleep睡觉了,抱着锁睡觉,不会释放
3、使用的范围不同
wait
必须在同步代码块中
sleep
可以在任何地方睡
4、是否需要捕获异常
wait不需要捕获异常
sleep必须捕获异常
3、Lock锁(重点)
//卖票的例子
//真正的多线程开发
//线程就是一个单独的资源类,没有任何附属的操作
public class Test1 {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(()->{
for (int i = 0; i < 40; i++) {
ticket.sale();
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 40; i++) {
ticket.sale();
}
},"B").start();
new Thread(()->{
for (int i = 0; i < 40; i++) {
ticket.sale();
}
},"C").start();
}
}
//资源类 OOP
class Ticket{
//属性 方法
private int number = 50;
//卖票的方式
public synchronized void sale(){
if(number > 0){
System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票,剩余:"+number);
}
}
}
//卖票的例子
//真正的多线程开发
//线程就是一个单独的资源类,没有任何附属的操作
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test02 {
public static void main(String[] args) {
Ticket2 ticket = new Ticket2();
new Thread(()->{for (int i = 0; i < 40; i++) ticket.sale();},"A").start();
new Thread(()->{for (int i = 0; i < 40; i++) ticket.sale();},"B").start();
new Thread(()->{for (int i = 0; i < 40; i++) ticket.sale();},"C").start();
}
}
//Lock三部曲
//1、Lock lock = new ReentrantLock();
//2、lock.lock(); //加锁
//3、finally------>lock.unlock();
//资源类 OOP
class Ticket2{
//属性 方法
private int number = 50;
//创建锁
Lock lock = new ReentrantLock();
//卖票的方式
public synchronized void sale(){
lock.lock();//加锁
try {
//业务代码
if(number > 0){
System.out.println(Thread.currentThread().getName()+"卖出了"+(number--)+"票,剩余:"+number);
}
} finally {
//解锁
lock.unlock();
}
}
}
Synchronized 和Lock的区别?
1、Synchronized 内置的java关键字,Lock是一个java类
2、Synchronized 无法判断获取锁的状态,Lock可以判断是否获取到了锁
3、Synchronized 会自动释放锁,Lock必须手动释放锁,如果不释放锁,会产生死锁
4、Synchronized 线程1(获得锁,阻塞)、线程2(等待,傻傻的等);Lock锁就不一定会等下去
5、Synchronized 可重入锁,不可中断的,非公平;Lock,可重入锁,可以判断锁,非公平(可以自己设置)
6、Synchronized 适合锁少量的代码同步问题,Lock适合锁大量的同步代码
锁是什么?如何判断锁的是谁?
4、生产者消费者问题
面试问题:单例模式,排序算法,生产者消费者,死锁
业务:判断等待,执行,通知
两个线程的生产者消费者问题
//生产者消费者问题实现加一减一操作
public class A {
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
}
}
class Data{
private int number = 0;
//+1
public synchronized void increment() throws InterruptedException {
//业务:判断等待,执行,通知
if(number != 0){
//等待
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName()+"->"+number);
//通知其他线程,+1完毕了
this.notifyAll();
}
//-1
public synchronized void decrement() throws InterruptedException {
//业务:判断等待,执行,通知
if(number == 0){
//等待
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"->"+number);
//通知其他线程,-1完毕了
this.notifyAll();
}
}
新的问题:4个线程,ABCD怎么解决?
如果是4个线程的话就会出现问题,因为if()只判断一次,可能两个线程都进去了,就不会等待,解决方案就是把if()改为while(),就会循环等待,一个线程A拿到了锁,另一个线程C等待,B拿到锁了,D等待
//将if()判断语句改为while()
public class A {
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"C").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"D").start();
}
}
class Data{
private int number = 0;
//+1
public synchronized void increment() throws InterruptedException {
while(number != 0){
//等待
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName()+"->"+number);
//通知其他线程,+1完毕了
this.notifyAll();
}
//-1
public synchronized void decrement() throws InterruptedException {
while(number == 0){
//等待
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"->"+number);
//通知其他线程,-1完毕了
this.notifyAll();
}
}
JUC版的生产者消费者问题,使用condition监视器实现
代码实现
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class B {
public static void main(String[] args) {
Data2 data = new Data2();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"C").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"D").start();
}
}
class Data2{
private int number = 0;
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
// condition.await();//等待
// condition.signalAll();//唤醒全部
//+1
public void increment() throws InterruptedException {
lock.lock();
try {
while(number != 0){
//等待
condition.await();
}
number++;
System.out.println(Thread.currentThread().getName()+"->"+number);
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
//-1
public void decrement() throws InterruptedException {
lock.lock();
try {
while(number == 0){
//等待
condition.await();
}
number--;
System.out.println(Thread.currentThread().getName()+"->"+number);
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
Condition监视器实现精准通知线程执行:
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class C {
public static void main(String[] args) {
Data3 data = new Data3();
new Thread(()->{
for (int i = 0; i < 10; i++) {
data.printA();
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
data.printB();
}
},"B").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
data.printC();
}
},"C").start();
}
}
class Data3{
public int number = 1;
private Lock lock = new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();
public void printA(){
lock.lock();
try {
while(number != 1){
condition1.await();
}
System.out.println(Thread.currentThread().getName()+"->AAAAAA");
number = 2;
//唤醒指定的人,B
condition2.signal();
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void printB() {
lock.lock();
try {
while(number != 2){
condition2.await();
}
System.out.println(Thread.currentThread().getName()+"->BBBBBB");
number = 3;
//唤醒指定的人,C
condition3.signal();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
public void printC() {
lock.lock();
try {
while(number != 3){
condition3.await();
}
System.out.println(Thread.currentThread().getName()+"->BBBBBB");
number = 1;
//唤醒指定的人,C
condition1.signal();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
5、8锁现象
锁是什么?如何判断锁的是谁?
对象、Class
Test01.java
/**
* 8锁,就是关于锁的8个问题
* 1、标准情况下,两个线程先打印 发短信 还是 打电话
* 1、sendSms延迟4秒,两个线程先打印 发短信 是 打电话?
*/
import java.util.concurrent.TimeUnit;
public class Test01 {
public static void main(String[] args) {
Phone phone = new Phone();
//锁的存在
new Thread(()->{
phone.sendSms();
},"A").start();
//捕获
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
},"A").start();
}
}
class Phone{
//synchronized 锁的对象是方法的调用者
//两个方法用的是同一个锁,谁先拿到谁先执行
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
Test02.java
/**
* 3、增加了一个普通方法,先执行发短信还是hello? 普通方法
* 4、两个对象,两个同步方法,先执行发短信还是打电话
*/
import java.util.concurrent.TimeUnit;
public class Test02 {
public static void main(String[] args) {
//两个对象,两个调用者,两把锁
Phone2 phone1 = new Phone2();
Phone2 phone2 = new Phone2();
//锁的存在
new Thread(()->{
phone1.sendSms();
},"A").start();
//捕获
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
},"B").start();
}
}
class Phone2{
//synchronized 锁的对象是方法的调用者
//两个方法用的是同一个锁,谁先拿到谁先执行
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
//这里没有锁,不是同步方法,不受锁的影响
public void hello(){
System.out.println("hello");
}
}
Test03.java
import java.util.concurrent.TimeUnit;
/**
* 5、增加两个静态的同步方法,先打印发短信还是打电话
* 两个方法是同一个锁,锁的是Class
*/
public class Test3 {
public static void main(String[] args) {
//两个对象的类模板只有一个,锁的是Class
Phone3 phone1 = new Phone3();
Phone3 phone2 = new Phone3();
//锁的存在
new Thread(()->{
phone1.sendSms();
},"A").start();
//捕获
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
},"B").start();
}
}
class Phone3{
//synchronized 锁的对象是方法的调用者
//static 静态方法,类一加载,就有了,锁的是Class模板
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public static synchronized void call(){
System.out.println("打电话");
}
//这里没有锁,不是同步方法,不受锁的影响
public void hello(){
System.out.println("hello");
}
}
Test04.java
/**
* 1、1个静态的同步方法,1个普通同步方法,1个对象
* 1、1个静态的同步方法,1个普通同步方法,2个对象,先打印哪个?
*/
import java.util.concurrent.TimeUnit;
public class Test04 {
public static void main(String[] args) {
//两个对象的类模板只有一个,锁的是Class
Phone4 phone1 = new Phone4();
Phone4 phone2 = new Phone4();
//锁的存在
new Thread(()->{
phone1.sendSms();
},"A").start();
//捕获
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
},"B").start();
}
}
class Phone4{
//static 静态方法,类一加载,就有了,锁的是Class模板
//静态同步方法,锁的是Class模板
public static synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
//普通同步方法,锁的是调用者
public synchronized void call(){
System.out.println("打电话");
}
}
Set不安全
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;
//1、Set<String> set = Collections.synchronizedSet(new HashSet<>());
//2、
public class SetTest {
public static void main(String[] args) {
// Set<String> set = new HashSet<>();//java.util.ConcurrentModificationException并发修改异常
// Set<String> set = Collections.synchronizedSet(new HashSet<>());
Set<String> set = new CopyOnWriteArraySet<>();
for (int i = 1; i <= 30 ; i++) {
new Thread(()->{
set.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(set);
},String.valueOf(i)).start();
}
}
}
HashSet底层是什么?
public HashSet() {
map = new HashMap<>();
}
//add set 本质就是map key 是无法重复的
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
private static final Object PRESENT = new Object();//不变的值
Map不安全
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
// java.util.ConcurrentModificationException 并发修改异常
public class MapTest {
public static void main(String[] args) {
//map是这样用的吗? 不是,在工作中不用HashMap
//默认等价于什么? new HashMap<>(16, 0.75);
//Map<String, String> map = new HashMap<>();
Map<String, String> map = new ConcurrentHashMap<>();
for (int i = 1; i < 30; i++) {
new Thread(()->{
map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
System.out.println(map);
}).start();
}
}
}
ConcurrentHashMap底层原理?
Callable
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
new Thread().start();//怎么启动??
//new Thread(new Runnable()).start();
//new Thread(new FutureTask<V>()).start();
//new Thread(new FutureTask<V>( Callable )).start();
MyThread thread = new MyThread();
FutureTask futureTask = new FutureTask(thread);//适配类
new Thread(futureTask,"A").start();
Integer o = (Integer) futureTask.get();
System.out.println(o);
}
}
class MyThread implements Callable<Integer>{
@Override
public Integer call() {
System.out.println("call()");
return 1024;
}
}
两个线程,会打印几个call()???
答案:1个,结果会被缓存
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
new Thread().start();//怎么启动??
//new Thread(new Runnable()).start();
//new Thread(new FutureTask<V>()).start();
//new Thread(new FutureTask<V>( Callable )).start();
MyThread thread = new MyThread();
FutureTask futureTask = new FutureTask(thread);//适配类
new Thread(futureTask,"A").start();//两个线程,会打印几个call()
new Thread(futureTask,"B").start();//结果会被缓存
Integer o = (Integer) futureTask.get();//这个get方法可能会产生阻塞,把他放到最后
//或者使用异步通信来处理
System.out.println(o);
}
}
class MyThread implements Callable<Integer>{
@Override
public Integer call() {
System.out.println("call()");//会打印几个call()
return 1024;
}
}
8、常用的辅助类
8.1、CountDownLatch(减法计数器)
import java.util.concurrent.CountDownLatch;
//减法计数器
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
//总数是6,必须要执行任务的时候,再使用!
CountDownLatch countDownLatch = new CountDownLatch(6);
for (int i = 1; i <= 6; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+" go out");
countDownLatch.countDown();//数量减1
},String.valueOf(i)).start();
}
countDownLatch.await();//等待计数器归零,然后向下执行
System.out.println("Close door");
}
}
原理:
countDownLatch.countDown();//数量减1
countDownLatch.await();//等待计数器归零,然后向下执行
每次有线程调用countDown()数量减1,假设计数器变为0,countDownLatch.await()就会被唤醒,继续执行!
8.2、CyclicBarrier(加法计数器)
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
//加法计数器 //集齐七颗龙珠召唤神龙
public class CyclicBarrierDemo {
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(7, ()->{
System.out.println("召唤神龙");
});
for (int i = 1; i <= 7; i++) {
final int tmp = i;//lambda拿不到i,需要final修饰的中间变量
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"收集"+tmp+"个龙珠");
try {
cyclicBarrier.await();//等待
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
8.3、Semaphore
import java.util.concurrent.Semaphore;
public class SemphoreDemo {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(3);
for (int i = 1; i <= 6; i++) {
new Thread(()->{
try {
// acquire() 得到
semaphore.acquire();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
// release() 释放
semaphore.release();
}
},String.valueOf(i)).start();
}
}
}
原理:
semphore.acquire(),获得,假设如果已经满了,等待,等待被释放为止
semphore.release(),释放,会将当前的信号量释放+1,然后唤醒等待的线程
作用:多个共享资源互斥的使用!并发限流,控制最大的线程数
9、ReadWriteLock
//独占锁(写锁)一次只能被一个线程占有
//共享锁(读锁)多个线程可以同时占有
import java.io.ObjectInputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
//独占锁(写锁)一次只能被一个线程占有
//共享锁(读锁)多个线程可以同时占有
//ReadWriteLoack
//读-读 可以共存
//读-写 不能共存
//写-写 不能共存
public class ReadWriteLockDemo {
public static void main(String[] args) {
MyCacheLock myCache = new MyCacheLock();
for (int i = 1; i <= 5; i++) {
final int tmp = i;
new Thread(()->{
myCache.put(tmp+"", tmp+"");
},String.valueOf(i)).start();
}
for (int i = 1; i <= 5; i++) {
final int tmp = i;
new Thread(()->{
myCache.get(tmp+"");
},String.valueOf(i)).start();
}
}
}
//加锁的
class MyCacheLock{
private volatile Map<String, Object> map = new HashMap<>();
//读写锁:更加细粒度的控制
ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
//存,写入的时候,只希望同时只有一个线程写
public void put(String key, Object value){
readWriteLock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"写入"+key);
map.put(key, value);
System.out.println(Thread.currentThread().getName()+"写入OK");
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.writeLock().unlock();
}
}
//取,读,所有人都可以读
public void get(String key){
readWriteLock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"读取"+key);
Object o = map.get(key);
System.out.println(Thread.currentThread().getName()+"读取OK");
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.readLock().unlock();
}
}
}
//自定义缓存
//没加锁的
class MyCache{
private volatile Map<String, Object> map = new HashMap<>();
public void put(String key, Object value){
System.out.println(Thread.currentThread().getName()+"写入"+key);
map.put(key, value);
System.out.println(Thread.currentThread().getName()+"写入OK");
}
public void get(String key){
System.out.println(Thread.currentThread().getName()+"读取"+key);
Object o = map.get(key);
System.out.println(Thread.currentThread().getName()+"读取OK");
}
}
10、阻塞队列
什么情况下我们会使用阻塞队列:多线程并发处理,线程池!
学会使用队列:添加元素,删除元素
四组API:
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
public class TestBlockingQueue {
public static void main(String[] args) throws InterruptedException {
test4();
}
public static void test1(){
//队列大小
ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(blockingQueue.add("a"));
System.out.println(blockingQueue.add("b"));
System.out.println(blockingQueue.add("c"));
System.out.println("---------------------------");
// java.lang.IllegalStateException: Queue full 抛出队列满的异常
// System.out.println(blockingQueue.add("d"));
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
// java.util.NoSuchElementException 抛出异常
// System.out.println(blockingQueue.remove());
}
public static void test2(){
//队列大小
ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(blockingQueue.offer("a"));
System.out.println(blockingQueue.offer("b"));
System.out.println(blockingQueue.offer("c"));
System.out.println(blockingQueue.offer("d"));//不抛出异常
System.out.println("---------------------------");
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll()); //不抛出异常
}
//等待,阻塞(一直阻塞)
public static void test3() throws InterruptedException {
//队列大小
ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
blockingQueue.put("a");
blockingQueue.put("b");
blockingQueue.put("c");
//队列没有位置了,一直阻塞
// blockingQueue.put("d");
System.out.println("---------------------------");
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());
System.out.println(blockingQueue.take());
//队列没有元素了,一直阻塞
System.out.println(blockingQueue.take());
}
//等待,阻塞(超时等待)
public static void test4() throws InterruptedException {
//队列大小
ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(blockingQueue.offer("a"));
System.out.println(blockingQueue.offer("a"));
System.out.println(blockingQueue.offer("a"));
System.out.println(blockingQueue.offer("a", 2, TimeUnit.SECONDS));
//队列没有位置了,一直阻塞
System.out.println("---------------------------");
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll(2, TimeUnit.SECONDS));
}
}
SynchronousQueue同步队列
没有容量,进去一个元素,必须等待取出来之后,才能再往里面放一个元素
put、take
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
/**
* 同步队列
* 和其他的BlockingQueue不一样,SynchronousQueue 不存储元素
* put了一个元素,必须从里面先take取出来,否则不能put进去值
*/
public class SynchronousQueueDemo {
public static void main(String[] args) {
BlockingQueue blockingQueue = new SynchronousQueue();
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+" put 1");
blockingQueue.put("1");
System.out.println(Thread.currentThread().getName()+" put 2");
blockingQueue.put("2");
System.out.println(Thread.currentThread().getName()+" put 3");
blockingQueue.put("3");
} catch (InterruptedException e) {
e.printStackTrace();
}
},"T1").start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+"->"+ blockingQueue.take());
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+"->"+ blockingQueue.take());
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+"->"+ blockingQueue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
},"T2").start();
}
}
11、线程池(三大方法,七大参数,四个拒绝策略)
线程池:
池化技术
程序的运行,本质:占用系统资源!优化资源的使用----->池化技术
线程池、连接池、内存池、对象池。。。。创建,销毁,十分浪费资源
池化技术:事先准备好的一些资源,有人要用,就来我这里拿,用完之后还给我
线程池的好处:
1、降低资源的消耗
2、提高响应速度
3、方便管理
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//Executors 工具类、3大方法
public class Demo01 {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程的线程池
// ExecutorService threadPool = Executors.newFixedThreadPool(5);//创建一个固定大小的线程池
// ExecutorService threadPool = Executors.newCachedThreadPool();//可伸缩的,遇强则强,遇弱则弱
try {
for (int i = 0; i < 100; i++) {
//使用了线程池之后,使用线程池进行创建线程
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+" OK");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//线程池结束,程序结束,关闭线程池
threadPool.shutdown();
//放到finally块,保证一定结束
}
}
}
源码分析:(3种方法核心底层还是ThreadPoolExecutor)
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
//ThreadPoolExecutor() 这里就牵扯到7大参数,4种拒绝策略了
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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
线程池(模拟银行办理业务)****(7大参数,4种拒绝策略)
(模拟去银行办理业务,银行只开放2个窗口(①corePoolSize),总共5个窗口(②maximumPoolSize),其余3个(前两个窗口在营业,后3个在等待,这里的就是等待时间③keepAliveTime)不开,等待时间单位(④TimeUnit.SECONDS)来人了暂时去候客区(Deque阻塞队列,这里候客区3个座位,⑤new LinkedBlockingDeque<>(3)),如果人多了,比如来第6个以上人了,就开放一个窗口,银行最多容纳8个人(Deque + max),第六个参数是创建线程的工厂方法(默认为⑥Executors.defaultThreadFactory()),
如果再来人的话就有四种拒绝策略⑦new ThreadPoolExecutor.CallerRunsPolicy())
import java.util.concurrent.*;
/**
* 4种拒绝策略
* new ThreadPoolExecutor.AbortPolicy()//拒绝策略,满了的话直接抛出异常java.util.concurrent.RejectedExecutionException
* new ThreadPoolExecutor.CallerRunsPolicy()//拒绝策略(满了的话就说我这人满了,你要办理你们公司的,去你们公司办理,哪来的回哪去)
* new ThreadPoolExecutor.DiscardPolicy()//拒绝策略(从阻塞队列丢弃最新的任务(队尾),不会抛出异常)
* new ThreadPoolExecutor.DiscardOldestPolicy()//拒绝策略(从阻塞队列丢弃最旧的任务(队首),不会抛出异常)
*/
public class ThreadPoolDemo {
public static void main(String[] args) {
//7大参数
/**
* 了解:IO密集型、CPU密集型(调优)
* 最大线程到底该如何定义
* 1、CPU密集型,电脑是几核CPU,就可以定义为几,可以保持CPU的效率
* 获取方式: Runtime.getRuntime().availableProcessors()
* 2、IO密集型 判断程序中十分消耗IO的线程有几个,比如15个,那就可以定义为它的两倍,30个
*/
ExecutorService threadPool = new ThreadPoolExecutor(
2, //核心池大小(银行开放2个窗口)
5, //最大池的大小(银行最多开放5个窗口)CPU密集型定义:Runtime.getRuntime().availableProcessors()
3, //存活时间 (比如前两个窗口在营业,后3个在等待,这里的就是等待时间)
TimeUnit.SECONDS, //等待的时间单位
new LinkedBlockingDeque<>(3),//阻塞队列(模拟银行的候客区,有3个座位)
Executors.defaultThreadFactory(),//线程池创建Thread线程的工厂类。没有提供的话,就使用线程池内部默认的创建线程的方式
new ThreadPoolExecutor.CallerRunsPolicy()//拒绝策略(从阻塞队列丢弃最旧的任务(队首),不会抛出异常)
);
try {
//最大承载;Deque(阻塞队列--候客区椅子座位数,这里是3) + max(最大池大小---最多开放的窗口,这里是5)
//超过RejectedExecutionException
for (int i = 1; i <= 9; i++) { //这里可以从1-9逐个测试不同的拒绝策略会怎么样
final int tmp = i;
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+ " OK");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//线程池用完,程序结束,关闭线程池
threadPool.shutdown();
}
}
}
池的大小如何去设置?
了解:CPU密集型、IO密集型(调优)
面试问你创建多少个线程,该如何回答
最大线程到底该如何定义
1、CPU密集型,电脑是几核CPU,就可以定义为几,在这基础上+1,可以保持CPU的效率
获取方式: Runtime.getRuntime().availableProcessors()
2、IO密集型 判断程序中十分消耗IO的线程有几个(N),比如15个,那就可以定义为它的两倍再多一个(2N+1)个
12、四大函数式接口(必会)
泛型、枚举、反射
新时代的程序猿:lambda表达式、链式编程、函数式接口、Stream流式计算
函数式接口的作用:简化编程模型
import java.util.function.Function;
/**
* Function 函数式接口,有一个输入参数,有一个输出参数
*/
public class Demo01 {
public static void main(String[] args) {
// Function function = new Function<String, String>() {
// @Override
// public String apply(String str) {
// return str;
// }
// };
//写成lambda表达式:
Function function = (str)->{return str;};
System.out.println(function.apply("abcd"));
}
}
import java.util.function.Predicate;
/**
* 断定型接口:有一个输入参数,返回值只能是布尔值
*/
public class Demo02 {
public static void main(String[] args) {
// Predicate<String> predicate = new Predicate<String>() {
// @Override
// public boolean test(String str) {
// return str.isEmpty();
// }
// };
//写成lambda表达式:
Predicate<String> predicate = (str)->{return str.isEmpty();};
System.out.println(predicate.test("abcd"));
}
}
import java.util.function.Consumer;
/**
* 消费型接口:没有返回值,只有一个参数
*/
public class Demo03 {
public static void main(String[] args) {
// Consumer<String> consumer = new Consumer<String>() {
// @Override
// public void accept(String str) {
// System.out.println(str);
// }
// };
//lambda表达式
Consumer<String> consumer = (str)->{System.out.println(str);};
consumer.accept("abcd");
}
}
import java.util.function.Supplier;
/**
* 供给型接口:只有一个返回值,没有参数
*/
public class Demo04 {
public static void main(String[] args) {
// Supplier<Integer> supplier = new Supplier<Integer>() {
// @Override
// public Integer get() {
// System.out.println("abcd");
// return 1024;
// }
// };
Supplier<Integer> supplier = ()->{return 1024;};
System.out.println(supplier.get());
}
}
13、Stream流式计算
什么是Stream流式计算?
大数据:存储+计算
集合、MySQL本质就是存储东西的;
计算都应该交给流来操作
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
private int id;
private String name;
private int age;
}
import javax.print.DocFlavor;
import java.util.Arrays;
import java.util.List;
/**
* 题目要求:一分钟内完成此题,只用一行代码
* 现在有5个用户,筛选:
* 1、ID必须是偶数
* 2、年龄必须大于23
* 3、用户名转为大写字母
* 4、用户名字母到这排序
* 5、只输出一个用户
*/
public class Test {
public static void main(String[] args) {
User u1 = new User(1, "a", 21);
User u2 = new User(2, "b", 22);
User u3 = new User(3, "c", 23);
User u4 = new User(4, "d", 24);
User u5 = new User(6, "e", 25);
//集合就是存储
List<User> list = Arrays.asList(u1,u2,u3,u4,u5);
//计算交给Stream流
list.stream()
.filter(u->{return u.getId()%2 == 0;})
.filter(u->{return u.getAge() > 23;})
.map(u->{return u.getName().toUpperCase();})
.sorted((uu1, uu2)->{return uu2.compareTo(uu1);})
.limit(1)
.forEach(System.out::println);
}
}
14、ForkJoin
ForkJoin的特点:工作窃取
这里面维护的都是双端队列
import java.util.concurrent.RecursiveTask;
/**
* 求和计算的任务
* 3000 6000(ForkJoin) 10000(Stream并行流)
* 如何使用ForkJoin
* 1、forkJoinPool 通过它来执行
* 2、计算任务 forkJoinPool.execute(ForkJoinTask task)
* 3、计算类要继承ForkJoinTask
*/
public class ForkJoinDemo extends RecursiveTask<Long> {
private Long start; //1
private Long end; //100000000000
//临界值
private Long tmp = 10000L;
public ForkJoinDemo(Long start, Long end){
this.start = start;
this.end = end;
}
@Override
protected Long compute() {
if((end - start) < tmp){
Long sum = 0L;
for (Long i = start; i <= end; i++) {
sum += i;
}
return sum;
}else{ //forkJoin递归
long middle = (start + end) / 2; //中间值
ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
task1.fork();//拆分任务,把任务压入线程队列
ForkJoinDemo task2 = new ForkJoinDemo(middle + 1, end);
task2.fork();//拆分任务,把任务压入线程队列
return task1.join() + task2.join();
}
}
}
测试:
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;
public class Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// test1();
// test2();
test3();
}
//普通程序猿
public static void test1(){
Long sum = 0L;
long start = System.currentTimeMillis();
for (Long i = 1L; i <= 10_0000_0000; i++) {
sum += i;
}
long end = System.currentTimeMillis();
System.out.println("sum="+sum+"Time:"+(end - start));
}
//使用ForkJoin的牛逼程序猿
public static void test2() throws ExecutionException, InterruptedException {
long start = System.currentTimeMillis();
ForkJoinPool forkJoinPool = new ForkJoinPool();
ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0000L);
ForkJoinTask<Long> submit = forkJoinPool.submit(task);//提交任务
Long sum = submit.get();
long end = System.currentTimeMillis();
System.out.println("sum="+sum+"Time:"+(end - start));
}
//顶级大佬程序猿
public static void test3(){
long start = System.currentTimeMillis();
//Stream并行流 (]
long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0,Long::sum);
long end = System.currentTimeMillis();
System.out.println("sum="+sum+"Time:"+(end - start));
}
}
15、异步回调
与同步相对,异步回调不会影响主线程,不用阻塞等待当前线程,提高效率,和Ajax很像
package com.fang.future;/*
* @Program:untitled
* @Description:description
* @Author:Pufang
* @Time:2020-06-24 12-22-33
**/
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
/**
* 异步调用: CompletableFuture
* // 异步执行
* // 成功回调
* // 失败回调
*/
public class Demo01 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 没有返回值的 runAsync 异步回调
// CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
// try {
// TimeUnit.SECONDS.sleep(2);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// System.out.println(Thread.currentThread().getName()+"runAsync=>Void");
// });
//
// System.out.println("1111");
//
// completableFuture.get(); // 获取阻塞执行结果
// 有返回值的 supplyAsync 异步回调
// ajax,成功和失败的回调
// 返回的是错误信息;
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
int i = 10/0;
return 1024;
});
System.out.println(completableFuture.whenComplete((t, u) -> {
System.out.println("t=>" + t); // 正常的返回结果
System.out.println("u=>" + u); // 错误信息:java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
}).exceptionally((e) -> {
System.out.println(e.getMessage());
return 233; // 可以获取到错误的返回结果
}).get());
/**
* succee Code 200
* error Code 404 500
*/
}
}
16、JMM
JMM即为JAVA 内存模型(java memory model)。
JMM规定了内存主要划分为主内存和工作内存两种。
关于JMM的一些同步约定:
1、线程解锁前,必须把共享变量立刻刷回主存
2、线程加锁前,必须读取主存中的最新值到工作内存中!
3、加锁和解锁是同一把锁
线程 工作内存、主内存
8种操作
JVM在设计时候考虑到,如果JAVA线程每次读取和写入变量都直接操作主内存,对性能影响比较大,所以每条线程拥有各自的工作内存,工作内存中的变量是主内存中的一份拷贝,线程对变量的读取和写入,直接在工作内存中操作,而不能直接去操作主内存中的变量。但是这样就会出现一个问题,当一个线程修改了自己工作内存中变量,对其他线程是不可见的,会导致线程不安全的问题。因为JMM制定了一套标准来保证开发者在编写多线程程序的时候,能够控制什么时候内存会被同步给其他线程。
内存交互操作
内存交互操作有8种,虚拟机实现必须保证每一个操作都是原子的,不可在分的(对于double和long类型的变量来说,load、store、read和write操作在某些平台上允许例外)
lock (锁定):作用于主内存的变量,把一个变量标识为线程独占状态
unlock (解锁):作用于主内存的变量,它把一个处于锁定状态的变量释放出来,释放后的变量才可以被其他线程锁定
read (读取):作用于主内存变量,它把一个变量的值从主内存传输到线程的工作内存中,以便随后的load动作使用
load (载入):作用于工作内存的变量,它把read操作从主存中变量放入工作内存中
use (使用):作用于工作内存中的变量,它把工作内存中的变量传输给执行引擎,每当虚拟机遇到一个需要使用到变量的值,就会使用到这个指令
assign (赋值):作用于工作内存中的变量,它把一个从执行引擎中接受到的值放入工作内存的变量副本中
store (存储):作用于主内存中的变量,它把一个从工作内存中一个变量的值传送到主内存中,以便后续的write使用
write (写入):作用于主内存中的变量,它把store操作从工作内存中得到的变量的值放入主内存的变量中
JMM对这八种指令的使用,制定了如下规则:
不允许read和load、store和write操作之一单独出现。即使用了read必须load,使用了store必须write
不允许线程丢弃他最近的assign操作,即工作变量的数据改变了之后,必须告知主存
不允许一个线程将没有assign的数据从工作内存同步回主内存
一个新的变量必须在主内存中诞生,不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前,必须经过assign和load操作
一个变量同一时间只有一个线程能对其进行lock。多次lock后,必须执行相同次数的unlock才能解锁
如果对一个变量进行lock操作,会清空所有工作内存中此变量的值,在执行引擎使用这个变量前,必须重新load或assign操作初始化变量的值
如果一个变量没有被lock,就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
对一个变量进行unlock操作之前,必须把此变量同步回主内存
17、volatile
volatile是Java虚拟机提供轻量级的同步机制
1、保证可见性
为了提高效率,JVM在执行过程中,会尽可能的将数据在工作内存中执行,但这样会造成一个问题,共享变量在多线程之间不能及时看到改变,这个就是可见性问题
2、不保证原子性
3、禁止指令重排序
import java.util.concurrent.TimeUnit;
public class JMMDemo {
//不加volatile 程序就会死循环
//加volatile 可以保证可见性
private volatile static int num = 0;
public static void main(String[] args) {
new Thread(()->{//线程1对主内存的变化是不知道的
while(num == 0){
}
}).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
num = 1;
System.out.println(num);
}
}
2、不保证原子性
原子性 : 不可分割
线程A在执行任务的时候,不能被打扰,也不能被分割。要么同时成功,要么同时失败。
public class VolatileDemo02 {
//volatile不保证原子性
private volatile static int num = 0;
public static void add(){
num++;
}
public static void main(String[] args) {
//理论上num结果应该为2万
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while(Thread.activeCount() > 2){ //main线程 gc线程
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+" "+num);
}
}
使用原子类,解决原子性问题
import java.util.concurrent.atomic.AtomicInteger;
public class VolatileDemo02 {
//volatile不保证原子性
//原子类的Integer
private volatile static AtomicInteger num = new AtomicInteger();
public static void add(){
// num++; //不是原子性的操作
num.getAndIncrement(); // AtomicInteger + 1 方法,CAS
}
public static void main(String[] args) {
//理论上num结果应该为2万
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while(Thread.activeCount() > 2){ //main线程 gc线程
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+" "+num);
}
}
3、禁止指令重排序
一段代码是这样的:
- 去前台取下 U 盘
- 去教室写 10 分钟作业
- 去前台取下快递
代码有其执行顺序,在单线程情况下,JVM、CPU指令集会对其进行优化重排序,比如,按 1->3->2的方式执行,也是没问题,可以少跑一次前台,这种叫做指令重排序。
但在多线程场景下就有问题了,什么问题呢。可能快递是在你写作业的10分钟内被另一个线程放过来的,或者被人变过了,如果指令重排序了,代码就会是错误的
volatile可以避免指令重排
内存屏障。CPU指令。作用:
1、保证特定的操作执行顺序
2、可以保证某些变量的内存可见性(利用这些特性volatile实现了可见性)
volatile是可以保证可见性。不能保证原子性,由于内存屏障,可以保证避免指令重排的现象
18、单例模式
单例模式(Singleton Pattern)是Java中最简单的设计模式,是一种创建型模式,它提供了一种创建对象的最佳方式,这种模式涉及到一个单一的类来创建对象,同时确保只有一个对象被创建。这个类提供了访问其唯一对象的方式,可以直接访问,不需要实例化该类的对象。
注意:
1、单例类只能有一个实例对象
2、单例类必须自己创建自己的唯一实例
3、单例类必须给其他对象提供该实例
饿汉式
线程安全,比较常用,但容易产生垃圾,因为一开始就初始化,没有加锁,执行效率会提高。
public class Singleton{
private static Singleton singleton = new Singleton();
private Singleton(){}
public static Singleton getInstance(){
return singleton;
}
}
懒汉式(单线程)
第一次调用,才初始化,避免浪费内存
线程不安全,延迟初始化,没有加锁,在多线程不能正常工作
public class Singleton{
private static Singleton singleton;
private Singleton(){}
public static Singleton getInstance(){
if(singleton == null){
singleton = new Singleton();
}
return singleton;
}
}
懒汉式(多线程下)
第一次调用,才初始化,避免浪费内存
必须加锁 synchronized 才能保证线程安全,但加锁会影响效率
public class Singleton{
private static Singleton singleton;
private Singleton(){}
public static synchronized Singleton getInstance(){
if(singleton == null){
singleton = new Singleton();
}
return singleton;
}
}
双重校验锁 DCL(Double Check Locking)多线程安全
双重校验锁写法保证线程安全
使用volatile:保证可见性,禁止指令重排序
线程安全,延迟初始化。这种方式采用双锁机制,安全且在多线程情况下能保持高性能。
public class Singleton{
private volatile static Singleton singleton;
private Singleton(){}
public static Singleton getInstance(){
if(singleton == null){
Synchronized(Singleton.class){
//Synchronized保证了原子性
if(singleton == null){
//new对象分解三条指令:前两个指令是new,第三个是 =
//1、分配内存空间
//2、初始化对象
//3、赋值给变量
singleton = new Singleton();
}
}
}
}
}
19、深入理解CAS
CAS:比较并交换,比较当前工作内存中的值和主内存中的值,如果这个值是期望的,那么则执行操作,如果不是就一直循环
CAS实现原子操作的三大问题:
1、ABA问题
2、循环时间长开销大
3、只能保证一个共享变量的原子操作