并发编程（第二天）

随风~IT

于 2024-08-13 15:03:44 发布

阅读量396

点赞数 14

文章标签： java 开发语言并发编程

本文链接：https://blog.csdn.net/GD2604279407/article/details/141163338

版权

interrupt 方法详解

打断 sleep，wait，join 的线程这几个方法都会让线程进入阻塞状态打断 sleep 的线程, 会清空打断状态
打断正常运行的线程打断正常运行的线程, 不会清空打断状态
打断 park 线程打断 park 线程, 不会清空打断状态

如果打断标记已经是 true, 则 park 会失效

两阶段终止模式

class TPTInterrupt {
 private Thread thread;
 public void start(){
     thread = new Thread(() -> {
     while(true) {
     Thread current = Thread.currentThread();
     if(current.isInterrupted()) {
         log.debug("料理后事");
         break;
    }
 try {
     Thread.sleep(1000);
     log.debug("将结果保存");
  } 
  catch (InterruptedException e) {
      current.interrupt();
  }
 // 执行监控操作               
 }
},"监控线程");
thread.start();
}
 public void stop() {
 thread.interrupt();
    }
 }

调用

TPTInterrupt t = new TPTInterrupt();
 t.start();
 Thread.sleep(3500);
 log.debug("stop");
 t.stop();

11:49:42.915 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:43.919 c.TwoPhaseTermination[监控线程] - 将结果保存
11:49:44.919 c.TwoPhaseTermination[监控线程] - 将结果保存
11:49:45.413 c.TestTwoPhaseTermination [main] - stop
11:49:45.413 c.TwoPhaseTermination[监控线程] - 料理后事

主线程与守护线程

默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

log.debug("开始运行...");
 Thread t1 = new Thread(() -> {
 log.debug("开始运行...");
 sleep(2);
 log.debug("运行结束...");
 }, "daemon");
 // 设置该线程为守护线程
t1.setDaemon(true);
 t1.start();
 sleep(1);
 log.debug("运行结束...");

垃圾回收器线程就是一种守护线程
Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

五种状态（线程）

从操作系统层面来描述

【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联

【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行

【运行状态】指获取了 CPU 时间片运行中的状态

当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换

【阻塞状态】

如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】
等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们

【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

六种状态

是从 Java API 层面来描述

根据 Thread.State 枚举，分为六种状态

NEW 线程刚被创建，但是还没有调用 start() 方法
RUNNABLE 当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了操作系统层面的【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行）
BLOCKED ， WAITING ，详述 TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分，后面会在状态转换一节
TERMINATED 当线程代码运行结束

共享模型之管程

临界区 Critical Section

一个程序运行多个线程本身是没有问题的

问题出在多个线程访问共享资源

多个线程读共享资源其实也没有问题
在多个线程对共享资源读写操作时发生指令交错，就会出现问题

一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

竞态条件 Race Condition

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件

synchronized

俗称的【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换

语法

synchronized(对象) // 线程1， 线程2(blocked)
{
     临界区
}

static int counter = 0;
 static final Object room = new Object();
 public static void main(String[] args) throws InterruptedException {
 Thread t1 = new Thread(() -> {
 for (int i = 0; i < 5000; i++) {
 synchronized (room) {
 counter++;
            }
        }
    }, 
"t1");
 Thread t2 = new Thread(() -> {
 for (int i = 0; i < 5000; i++) {
 synchronized (room) {
 counter--;
            }
        }
    }, 
"t2");
 }
 t1.start();
 t2.start();
 t1.join();
 t2.join();
 log.debug("{}",counter);

加上同一把对象所之后结果就只会是0，不会因为多线程问题导致结果不唯一。

方法上的 synchronized

class Test{
 public synchronized void test() {
  }
}
等价于
class Test{
 public void test() {
 synchronized(this) {
     }
    }
 }

 class Test{
 public synchronized static void test() {
   }
 }
等价于
class Test{
 public static void test() {
 synchronized(Test.class) {
   }
 }

加在普通方法上表示锁的对象是自己

加在静态方法上表示锁的对象是类（字节码）

所谓的“线程八锁”

情况1： 12 或 21

 @Slf4j(topic = "c.Number")
 class Number{
 public synchronized void a() {
 log.debug("1");
    }
 public synchronized void b() {
 log.debug("2");
    }
 }
 public static void main(String[] args) {
 Number n1 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n1.b(); }).start();
 }

情况2： 1s后12，或 2 1s后 1

 @Slf4j(topic = "c.Number")
 class Number{
 public synchronized void a() {
 sleep(1);
 log.debug("1");
    }
 public synchronized void b() {
 log.debug("2");
    }
 }
 public static void main(String[] args) {
 Number n1 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n1.b(); }).start();
 }

情况3： 3 1s 12 或 23 1s 1 或 32 1s 1

@Slf4j(topic = "c.Number")
class Number{
 public synchronized void a() {
 sleep(1);
 log.debug("1");
    }
 public synchronized void b() {
 log.debug("2");
    }
 public void c() {
 log.debug("3");
    }
 }
 public static void main(String[] args) {
 Number n1 = new Number();
 new Thread(()->{ n1.a(); }).start();
 new Thread(()->{ n1.b(); }).start();
 new Thread(()->{ n1.c(); }).start();
 }

过多也就不展示了，本质上其实就是考察 synchronized 锁住的是哪个对象