源码+官方文档（面试高频）！
视频资料：b站狂神–JUC并发编程篇
**程序：**是指令和数据的有序集合，其本身没有任何的运行的含义，是一个静态的概念。
**进程：**是执行程序的一次执行过程，是一个动态概念。是系统分配资源的单位
**线程：**是操作系统能够执行调度的最小单位，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
**java能开启线程吗？**开不了,java调用了本地方法（底层的C++）,Java无法直接操作硬件
并发：多个线程交替执行
并行：多个线程一起执行
wait->java.lang.Object
sleep->java.lang.Thread
TimeUnit->java.util.concurrent.TimeUnit
wait会释放锁
sleep抱着锁睡觉，不会释放！
wait:wait必须在同步代码块中
sleep:可以在任何地方睡
wait和sleep都需要捕获InterruptedException异常
传统:Synchronized
package com.lxf.demo01; /** * 真正的多线程开发，公司中的开发，降低耦合性 * 线程就是一个单独的资源类，没有任何附属的操作！ * 1.属性、方法 */ public class SaleTicketDemo01 { public static void main(String[] args) { //并发，多个线程操作同一个资源类 Ticket ticket=new Ticket(); new Thread(()->{ for (int i = 0; i < 60; i++) { ticket.sale(); } },"A").start(); new Thread(()->{ for (int i = 0; i < 60; i++) { ticket.sale(); } },"B").start(); new Thread(()->{ for (int i = 0; i < 60; i++) { ticket.sale(); } },"C").start(); } } //资源类 class Ticket{ //属性、方法 private int number=50; //卖票的方式 //synchronized:本质：队列，锁 public synchronized void sale(){ if(number>0){ System.out.println(Thread.currentThread().getName()+"卖出了第"+number--+"票,剩余："+number); } } }Lock锁
使用方法：
Lock l = ...; l.lock(); try { // access the resource protected by this lock } catch(Exception e){ e.printStackTrace(); } finally { l.unlock(); } //当在不同范围内发生锁定和解锁时，必须注意确保在锁定时执行的所有代码由try-finally或try-catch保护，以确保在必要时释放锁定。锁的类型：
公平锁：十分公平，先来后到
非公平锁：不公平，可以插队（默认）
代码实例：
package com.lxf.demo01; import sun.security.krb5.internal.Ticket; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 真正的多线程开发，公司中的开发，降低耦合性 * 线程就是一个单独的资源类，没有任何附属的操作！ * 1.属性、方法 */ public class SaleTicketDemo02 { public static void main(String[] args) { //并发，多个线程操作同一个资源类 Ticket02 ticket=new Ticket02(); new Thread(()->{ for (int i = 0; i < 60; i++) ticket.sale();},"A").start(); new Thread(()->{ for (int i = 0; i < 60; i++) ticket.sale();},"B").start(); new Thread(()->{ for (int i = 0; i < 60; i++) ticket.sale();},"C").start(); } } //资源类 class Ticket02{ //属性、方法 private int number=50; //新建ReentrantLock可重入锁对象 Lock lock=new ReentrantLock(); //卖票的方式 public synchronized void sale(){ //上锁 lock.lock(); try { //业务代码 if(number>0){ System.out.println(Thread.currentThread().getName()+"卖出了第"+number--+"票,剩余："+number); } } catch (Exception e) { e.printStackTrace(); } finally { //解锁 lock.unlock(); } } }Synchronized和Lock的区别
Synchronized是内置的java的关键字，lock是一个java类Synchronized无法判断获取锁的状态，lock可以判断是否获取到了锁Synchronized会自动释放锁。lock必须手动释放锁，如果不释放锁->死锁Synchronized 线程1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等待下去；Synchronized 可重入锁，不可以中断的，非公平。lock，可重入锁，可判断锁，可以自己设置为公平或非公平锁Synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码！面试题：单例模式、排序算法、生产者和消费者、死锁
package com.lxf.pc; /** * 线程之间的通信问题：生产者与消费者问题 ,等待唤醒，通知唤醒 * 线程交替执行 A B操作同一个变量 num=0 * A num=1 * B num=-1 */ public class A { public static void main(String[] args) { Data data = new Data(); //+1线程 new Thread(() -> { for (int i = 0; i < 10; i++) { try { data.increment(); } catch (InterruptedException e) { e.printStackTrace(); } } }, "A").start(); //-1线程 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(); } // public synchronized void decrement() throws InterruptedException { if (number == 0) { //等待 this.wait(); } number--; System.out.println(Thread.currentThread().getName() + "=>" + number); //通知其它线程，我-1完毕了 this.notifyAll(); } }问题存在，假如四个线程：A,B,C,D呢(if改成while就能解决问题)
通过Lock类找到Condition类：
代码实现：
package com.lxf.pc; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 线程之间的通信问题：生产者与消费者问题 ,等待唤醒，通知唤醒 * 线程交替执行 A B操作同一个变量 num=0 * A num=1 * B num=-1 */ public class B { public static void main(String[] args) { Data2 data = new Data2(); //+1线程 new Thread(() -> { for (int i = 0; i < 10; i++) { try { data.increment(); } catch (InterruptedException e) { e.printStackTrace(); } } }, "A").start(); //-1线程 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; //new一个lock对象 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); //通知其它线程，我+1完毕了 condition.signalAll(); } catch (InterruptedException e) { e.printStackTrace(); } finally { //解锁 lock.unlock(); } } // public void decrement() throws InterruptedException { //上锁 lock.lock(); try { while (number == 0) { //等待 condition.await(); } number--; System.out.println(Thread.currentThread().getName() + "=>" + number); //通知其它线程，我-1完毕了 condition.signalAll(); } catch (InterruptedException e) { e.printStackTrace(); } finally { //解锁 lock.unlock(); } } }如此一看，好像和Synchronized版没什么区别，但是任何一个新的技术，绝对不是仅仅覆盖了原来的技术，肯定有优势和补充！
精准通知和唤醒线程：
package com.lxf.pc; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * A 执行完调用B,B执行完调用C，C执行完调用A */ public class C { public static void main(String[] args) { //新建一个资源类对象 Data3 data3 = new Data3(); //执行三个线程（顺序执行） new Thread(() -> { for (int i = 0; i < 10; i++) { data3.printA(); } }, "A").start(); new Thread(() -> { for (int i = 0; i < 10; i++) { data3.printB(); } }, "B").start(); new Thread(() -> { for (int i = 0; i < 10; i++) { data3.printC(); } }, "C").start(); } } //资源类 class Data3 { //lock对象 private Lock lock = new ReentrantLock(); //同步监视器 Condition condition1 = lock.newCondition(); Condition condition2 = lock.newCondition(); Condition condition3 = lock.newCondition(); private int number = 1;//1->A执行 2->B执行 3->C执行 public void printA() { //加锁 lock.lock(); try { //业务代码,判断->执行->通知 while (number != 1) { //等待 condition1.await(); } System.out.println(Thread.currentThread().getName() + "=>AAAAAAAAAA"); //执行代码 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() + "=>BBBBBBBBB"); //执行代码 number = 3; //精确唤醒C condition3.signal(); } catch (Exception e) { e.printStackTrace(); } finally { //解锁 lock.unlock(); } } public void printC() { //加锁 lock.lock(); try { //业务代码 while (number != 3) { //等待 condition3.await(); } System.out.println(Thread.currentThread().getName() + "=>CCCCCCCCC"); //执行代码 number = 1; //精确通知A condition1.signal(); } catch (Exception e) { e.printStackTrace(); } finally { //解锁 lock.unlock(); } } }学习要点及解释：
如何判断锁的是谁！永远知道什么是锁，锁的到底是谁8锁就是关于锁的8个问题运行结果顺序：1.发短信 2.打电话
运行结果顺序：1.发短信 2.打电话
思考：按照cpu调度算法，在等待的线程肯定会让出给就绪的线程执行，为什么上述两个问题和这相反呢？
解释：synchornized 锁的对象是方法的调用者：phone对象，两个方法用的是同一把锁。谁先拿到谁执行
答案：1.hello2.发短信。因为hello方法无锁，不是同步方法，不受锁的影响
运行结果顺序：1.打电话 2.发短信。因为两个对象拿到的锁不一样
运行结果顺序：1.发短信 2.打电话。static静态方法类一加载就有了：锁的是Class
运行结果顺序：1.发短信 2.打电话。原因也是static静态方法类一加载就有了：锁的是Class
运行结果顺序：1.打电话 2发短信。对象不一样，不是抢占式，而是先来后到式
运行结果顺序：1.打电话 2发短信。锁的对象不一样，不相关
java集合系列——List集合之Vector介绍
补充：Set和List以及BlockingQueue（阻塞队列）是同一级的
和List的解决方式差不多：
扩展：HashSet的底层是什么？
//新建HashSet集合的源码： public HashSet() { map = new HashMap<>(); } //HashSet的add方法源码 //map的key是无序且不重复的所以HashSet存储的值也不能重复且无序 //PRESENT：不变的值 public boolean add(E e) { return map.put(e, PRESENT)==null; }特点：
可以有返回值
可以抛出异常
方法不同，run()/call()
测试：
package com.lxf.unSafeList; 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 { MyThread myThread=new MyThread(); FutureTask futureTask=new FutureTask(myThread);//适配类 new Thread(futureTask,"A").start(); //new Thread(futureTask,"B").start();两个线程但只打印一次，因为：结果会被缓存，效率高 String result = (String) futureTask.get();//获取Callable的返回结果 System.out.println("result = " + result); } } class MyThread implements Callable<String> { @Override public String call() throws Exception { System.out.println("call()"); return "123456"; } }举例（学校关门）：
package com.lxf.add; 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 = 0; i < 6; i++) { new Thread(()->{ System.out.println(Thread.currentThread().getName()+"Go out"); countDownLatch.countDown();//数量减一 },String.valueOf(i)).start(); } countDownLatch.await();//等待计数器归零，然后再向下进行 System.out.println("Close Door!还有的线程数："+countDownLatch.getCount()); } }原理（减法计数器）：
countDownLatch.countDown():数量减一
countDownLatch.await():等待计数器归零，然后再向下进行
每次有线程调用countDown()数量-1，假设计数器变为0，countDownLatch.await()就会被唤醒，继续执行！
举例（集齐七颗龙珠召唤神龙）：
package com.lxf.add; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; public class CyclicBarrierDemo { public static void main(String[] args) { /** * 集齐7颗龙珠召唤神龙 */ //召唤龙珠的线程 CyclicBarrier cyclicBarrier=new CyclicBarrier(7,()->{ System.out.println("召唤神龙成功！"); }); for (int i = 1; i <= 7; i++) { //中间值，Lambda表达式中i不可以直接用 int finalI = i; new Thread(()->{ System.out.println(Thread.currentThread().getName()+"收集"+ finalI +"个龙珠"); try { cyclicBarrier.await();//等待 } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } }).start(); } } }原理（减法计数器）：
cyclicBarrier.await():等待计数器计数为7（每执行一个线程会+1），然后再召唤神龙
每次有线程cyclicBarrier计数器计数+1，假设计数器变为7，线程：()->{ System.out.println(“召唤神龙成功！”);执行，召唤神龙！
举例（抢车位6车->3个停车位置）：
package com.lxf.add; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; public class SemaphoreDemo { public static void main(String[] args) { //线程数量：停车位,限流 Semaphore semaphore=new Semaphore(3); //semaphore.acquire();得到 //semaphore.release();释放 for (int i = 0; i < 6; i++) { new Thread(()->{ try { //抢车位 semaphore.acquire(); System.out.println(Thread.currentThread().getName()+"抢到车位"); TimeUnit.SECONDS.sleep(2);//线程休眠2秒 System.out.println(Thread.currentThread().getName()+"离开车位"); //离开车位 semaphore.release(); } catch (InterruptedException e) { e.printStackTrace(); } }).start(); } } }原理（信号量法）：
semaphore.acquire():得到,假设已经满了，等待进去的出来
semaphore.release():释放,会将当前的信号量释放+1，然后唤醒等待的线程！
作用：多个互斥资源的使用！并发限流，控制最大的线程数!
代码测试：
package com.lxf.rw; import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.locks.ReentrantReadWriteLock; /** * 共享锁（写锁）一次只能被一个线程占有 * 排它锁（读锁）多个线程可以同时占有 * ReadWriteLock * 读-写 不能共存 * 读-读 可以共存 * 写-写 不能共存 */ public class ReadWriteLockDemo { public static void main(String[] args) { //MyCache myCache = new MyCache();无锁 //读写锁 MyCacheLock myCacheLock=new MyCacheLock(); //5个写入线程 for (int i = 1; i <= 5; i++) { int finalI = i; new Thread(() -> { myCacheLock.put(finalI + "", finalI + ""); }, String.valueOf(i)).start(); } //5个读取线程 for (int i = 1; i <= 5; i++) { int finalI = i; new Thread(() -> { myCacheLock.get(finalI + ""); }, String.valueOf(i)).start(); } } } /** * 加锁的 */ class MyCacheLock { private volatile Map<String, Object> map = new HashMap<>(); //读写锁：更加细粒度的控制，读锁：可多线程访问。写锁：只可以单线程访问 private ReadWriteLock readWriteLock=new ReentrantReadWriteLock(); //private Lock lock=new ReentrantLock();只是可重入锁，不细分，只可以保证一个区间内只允许一个线程访问 //存，写入的时候，只希望同时只有一个线程写 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); 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); map.get(key); System.out.println(Thread.currentThread().getName() + "读取OK"); } }使用场景：多线程并发处理，线程池
8.5.1、抛出异常
package com.lxf.bq; import java.util.concurrent.ArrayBlockingQueue; public class Test { public static void main(String[] args) { test1(); } /** * 抛出异常 */ public static void test1(){ //队列的大小 ArrayBlockingQueue blockingQueue1 = new ArrayBlockingQueue<>(3); //增加三个元素：会成功打印三个true System.out.println(blockingQueue1.add('a')); System.out.println(blockingQueue1.add('b')); System.out.println(blockingQueue1.add('c')); //超出队列容量添加：java.lang.IllegalStateException: Queue full 抛出队列已满异常 //System.out.println(blockingQueue.add('d')); System.out.println(blockingQueue1.element());//打印队首元素 System.out.println("======================================"); //移除三个元素：会成功打印三个数a，b，c System.out.println(blockingQueue1.remove()); System.out.println(blockingQueue1.remove()); System.out.println(blockingQueue1.remove()); //空队列移除：java.util.NoSuchElementException 抛出没有元素异常 System.out.println(blockingQueue1.remove()); } }8.5.2、有返回值
/** * 有返回值 */ public static void test2(){ //队列大小 ArrayBlockingQueue<Object> blockingQueue2 = new ArrayBlockingQueue<>(3); //增加三个元素：会成功打印三个true System.out.println(blockingQueue2.offer('1')); System.out.println(blockingQueue2.offer('2')); System.out.println(blockingQueue2.offer('3')); //超出队列容量添加：返回false System.out.println(blockingQueue2.offer('4')); System.out.println(blockingQueue2.peek());//打印队首元素 System.out.println("======================================"); //移除三个元素：会成功打印三个数1，2，3 System.out.println(blockingQueue2.poll()); System.out.println(blockingQueue2.poll()); System.out.println(blockingQueue2.poll()); //队列为空时移除元素，返回null System.out.println(blockingQueue2.poll()); } }8.5.3、阻塞等待
/** * 阻塞等待 */ public static void test3() throws InterruptedException { ArrayBlockingQueue<Object> blockingQueue3 = new ArrayBlockingQueue<>(3); //正常存 blockingQueue3.put("one"); blockingQueue3.put("two"); blockingQueue3.put("three"); //blockingQueue3.put("four");//队列没有位置了，一直阻塞 System.out.println("====================================="); //正常取 System.out.println(blockingQueue3.take()); System.out.println(blockingQueue3.take()); System.out.println(blockingQueue3.take()); //System.out.println(blockingQueue3.take());//队列中没有元素了，一直阻塞 }8.5.4、超时等待
/** * 超时等待 */ public static void test4() throws InterruptedException { ArrayBlockingQueue<Object> blockingQueue4 = new ArrayBlockingQueue<>(3); //正常存 System.out.println(blockingQueue4.offer("一起")); System.out.println(blockingQueue4.offer("尼")); System.out.println(blockingQueue4.offer("桑")); System.out.println(blockingQueue4.offer("用", 2, TimeUnit.SECONDS));//超时两秒等待存，两秒内还没有位置，就打印false直接退出 System.out.println("==========================================="); //正常取 System.out.println(blockingQueue4.poll()); System.out.println(blockingQueue4.poll()); System.out.println(blockingQueue4.poll()); System.out.println(blockingQueue4.poll(2,TimeUnit.SECONDS));//超时两秒等待取，两秒内队列还是空的,就打印null直接退出 }特点：没有容量，进去一个元素，必须等待取出来之后，才能再往里面放一个元素！
package com.lxf.bq; import java.util.concurrent.SynchronousQueue; import java.util.concurrent.TimeUnit; /** * 同步队列 */ public class SynchronizedQueueDemo { public static void main(String[] args) { SynchronousQueue<Object> synchronousQueue = new SynchronousQueue<>(); //存线程 new Thread(()->{ try { System.out.println(Thread.currentThread().getName()+"put 1"); synchronousQueue.put("1"); System.out.println(Thread.currentThread().getName()+"put 2"); synchronousQueue.put("2"); System.out.println(Thread.currentThread().getName()+"put 3"); synchronousQueue.put("3"); } catch (InterruptedException e) { e.printStackTrace(); } },"T1").start(); //取线程 new Thread(()->{ try { TimeUnit.SECONDS.sleep(3);//等待3秒钟 System.out.println(Thread.currentThread().getName()+"取出："+synchronousQueue.take()); TimeUnit.SECONDS.sleep(3);//等待3秒钟 System.out.println(Thread.currentThread().getName()+"取出："+synchronousQueue.take()); TimeUnit.SECONDS.sleep(3);//等待3秒钟 System.out.println(Thread.currentThread().getName()+"取出："+synchronousQueue.take()); } catch (InterruptedException e) { e.printStackTrace(); } },"T2").start(); } }结果：
T1put 1 T2取出：1 T1put 2 T2取出：2 T1put 3 T2取出：3池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完还给我。如果要用再new就会十分浪费资源
例如：线程池、连接池、内存池、对象池…
程序的运行，本质：占用系统的资源，优化资源的使用=>池化技术
线程池的好处：
降低资源的消耗提高响应的速度方便管理简单来说：线程复用、可以控制最大并发数，管理线程
学习重点：三大方法和七大参数
通过代码去获取电脑核数：Runtime.getRuntime().availableProcessors();
//自定义线程 ExecutorService threadPool =new ThreadPoolExecutor(2,//核心线程数 Runtime.getRuntime().availableProcessors(),//最大核心线程池大小 3,//超时了，没有调用就会释放 TimeUnit.SECONDS, new LinkedBlockingQueue<>(3),//链式队列 Executors.defaultThreadFactory(),//默认线程工厂 new ThreadPoolExecutor.CallerRunsPolicy()//队列满了，尝试和最早的竞争，竞争失败直接丢掉，不会抛出异常 );新时代的程序员：Lambda表达式、链式编程、函数式接口、Stream流式计算
函数式接口：只有一个方法的接口
//例如Runnable接口： @FunctionalInterface public interface Runnable { /** * When an object implementing interface <code>Runnable</code> is used * to create a thread, starting the thread causes the object's * <code>run</code> method to be called in that separately executing * thread. * <p> * The general contract of the method <code>run</code> is that it may * take any action whatsoever. * * @see java.lang.Thread#run() */ public abstract void run(); } //@FunctionalInterface超级多 //简化编程模型，在新版本的框架底层大量应用！ //foreach(消费者类的函数式接口)什么是Stream流式计算？
大数据：存储+计算
集合、MySQL本质就是存储东西的；
计算都应该交给流来操作！
package com.lxf.stream; 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(5,"e",25); //集合就是存储 List<User> users = Arrays.asList(u1, u2, u3, u4, u5); //计算交给stream流 //1.ID 必须是偶数 users.stream().filter(u->{return u.getId()%2==0;}).forEach(System.out::println); System.out.println("===================================================="); //2.年龄必须大于23岁 users.stream().filter(u->{return u.getAge()>23;}).forEach(System.out::println); System.out.println("===================================================="); //3.用户名转为大写 users.stream().map(u->{return u.getName().toUpperCase();}).forEach(System.out::println); System.out.println("===================================================="); //4.用户名字母倒着排序 users.stream() .map(u->{return u.getName().toUpperCase();}) .sorted((uu1,uu2)->{return uu2.compareTo(uu1);}) .forEach(System.out::println); System.out.println("=================================================="); //5.只输出一个用户！ users.stream() .map(u->{return u.getName().toUpperCase();}) .sorted((uu1,uu2)->{return uu2.compareTo(uu1);}) .limit(1) .forEach(System.out::println); } }什么是ForkJoin ：在JDK1.7出来，提高效率，大数据量！
大数据：Map Reduce(把大任务拆分为小任务)
ForkJoin特点：工作窃取（两个工作A、B同时开始,然后B执行快全部运行完了，此时B就会窃取A的工作，提高效率）
三等 （普通方法）：
package com.lxf.forkjoin; /** * 求和计算的任务！ * 三等（普通方法） * */ public class ForkJoinDemo { public static void main(String[] args) { long sum=0L; //获取开始时间 long startTime=System.currentTimeMillis(); for (int i = 1; i <= 10_0000_0000L; i++) { sum+=i; } //获取结束时间 long endTime=System.currentTimeMillis(); //打印结果 System.out.println("结果:"+sum+",所花时间:"+(endTime-startTime)); } }结果:500000000500000000,所花时间:2367
六等（ForkJoin）:
ForkJoinDemo类：
package com.lxf.forkjoin; import java.util.concurrent.RecursiveTask; /** * 求和计算的任务！ * 六等（ForkJoin） * 继承RecursiveTask<Long> */ public class ForkJoinDemo extends RecursiveTask<Long> { private Long start;//1 private Long end;//1990900000 //临界值 private Long temp=10000L; public ForkJoinDemo(Long start, Long end) { this.start = start; this.end = end; } //计算方法 @Override protected Long compute() { if((end-start)<temp){ //10000以下不使用Forkjoin方法，用普通方法 Long sum=0L; for (Long i = start; i < end; i++) { sum+=i; } return sum; }else{//分支合并计算 //中间值 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(); } } }测试方法：
//forkjoin方法 public static void test2(){ //获取ForkJoinPool对象 ForkJoinPool forkJoinPool = new ForkJoinPool(); //获取ForkJoinTask<Long>对象 ForkJoinTask<Long> task = new ForkJoinDemo(1L, 10_0000_0000L); //获取开始时间 long startTime = System.currentTimeMillis(); //提交任务 ForkJoinTask<Long> submit = forkJoinPool.submit(task); //结果值 Long sum = null; try { sum = submit.get(); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } //获取结束时间 long endTime = System.currentTimeMillis(); //打印结果 System.out.println("结果:" + sum + ",所花时间:" + (endTime - startTime)); }结果:500000000500000000,所花时间:17231//可能因为我的电脑cpu核数太低了，哈哈哈，一般要比第一种快几倍
九等（ForkJoin）:
//LongStream流式计算方法 private static void test3() { //获取开始时间 long startTime = System.currentTimeMillis(); long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum); //获取结束时间 long endTime = System.currentTimeMillis(); //打印结果 System.out.println("结果:" + sum + ",所花时间:" + (endTime - startTime)); }结果:500000000500000000,所花时间:2049
注意：我用的电脑cpu才4核，所以结果感觉有点不符合预期。预期：流式计算是ForkJoin方法的几十倍速度，而ForkJoin方法是普通方法的几倍速度（跟电脑核数有关）
个人见解：callable接口和这个接口很类似，而callable是同步的，CompletableFuture是异步的。在我看来他们的区别在于：callable接口提交一个线程执行的时候会阻塞等待结果的返回，而且它返回结果的时间不可预知，线程内部发生错误无法有效返回，对结果的操作也没有。CompletableFutur接口不会阻塞等待结果的返回，有方法可以预知结果返回的时间，线程回调可以分为正确和错误回调，而且可以对结果处理。
Volatile是Java虚拟机提供的轻量级的同步机制
保证可见性不保证原子性禁止指令重排JMM:java内存模型，不存在的东西，概念！约定！
线程的内存交互操作：
代码测试：
package com.lxf.volatileT; import java.util.concurrent.TimeUnit; public class JMMDemo { private static int num=0; public static void main(String[] args) { new Thread(()->{//线程1 while (num==0){ } }).start(); try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } num=1; System.out.println(num); } }结果打印1，但是线程1一直运行。
private static volatile int num=0;加上volatile 关键字之后结果：打印1，并且程序成功结束
原子性：不可分割
线程A在执行任务的时候，不能被打扰的，也不能被分割。要么同时成功，要么同时失败
package com.lxf.volatileT; //不保证原子性 public class VDemo02 { private volatile static int num=0; public static void add(){ num++; } public static void main(String[] args) { for (int i = 0; i < 20; i++) { new Thread(()->{ for (int j = 0; j < 1000; j++) { add(); } }).start(); } //如果还有除main和gc之外的其它线程，说明还没结束 while (Thread.activeCount()>2){//main gc Thread.yield(); } System.out.println(Thread.currentThread().getName()+"，结果："+num); } }分析：
private static int num=0;如果不加volatile ，结果可能会不符合预期，而加了volatile 之后：private static volatile int num=0;
结果还是可能不符合预期，因为多个线程存在并发操作，虽然volatile 可以保证num可以被各个线程所见，但是每个线程内的操作是一组操作，可能这个线程有一组操作如num++(num起始值为100)，它在读取到num的值后被阻塞，另一个线程已经在用了这个变量了更新num值为101，然后阻塞的线程再运行值刷新到主存后num还是101。
参考博文：volatile为什么不能保证原子性
解释：
上面说的num++不是一个原子操作，它有三个子操作（子操作是原子的）：
读取num值
num+1
写回内存
问题：因为num++不是原子操作所以造成了结果不符合预期，那么如何解决？（在不使用lock和synchronized情况下）
解决方法：java.util.concurrent.atomic包下就有对应的解决类（这些类底层直接和操作系统挂钩，在内存中修改值，Unsafe类是一个很特殊的存在）
测试类：
package com.lxf.volatileT; import java.util.concurrent.atomic.AtomicInteger; //不保证原子性 public class VDemo02 { private volatile static AtomicInteger num=new AtomicInteger(); public static void add(){ // num++; num.getAndIncrement();//AtomicInteger + 1方法，CAS } public static void main(String[] args) { for (int i = 0; i < 20; i++) { new Thread(()->{ for (int j = 0; j < 1000; j++) { add(); } }).start(); } //如果还有除main和gc之外的其它线程，说明还没结束 while (Thread.activeCount()>2){//main gc Thread.yield(); } System.out.println(Thread.currentThread().getName()+"，结果："+num); } }指令重排
什么是指令重排：指令重排是指在程序执行过程中, 为了性能考虑, 编译器和CPU可能会对指令重新排序.
源代码–>编译器优化的重排–>指令并行也可能会重排–>内存系统也会重排–>执行
处理器在进行指令重排的时候，考虑：数据之间的依赖性！
int x=1;//1 int x=2;//2 x=x+5;//3 y=x+x;//4 //我们所期望的：1234 //而1234、2134、1324执行的结果都是一样的可能造成影响的结果（a,b,x,y这四个值默认都是0）：
线程A线程Bx=ay=bb=1a=2正常的结果：x=0;y=0；
但是可能指令重排：
线程A线程Bb=1a=2x=ay=b指令重排可能导致的结果：x=2,y=1
volatile关键字可以避免指令重排：
内存屏障、CPU指令。作用：
保证特定操作的执行顺序！可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）通过反射打破线程安全：
package com.lxf.factory.single; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; //饿汉式单例 //禁止指令重排序优化模式 public class LazyMan { private LazyMan(){ //System.out.println("当前线程："+Thread.currentThread().getName()+"ok"); } //volatile防止指令重排 private volatile static LazyMan lazyMan; //双重检测锁模式的饿汉式单例 DCL懒汉式 public static LazyMan getInstance(){ if(lazyMan==null){ synchronized (LazyMan.class){ if(lazyMan==null){ lazyMan=new LazyMan();//不是一个原子性操作 /** * 1.分配内存空间 * 2.执行构造方法，初始化对象 * 3.把这个对象指向这个空间 * * 可能会出现指令重排： * 期望：123 * 可能：132 假如这个线程是A,132为A线程的对象创建过程 * 3的时候此时还没有初始化对象，如果此时B线程也在创建，B就会发生错误 */ } } } return lazyMan; } public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { //通过类的静态方法获取LazyMan对象 LazyMan lazyMan1=LazyMan.getInstance(); //通过反射获取LazyMan对象 Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null); //打破访问安全机制 declaredConstructor.setAccessible(true); //通过反射获取的LazyMan对象 LazyMan lazyMan2 = declaredConstructor.newInstance(); System.out.println("lazyMan1="+lazyMan1.hashCode()); System.out.println("lazyMan2="+lazyMan2.hashCode()); // 结果（明显不一样）： // lazyMan1=356573597 // lazyMan2=1735600054 } }构造函数再加锁检测：
package com.lxf.factory.single; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; //饿汉式单例 //禁止指令重排序优化模式 public class LazyMan { private LazyMan(){ synchronized (LazyMan.class){ if(lazyMan!=null){ throw new RuntimeException("不要试图使用反射破坏安全机制"); } } } //volatile防止指令重排 private volatile static LazyMan lazyMan; //双重检测锁模式的饿汉式单例 DCL懒汉式 public static LazyMan getInstance(){ if(lazyMan==null){ synchronized (LazyMan.class){ if(lazyMan==null){ lazyMan=new LazyMan();//不是一个原子性操作 /** * 1.分配内存空间 * 2.执行构造方法，初始化对象 * 3.把这个对象指向这个空间 * * 可能会出现指令重排： * 期望：123 * 可能：132 假如这个线程是A,132为A线程的对象创建过程 * 3的时候此时还没有初始化对象，如果此时B线程也在创建，B就会发生错误 */ } } } return lazyMan; } public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { //通过类的静态方法获取LazyMan对象 LazyMan lazyMan1=LazyMan.getInstance(); //通过反射获取LazyMan对象 Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null); //打破访问安全机制 declaredConstructor.setAccessible(true); //通过反射获取的LazyMan对象 LazyMan lazyMan2 = declaredConstructor.newInstance(); System.out.println("lazyMan1="+lazyMan1.hashCode()); System.out.println("lazyMan2="+lazyMan2.hashCode()); // 结果(报错)： // Exception in thread "main" java.lang.reflect.InvocationTargetException // at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) // at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62) // at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45) // at java.lang.reflect.Constructor.newInstance(Constructor.java:423) // at com.lxf.factory.single.LazyMan.main(LazyMan.java:49) //Caused by: java.lang.RuntimeException: 不要试图使用反射破坏安全机制 // at com.lxf.factory.single.LazyMan.<init>(LazyMan.java:12) // ... 5 more } }获取对象都用反射（再次打破安全机制）：
package com.lxf.factory.single; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; //饿汉式单例 //禁止指令重排序优化模式 public class LazyMan { private LazyMan(){ synchronized (LazyMan.class){ if(lazyMan!=null){ throw new RuntimeException("不要试图使用反射破坏安全机制"); } } } //volatile防止指令重排 private volatile static LazyMan lazyMan; //双重检测锁模式的饿汉式单例 DCL懒汉式 public static LazyMan getInstance(){ if(lazyMan==null){ synchronized (LazyMan.class){ if(lazyMan==null){ lazyMan=new LazyMan();//不是一个原子性操作 /** * 1.分配内存空间 * 2.执行构造方法，初始化对象 * 3.把这个对象指向这个空间 * * 可能会出现指令重排： * 期望：123 * 可能：132 假如这个线程是A,132为A线程的对象创建过程 * 3的时候此时还没有初始化对象，如果此时B线程也在创建，B就会发生错误 */ } } } return lazyMan; } public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { //通过反射获取LazyMan对象 Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null); //打破访问安全机制 declaredConstructor.setAccessible(true); //通过反射获取的LazyMan1对象 LazyMan lazyMan1=declaredConstructor.newInstance(); //通过反射获取的LazyMan2对象 LazyMan lazyMan2 = declaredConstructor.newInstance(); System.out.println("lazyMan1="+lazyMan1.hashCode()); System.out.println("lazyMan2="+lazyMan2.hashCode()); // 结果(对象不一样)： // lazyMan1=356573597 // lazyMan2=1735600054 } }再次添加标志(或密钥等)拦截：
package com.lxf.factory.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(flag==false){ flag=true; }else{ throw new RuntimeException("不要试图使用反射破坏安全机制"); } } } //volatile防止指令重排 private volatile static LazyMan lazyMan; //双重检测锁模式的饿汉式单例 DCL懒汉式 public static LazyMan getInstance(){ if(lazyMan==null){ synchronized (LazyMan.class){ if(lazyMan==null){ lazyMan=new LazyMan();//不是一个原子性操作 /** * 1.分配内存空间 * 2.执行构造方法，初始化对象 * 3.把这个对象指向这个空间 * * 可能会出现指令重排： * 期望：123 * 可能：132 假如这个线程是A,132为A线程的对象创建过程 * 3的时候此时还没有初始化对象，如果此时B线程也在创建，B就会发生错误 */ } } } return lazyMan; } public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { //通过反射获取LazyMan对象 Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null); //打破访问安全机制 declaredConstructor.setAccessible(true); //通过反射获取的LazyMan1对象 LazyMan lazyMan1=declaredConstructor.newInstance(); //通过反射获取的LazyMan2对象 LazyMan lazyMan2 = declaredConstructor.newInstance(); System.out.println("lazyMan1="+lazyMan1.hashCode()); System.out.println("lazyMan2="+lazyMan2.hashCode()); // 结果(报错)： // Exception in thread "main" java.lang.reflect.InvocationTargetException // at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) // at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62) // at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45) // at java.lang.reflect.Constructor.newInstance(Constructor.java:423) // at com.lxf.factory.single.LazyMan.main(LazyMan.java:54) //Caused by: java.lang.RuntimeException: 不要试图使用反射破坏安全机制 // at com.lxf.factory.single.LazyMan.<init>(LazyMan.java:17) // ... 5 more } }修改标志位再破解安全机制：
package com.lxf.factory.single; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; //饿汉式单例 //禁止指令重排序优化模式 public class LazyMan { //标志位 private static boolean flag=false; private LazyMan(){ synchronized (LazyMan.class){ //第一次进来就把标志位换了 if(flag==false){ flag=true; }else{ throw new RuntimeException("不要试图使用反射破坏安全机制"); } } } //volatile防止指令重排 private volatile static LazyMan lazyMan; //双重检测锁模式的饿汉式单例 DCL懒汉式 public static LazyMan getInstance(){ if(lazyMan==null){ synchronized (LazyMan.class){ if(lazyMan==null){ lazyMan=new LazyMan();//不是一个原子性操作 /** * 1.分配内存空间 * 2.执行构造方法，初始化对象 * 3.把这个对象指向这个空间 * * 可能会出现指令重排： * 期望：123 * 可能：132 假如这个线程是A,132为A线程的对象创建过程 * 3的时候此时还没有初始化对象，如果此时B线程也在创建，B就会发生错误 */ } } } return lazyMan; } public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException { //通过反射获取LazyMan对象 Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null); //打破访问安全机制 declaredConstructor.setAccessible(true); //通过反射获取flag标志字段 Field flag = LazyMan.class.getDeclaredField("flag"); //将flag标志字段打破安全机制 flag.setAccessible(true); //通过反射获取的LazyMan1对象 LazyMan lazyMan1=declaredConstructor.newInstance(); //通过反射获取的LazyMan2对象 flag.set(lazyMan1,false);//将flag再设置为false LazyMan lazyMan2 = declaredConstructor.newInstance(); System.out.println("lazyMan1="+lazyMan1.hashCode()); System.out.println("lazyMan2="+lazyMan2.hashCode()); // 结果(获得两个对象，且不一样)： // lazyMan1=1735600054 // lazyMan2=21685669 } }思考：有没有一种方法能完全解决这个问题呢?答案是有，我们知道枚举类里的方法和字段都是static final类型的，所以当我们直接获取的时候得到的结果肯定是一致的，我也都知道，枚举也是类，那么通过反射来取呢：
package com.lxf.factory.single; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; //enum 本身也是一个Class类 public enum EnumSingle { INSTANCE; public EnumSingle getInstance(){ return INSTANCE; } } class Test{ public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { //通过类的静态方法获取实例： EnumSingle instance1=EnumSingle.INSTANCE; //反射获取构造函数 Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null); //打破安全机制 declaredConstructor.setAccessible(true); //通过反射获取的实例： EnumSingle instance2 = declaredConstructor.newInstance(); //打印 System.out.println(instance1.hashCode()); System.out.println(instance2.hashCode()); //结果（报错） //Exception in thread "main" java.lang.NoSuchMethodException: com.lxf.factory.single.EnumSingle.<init>() // at java.lang.Class.getConstructor0(Class.java:3082) // at java.lang.Class.getDeclaredConstructor(Class.java:2178) // at com.lxf.factory.single.Test.main(EnumSingle.java:21) } }反编译一下这个类：
C:\Users\dell\IdeaProjects\20200624-GoF23\out\production\20200624-GoF23\com\lxf\factory\single>javap -p EnumSingle.class Compiled from "EnumSingle.java" public final class com.lxf.factory.single.EnumSingle extends java.lang.Enum<com.lxf.factory.single.EnumSingle> { public static final com.lxf.factory.single.EnumSingle INSTANCE; private static final com.lxf.factory.single.EnumSingle[] $VALUES; public static com.lxf.factory.single.EnumSingle[] values(); public static com.lxf.factory.single.EnumSingle valueOf(java.lang.String); private com.lxf.factory.single.EnumSingle(); public com.lxf.factory.single.EnumSingle getInstance(); static {}; }可以看出这个类就是普通类继承类枚举类 我们还可以看到自己写的字段和方法，当然还有空参构造
当然系统编译出来当然没有专业工具厉害,我们再用jad反编译工具反编译出java文件：
C:\Users\dell\IdeaProjects\20200624-GoF23\out\production\20200624-GoF23\com\lxf\factory\single>jad -sjava EnumSingle.class Parsing EnumSingle.class... Generating EnumSingle.java C:\Users\dell\IdeaProjects\20200624-GoF23\out\production\20200624-GoF23\com\lxf\factory\single>反编译出的EnumSingle.java文件：
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov. // Jad home page: http://www.kpdus.com/jad.html // Decompiler options: packimports(3) // Source File Name: EnumSingle.java package com.lxf.factory.single; public final class EnumSingle extends Enum { public static EnumSingle[] values() { return (EnumSingle[])$VALUES.clone(); } public static EnumSingle valueOf(String name) { return (EnumSingle)Enum.valueOf(com/lxf/factory/single/EnumSingle, name); } private EnumSingle(String s, int i) { super(s, i); } public EnumSingle getInstance() { return INSTANCE; } public static final EnumSingle INSTANCE; private static final EnumSingle $VALUES[]; static { INSTANCE = new EnumSingle("INSTANCE", 0); $VALUES = (new EnumSingle[] { INSTANCE }); } }终于知道了，EnumSingle带的不是无参构造，而是有构造，我们再尝试下：
package com.lxf.factory.single; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; //enum 本身也是一个Class类 public enum EnumSingle { INSTANCE; public EnumSingle getInstance(){ return INSTANCE; } } class Test{ public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { //通过类的静态方法获取实例： EnumSingle instance1=EnumSingle.INSTANCE; //反射获取构造函数 Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class); //打破安全机制 declaredConstructor.setAccessible(true); //通过反射获取的实例： EnumSingle instance2 = declaredConstructor.newInstance(); //打印 System.out.println(instance1.hashCode()); System.out.println(instance2.hashCode()); //结果（报错） //Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects // at java.lang.reflect.Constructor.newInstance(Constructor.java:417) // at com.lxf.factory.single.Test.main(EnumSingle.java:25) } }什么是CAS
大厂你必须要深入研究底层！有所突破！ 修内功：操作系统、计算机网路原理
结果：
true 2021 true 2020 true 6666
（带版本的原子操作）
package com.lxf.cas; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicStampedReference; public class CASDemo { //CAS public static void main(String[] args) { //原子引用 //包装类Integer使用了对象缓存机制，默认范围是-128~127,推荐使用valueOf获取对象实例， //而不是new,因为valueOf使用缓存，而new一定会创建新的对象分配新的内存空间 //如果你在下面例子中将期望值和更新值传入的不在-128~127范围，会得到不一样的结果 AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(7,1); //a线程 new Thread(()->{ int stamp = atomicStampedReference.getStamp();//获得版本号 System.out.println("a1=>"+stamp); try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(atomicStampedReference.compareAndSet(7, 6, atomicStampedReference.getStamp(), atomicStampedReference.getStamp()+1)); System.out.println("a2=>"+atomicStampedReference.getStamp()); System.out.println(atomicStampedReference.compareAndSet(6, 7, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1)); System.out.println("a2=>"+atomicStampedReference.getStamp()); },"a").start(); //b线程 new Thread(()->{ int stamp = atomicStampedReference.getStamp();//获得版本号 System.out.println("b1=>"+stamp); try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(atomicStampedReference.compareAndSet(7, 5, stamp, stamp + 1)); System.out.println("b2=>"+atomicStampedReference.getStamp()); },"b").start(); } }结果：
a1=>1 b1=>1 true a2=>2 true a2=>3 false b2=>3
注意点:
公平锁：非常公平，不能够插队，必须先来后到！
非公平锁：非常不公平，可以插队（默认都是非公平）
又名递归锁:下面例子中sms方法调用了call方法，两个方法都是加了可重入锁的，锁的是对象。A和B线程都调用sms方法，又因为sms方法调用了call方法，这就是可重入，什么是 “可重入”，可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。
package com.lxf.lock; public class Demo01 { public static void main(String[] args) { Phone phone=new Phone(); new Thread(()->{ phone.sms(); },"A").start(); new Thread(()->{ phone.sms(); },"B").start(); } } class Phone{ public synchronized void sms(){ System.out.println(Thread.currentThread().getName()+"sms"); call();//这里也有锁 } public synchronized void call(){ System.out.println(Thread.currentThread().getName()+"call"); } }自定义锁测试：
SpinlockDemo(自己写的锁类)：
package com.lxf.lock; import java.util.concurrent.atomic.AtomicReference; /** * 自旋锁 */ public class SpinlockDemo { //int 0 //Thread null 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 myUnLock(){ Thread thread=Thread.currentThread(); System.out.println(Thread.currentThread().getName()+"==>myUnlock"); //CAS将值改为null atomicReference.compareAndSet(thread,null); } }测试类：
package com.lxf.lock; import java.util.concurrent.TimeUnit; public class TestSpinLock { public static void main(String[] args) throws InterruptedException { //底层使用的自旋锁CAS SpinlockDemo lock = new SpinlockDemo(); new Thread(()->{ lock.myLock(); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }finally { lock.myUnLock(); } },"T1").start(); TimeUnit.SECONDS.sleep(1); new Thread(()->{ lock.myLock(); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }finally { lock.myUnLock(); } },"T2").start(); } }结果：
T1lock:lockA,want:lockB T2lock:lockB,want:lockA
出现死锁，无法执行
解决方法：
在终端使用jps -l定位进程号命令（26024）2.在终端使用==jstack 进程号（26024）==找到死锁问题
//抓取重要信息： "T2": at com.lxf.lock.MyThread.run(DeadLockDemo.java:36) - waiting to lock <0x00000000ebb36b90> (a java.lang.String) - locked <0x00000000ebb36bc8> (a java.lang.String) at java.lang.Thread.run(Thread.java:748) "T1": at com.lxf.lock.MyThread.run(DeadLockDemo.java:36) - waiting to lock <0x00000000ebb36bc8> (a java.lang.String) - locked <0x00000000ebb36b90> (a java.lang.String) at java.lang.Thread.run(Thread.java:748) Found 1 deadlock.