山东大学软件学院项目实训-创新实训-基于大模型的旅游平台（十六）- JUC（2）

最新推荐文章于 2024-08-10 16:13:20 发布
最新推荐文章于 2024-08-10 16:13:20 发布
阅读量696 收藏 20
点赞数 19
分类专栏： 山东大学软件学院项目实训 文章标签： java 算法 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64663346/article/details/139114013
版权

目录

同步

两阶段终止模式

守护线程

线程状态

五种(操作系统角度)

六种(Java API角度)

烧水案例

共享模型之管程

临界区

竞态条件

同步

  
  @Slf4j(topic = "c.TestJoin")
  public class TestJoin {
      static int r = 0;
      static int r1 = 0;
      static int r2 = 0;
  ​
      public static void main(String[] args) throws InterruptedException {
          test2();
      }
  ​
      public static void test3() throws InterruptedException {
          Thread t1 = new Thread(() -> {
              sleep(2);
              r1 = 10;
          });
  ​
          long start = System.currentTimeMillis();
          t1.start();
  ​
          // 线程执行结束会导致 join 结束
          log.debug("join begin");
          t1.join(3000);
          long end = System.currentTimeMillis();
          log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
      }
  ​
      private static void test2() throws InterruptedException {
          Thread t1 = new Thread(() -> {
              sleep(1);
              r1 = 10;
          });
          Thread t2 = new Thread(() -> {
              sleep(2);
              r2 = 20;
          });
          t1.start();
          t2.start();
          long start = System.currentTimeMillis();
          log.debug("join begin");
  ​
          t1.join();
          log.debug("t1 join end");
          t2.join();
          log.debug("t2 join end");
          long end = System.currentTimeMillis();
          log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
      }
  ​
      private static void test1() throws InterruptedException {
          log.debug("开始");
          Thread t1 = new Thread(() -> {
              log.debug("开始");
              sleep(1);
              log.debug("结束");
              r = 10;
          });
          t1.start();
          t1.join();
          log.debug("结果为:{}", r);
          log.debug("结束");
      }
  }

多线程的join只需要等待最长的那个线程就可以了，因为他们都是并行执行的。如果是t1先的话，那么就是t1在处理1秒的同时，t2也在处理一秒，然后t2执行join，那么还只剩下1s处理，那么t1和t2也只需要等待多1s就能够继续执行主线程的。

如果是t2先那么在处理2s的同时，t1已经先处理了1s并且进入了等待状态，等待t2处理完那么就可以执行主线程了。在t2的join end的同时，t1处理完，并且也会执行join end。

简单来说就是两个线程开启，如果下面两个都是join，那么实际上两个线程都会各自执行，互不干扰，直到最后一个线程执行完，那么才会执行join下面的代码。

test3案例，实际上就是限时等待，如果超过时间那么就不等了。如果没有超过时间，那么结束join还是以处理完线程的任务时间为主，而不是最大的等待时间

两阶段终止模式

  
  ​
  @Slf4j
  public class Test {
      public static void main(String[] args) throws InterruptedException {
          TwoPhaseTermination tpt = new TwoPhaseTermination();
          tpt.start();
  ​
          Thread.sleep(3500);
          tpt.stop();
      }
  ​
  }
  ​
  @Slf4j
  class TwoPhaseTermination{
      private Thread monitor;
  ​
      // 启动监控线程
      public void start(){
          monitor = new Thread(() -> {
              while(true){
                  Thread thread = Thread.currentThread();
                  if(thread.isInterrupted()){
                      log.debug("料理后事");
                      break;
                  }
                  try {
                      Thread.sleep(1000);  // 情况一   在睡眠时被打断  打断标记是false
                      log.debug("监控记录");     // 情况二
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                      // 如果是睡眠中被打断 ， 就重新设置打断标记
                      thread.interrupt();
                  }
              }
          });
          monitor.start();
      }
  ​
      // 停止监控线程
      public void stop() {
          monitor.interrupt();
      }
  }

打断park线程

  
  @Slf4j
  public class Test {
      public static void main(String[] args) throws InterruptedException {
          Thread t1 = new Thread(() -> {
              log.debug("park...");
              LockSupport.park();
              log.debug("unpark");
              log.debug("打断状态: {}",Thread.currentThread().isInterrupted());
          },"t1");
          t1.start();
  ​
          Thread.sleep(1000);
          t1.interrupt();
      }
  ​
  }

守护线程

守护线程其实就是Daemon也就是在其他非守护线程运行完之后，无论守护线程是否还有任务需要执行都会强制停止。

  • 垃圾回收器是守护线程

  • tomcat的Acceptor和Poller

  
  @Slf4j
  public class Test {
      public static void main(String[] args) throws InterruptedException {
          Thread t1 = new Thread(() -> {
              while(true){
                  if(Thread.currentThread().isInterrupted()){
                      break;
                  }
              }
              log.debug("结束");
          },"t1");
  ​
          t1.setDaemon(true);   // 设为守护线程
          t1.start();
          Thread.sleep(1000);
          log.debug("结束");
      }
  ​
  }
  ​

线程状态

五种(操作系统角度)

①初始：new线程的时候,只创建了，还没和操作系统关联

②可运行：执行了start

③运行：线程可以使用cpu的时候

④阻塞：不能被cpu调度器使用的时候

⑤终止：线程生命周期结束的时候

六种(Java API角度)

NEW：初始化

RUNNABLE：包括了运行、可运行和阻塞，通常表示正在运行

WAITING：没有时间限制

TIMED_WAITING：有时限的等待

BLOCKED：阻塞

TERMINATED：终止

烧水案例

  
  @Slf4j
  public class Test {
      public static void main(String[] args) {
          Thread t1 = new Thread(() -> {
              log.debug("洗水壶");
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  throw new RuntimeException(e);
              }
              log.debug("烧开水");
              try {
                  Thread.sleep(5000);
              } catch (InterruptedException e) {
                  throw new RuntimeException(e);
              }
          },"老王");
  ​
          Thread t2 = new Thread(() ->{
              log.debug("洗茶壶");
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  throw new RuntimeException(e);
              }
              log.debug("洗茶杯");
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  throw new RuntimeException(e);
              }
              log.debug("拿茶叶");
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  throw new RuntimeException(e);
              }
              try {
                  t1.join();
              } catch (InterruptedException e) {
                  throw new RuntimeException(e);
              }
              log.debug("泡茶");
          }, "小王");
  ​
  ​
  ​
          t1.start();
          t2.start();
  ​
  ​
      }
  ​
  }

共享模型之管程

  
  @Slf4j
  public class Test {
  ​
      static int counter = 0 ;
      public static void main(String[] args) throws InterruptedException {
          Thread t1 = new Thread(() ->{
              for (int i = 0; i < 5000; i++) {
                  counter ++ ;
              }
          });
  ​
          Thread t2= new Thread(() ->{
              for (int i = 0; i < 5000; i++) {
                  counter -- ;
              }
          });
  ​
  ​
          t1.start();
          t2.start();
          t1.join();
          t2.join();
          System.out.println(counter);    // 并不是输出0
  ​
      }
  ​
  }

临界区

实际上就是多个线程访问的代码里面有共享资源，那么这段代码就是临界区

竞态条件

如果在临界区中多线程执行发生执行指令序列不同导致结果无法预测的状况就是竞态条件

qq_64663346
关注
  • 19
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
山东大学软件学院项目实训-创新实训-基于大模型的旅游平台（十七）- JUC（3）
qq_64663346的博客
05-23 852
线程1上锁之后，线程2无法获取锁不能够执行临时区，线程2阻塞等待线程1完成释放锁之后才能够使用。可以把synchronize类比成一个房间，每次有锁的人才能够进入房间做事情，就算cpu时间片用完，只要没有这个锁那么其他线程是无法进入房间的。情况3 : 3 ,1s后 1 2 || 3 , 2 1s后打印1 || 2 , 3 1s后打印1。情况6 : 1s后打印1 后2 || 2 1s后打印1。情况8 : 1s后打印1 后2 || 2 1s后打印1。情况2 : 1s后1 2 或 1s后2 1。
山东大学软件学院项目实训-创新实训-基于大模型的旅游平台（十八）- JUC（4）
qq_64663346的博客
05-24 817
如果又有线程进来，那么会看看obj是否关联锁，然后再看看锁是否有owner，如果有那么就进入到EntryList阻塞等待。replace也实际上只是创建数组，然后对比原数组的旧值，如果是旧值那么直接给新的数组的那个位置赋值新值。下面的代码出现的问题就是线程1判断成功之后切换，刚好释放了锁，然后就是线程2获取锁进行判断，再次切换线程1获取锁处理put，切换线程2也可以获取锁处理put。如果只有读操作，则线程安全如果有读写操作，则这段代码是临界区，需要考虑线程安全共享且有读写操作不一定安全。
山东大学软件学院项目实训-创新实训-基于大模型的旅游平台（十九）- JUC（5）
qq_64663346的博客
05-25 941
如果在尝试加轻量级锁的过程中，CAS 操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量级锁（有 竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步块，释放了锁），这时当前线程就可以避免阻塞。当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重入计数减一。如果两个线程用同一个偏向级锁，那么锁会变成不可偏向，升级为轻量级锁。
山东大学软件学院项目实训-创新实训-基于大模型的旅游平台（二十）- JUC（6）
qq_64663346的博客
05-26 722
相当于就是生产者给队列生产结果，消费者负责处理结果不需要一一对应平衡资源消息队列有容量控制阻塞队列控制结果出队列​i < 3;queue.set(new Message(id, "值" + id));},"生产者" + i).start();​try {}, "消费者").start();​​@Slf4j//存消息的集合// 消息容量​​// 获取消息// 检查队列是否为空try {
山东大学软件学院项目实训-创新实训-基于大模型的旅游平台（十五）- JUC（1）
qq_64663346的博客
05-21 520
睡眠可以使用在while循环自转的地方，如果长时间自转就会消耗CPU的使用时间，其它线程无法使用。先分配栈给线程，线程调用main方法，在栈分配一个栈帧给main方法，栈帧保存锁记录、局部变量表、操作数栈、返回地址（返回到原来的栈帧方法的下一条指令）Runnable runnable = () -> log.debug("aaa");log.debug("打断标记 : {}",t.isInterrupted());每次开启一个线程都会产生一个线程的栈给线程使用，实际上就是一开始分配的虚拟机栈。
CSDN博客专家证书发放名单（已暂停）
热门推荐
CSDN 官方博客
07-12 5万+
博客专家专属奖励。
heima-JUC-资料
04-25
JUC是Java 5及后续版本引入的一个重要特性，极大地提升了Java在多处理器和高并发环境下的性能表现。 在Java中，JUC包（java.util.concurrent）包含了一系列的类和接口，这些类和接口主要用于解决并发问题，如线程池...
JUC-High-Concurrency:java.util.concurrent JUC高并发处理
04-03
Java.util.concurrent（JUC）是Java平台中处理高并发的核心工具包，它为开发者提供了丰富的并发组件和机制，使得在多线程环境下的编程变得更加高效和安全。本篇将深入探讨JUC中的重要知识点，包括同步、可重入锁、类...
个人学习-JUC-笔记
02-25
Java并发编程是Java开发中的重要领域，而JUC（Java Util Concurrency）是Java平台提供的一套高级并发工具包，它极大地简化了多线程和并发控制的复杂性。本笔记主要围绕尚硅谷周阳老师的JUC课程展开，旨在帮助个人...
tuling-juc-final.zip
05-23
本项目"tuling-juc-final.zip"显然聚焦于Java并发编程的实践，通过一系列代码示例来演示和解释Java内存模型（JMM）、`synchronized`关键字以及`volatile`关键字的使用。下面我们将深入探讨这些核心概念。 Java内存...
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶 Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC...
C++ - 函数重载
jiaowenjie的专栏
08-06 326
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 202
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
Spring事务
c1tenj2的博客
08-07 435
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
反射和注解
supercool7的博客
08-08 254
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
Java：继承，this，super
最新发布
m0_75257168的博客
08-10 276
可以同名，但参数列表不能相同（有参无参构造）
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 271
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
Spring一个强大便捷的代理工厂类
330553352的专栏
08-10 196
但如果你需要一种更加灵活和可配置性，那么Spring还提供了一个非常方便强大的ProxyFactoryBean类，该类特别适合那些需要更多自定义和控制的场景，例如当你需要为特定的Bean创建代理，或者需要在不修改原始代码的情况下为现有类添加额外的功能时。在Spring框架中，AOP（面向切面编程）是一种强大的编程范式，它允许开发者在不修改原有代码的情况下，为程序添加额外的功能，如日志记录、事务管理、安全控制等。在上面配置拦截器时，我们都是指定的具体拦截器，其实我们还可以使用通配符，指定拦截器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值