第二章 Java多线程--线程的使用

已于 2024-06-24 14:11:57 修改
阅读量752 收藏 19
点赞数 33
分类专栏： 并发编程 文章标签： jvm java
于 2024-06-24 11:41:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lin_Miao_09/article/details/139884288
版权

目录

一、线程的状态

二、线程的常用方法

1 获取当前线程

2 线程的名字

3 线程的优先级

4 线程的让步

5 线程的休眠

6 线程的强占

7 守护线程

8 线程的等待和唤醒

三、线程的结束方式

1 stop方法（不建议）

2 使用共享变量（很少会用）

3 interrupt方式

一、线程的状态

网上对线程状态的描述很多，有5种，6种，7种，都可以接受

比较常见的说法是5种，5种状态一般是针对传统的线程状态来说（操作系统层面）

按Java线程区分有6种状态

NEW：Thread对象被创建出来了，但是还没有执行start方法。

RUNNABLE：Thread对象调用了start方法，就为RUNNABLE状态（CPU调度/没有调度）

BLOCKED、WAITING、TIME_WAITING：都可以理解为是阻塞、等待状态，因为处在这三种状态下，CPU不会调度当前线程

BLOCKED：synchronized没有拿到同步锁，被阻塞的情况

WAITING：调用wait方法就会处于WAITING状态，需要被手动唤醒

TIME_WAITING：调用sleep方法或者join方法，会被自动唤醒，无需手动唤醒

TERMINATED：run方法执行完毕，线程生命周期到头了

线程状态打印测试：
NEW：

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
  
    });
    System.out.println(t1.getState());
}

RUNNABLE：

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        while(true){

        }
    });
    t1.start();
    Thread.sleep(500);
    System.out.println(t1.getState());
}

 BLOCKED：

public static void main(String[] args) throws InterruptedException {
    Object obj = new Object();
    Thread t1 = new Thread(() -> {
        // t1线程拿不到锁资源，导致变为BLOCKED状态
        synchronized (obj){

        }
    });
    // main线程拿到obj的锁资源
    synchronized (obj) {
        t1.start();
        Thread.sleep(500);
        System.out.println(t1.getState());
    }
}

WAITING：

public static void main(String[] args) throws InterruptedException {
    Object obj = new Object();
    Thread t1 = new Thread(() -> {
        synchronized (obj){
            try {
                obj.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    t1.start();
    Thread.sleep(500);
    System.out.println(t1.getState());
}

TIMED_WAITING：

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    t1.start();
    Thread.sleep(500);
    System.out.println(t1.getState());
}

TERMINATED：

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    t1.start();
    Thread.sleep(1000);
    System.out.println(t1.getState());
}

二、线程的常用方法

1 获取当前线程

public static void main(String[] args) throws ExecutionException, InterruptedException {
	// 获取当前线程的方法
    Thread main = Thread.currentThread();
    System.out.println(main);
}

2 线程的名字

public static void main(String[] args) throws ExecutionException, InterruptedException {
    Thread t1 = new Thread(() -> {
        System.out.println(Thread.currentThread().getName());
    });
    t1.setName("模块-功能-计数器");
    t1.start();
}

3 线程的优先级

线程的优先级就是CPU调度线程的优先级。

Java线程的有10个优先级可以设置，从1~10任取一整数。

超过这个区间，会抛出参数异常错误。

先执行的线程级别低，也是需要高级别执行完之后，才执行。

public static void main(String[] args) throws ExecutionException, InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 1000; i++) {
            System.out.println("t1:" + i);
        }
    });
    Thread t2 = new Thread(() -> {
        for (int i = 0; i < 1000; i++) {
            System.out.println("t2:" + i);
        }
    });
    t1.setPriority(1);
    t2.setPriority(10);
    t2.start();
    t1.start();
}

4 线程的让步

Thread的静态方法yield，可以让当前线程从运行状态转变为就绪状态。

public static void main(String[] args) throws ExecutionException, InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 100; i++) {
            if(i == 50){
                Thread.yield();
            }
            System.out.println("t1:" + i);
        }
    });
    Thread t2 = new Thread(() -> {
        for (int i = 0; i < 100; i++) {
            System.out.println("t2:" + i);
        }
    });
    t2.start();
    t1.start();
}

5 线程的休眠

Thread的静态方法sleep，让线程从运行状态转变为等待状态

sleep有两个方法重载：

  • 第一个就是native修饰的，让线程转为等待状态的效果
  • 第二个是可以传入毫秒和一个纳秒的方法（如果纳秒值大于等于0.5毫秒，就给休眠的毫秒值+1。如果传入的毫秒值是0，纳秒值不为0，就休眠1毫秒）
public static void main(String[] args) throws InterruptedException {
    System.out.println(System.currentTimeMillis());
    Thread.sleep(1000);
    System.out.println(System.currentTimeMillis());
}

6 线程的强占

Thread的非静态方法join方法，在main线程中调用了t1.join()，那么main线程会进入到等待状态，需要等待t1线程全部执行完毕，在恢复到就绪状态等待CPU调度。

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 10; i++) {
            System.out.println("t1:" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    t1.start();
    for (int i = 0; i < 10; i++) {
        System.out.println("main:" + i);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (i == 1){
            try {
                // 调用join方法，main线程会进入等待状态，
                // 需要等待t1执行2s后，再恢复就绪状态等待CPU调度。
                // 如果t1结束了，main线程就自动变为就绪状态等待调度。
                t1.join(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

7 守护线程

创建的线程，默认都不是守护线程。JVM在程序中没有非守护线程，就会结束当前JVM，主线程默认是非守护线程。Daemon守护线程设置，默认false。

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 10; i++) {
            System.out.println("t1:" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    t1.setDaemon(true);
    t1.start();
}

8 线程的等待和唤醒

wait方法将进入等待池，并释放锁资源。

notify或者notifyAll方法，将等待池中的线程唤醒，添加到锁池中。

notify随机的唤醒等待池中的一个线程到锁池

notifyAll将等待池中的全部线程都唤醒，并且添加到锁池

wait方法和notify以及norifyAll方法，必须在synchronized修饰的代码块或者方法内部使用，因为要操作基于某个对象的锁的信息维护。

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        sync();
    },"t1");

    Thread t2 = new Thread(() -> {
        sync();
    },"t2");
    t1.start();
    t2.start();
    Thread.sleep(12000);
    synchronized (MiTest.class) {
        MiTest.class.notifyAll();
    }
}

public static synchronized void sync()  {
    try {
        for (int i = 0; i < 10; i++) {
            if(i == 5) {
                MiTest.class.wait();
            }
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName());
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

三、线程的结束方式

1 stop方法（不建议）

stop方法是进行强制结束，极不建议使用，可能会有问题。

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    t1.start();
    Thread.sleep(500);
    t1.stop();
    System.out.println(t1.getState());
}

2 使用共享变量（很少会用）

有些线程可以使用死循环保证线程一直运行，可以通过变更共享变量，破坏死循环，使线程退出线程，结束run方法。

static volatile boolean flag = true;

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        while(flag){
            // 处理任务
        }
        System.out.println("任务结束");
    });
    t1.start();
    Thread.sleep(500);
    flag = false;
}

3 interrupt方式

public static void main(String[] args) throws InterruptedException {
    // 线程默认情况下，    interrupt标记位：false
    System.out.println(Thread.currentThread().isInterrupted());
    // 执行interrupt之后，再次查看打断信息
    Thread.currentThread().interrupt();
    // interrupt标记位：ture
    System.out.println(Thread.currentThread().isInterrupted());
    // 返回当前线程，并归位为false interrupt标记位：ture
    System.out.println(Thread.interrupted());
    // 已经归位了
    System.out.println(Thread.interrupted());

    // =====================================================
    Thread t1 = new Thread(() -> {
        while(!Thread.currentThread().isInterrupted()){
            // 处理业务
        }
        System.out.println("t1结束");
    });
    t1.start();
    Thread.sleep(500);
    t1.interrupt();
}

打断WAITING或者TIMED_WAITING状态的线程，从而抛出异常自行处理

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        while(true){
            // 获取任务
            // 拿到任务，执行任务
            // 没有任务了，让线程休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println("基于打断形式结束当前线程");
                return;
            }
        }
    });
    t1.start();
    Thread.sleep(500);
    t1.interrupt();
}

wait和sleep的区别？

  • sleep属于Thread类中的static方法、wait属于Object类的方法
  • sleep属于TIMED_WAITING，自动被唤醒、wait属于WAITING，需要手动唤醒。
  • sleep方法在持有锁时，执行，不会释放锁资源、wait在执行后，会释放锁资源。
  • sleep可以在持有锁或者不持有锁时，执行。 wait方法必须在只有锁时才可以执行。

wait方法会将持有锁的线程从owner移到WaitSet集合中，这个操作是在修改ObjectMonitor对象，需要持有synchronized锁的，才能操作ObjectMonitor对象的。

Lin_Miao_09
关注
  • 33
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第-章-JAVA多线程优秀文档.pptx
12-01
二、JAVA 多线程特点 JAVA 多线程有以下几个特点： * 多线程可以提高程序的执行效率，尤其是在 CPU 密集型任务中。 * 多线程可以提高程序的响应速度，尤其是在 GUI 编程中。 * 多线程可以使程序更加灵活和可扩展。...
JAVA-练习题第一章-(ppt文档).pptx
11-13
" JAVA-练习题第一章-(ppt文档).pptx" 本资源是一个Java语言的练习题集合，涵盖了Java语言的基本特点、核心包、编程应用等方面的知识点。 一、Java语言的基本特点 Java语言是一种纯面向对象的语言，支持分布式的...
java--第10章 多线程
北山啦的博客
01-09 2791
实验目的： 1.理解解线程的概念及线程的生命周期。 2.掌握多线程的编程。 实验内容： 1.通过继承Thread类创建线程。 2.通过实现Runnable接口创建线程。 3.线程优先级操作。 4.用两个线程玩猜数字的游戏。 实验步骤： 1.通过继承Thread类创建一个实现睡眠(时间在1～5秒)功能的线程，显示它的睡眠时间及其线程名称。 源代码： package homework.实验10_多线程...
Java：26-多线程
qq_59609098的博客
01-25 1818
Thread() ，使用无参的方式构造对象 Thread(String name) ，根据参数指定的名称来构造对象 Thread(Runnable target) ，根据参数指定的引用来构造对象，其中 Runnable 是个接口类型 Thread(Runnable target , String name) ，根据参数指定引用和名称来构造对象 void run() ，若使用 Runnable 引用构造了线程对象，调用该方法时最终调用接口中的版本。
Java并发编程 - 第二章 - 线程
SongYu的博客
08-17 1万+
一、线程的创建与运行 1.1 使用 Thread 创建线程 // 创建线程对象 Thread t = new Thread("thread") { // 线程名称为 thread @Override public void run() { // 要执行的任务 } }; // 启动线程 t.start(); 1.2 使用 Runnable 创建线程 Runnable runnable = new Runnable() { @Override public v
Java基础 - 第三章 -多线程
SongYu的博客
08-28 1万+
多线程 例一：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式 1.同步代码块处理实现Runnable的线程安全问题 synchronized(同步监视器){ //需要被同步的代码 } 说明： 1.操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。 2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。 3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。 要
java多线程--集合并发
云梦九章～
02-08 5069
1.问题引入： 1.1 常见的list获取最后一个对象。 Object haha = list.get(list.size() - 1); 大致看起来没有问题。但是这个代码在多线程情况下就会出 java.lang.ArrayIndexOutOfBoundsException 1.2 为什么呢？ 如下测试代码 @Test public void testSynchronizedList() throws Exception { long fisrtTime = System
Java面试题--多线程
青春季风暴
04-07 1万+
什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。 线程和进程有什么区别？ 线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。 如何在Java中实现线程？ 由于线程类本身就是调用的...
Java第二十章多线程
好好活就是做有意义的事，做有意义的事就是好好活
11-28 1199
本篇文章，主要讲述了线程简介、创建线程、线程的生命周期、操作线程的方法、线程的优先级、线程同步
Java核心技术卷一 -第十二章：多线程
weixin_54185681的博客
02-14 1043
系列文章目录 Java核心技术卷一 -第一章：java“白皮书”的关键术语 Java核心技术卷一 -第三章：数据类型 Java核心技术卷一 -第三章：变量与常量 Java核心技术卷一 -第三章：运算符 Java核心技术卷一 -第三章：字符串 Java核心技术卷一 -第三章：输入与输出 Java核心技术卷一 -第三章：数组 Java核心技术卷一 -第四章：类之间的关系-依赖 Java核心技术卷一 -第四章：预定义类-LocalDate类小应用 Java核心技术卷一 -第四章：构造器 Java核心技术卷一 -第
Java多线程实战-从零手搓一个简易线程池(三)线程工厂，核心线程与非核心线程逻辑实现
热门推荐
qq_35716689的博客
04-02 1万+
在上一节我们实现了线程池内部的基本运转逻辑，池化了线程资源进行任务处理，细心的同学可以发现，我们上章没有划分核心线程与非核心线程的概念，在JDK官方的提供的线程池中，线程池中的线程从概念上分为核心线程和非核心线程，核心线程是线程池中长久存在的线程，默认不会被回收，而非核心线程在空闲时间超过设置的最大空闲时间时会被回收，当然，我们也可以通过设置一个属性来运行核心线程被回收。
java多线程-笔记
飞翔的鸡肉
08-23 1070
第一章：多线程的创建方式                                                    第二章：线程常用方法 第三章：多线程练习案例：模拟火车站多窗口售票                第四章：线程的安全问题 第五章：线程的同步机制                                                        第六章：线程...
第2章-Java多线程应用ppt课件(全).ppt
04-12
Java多线程应用ppt课件 本课件主要讲解了Java多线程应用的基本概念、线程的生命周期、多线程同步机制等重要知识点。 首先，课件讲解了线程的基本概念。线程是计算机正在执行的程序中的一个控制流程。线程本身不是...
Java高级程序设计-多线程(二).pptx
05-30
本章内容 掌握同步代码块的使用 掌握同步方法的使用 理解线程死锁 掌握 ThreadLocal 类的使用 使用多线程模拟猴子采花 使用同步方法模拟购票 使用多线程模拟购物订单生成 使用 ThreadLocal 类模拟银行取款 Java高级...
Java程序设计与数据结构第二章习题答案
11-05
在Java程序设计与数据结构的学习过程中，第二章通常会涵盖基础的编程概念和初步的数据结构。这个主题旨在帮助初学者建立坚实的编程基础，理解和运用核心的Java语法，以及理解数据结构的基本原理。以下是对这些知识点...
面试题005-Java-JVM(上)
zouhuu的博客
07-05 1118
1. JVM由哪几部分组成？ 2. 运行时数据区中包含哪些区域？ 3. 栈和堆中分别存放什么数据？ 4. 为什么要将永久代 (PermGen) 替换为元空间 (MetaSpace) ？ 5. 堆空间的基本结构了解吗？什么情况下对象会进入老年代？ 6. 大对象放在哪个内存区域？ 7. Java对象的创建过程？
科普文：一文搞懂jvm实战(二)Cleaner回收jvm资源
为无为，事无事，味无味。
07-02 1072
finalize()方法实际上从JDK1.0时就开始提供，但一直到JDK1.9后才发现此方法成为了不推荐使用的方法，同时这个方法上所抛出的一个Throwabke类型的异常（Erroe和Exception），在对象回收时可能会出现各种问题，但不影响回收！System.out.println("诞生！");@Overrideprotected void finalize() throws Throwable { //可能抛错误，也可能抛异常System.out.println("回收！");
C++ 学习笔记一
m0_51830537的博客
07-03 813
由于在 C++ 中输入或显示指数可能很困难，我们使用字母“e”（有时为“E”）来表示等式的“乘以 10 的幂”部分。例如，1.2 x 10⁴将写为1.2e4，而5.9722 x 10²⁴将写为5.9722e24。对于小于 1 的数，指数可以为负数。该数5e-2相当于5 * 10⁻²，即5 / 10²，或0.05。电子的质量为9.1093837e-31 kg。
Java的垃圾回收机制解说
最新发布
s44359487yad的博客
07-06 1011
JDK 1.7 中的各种垃圾收集器到此已全部介绍完毕，在描述过程中提到了很多虚拟机非稳定的运行参数，在表3-2中整理了这些参数供读者实践时参考。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值