第二章 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--第10章 多线程
北山啦的博客
01-09 2792
实验目的： 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多线程优秀文档.pptx
12-01
二、JAVA 多线程特点 JAVA 多线程有以下几个特点： * 多线程可以提高程序的执行效率，尤其是在 CPU 密集型任务中。 * 多线程可以提高程序的响应速度，尤其是在 GUI 编程中。 * 多线程可以使程序更加灵活和可扩展。...
JAVA-练习题第一章-(ppt文档).pptx
11-13
" JAVA-练习题第一章-(ppt文档).pptx" 本资源是一个Java语言的练习题集合，涵盖了Java语言的基本特点、核心包、编程应用等方面的知识点。 一、Java语言的基本特点 Java语言是一种纯面向对象的语言，支持分布式的...
第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 1074
finalize()方法实际上从JDK1.0时就开始提供，但一直到JDK1.9后才发现此方法成为了不推荐使用的方法，同时这个方法上所抛出的一个Throwabke类型的异常（Erroe和Exception），在对象回收时可能会出现各种问题，但不影响回收！System.out.println("诞生！");@Overrideprotected void finalize() throws Throwable { //可能抛错误，也可能抛异常System.out.println("回收！");
C++ 学习笔记一
m0_51830537的博客
07-03 814
由于在 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 1013
JDK 1.7 中的各种垃圾收集器到此已全部介绍完毕，在描述过程中提到了很多虚拟机非稳定的运行参数，在表3-2中整理了这些参数供读者实践时参考。
【JVM】类加载机制
栗子的博客
07-01 673
如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把请求委托给父加载器去完成，依次向上，因此，所有的类加载请求最终都应该被传递到顶层的启动类加载器中，只有当父加载器在它的搜索范围中没有找到所需的类时，即无法完成该加载，子加载器才会尝试自己去加载该类。解析阶段是虚拟机将常量池内符号引用转换为直接引用的过程，符号引用包括类和接口的全限定名、变量的名称和描述符号、方法的名称和描述符。直接引用就是指向目标的指针。验证阶段主要进行的是对文件格式的验证、元数据验证、字节码验证和符号引用验证。
Java多线程
柒月
07-01 1066
日常开发中我们常常需要使用到多线程来充分利用cpu实现高效执行，这其中需要我们多线程的执行和线程安全有充分的了解，本文主要围绕相关问题展开。
详解Java垃圾回收（GC）机制
s44359487yad的博客
07-06 1141
最基本、发展历史最久的收集器，这个收集器是一个采用复制算法的单线程的收集器，单线程一方面意味着它只会使用一个CPU或一条线程去完成垃圾收集工作，另一方面也意味着它进行垃圾收集时必须暂停其他线程的所有工作，直到它收集结束为止。反之，若对象覆盖了finalize方法并且该finalize方法并没有被执行过，那么，这个对象会被放置在一个叫F-Queue的队列中，之后会由虚拟机自动建立的、优先级低的Finalizer线程去执行，而虚拟机不必要等待该线程执行结束，即虚拟机只负责建立线程，其他的事情交给此线程去处理。
java八股文面试题
m0_46552684的博客
07-02 1064
Java八股文面试题通常涵盖了Java语言的基础知识、高级特性、框架应用、数据库操作等多个方面。
64.ThreadLocal造成的内存泄漏
卷土的博客
06-30 301
程序中已动态分配的堆内存，由于某种原因程序为释放和无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。内存泄漏的堆积终将导致内存溢出。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值