devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

多线程--JUC并发编程_set dataset = new concurrentskiplistset<>(
作者：Gausst松鼠会 | 2024-05-06 19:38:03

赞

踩

set dataset = new concurrentskiplistset<>()

全部测试代码

什么是JUC

JUC就是java.util.concurrent工具包的简称

 

线程和进程

进程

一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。

线程

进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。

java默认有2个线程 mian线程 gc线程

并行和并发有什么区别？

  • 并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。

  • 并行：单位时间内，多个处理器或多核处理器同时处理多个任务，是真正意义上的“同时进行”。

  • 串行：有n个任务，由一个线程按顺序执行。由于任务、方法都在一个线程执行所以不存在线程不安全情况，也就不存在临界区的问题。

做一个形象的比喻：

并发 = 两个队列和一台咖啡机。

并行 = 两个队列和两台咖啡机。

串行 = 一个队列和一台咖啡机。

并发变成的本质: 充分利用CPU资源

线程的状态

NEW  //新生
RUNNABLE,// 运行
BLOCKED,//阻塞
WAITING,// 等待,死等 
TIMED_WAITING,// 超时等待
TERMINATED;// 终止

wait/sleep的区别 ?

  1. 来自不同的类

    1. wait --> Object

    2. sleep --> Thread

  2. 锁的释放

    1. wait 会释放锁

    2. sleep 抱着锁睡觉,不会释放锁

  3. 使用的范围不同

    1. wait 必须在同步代码块

    2. sleep 可以在任何地方睡

  4. 是否需要捕获异常

    1. wait 需要捕获异常wait需要被唤醒，

    2. sleep 须捕获异常 ,sleep不需要被唤醒

Lock锁

传统synchronized

 

 

公平锁: 十分公平 , 可以先来后到

非公平锁: 不公平 , 可以插队 (默认使用)

  1. package com.juc;
  2.  
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  5.  
  6. //买票
  7. public class SaleTickDemo2 {
  8.     public static void main(String[] args) {
  9. //        多线程操作
  10.         Ticket2 ticket = new Ticket2();
  11.  
  12. //        Runnable ; @FunctionalInterface 函数式接口    lambda   (参数) - > {代码}
  13.         new Thread( ()-> {
  14.             for (int i = 0; i < 60 ; i++) {
  15.                 ticket.sale();
  16.             }
  17.         },"A").start();
  18.         new Thread( ()-> {
  19.             for (int i = 0; i < 60 ; i++) {
  20.                 ticket.sale();
  21.             }
  22.         },"B").start();
  23.         new Thread( ()-> {
  24.             for (int i = 0; i < 60 ; i++) {
  25.                 ticket.sale();
  26.             }
  27.         },"C").start();
  28.     }
  29. }
  30. /*
  31. *  1. new ReentrantLock()
  32. *  2. lock.lock(); 加锁
  33. *  3.finally  lock.unlock();解锁
  34. * */
  35. class Ticket2 {
  36.     private int num = 50;
  37.  
  38.     Lock lock = new ReentrantLock();
  39.  
  40. //    买票的方法
  41.     public void sale(){
  42.         lock.lock(); //加锁
  43.         try {
  44. //            业务代码
  45.             if (num > 0) {
  46.                 System.out.println(Thread.currentThread().getName() + "第几张" + (num--) + "剩余" + num + "张");
  47.             }
  48.         } catch (Exception e) {
  49.             e.printStackTrace();
  50.         }finally {
  51. //            解锁
  52.             lock.unlock();
  53.         }
  54.     }
  55. }

Synchronized 与 lock 区别

  1. Synchronized 内置java关键字, lock是java的一个类

  2. Synchronized 无法判断获取锁的状态, lock可以判断是否获取到了锁

  3. Synchronized 会自动释放锁 , lock必须手动释放锁, 不释放锁会导致死锁

  4. Synchronized 线程1 获得锁 线程2 等待 线程1阻塞线程2 会死等; lock 不一定会等待 lock.tryLock(); 尝试获取锁

  5. Synchronized 可重入锁,不可中断,非公平. lock 可重入锁,可以判断锁 ,锁的公平(可以自定义)

  6. Synchronized 适合少量代码同步问题, lock 适合大量代码同步

生产者消费者问题

  1. package com.pc; 
  2. /*
  3. * 线程之间的通信问题,生产者和消费者问题   等待唤醒   通知唤醒
  4. * 线程交替执行 A  B  操作同一变量*/
  5. public class A {
  6.     public static void main(String[] args) {
  7.  
  8.         Data date = new Data();
  9.         new Thread(()->{
  10.             for (int i = 0; i < 10; i++) {
  11.                 try {
  12.                     date.increment();
  13.                 } catch (InterruptedException e) {
  14.                     e.printStackTrace();
  15.                 }
  16.             }
  17.         },"A").start();
  18.         new Thread(()->{
  19.             for (int i = 0; i < 10; i++) {
  20.                 try {
  21.                     date.decrement();
  22.                 } catch (InterruptedException e) {
  23.                     e.printStackTrace();
  24.                 }
  25.             }
  26.         },"B").start();
  27.     }
  28.  
  29.  
  30. }
  31. // 等待  业务  通知
  32. class Data{
  33.     private int number = 0;
  34.  
  35.     public synchronized void increment() throws InterruptedException {
  36. //        +1
  37.         if (number != 0) {
  38. // 等待
  39.             this.wait();
  40.         }
  41.         number++;
  42.         System.out.println(Thread.currentThread().getName()+"  "+number);
  43. //        通知其他线程  我 +1 完毕了
  44.         this.notifyAll();
  45.     }
  46.     public synchronized void decrement() throws InterruptedException {
  47. //        -1
  48.         if (number == 0) {
  49. //等待
  50.             this.wait();
  51.         }
  52.         number--;
  53.         System.out.println(Thread.currentThread().getName()+"  "+number);
  54. //        通知其他线程 我-1  完毕了
  55.         this.notifyAll();
  56.     }
  57. }

 如果有 ABCD四个线程, 会出现虚假唤醒的情况 此时, 将if判断改为while 判断

  1. package com.pc;
  2. /*
  3. * 线程之间的通信问题,生产者和消费者问题   等待唤醒   通知唤醒
  4. * 线程交替执行 A  B  操作同一变量*/
  5. public class A {
  6.     public static void main(String[] args) {
  7.  
  8.         Data date = new Data();
  9.         new Thread(()->{
  10.             for (int i = 0; i < 10; i++) {
  11.                 try {
  12.                     date.increment();
  13.                 } catch (InterruptedException e) {
  14.                     e.printStackTrace();
  15.                 }
  16.             }
  17.         },"A").start();
  18.         new Thread(()->{
  19.             for (int i = 0; i < 10; i++) {
  20.                 try {
  21.                     date.decrement();
  22.                 } catch (InterruptedException e) {
  23.                     e.printStackTrace();
  24.                 }
  25.             }
  26.         },"B").start();
  27.         new Thread(()->{
  28.             for (int i = 0; i < 10; i++) {
  29.                 try {
  30.                     date.increment();
  31.                 } catch (InterruptedException e) {
  32.                     e.printStackTrace();
  33.                 }
  34.             }
  35.         },"C").start();
  36.         new Thread(()->{
  37.             for (int i = 0; i < 10; i++) {
  38.                 try {
  39.                     date.decrement();
  40.                 } catch (InterruptedException e) {
  41.                     e.printStackTrace();
  42.                 }
  43.             }
  44.         },"D").start();
  45.     }
  46.  
  47. }
  48.  
  49. // 等待  业务  通知
  50. class Data{
  51.     private int number = 0;
  52.  
  53.     public synchronized void increment() throws InterruptedException {
  54. //        +1
  55.         while (number != 0) {
  56. // 等待
  57.             this.wait();
  58.         }
  59.         number++;
  60.         System.out.println(Thread.currentThread().getName()+"  "+number);
  61. //        通知其他线程  我 +1 完毕了
  62.         this.notifyAll();
  63.     }
  64.     public synchronized void decrement() throws InterruptedException {
  65. //        -1
  66.         while (number == 0) {
  67. //等待
  68.             this.wait();
  69.         }
  70.         number--;
  71.         System.out.println(Thread.currentThread().getName()+"  "+number);
  72. //        通知其他线程 我-1  完毕了
  73.         this.notifyAll();
  74.     }
  75. }

JUC版的生产者消费者

通过Lock 找到 Condition

 

  1. package com.pc;
  2.  
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  6.  
  7. public class B {
  8.     public static void main(String[] args) {
  9.  
  10.         Data2 date = new Data2();
  11.         new Thread(()->{
  12.             for (int i = 0; i < 10; i++) {
  13.                 try {
  14.                     date.increment();
  15.                 } catch (InterruptedException e) {
  16.                     e.printStackTrace();
  17.                 }
  18.             }
  19.         },"A").start();
  20.         new Thread(()->{
  21.             for (int i = 0; i < 10; i++) {
  22.                 try {
  23.                     date.decrement();
  24.                 } catch (InterruptedException e) {
  25.                     e.printStackTrace();
  26.                 }
  27.             }
  28.         },"B").start();
  29.         new Thread(()->{
  30.             for (int i = 0; i < 10; i++) {
  31.                 try {
  32.                     date.increment();
  33.                 } catch (InterruptedException e) {
  34.                     e.printStackTrace();
  35.                 }
  36.             }
  37.         },"C").start();
  38.         new Thread(()->{
  39.             for (int i = 0; i < 10; i++) {
  40.                 try {
  41.                     date.decrement();
  42.                 } catch (InterruptedException e) {
  43.                     e.printStackTrace();
  44.                 }
  45.             }
  46.         },"D").start();
  47.  
  48.     }
  49. }
  50.  
  51. // 等待  业务  通知
  52. class Data2{
  53.     private int number = 0;
  54.     Lock lock = new ReentrantLock();
  55.     Condition condition = lock.newCondition();
  56. //            condition.wait(); // 等待
  57. //            condition.signalAll(); // 唤醒
  58.  
  59.     public  void increment() throws InterruptedException {
  60.         lock.lock();
  61.         try {
  62. //            业务代码
  63. //        +1
  64.             while (number != 0) {
  65.                 condition.await(); // 等待
  66.             }
  67.             number++;
  68.             System.out.println(Thread.currentThread().getName()+"-->"+number);
  69. //        通知其他线程  我 +1 完毕了
  70.             condition.signalAll(); // 唤醒
  71.         } catch (Exception e) {
  72.             e.printStackTrace();
  73.         } finally {
  74.             lock.unlock();
  75.         }
  76.     }
  77.     public  void decrement() throws InterruptedException {
  78.         lock.lock();
  79.         try {
  80.             //        -1
  81.             while (number == 0) {
  82.                 condition.await();// 等待
  83.             }
  84.             number--;
  85.             System.out.println(Thread.currentThread().getName()+"-->"+number);
  86. //        通知其他线程 我-1  完毕了
  87.             condition.signalAll(); // 唤醒
  88.         } catch (Exception e) {
  89.             e.printStackTrace();
  90.         } finally {
  91.             lock.unlock();
  92.         }
  93.     }
  94. }

不会出现虚假唤醒,但是 唤醒的没有规律

condition 精准通知和唤醒线程

  1. package com.pc;
  2.  
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  6.  
  7. /*
  8. * A执行完调用B
  9. * B执行完调用C
  10. * C执行完调用A
  11. * */
  12. public class C {
  13.     public static void main(String[] args) {
  14.         Data3 data3 = new Data3();
  15.         new Thread(()->{
  16.             for (int i = 0; i < 10; i++) {
  17.                 data3.printA();
  18.             }
  19.         },"A").start();
  20.         new Thread(()->{
  21.             for (int i = 0; i < 10; i++) {
  22.                 data3.printB();
  23.             }
  24.         },"B").start();
  25.         new Thread(()->{
  26.             for (int i = 0; i < 10; i++) {
  27.                 data3.printC();
  28.             }
  29.         },"C").start();
  30.     }
  31. }
  32.  
  33. class Data3{
  34.     private Lock lock = new ReentrantLock();
  35.     private Condition condition1 = lock.newCondition();
  36.     private Condition condition2 = lock.newCondition();
  37.     private Condition condition3 = lock.newCondition();
  38.  
  39.     private int number = 1;
  40.     public void printA(){
  41.         lock.lock();
  42.         try {
  43.             while (number != 1) {
  44. //                等待
  45.                 condition1.await();
  46.             }
  47.             System.out.println(Thread.currentThread().getName() + "--->A");
  48. //            唤醒指定的人
  49. //            业务代码 判断是否等待  执行   通知
  50.             number = number+1;
  51.             condition2.signal();
  52.         } catch (Exception e) {
  53.             e.printStackTrace();
  54.         } finally {
  55.             lock.unlock();
  56.         }
  57.     }
  58.     public void printB(){
  59.         lock.lock();
  60.         try {
  61. //            业务代码 判断是否等待  执行   通知
  62.             while (number != 2) {
  63.                 condition2.await();
  64.             }
  65.             System.out.println(Thread.currentThread().getName() + "--->B");
  66.             number = 3;
  67.             condition3.signal();
  68.         } catch (Exception e) {
  69.             e.printStackTrace();
  70.         } finally {
  71.             lock.unlock();
  72.         }
  73.     }
  74.     public void printC(){
  75.         lock.lock();
  76.         try {
  77.             while (number != 3) {
  78.                 condition3.await();
  79.             }
  80.             System.out.println(Thread.currentThread().getName() + "--->C");
  81.             number = 1;
  82.             condition1.signal();
  83. //            业务代码 判断是否等待  执行   通知
  84.         } catch (Exception e) {
  85.             e.printStackTrace();
  86.         } finally {
  87.             lock.unlock();
  88.         }
  89.     }
  90. }

8锁现象

怎么判断锁的是谁

8锁 测试代码

new this 具体的都关系

static 锁的是Class

集合类不安全

List - CopyOnWriteArrayList

  1. package com.unsafe;
  2.  
  3. import java.util.*;
  4. import java.util.concurrent.CopyOnWriteArrayList;
  5.  
  6. /*
  7. * java.util.ConcurrentModificationException 并发修改异常
  8. * */
  9. public class ListTest {
  10.     public static void main(String[] args) {
  11. //        List<String> list = Arrays.asList("1", "12", "13");
  12. //        list.forEach(System.out::println);
  13.  
  14. //        并发下 ArrayList 不安全
  15.         /*
  16.         * 解决方法：
  17.         * 1. List<String> list = new Vector<>();
  18.         * 2. List<String> list = Collections.synchronizedList(new ArrayList<>());
  19.         * 3. List<String> list = new CopyOnWriteArrayList<>();
  20.         * */
  21. //        CopyOnWrite写入是复制  多个线程调用的时候 读取的是固定的，写入避免覆盖，写入的时候先copyof一份 ，最后在set回去
  22. //        CopyOnWriteArrayList 比 Vector 厉害在哪
  23.         List<String> list = new CopyOnWriteArrayList<>();
  24.         for (int i = 1; i <= 10; i++) {
  25.             new Thread(() -> {
  26.                 list.add(UUID.randomUUID().toString().substring(0, 5));
  27.                 System.out.println(list);
  28.             }, String.valueOf(i)).start();
  29.         }
  30.     }
  31. }

set - ConcurrentSkipListSet

  1. package com.unsafe;
  2.  
  3. import java.util.Collections;
  4. import java.util.HashSet;
  5. import java.util.Set;
  6. import java.util.UUID;
  7. import java.util.concurrent.ConcurrentSkipListSet;
  8.  
  9. /*
  10. *解决方案:
  11. * 1.Set<String> set = Collections.synchronizedSet(new HashSet<>());
  12. * 2.Set<String> set = new ConcurrentSkipListSet<>();
  13. * */
  14. public class SetTest {
  15.     public static void main(String[] args) {
  16. //        Set<String> set = new ConcurrentSkipListSet<>();
  17.         HashSet<Object> set = new HashSet<>();
  18.         for (int i = 0; i < 30; i++) {
  19.             new Thread(()->{
  20.                 set.add(UUID.randomUUID().toString().substring(0, 5));
  21.                 System.out.println(set);
  22.             },String.valueOf(i)).start();
  23.         }
  24.     }
  25. }

hashSet底层是啥??

hashSet底层new 了一个HashMap

 add方法   也是map.put()

map - ConcurrentHashMap

  1. package com.unsafe;
  2.  
  3. import java.util.Collections;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import java.util.UUID;
  7. import java.util.concurrent.ConcurrentHashMap;
  8.  
  9. /*
  10. * java.util.ConcurrentModificationException
  11. * */
  12. public class MapTest {
  13.     public static void main(String[] args) {
  14. //        Map<String, String> map = new HashMap<>()
  15.  
  16.         Map<Object, Object> map = Collections.synchronizedMap(new HashMap<>());
  17. //        ConcurrentHashMap不能接受null的key和null的value,会抛出空指针异常
  18. //        Map<String, String> map = new ConcurrentHashMap<>();
  19.         for (int i = 1; i <= 30; i++) {
  20.             new Thread(()->{
  21.                 map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 5));
  22.                 System.out.println(map);
  23.             },String.valueOf(i)).start();
  24.         }
  25.     }
  26. }

Callable

  1. 可以有返回值

  2. 可以抛出异常

  3. 方法不同 run() call()

 

 

  1. package com.callable;
  2.  
  3. import java.util.concurrent.Callable;
  4. import java.util.concurrent.ExecutionException;
  5. import java.util.concurrent.FutureTask;
  6.  
  7. public class CallableTest {
  8.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  9. //        new Thread(new Runnable()).start();
  10. //        new Thread(new FutureTask<V>() ).start();
  11. //        new Thread(new FutureTask<V>(Callable) ).start();
  12.         new Thread().start();    // 怎么启动Callable
  13.  
  14.         MyThread myThread = new MyThread();
  15.         FutureTask futureTask = new FutureTask(myThread);//        适配类
  16.  
  17.         new Thread(futureTask,"A").start();
  18.         new Thread(futureTask,"B").start();
  19.         // 两个线程，但只打印了一份  由于JVM第二次再调用FutrueTask对象所持有的线程， 此时FutrueTask的state此时已非NEW状态
  20. //        则此时会直接结束对应线程，就会导致任务也不执行,只是在第一次调用时返回结果保存了
  21. //        只执行一次，判断不是第一次就直接return了
  22.         String o = (String)futureTask.get(); //获取Callable返回结果    get 方法可能会产生阻塞 或者使用异步通信处理
  23.         System.out.println(o);
  24.     }
  25. }
  26. class MyThread implements Callable<String>{  // Callable的泛型是啥返回值就是啥
  27.  
  28.     @Override
  29.     public String call()  {
  30.         System.out.println("call");
  31.         return "999";
  32.     }
  33. }

常用的辅助类

CountDownLatch

 

  1. package com.add;
  2.  
  3. import java.util.concurrent.CountDownLatch;
  4.  
  5. //计数器
  6. public class CoundDownLatchDemo {
  7.     public static void main(String[] args) throws InterruptedException {
  8. //        倒计时,总数是6
  9.         CountDownLatch countDownLatch = new CountDownLatch(6);
  10.         for (int i = 0; i < 6; i++) {
  11.             new Thread(() -> {
  12.                 System.out.println(Thread.currentThread().getName() + "走了");
  13.                 countDownLatch.countDown(); // 数量减一
  14.             },String.valueOf(i)).start();
  15.         }
  16.         countDownLatch.await();//等待计数器归零,然后向下执行
  17.         System.out.println("关门");
  18.     }
  19. }

原理:

countDownLatch.countDown(); // 数量减一

countDownLatch.await();//等待计数器归零

每次调用countDown() 数量减一 , 假设计数器变为0 countDownLatch.await() 就会被唤醒 ,继续执行

CyclicBarrier

  1. package com.add;
  2.  
  3. import java.util.concurrent.BrokenBarrierException;
  4. import java.util.concurrent.CyclicBarrier;
  5.  
  6. //CyclicBarrier   执行达到指定线程数再执行操作
  7. //集齐7个葫芦娃合体
  8. public class CyclicBarrierDemo {
  9.     public static void main(String[] args) {
  10.  
  11. //        呼叫葫芦娃的线程
  12.         CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
  13.             System.out.println("葫芦娃合体");
  14.         });
  15.         for (int i = 1; i <= 7; i++) {
  16. //            lambda拿不到i 设置中间变量
  17.             final int temp = i;
  18.             new Thread(() -> {
  19.                 System.out.println(Thread.currentThread().getName()+"召集了" + temp + "个葫芦娃");
  20.                 try {
  21.                     cyclicBarrier.await(); //等待
  22.                 } catch (InterruptedException e) {
  23.                     e.printStackTrace();
  24.                 } catch (BrokenBarrierException e) {
  25.                     e.printStackTrace();
  26.                 }
  27.             }).start();
  28.         }
  29.     }
  30. }

Semaphore

  1. package com.add;
  2.  
  3. import java.util.concurrent.Semaphore;
  4. import java.util.concurrent.TimeUnit;
  5.  
  6. //CyclicBarrier : 指定个数线程执行完毕再执行操作
  7. //CyclicBarrier   执行达到指定线程数再执行操作
  8. public class SemaohoreDemo {
  9.     public static void main(String[] args) {
  10. //        线程数量 : 停车位   限流的时候可以用
  11.         Semaphore semaphore = new Semaphore(3);
  12.         for (int i = 1; i < 6; i++) {
  13.             new Thread(() -> {
  14.                 try {
  15.                     semaphore.acquire(); // 得到
  16.                     System.out.println(Thread.currentThread().getName() + " 得到车位");
  17.                     TimeUnit.SECONDS.sleep(2);
  18.                     System.out.println(Thread.currentThread().getName() + " 离开车位");
  19.                 } catch (InterruptedException e) {
  20.                     e.printStackTrace();
  21.                 }finally {
  22.                     semaphore.release(); // 释放
  23.                 }
  24.             },String.valueOf(i)).start();
  25.  
  26.         }
  27.     }
  28. }

semaphore.acquire(); 获得 ,假设已经满了,等待, 知道被释放为止

semaphore.release(); 释放 会将当前信号量释放 +1 , 然后唤醒等待的线程

作业 : 多个共享资源互斥使用 ; 并发限流(控制最大线程数)

读写锁

ReadWriteLock

  1. package com.rw;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.concurrent.locks.ReadWriteLock;
  6. import java.util.concurrent.locks.ReentrantReadWriteLock;
  7.  
  8. /*
  9. * ReadWriteLock
  10. * 独占锁(写锁) 一次只能被一个线程占有
  11. * 共享锁(读锁) 多个线程可以同时操作
  12. * 读 - 读  可以共存
  13. * 读 - 写 不能共存
  14. * 写 - 学 不能共存
  15. * */
  16. public class ReadWriteLockDemo {
  17.     public static void main(String[] args) {
  18.         MyCacheLock myCache = new MyCacheLock();
  19.         for (int i = 1; i <= 5; i++) {
  20.             final int temp = i;
  21. //            写入
  22.             new Thread(() -> {
  23.                 myCache.put(temp+"",temp+"");
  24.             },String.valueOf(i)).start();
  25.         }
  26.         for (int i = 1; i <= 5; i++) {
  27.             final int temp = i;
  28. //            读取
  29.             new Thread(() -> {
  30.                 myCache.get(temp+"");
  31.             },String.valueOf(i)).start();
  32.         }
  33.     }
  34. }
  35.  
  36. //自定义缓存
  37. // 会出现 写操作的时候被别的线程插队 , 所以引出ReadWriteLock 
  38. class MyCache{
  39.     private volatile Map<String, Object> map = new HashMap<>();
  40. //    存  写
  41.     public void put(String key , Object value) {
  42.         System.out.println(Thread.currentThread().getName() + "写入" + key);
  43.         map.put(key, value);
  44.         System.out.println(Thread.currentThread().getName() + "写入完成");
  45.     }
  46.     //    读  取
  47.     public void get(String key) {
  48.         System.out.println(Thread.currentThread().getName() + "读取" + key);
  49.         Object o = map.get(key);
  50.         System.out.println(Thread.currentThread().getName() + "读取完成");
  51.     }
  52. }
  53.  
  54. //加锁
  55. class MyCacheLock{
  56.  
  57.     private volatile Map<String, Object> map = new HashMap<>();
  58.     //读写锁 :
  59.     private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  60.  
  61.     //    存 的时候,希望只有一个线程去写操作
  62.     public void put(String key , Object value) {
  63.         readWriteLock.writeLock().lock();
  64.         try {
  65.             System.out.println(Thread.currentThread().getName() + "写入" + key);
  66.             map.put(key, value);
  67.             System.out.println(Thread.currentThread().getName() + "写入完成");
  68.         } catch (Exception e) {
  69.             e.printStackTrace();
  70.         } finally {
  71.             readWriteLock.writeLock().unlock();
  72.         }
  73.     }
  74.  
  75.     //    读的时候,所有人都可以去读
  76.     public void get(String key) {
  77.         readWriteLock.readLock().lock();
  78.         try {
  79.             System.out.println(Thread.currentThread().getName() + "读取" + key);
  80.             Object o = map.get(key);
  81.             System.out.println(Thread.currentThread().getName() + "读取完成");
  82.         } catch (Exception e) {
  83.             e.printStackTrace();
  84.         } finally {
  85.             readWriteLock.readLock().unlock();
  86.         }
  87.     }
  88. }

阻塞队列

阻塞

队列

 

四组API

方式抛出异常有返回值,不抛出异常阻塞 等待超时等待
添加addofferput()offer( , ,)
移除removepolltake()pool( , )
判断队列首elementpeek--
  1. package com.bq;
  2.  
  3. import java.util.concurrent.ArrayBlockingQueue;
  4.  
  5. public class test {
  6.     public static void main(String[] args) {
  7.         test1();
  8.     }
  9.     /*
  10.     * 抛出异常
  11.     * */
  12.     public static void test1(){
  13. //        队列的大小
  14.         ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
  15.         System.out.println(arrayBlockingQueue.add("a"));
  16.         System.out.println(arrayBlockingQueue.add("c"));
  17.         System.out.println(arrayBlockingQueue.add("v"));
  18.         System.out.println("---------------");
  19. //        java.lang.IllegalStateException: Queue full
  20. //        System.out.println(arrayBlockingQueue.add("f"));
  21.  
  22.  
  23. //        System.out.println(arrayBlockingQueue.element()); // 查看队首元素
  24.         System.out.println(arrayBlockingQueue.remove());
  25.         System.out.println(arrayBlockingQueue.remove());
  26.         System.out.println(arrayBlockingQueue.remove());
  27.  
  28. //         java.util.NoSuchElementException
  29. //        System.out.println(arrayBlockingQueue.remove());
  30.     }
  31. }

  1.     /*
  2.     * 有返回值,没有异常*/
  3.     public static void test2(){
  4. //        队列大小
  5.         ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
  6.         System.out.println(arrayBlockingQueue.offer("a"));
  7.         System.out.println(arrayBlockingQueue.offer("b"));
  8.         System.out.println(arrayBlockingQueue.offer("c"));
  9.         System.out.println(arrayBlockingQueue.offer("d")); // 返回false  不抛出异常
  10.  
  11.         System.out.println(arrayBlockingQueue.peek()); //检测队首元素
  12.         System.out.println(arrayBlockingQueue.poll());
  13.         System.out.println(arrayBlockingQueue.poll());
  14.         System.out.println(arrayBlockingQueue.poll());
  15.         System.out.println(arrayBlockingQueue.poll()); // 返回 null  不抛出异常
  16.     }

  1.     /*
  2.     * 等待 阻塞  (一直阻塞)
  3.     * */
  4.     public static void  test3() throws InterruptedException {
  5.         ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
  6. //        一直阻塞
  7.         arrayBlockingQueue.put("a");
  8.         arrayBlockingQueue.put("b");
  9.         arrayBlockingQueue.put("c");
  10. //        arrayBlockingQueue.put("d"); // 队列没有位置,一直阻塞
  11.  
  12.         System.out.println(arrayBlockingQueue.take());
  13.         System.out.println(arrayBlockingQueue.take());
  14.         System.out.println(arrayBlockingQueue.take());
  15.         System.out.println(arrayBlockingQueue.take()); // 没有多余元素. 一直等待
  16.     }
  1.     /*
  2.      * 等待 阻塞  (等待超时)
  3.      * */
  4.     public static void test4() throws InterruptedException {
  5.         ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
  6.  
  7.         System.out.println(arrayBlockingQueue.offer("a"));
  8.         System.out.println(arrayBlockingQueue.offer("b"));
  9.         System.out.println(arrayBlockingQueue.offer("c"));
  10.         System.out.println(arrayBlockingQueue.offer("c",2, TimeUnit.SECONDS));  //等待超过两秒直接退出
  11.  
  12.         System.out.println(arrayBlockingQueue.poll());
  13.         System.out.println(arrayBlockingQueue.poll());
  14.         System.out.println(arrayBlockingQueue.poll());
  15.         System.out.println(arrayBlockingQueue.poll(2,TimeUnit.SECONDS));  //等待超过两秒直接退出
  16.     }

SynchronizedQueue 同步队列

没有容量

存进去一个元素后,必须等到取出来后才可以存入下一个元素

  1. package com.blockingQueue;
  2.  
  3. import java.util.concurrent.BlockingQueue;
  4. import java.util.concurrent.SynchronousQueue;
  5. import java.util.concurrent.TimeUnit;
  6.  
  7. /*同步队列
  8. * 和其他的BlockingQueue 不一样 ,SynchronousQueue 不存储元素
  9. * put 一个元素,必须先取出来  否则不能再put进去值 */
  10. public class SynchronizedQueueDemo {
  11.     public static void main(String[] args) {
  12.         BlockingQueue<String> synchronousQueue = new SynchronousQueue<>(); //同步队列
  13.  
  14.         new Thread(()->{
  15.             try {
  16.                 System.out.println(Thread.currentThread().getName() + "----" + "put 1");
  17.                 synchronousQueue.put("1");
  18.                 System.out.println(Thread.currentThread().getName() + "----" + "put 2");
  19.                 synchronousQueue.put("2");
  20.                 System.out.println(Thread.currentThread().getName() + "----" + "put 3");
  21.                 synchronousQueue.put("3");
  22.             } catch (InterruptedException e) {
  23.                 e.printStackTrace();
  24.             }
  25.         },"A").start();
  26.  
  27.         new Thread(()->{
  28.             try {
  29.                 TimeUnit.SECONDS.sleep(2);
  30.                 System.out.println(Thread.currentThread().getName() + "----" + synchronousQueue.take());
  31.                 TimeUnit.SECONDS.sleep(2);
  32.                 System.out.println(Thread.currentThread().getName() + "----" + synchronousQueue.take());
  33.                 TimeUnit.SECONDS.sleep(2);
  34.                 System.out.println(Thread.currentThread().getName() + "----" + synchronousQueue.take());
  35.             } catch (InterruptedException e) {
  36.                 e.printStackTrace();
  37.             }
  38.         },"B").start();
  39.     }
  40. }

线程池

线程池三大方法 ; 七大参数 ; 四种拒绝策略

线程池的好处：

  • 降低资源消耗

  • 提高响应速度

  • 方便管理

线程复用 ， 可以控制最大并发，管理线程

池化技术

事先准备好一些资源，有人要用就来拿，用完之后归还

三大方法

  1. package com.pool;
  2.  
  3. import java.util.concurrent.Executor;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  6. import java.util.concurrent.ThreadPoolExecutor;
  7.  
  8. /*
  9. * Executors 工具类 3大方法
  10. * 使用线程池创建线程
  11. * */
  12. public class Demo1 {
  13.     public static void main(String[] args) {
  14. //        ExecutorService threadPoolExecutor= Executors.newSingleThreadExecutor();//当个线程
  15. //        ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(5); //创建一个固定的线程池大小
  16.         ExecutorService threadPoolExecutor = Executors.newCachedThreadPool(); //;可伸缩的 最大创建线程
  17.  
  18.         try {
  19.             for (int i = 0; i < 10; i++) {
  20. //                使用线程池来创建线程
  21.                 threadPoolExecutor.execute(() -> {
  22.                     System.out.println(Thread.currentThread().getName() + "   ok");
  23.                 });
  24.             }
  25.         } catch (Exception e) {
  26.             e.printStackTrace();
  27.         } finally {
  28. //            线程池使用完毕,程序结束,关闭线程池
  29.             threadPoolExecutor.shutdown();
  30.         }
  31.  
  32.     }
  33. }

7大参数

  1. public ThreadPoolExecutor(int corePoolSize,  // 核心线程大小
  2.                               int maximumPoolSize, // 最大线程大小
  3.                               long keepAliveTime, // 超时没人调用就会释放
  4.                               TimeUnit unit, //超时单位
  5.                               BlockingQueue<Runnable> workQueue, // 阻塞队列
  6.                               ThreadFactory threadFactory, // 线程工厂 ,创建线程的 一般不动
  7.                               RejectedExecutionHandler handler // 拒绝策略  ) {  
  8.         if (corePoolSize < 0 ||
  9.             maximumPoolSize <= 0 ||
  10.             maximumPoolSize < corePoolSize ||
  11.             keepAliveTime < 0)
  12.             throw new IllegalArgumentException();
  13.         if (workQueue == null || threadFactory == null || handler == null)
  14.             throw new NullPointerException();
  15.         this.corePoolSize = corePoolSize;
  16.         this.maximumPoolSize = maximumPoolSize;
  17.         this.workQueue = workQueue;
  18.         this.keepAliveTime = unit.toNanos(keepAliveTime);
  19.         this.threadFactory = threadFactory;
  20.         this.handler = handler;
  21.     }

四种拒绝策略

  1. package com.pool;
  2.  
  3. import java.util.concurrent.*;
  4. /*
  5. * java.util.concurrent.RejectedExecutionException 超出最大线程, 抛出异常
  6. * ThreadPoolExecutor.CallerRunsPolicy() 哪里来会那里去
  7. * ThreadPoolExecutor.DiscardPolicy() // 队列满了不会抛出异常
  8. * ThreadPoolExecutor.DiscardOldestPolicy()  队列满了尝试和 最早的竞争
  9. * */
  10. public class Demo2 {
  11.     public static void main(String[] args) {
  12.         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
  13.                 5,
  14.                 3,
  15.                 TimeUnit.SECONDS,
  16.                 new LinkedBlockingDeque<>(3),
  17.                 Executors.defaultThreadFactory(),
  18.                 new ThreadPoolExecutor.DiscardOldestPolicy()); // 队列满了尝试和 最早的竞争
  19.  
  20.         try {
  21. //            最大线程数量=  max + LinkedBlockingDeque
  22.             for (int i = 1; i <= 9; i++) {
  23. //                使用线程池来创建线程
  24.                 threadPoolExecutor.execute(() -> {
  25.                     System.out.println(Thread.currentThread().getName() + "   ok");
  26.                 });
  27.             }
  28.         } catch (Exception e) {
  29.             e.printStackTrace();
  30.         } finally {
  31. //            线程池使用完毕,程序结束,关闭线程池
  32.             threadPoolExecutor.shutdown();
  33.         }
  34.     }
  35. }

IO密集型 CPU密集型

问题： 线程池最大线程怎么设置

  1. //        最大线程如何定义
  2. //        1.CPU 密集型  几核就是几, 可以保持CPU的效率最高
  3.         System.out.println(Runtime.getRuntime().availableProcessors());  // 获取CPU核数
  4. //        2. IO 密集型  判断程序中消耗IO的线程,只要大于这些线程即可 
  5. //        例 ; 程序中有15个大型任务, io特别占用资源  至少留15个线程处理这些任务

四大函数式接口

lambda表达式 ；链式编程 ；函数式接口 ；Stream流

函数时接口 : 只有一个方法的接口

  1. // 简化编程模型，新版本框架大量使用
  2. // foreach(消费者类的函数式接口)
  3. @FunctionalInterface
  4. public interface Runnable {
  5.     public abstract void run();
  6. }

Function函数式接口

  1. package com.Function;
  2.  
  3. import java.util.function.Function;
  4. /*
  5. * Function 函数式接口, 一个入参 一个输出
  6. * 是要是函数时接口 就可以用lambda表达式简化
  7. * */
  8. public class Demo {
  9.     public static void main(String[] args) {
  10. //        输出输入的值
  11. //        Function function = new Function<String, String>() {
  12. //            @Override
  13. //            public String apply(String s) {
  14. //                return s;
  15. //            }
  16. //
  17. //        };
  18.         Function<String, String> function = (str) -> {return   str; };
  19.         System.out.println(function.apply("123asd"));
  20.     }
  21. }

Predicate断定型接口

有一个入参 返回值式布尔值

  1. package com.Function;
  2.  
  3. import java.util.function.Predicate;
  4.  
  5. /*
  6.  * 断定型接口 有一个入参 返回值式布尔值
  7.  * */
  8. public class Demo2 {
  9.     public static void main(String[] args) {
  10. //        判断字符是否为空
  11. //        Predicate<String> predicate = new Predicate<String>(){
  12. //            @Override
  13. //            public boolean test(String s) {
  14. //                return s.isEmpty();
  15. //            }
  16. //        };
  17.         Predicate<String> predicate = (srt) -> { return srt.isEmpty(); };
  18.         System.out.println(predicate.test(""));
  19.     }
  20. }

Consumer消费型接口

只有入参没有返回值

  1. package com.Function;
  2.  
  3. import java.util.function.Consumer;
  4.  
  5. /*
  6. * Consumer 消费型接口 只有输入 ，没有返回值
  7. * */
  8. public class Demo3 {
  9.     public static void main(String[] args) {
  10. //        Consumer<String> consumer = new Consumer<String>() {
  11. //            @Override
  12. //            public void accept(String str) {
  13. //                System.out.println(str);
  14. //            }
  15. //        };
  16. //        Consumer<String> consumer = (str)->{ System.out.println(str); };
  17.         Consumer<String> consumer = System.out::println;
  18.         consumer.accept("123qwe");
  19.     }
  20. }

Supplier供给型接口

  1. package com.Function;
  2.  
  3. import java.util.function.Supplier;
  4.  
  5. /*
  6. * Supplier 没有参数 只有返回值
  7. * */
  8. public class Demo4 {
  9.     public static void main(String[] args) {
  10. //        Supplier<String> supplier = new Supplier<String>() {
  11. //            @Override
  12. //            public String get() {
  13. //                return "123";
  14. //            }
  15. //        };
  16.         Supplier<String> supplier = ()->{ return "123";};
  17.         System.out.println(supplier.get());
  18.     }
  19. }

Stream流式计算

集合 MySQL 存储的东西 交给Stream流来计算

  1. package com.stream;
  2.  
  3. import java.util.Arrays;
  4. import java.util.List;
  5. /*
  6. * 要求筛选：
  7. *  id必须式偶数
  8. * age 大于23
  9. * name 转换为大写
  10. * name 倒着排序
  11. * 只输出一个用户
  12. * */
  13. public class Test {
  14.     public static void main(String[] args) {
  15.         User u1 = new User(1,"a",21);
  16.         User u2 = new User(2,"b",22);
  17.         User u3 = new User(3,"c",23);
  18.         User u4 = new User(4,"d",24);
  19.         User u5 = new User(6,"e",25);
  20.  
  21.         List<User> list =  Arrays.asList(u1, u2, u3, u4, u5);
  22.  
  23.         list.stream()
  24.                 .filter(u -> {
  25.                     return u.getId() % 2 == 0;
  26.                 }).
  27.                 filter(u -> {
  28.                     return u.getAge() > 23;
  29.                 })
  30.                 .map(u -> {
  31.                     return u.getNamen().toUpperCase();
  32.                 }).sorted((uu1,uu2)->{
  33.             return uu1.compareTo(uu2);})
  34.                 .limit(1)
  35.                 .forEach(System.out::println);
  36.     }
  37. }

ForkJoin

ForkJoin 再jDK1.7之后出的 ， 并行执行任务 ， 提高效率 处理大数据量时使用

ForkJoin 特点 任务窃取

里面维护的都是双端队列

 

 

代码测试

  1. package com.forkJoin;
  2.  
  3.  
  4. import java.util.concurrent.RecursiveTask;
  5.  
  6. /*
  7. * 使用ForkJoin
  8. * 1. 通过ForkJoinPool执行
  9. * 2. 计算任务 forkJoinPool,execute(ForkJoinTxask task)
  10. * 3. 计算类继承  ForkJoinTxask
  11. * */
  12. public class ForkJoinDemo extends RecursiveTask<Long> {
  13.     private long start;
  14.     private long end;
  15.  
  16.     //    临界值
  17.     private long temp = 10000L;
  18.  
  19.     public ForkJoinDemo(long start, long end) {
  20.         this.start = start;
  21.         this.end = end;
  22.     }
  23.  
  24. //    计算方法
  25.     @Override
  26.     protected Long compute() {
  27.         if ((end - start) < temp) {
  28.             long sum = 0L;
  29.             for (long i = start; i <= end; i++) {
  30.                 sum += i;
  31.             }
  32.             return sum;
  33.         } else {
  34.             long midden = (start + end) / 2; // 中间值
  35.             ForkJoinDemo task1 = new ForkJoinDemo(start, midden);
  36.             task1.fork(); //拆分任务 ，任务压入队列
  37.             ForkJoinDemo task2 = new ForkJoinDemo(midden + 1 , end);
  38.             task2.fork();//拆分任务 ，任务压入队列
  39.  
  40.             return task1.join() + task2.join();
  41.         }
  42.     }
  43. }

 测试类

  1. package com.forkJoin;
  2.  
  3. import java.util.concurrent.ExecutionException;
  4. import java.util.concurrent.ForkJoinPool;
  5. import java.util.concurrent.ForkJoinTask;
  6. import java.util.stream.LongStream;
  7.  
  8. public class Test {
  9.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  10. //        test1(); //3820  239
  11. //        test2(); //1996  121
  12. //        test3(); //137  131
  13.     }
  14.  
  15. //    普通计算
  16.     public static void test1() {
  17.         long sum = 0;
  18.         long start = System.currentTimeMillis();
  19.         for (long i = 1; i <10_0000_0000 ; i++) {
  20.             sum += sum;
  21.         }
  22.         long end = System.currentTimeMillis();
  23.         System.out.println("时间：" + (end - start));
  24.     }
  25. //    使用ForkJoin
  26.     public static void test2() throws ExecutionException, InterruptedException {
  27.         long start = System.currentTimeMillis();
  28.  
  29.         ForkJoinPool forkJoinPool = new ForkJoinPool();
  30.         ForkJoinTask<Long> joinDemo1 = new ForkJoinDemo(0,10_0000_0000);
  31.         ForkJoinTask<Long> submit = forkJoinPool.submit(joinDemo1);//提交任务
  32.         Long sum = submit.get();
  33.  
  34.         long end = System.currentTimeMillis();
  35.         System.out.println("sum:" + sum + "时间：" + (end - start));
  36.     }
  37.  
  38. //    使用Stream并行流
  39.     public static void test3(){
  40.         long start = System.currentTimeMillis();
  41. //        Stream并行流
  42.         long sum = LongStream.rangeClosed(0L, 10_0000_0000).parallel().reduce(0L, Long::sum);
  43.         long end = System.currentTimeMillis();
  44.         System.out.println("sum:" + sum + "时间：" + (end - start));
  45.     }
  46. }

异步回调

对未来的某个事件结果进行建模

  1. package com.future;
  2.  
  3. import java.util.concurrent.CompletableFuture;
  4. import java.util.concurrent.ExecutionException;
  5. import java.util.concurrent.TimeUnit;
  6.  
  7. /*
  8. * 异步调用
  9. * 异步执行
  10. * 成功回调
  11. * 失败回调
  12. * */
  13. public class Demo1 {
  14.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  15. //        没有返回值的 runAsync 异步回调
  16.       /*  CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
  17.             try {
  18.                 TimeUnit.SECONDS.sleep(2);
  19.             } catch (InterruptedException e) {
  20.                 e.printStackTrace();
  21.             }
  22.             System.out.println(Thread.currentThread().getName()+"runAsync--->Void");
  23.         });
  24.         System.out.println("1111");
  25.         completableFuture.get();//阻塞获取执行结果
  26. */
  27. //      有返回值的异步回调
  28.         CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
  29.             System.out.println(Thread.currentThread().getName() + "---->supplyAsync");
  30.             int i = 10 / 0;
  31.             return 111;
  32.         });
  33.  
  34.         System.out.println(completableFuture.whenComplete((u1, u2) -> {
  35.             System.out.println("t: " + u1); // 正常返回结果java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero            java.lang.ArithmeticException: / by zero
  36.             System.out.println("u: " + u2);
  37.         }).exceptionally((e) -> {
  38.             System.out.println(e.getMessage());
  39.             return 999; //可以获取到错误的返回结果
  40.         }).get());
  41.     }
  42. }

JMM

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

  1. 保证可见性

  2. 不保证原子性

  3. 禁止指令重排

Volatile 可见性怎么保证？？ 那就要说JMM了

JMM： java内存模型 ， 是不存在的东西，是一种约定

关于JMM的约定：

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

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

3.加锁和解锁必须是同一把锁

线程 ： 工作内存 主内存

内存交互操作有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操作之前，必须把此变量同步回主内存

问题： 程序不知道主内存已经被修改过了

Volatile

1.Volatile保证可见性

  1. package com.testVolatile;
  2.  
  3. import java.util.concurrent.TimeUnit;
  4.  
  5. public class JMMDemo {
  6. //    不加volatile 程序就会死循环
  7. //    加上volatile 就能保证程序的可见性
  8.     private volatile  static int num = 0;
  9.     public static void main(String[] args) {
  10.  
  11.         new Thread(() -> { //线程1  对主内存的变化不知道
  12.             while (num == 0) {
  13.  
  14.             }
  15.         }).start();
  16.         try {
  17.             TimeUnit.SECONDS.sleep(2);
  18.         } catch (InterruptedException e) {
  19.             e.printStackTrace();
  20.         }
  21.         num = 1;
  22.         System.out.println(num);
  23.  
  24.     }
  25. }

2.Volatile不保证原子性

原子性： 不可分割

线程A再执行任务的时候，不能被打扰，不能被分割，要么同时成功，要么同时失败

  1. package com.testVolatile;
  2.  
  3. //不保证原子性
  4. public class VolatileDemo {
  5. //    volatile 不保证原子性
  6.     private volatile static int num = 0;
  7.     public static void add(){
  8.         num++;
  9.     }
  10.     public static void main(String[] args) {
  11. //        理论上num结果为20000
  12.         for (int i = 0; i < 20; i++) {
  13.             new Thread(()->{
  14.                 for (int i1 = 0; i1 < 1000; i1++) {
  15.                     add();
  16.                 }
  17.             }).start();
  18.         }
  19.         while (Thread.activeCount() > 2) { //默认两个线程开启  main  gc
  20.             Thread.yield();
  21.         }
  22.         System.out.println(Thread.currentThread().getName() + "  " + num);
  23.     }
  24. }

 如果不加 lock和synchronized 怎么保证原子性

 

使用原子类保证原子性

  1. package com.testVolatile;
  2.  
  3. import java.util.concurrent.atomic.AtomicInteger;
  4.  
  5. //不保证原子性
  6. public class VolatileDemo {
  7. //    volatile 不保证原子性
  8. //    原子类的Integer
  9.     private volatile static  AtomicInteger num = new AtomicInteger();
  10.     public static void add(){
  11. //        num++;  // 不是原子性操作
  12.         num.getAndIncrement(); //  CAS操作
  13.     }
  14.     public static void main(String[] args) {
  15. //        理论上num结果为20000
  16.         for (int i = 0; i < 20; i++) {
  17.             new Thread(()->{
  18.                 for (int i1 = 0; i1 < 1000; i1++) {
  19.                     add();
  20.                 }
  21.             }).start();
  22.         }
  23.         while (Thread.activeCount() > 2) { //默认两个线程开启  main  gc
  24.             Thread.yield();
  25.         }
  26.         System.out.println(Thread.currentThread().getName() + "  " + num);
  27.     }
  28. }

这些类的底层直接和操作系统挂钩，再内存中修改，Unsafe是一个很特殊的存在！

Volatile指令重排

指令重排： 你写的程序，计算机并不是按照你写的那样去执行的

源代码--> 编译器优化的重排--> 指令并行也可能回导致重排--> 内存系统也会重排--> 执行

处理器在进行指令重排的时候，会考虑数据之间的依赖性

内存屏障 CPU指令 作用：

保证特定的操作的执行顺序

可以保证某些变量的内存可见性（利用这些特性 Volatile实现了可见性）

 

单例模式

饿汉式 DCL懒汉式

饿汉式：

  1. package com.signal;
  2.  
  3. //饿汉式
  4. public class Hungry {
  5.  
  6. //    类加载的时候就将数组加载到内存，如果不使用，造成内存空间浪费
  7.     private byte[] data1 = new byte[1024 * 1024];
  8.     private byte[] data2 = new byte[1024 * 1024];
  9.     private byte[] data3 = new byte[1024 * 1024];
  10.     private byte[] data4 = new byte[1024 * 1024];
  11.     private Hungry(){
  12.  
  13.     }
  14.  
  15.     private final static Hungry HUNGRY = new Hungry();
  16.  
  17.     public static Hungry getInstance() {
  18.         return HUNGRY;
  19.     }
  20. }

懒汉式:

  1. package com.signal;
  2.  
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5.  
  6. //懒汉式单例
  7. public class LazyMan {
  8.  
  9.     private static boolean aaaa = false;
  10.     private LazyMan(){
  11.         synchronized (LazyMan.class) {
  12.             if (aaaa == false) {
  13.                 aaaa = true;
  14.             } else {
  15.  
  16.                 throw new RuntimeException("反射获取结果");
  17.             }
  18.         }
  19.         System.out.println(Thread.currentThread().getName()+" o k ");
  20.     }
  21.  
  22. //    加上volatile 避免 指令重排
  23.     private  volatile static LazyMan lazyMan;
  24.  
  25. //    双重检查锁模式的 懒汉式   ， 简称DCL懒汉式
  26.     public static LazyMan getInstance(){
  27.         if (lazyMan == null) {
  28.             synchronized (LazyMan.class) {
  29.                 if (lazyMan == null) {
  30.                     lazyMan = new LazyMan();  //不是原子性操作
  31.                     /*
  32.                     * 1. 分配内存空间
  33.                     * 2.执行构造方法初始化对象
  34.                     * 3.把对象指向这个空间
  35.                     *
  36.                     * */
  37.                 }
  38.             }
  39.         }
  40.         return lazyMan;
  41.     }
  42.  
  43.     多线程并发   加上volatile 后避免指令重排
  44. //public static void main(String[] args) {
  45. //    for (int i = 0; i < 10; i++) {
  46. //        new Thread(() -> {
  47. //            LazyMan.getInstance();
  48. //        }).start();
  49. //
  50. //
  51. //    }
  52. //}
  53. //    反射
  54. public static void main(String[] args) throws Exception {
  55. //        LazyMan instance = LazyMan.getInstance();
  56.  
  57.     Field aaaa = LazyMan.class.getDeclaredField("aaaa");
  58.     aaaa.setAccessible(true);
  59.  
  60.     Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
  61.     declaredConstructor.setAccessible(true);
  62.     LazyMan instance1 = declaredConstructor.newInstance();
  63.     aaaa.set(instance1, false);
  64.  
  65.     LazyMan instance2= declaredConstructor.newInstance();
  66.  
  67. //        System.out.println(instance);
  68.     System.out.println(instance1);
  69.     System.out.println(instance2);
  70. }
  71. }

静态内部类：

  1. package com.signal;
  2.  
  3. //静态内部类
  4. public class Holder {
  5.     private Holder(){
  6.  
  7.     }
  8.     public static Holder getInstance() {
  9.         return InnerClass.HOLDER;
  10.     }
  11.     public static class InnerClass{
  12.         private static final Holder HOLDER = new Holder();
  13.     }
  14. }

枚举

  1. package com.signal;
  2.  
  3. import java.lang.reflect.Constructor;
  4.  
  5. //enum本身是一个Class类
  6. public enum  EnumSingle {
  7.  
  8.     INSTANCE;
  9.     public EnumSingle getInstamce() {
  10.         return INSTANCE;
  11.     }
  12.  
  13.  
  14. }
  15. class Test{
  16.     public static void main(String[] args) throws Exception {
  17.         EnumSingle instance1 = EnumSingle.INSTANCE;
  18.         Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
  19.         declaredConstructor.setAccessible(true);
  20.         EnumSingle instance2 = declaredConstructor.newInstance();
  21.         System.out.println(instance1);
  22.         System.out.println(instance2);
  23.     }
  24. }

深入理解CAS

cas: 比较当前工作内存中的值和主内存中的值,如果这个值是期望的,那么就执行操作,如果不是就一直循环

缺点：

1.由于底层是自旋锁，循环回浪费时间

由于是底层CPU操作，一次不保证一个共享变量的原子性

  1. package com.cas;
  2.  
  3. import java.util.concurrent.atomic.AtomicInteger;
  4.  
  5. public class CASDemo {
  6. //    CompareAndSwap : 比较并交换
  7.     public static void main(String[] args) {
  8.  
  9.         AtomicInteger atomicInteger = new AtomicInteger(2020);
  10. //        如果期望值达到了 就更新，否则不更新   CAS是CPU的并发原语
  11.         System.out.println(atomicInteger.compareAndSet(2020, 2021));
  12.         System.out.println(atomicInteger.get());
  13.         atomicInteger.getAndIncrement();
  14.         System.out.println(atomicInteger.compareAndSet(2020, 2021));
  15.         System.out.println(atomicInteger.get());
  16.     }
  17. }

unsafe 类

 

ABA问题:

  1. package com.cas;
  2.  
  3. import java.util.concurrent.atomic.AtomicInteger;
  4.  
  5. public class CASDemo {
  6. //    CompareAndSwap : 比较并交换
  7.     public static void main(String[] args) {
  8.  
  9.         AtomicInteger atomicInteger = new AtomicInteger(2020);
  10. //        如果期望值达到了 就更新，否则不更新   CAS是CPU的并发原语
  11.  
  12. //        捣乱线程
  13.         System.out.println(atomicInteger.compareAndSet(2020, 2021));
  14.         System.out.println(atomicInteger.get());
  15. //        System.out.println(atomicInteger.getAndIncrement()+" 11111");
  16.         System.out.println(atomicInteger.compareAndSet(2021, 2020));
  17.         System.out.println(atomicInteger.get());
  18.  
  19. //        期望线程
  20.         System.out.println(atomicInteger.compareAndSet(2020, 6666));
  21.         System.out.println(atomicInteger.get());
  22.     }
  23. }

原子操作

带版本号的原子操作 解决ABA问题 ,引入原子引用 对应的思想: 乐观锁

  1. package com.cas;
  2.  
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.atomic.AtomicStampedReference;
  5.  
  6. /*integer默认缓存-128->127，超过这个范围就要new对象了，就会分配新的地址，我们看到源码是==，非数值类型，我们比较的是对象的地址
  8. 我想看怎么找到问题所在的片段
  9. 1. 看compareAndSet的源码，里面是使用 == 进行比较的。
  10. 2. 由于new的时候声明泛型肯定是装箱类，这个时候传入值类型将会自动装箱
  11. 3. 自动装箱的后果就是地址不一致，使用==判断的结果就为false\
  12. 4. 总结：最好不使用原子类型，使用原子类型得保证比较时候传入的为同一个装箱类
  13. * */
  14. public class CASDemo2 {
  15.     //    CompareAndSwap : 比较并交换
  16.     public static void main(String[] args) {
  17.  
  18. //        正常情况下泛型中写的都是对象
  19.         AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<>(1, 1);
  20.  
  21.         new Thread(() -> {
  22.             int stamp = atomicInteger.getStamp(); //获得版本号
  23.             System.out.println("A--->" + stamp);
  24.             try {
  25.                 TimeUnit.SECONDS.sleep(2);
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             }
  29.             System.out.println(atomicInteger.compareAndSet(1, 2,
  30.                     atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
  31.             System.out.println("A2--->" + atomicInteger.getStamp());
  32.  
  33.             System.out.println(atomicInteger.compareAndSet(2, 1,
  34.                     atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
  35.             System.out.println("A3--->" + atomicInteger.getStamp());
  36.         }, "A").start();
  37.  
  38.  
  39.         new Thread(() -> {
  40.             int stamp = atomicInteger.getStamp(); //获得版本号
  41.             System.out.println("B1--->" + stamp);
  42.             try {
  43.                 TimeUnit.SECONDS.sleep(2);
  44.             } catch (InterruptedException e) {
  45.                 e.printStackTrace();
  46.             }
  47.  
  48.             System.out.println(atomicInteger.compareAndSet(1, 5, stamp, stamp + 1));
  49.  
  50.             System.out.println("B2--->" + atomicInteger.getStamp());
  51.         }, "B").start();
  52.  
  53.     }
  54. }

integer默认缓存-128->127，超过这个范围就要new对象了，就会分配新的地址，我们看到源码是==，非数值类型，我们比较的是对象的地址

1. 看compareAndSet的源码，里面是使用 == 进行比较的。
2. 由于new的时候声明泛型肯定是装箱类，这个时候传入值类型将会自动装箱
3. 自动装箱的后果就是地址不一致，使用==判断的结果就为false\
4. 总结：最好不使用原子类型，使用原子类型得保证比较时候传入的为同一个装箱类

 

锁

可重入锁

也叫递归锁

synchronized 锁

  1. package com.lock;
  2.  
  3. //synchronized
  4. public class Demo1 {
  5.     public static void main(String[] args) {
  6.         Phone phone = new Phone();
  7.         new Thread(() -> {
  8.             phone.sms();
  9.         }, "A").start();
  10.         new Thread(() -> {
  11.             phone.sms();
  12.         }, "B").start();
  13.     }
  14. }
  15.  
  16. class Phone {
  17.     public synchronized void sms() {
  18.         System.out.println(Thread.currentThread().getName() + "  sms");
  19.         call();
  20.     }
  21.  
  22.     public synchronized void call() {
  23.         System.out.println(Thread.currentThread().getName() + "  call");
  24.     }
  25. }

lock版

  1. package com.lock;
  2.  
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  5.  
  6. public class Demo2 {
  7.     public static void main(String[] args) {
  8.         Phone2 phone = new Phone2();
  9.         new Thread(() -> {
  10.             phone.sms();
  11.         }, "A").start();
  12.         new Thread(() -> {
  13.             phone.sms();
  14.         }, "B").start();
  15.     }
  16. }
  17. //可重入锁也就是某个线程已经获得某个锁，可以再次获取锁而不会出现死锁
  18. class Phone2 {
  19.     Lock lock = new ReentrantLock();
  20.     public  void sms() {
  21.         lock.lock();  //  lock.lock() ,锁必须配对，否则回出现死锁
  22.         lock.lock();
  23.         try {
  24.             System.out.println(Thread.currentThread().getName() + "  sms");
  25.             call();
  26.         } catch (Exception e) {
  27.             e.printStackTrace();
  28.         } finally {
  29.             lock.unlock();
  30.             lock.unlock();
  31.         }
  32.     }
  33.  
  34.     public  void call() {
  35.         lock.lock();
  36.  
  37.         try {
  38.             System.out.println(Thread.currentThread().getName() + "  call");
  39.         } catch (Exception e) {
  40.             e.printStackTrace();
  41.         } finally {
  42.             lock.unlock();
  43.         }
  44.     }
  45. }

自旋锁

自定义自旋锁

  1. package com.lock;
  2.  
  3. import java.util.concurrent.atomic.AtomicReference;
  4.  
  5. /*
  6.  * 自旋锁
  7.  * */
  8. public class SpinLockDemo {
  9.     AtomicReference<Thread> atomicReference = new AtomicReference<>();
  10.  
  11.  
  12.     //    加锁
  13.     public void MyLock() {
  14.         Thread thread = Thread.currentThread();
  15.         System.out.println(thread.getName() + "   MyLock");
  16. //    自旋锁
  17.         while (!atomicReference.compareAndSet(null, thread)) {
  18.  
  19.         }
  20.     }
  21.  
  22. //    解锁
  23.     public void MyUnLock(){
  24.         Thread thread = Thread.currentThread();
  25.         System.out.println(thread.getName() + "     MyUnLock");
  26.         atomicReference.compareAndSet(thread, null);
  27.     }
  28. }

代码测试

  1. package com.lock;
  2.  
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.concurrent.locks.ReentrantLock;
  5.  
  6. public class TestSpinLock {
  7.     public static void main(String[] args) throws InterruptedException {
  8.         ReentrantLock reentrantLock = new ReentrantLock();
  9.         reentrantLock.lock();
  10.         reentrantLock.unlock();
  11.  
  12. //        底层使用的自旋锁CAS
  13.         SpinLockDemo lock = new SpinLockDemo();
  14.         new Thread(() -> {
  15.             lock.MyLock();
  16.             try {
  17.                 TimeUnit.SECONDS.sleep(3);
  18.             } catch (Exception e) {
  19.                 e.printStackTrace();
  20.             } finally {
  21.                 lock.MyUnLock();
  22.             }
  23.         }, "T1").start();
  24.         TimeUnit.SECONDS.sleep(2);
  25.  
  26.         new Thread(() -> {
  27.             lock.MyLock();
  28.             try {
  29.                 TimeUnit.SECONDS.sleep(1);
  30.             } catch (Exception e) {
  31.                 e.printStackTrace();
  32.             } finally {
  33.                 lock.MyUnLock();
  34.             }
  35.         }, "T2").start();
  36.     }
  37. }

 T1进来是拿到了锁, 然后期望值null, 变成了Thread, 此时T1没有自旋, 而是跳出了循环,T2此时在无限循环, 过了等待时间, T1解锁, 变回了null, T2才能跳出循环

死锁

多个线程各自占有一些共享资源，并且相互等待其他线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止执行的场景，某一个同步块同时拥有“两个以上对象的锁”时，就可能发生“死锁”的问题。

  1. package com.lock;
  2.  
  3. import java.util.concurrent.TimeUnit;
  4.  
  5. public class DeadLockDemo {
  6.     public static void main(String[] args) {
  7.         String lockA = "lockA";
  8.         String lockB = "lockB";
  9.  
  10.         new Thread(new MyThread(lockA,lockB),"A").start();
  11.         new Thread(new MyThread(lockB,lockA),"B").start();
  12.     }
  13. }
  14.  
  15. class MyThread implements Runnable {
  16.     private String lockA;
  17.     private String lockB;
  18.  
  19.     public MyThread(String lockA, String lockB) {
  20.         this.lockA = lockA;
  21.         this.lockB = lockB;
  22.     }
  23.  
  24.     @Override
  25.     public void run() {
  26.         synchronized (lockA) {
  27.             System.out.println(Thread.currentThread().getName() + "lock: " + lockA + " ->get" + lockB);
  28.             try {
  29.                 TimeUnit.SECONDS.sleep(2);
  30.             } catch (InterruptedException e) {
  31.                 e.printStackTrace();
  32.             }
  33.             synchronized (lockB) {
  34.                 System.out.println(Thread.currentThread().getName() + "lock: " + lockB + " ->get" + lockA);
  35.             }
  36.         }
  37.  
  38.     }
  39. }

死锁解决方案：

产生死锁的四个必要条件：

  • 互斥条件：一个资源每次只能被一个进程使用
  • 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
  • 不剥夺条件：进程已获得的资源，在未使用之前，不能强行剥夺
  • 循环等待条件：若干进程之间行程一种头尾相接的循环等待资源关系

 破坏上述4个条件任意一个或多个条件就会避免死锁的发生

jps -l 使用 jps 定位进程号

如果命令不识别可以试试这个:

找到 C:\Users{用户名}\AppData\Local\Temp\hsperfdata_{用户名} 右键属性->安全->添加用户，添加自己用户名，并且打开所有权限

jstack 70680 对应进程号找问题

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/545645
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。