Java多线程编程之线程状态与线程管理

简介: 笔记

一、线程状态


在线程的生命周期中,线程会有几种状态,如图所示:

3.png


(1)新建状态

新建状态(New)是通过new等方式创建线程对象,它仅仅是一个空的线程对象。


(2)就绪状态

当主线程调用新建线程的start()方法后,它就进入就绪状态(Runnable)。此时的线程尚未真正开始执行run()方法,它必须等待CPU的调度。


(3)运行状态

CPU的调度就绪状态的线程,线程进入运行状态(Running),处于运行状态的线程独占CPU, 执行run()方法。


(4)阻塞状态

因为某种原因运行状态的线程会进入不可运行状态,即阻塞状态(Blocked),处于阻塞状态的 线程JVM系统不能执行该线程,即使CPU空闲,也不能执行该线程。如下几个原因会导致线程 进入阻塞状态:


当前线程调用sleep()方法,进入休眠状态。

被其他线程调用了join()方法,等待其他线程结束。

发出I/O请求,等待I/O操作完成期间。

当前线程调用wait()方法。

处于阻塞状态可以重新回到就绪状态,如:休眠结束、其他线程加入、I/O操作完成和调用 notify或notifyAll唤醒wait线程。


(5)死亡状态

线程退出run()方法后,就会进入死亡状态(Dead),线程进入死亡状态有可以是正常实现完成

run()方法进入,也可能是由于发生异常而进入的。


二、线程管理


(1)线程优先级

线程的调度程序根据线程决定每次线程应当何时运行,Java提供了10种优先级,分别用1~10整数表 示,最高优先级是10用常量MAX_PRIORITY表示;最低优先级是1用常量MIN_PRIORITY;默认优先 级是5用常量NORM_PRIORITY表示。

Thread类提供了setPriority(int newPriority)方法可以设置线程优先级,通过getPriority()方法获得线程优 先级。

设置线程优先级示例代码如下:

public class HelloWorld {
    public static void main(String[] args) {
//        创建线程t1,参数是一个线程执行对象Runner
        Thread t1 = new Thread(new Runner());
//        设置线程最高优先级
        t1.setPriority(Thread.MAX_PRIORITY);
//        线程开始
        t1.start();
        //        创建线程t2,参数是一个线程执行对象Runner
        Thread t2 = new Thread(new Runner());
//        设置线程最低优先级
        t2.setPriority(Thread.MIN_PRIORITY);
//        线程开始
        t2.start();
        //        创建线程t3,参数是一个线程执行对象Runner
        Thread t3 = new Thread(new Runner());
//        设置线程6优先级
        t3.setPriority(6);
//        线程开始
        t3.start();
    }
}

多次运行上面的示例会发现,t1线程经常先运行,但是偶尔t2线程也会先运行。这些现象

说明了:影响线程获得CPU时间的因素,除了受到的线程优先级外,还与操作系统有关。


(2)等待线程结束

在介绍现在状态时提到过join()方法,当前线程调用t1线程的join()方法,则阻塞当前线程,等待t1线程 结束,如果t1线程结束或等待超时,则当前线程回到就绪状态。

Thread类提供了多个版本的join(),它们定义如下:


void join():等待该线程结束。

void join(long millis):等待该线程结束的时间最长为millis毫秒。如果超时为0意味着要一直等下 去。

void join(long millis, int nanos):等待该线程结束的时间最长为millis毫秒加nanos纳秒。

使用join()方法示例代码如下:

public class HelloWorld {
//    共享变量
    static int value = 0;
    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开始。。。");
//        创建线程t1
        Thread t1 = new Thread(() ->{
            System.out.println("线程ThreadA开始。。。");
            for (int i = 0;i<2;i++){
                System.out.println("线程ThreadA执行。。。");
                value++;
            }
            System.out.println("线程ThreadA结束。。。");
        },"线程ThreadA");
//        线程开始
        t1.start();
//        主线程被阻塞,等待线程t1结束
        t1.join();
        System.out.println("value="+value);
        System.out.println("主线程结束。。。。。");
    }
}

运行结果:

主线程开始。。。
线程ThreadA开始。。。
线程ThreadA执行。。。
线程ThreadA执行。。。
线程ThreadA结束。。。
value=2
主线程结束。。。。。

如果将t1.join();这一行代码注释掉,则运行结果如下:

主线程开始。。。
value=0
线程ThreadA开始。。。
线程ThreadA执行。。。
线程ThreadA执行。。。
线程ThreadA结束。。。
主线程结束。。。。。

使用join()方法的场景是,一个线程依赖于另外一个线程的运行结果,所以调用另一个线程 的join()方法等它运行完成。


(3)线程让步

线程类Thread还提供一个静态方法yield(),调用yield()方法能够使当前线程给其他线程让步。它类似于 sleep()方法,能够使运行状态的线程放弃CPU使用权,暂停片刻,然后重新回到就绪状态。与sleep()方 法不同的是,sleep()方法是线程进行休眠,能够给其他线程运行的机会,无论线程优先级高低都有机 会运行。而yield()方法只给相同优先级或更高优先级线程机会。

代码如下:

//编写线程执行类
public class Runner1 implements Runnable {
//编写线程执行代码
    @Override
    public void run() {
        for (int i = 0;i<10;i++){
//            打印线程次数和线程的名字
            System.out.printf("第%d次执行--%s\n",i,Thread.currentThread().getName());
//            线程让步
            Thread.yield();
        }
        //        线程执行结束
        System.out.println("执行完成"+Thread.currentThread().getName());
    }
}

测试代码:

public class HelloWorld {
    public static void main(String[] args) {
        //        创建线程t1,参数是一个线程执行对象Runner
        Thread t1 = new Thread(new Runner1());
        //        设置线程最高优先级
        t1.setPriority(Thread.MAX_PRIORITY);
//        线程开始
        t1.start();
    }
}

相比较,yield()方法只能给相同优先级或更高优先级的线程让步,sleep()方法能够给其他线程运行的机会,无论线程优先级高低都有机 会运行。

sleep()方法可以控制时间,而yield()方法不能。


(4)线程停止

线程体中的run()方法结束,线程进入死亡状态,线程就停止了。但是有些业务比较复杂,例如想开发 一个下载程序,每隔一段执行一次下载任务,下载任务一般会在由子线程执行的,休眠一段时间再执 行。这个下载子线程中会有一个死循环,但是为了能够停止子线程,设置一个结束变量。

代码如下:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class HelloWorld {
    private  static String command = "";
    public static void main(String[] args) {
//        创建线程t1,参数是一个线程执行对象Runner
        Thread t1 = new Thread(() -> {
//            一直循环
            while (!command.equalsIgnoreCase("exit")){
//                线程开始工作
//                TODO
                System.out.println("下载中");
                try {
//                    线程休眠
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
//            线程执行结束
            System.out.println("线程执行完成");
        });
//        开始线程t1
        t1.start();
        try( InputStreamReader ir  = new InputStreamReader(System.in);
             BufferedReader in = new BufferedReader(ir)){
//            从键盘接受一个字符串的输入
            command = in.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

用户在控制台输入的是否为exit 字符串,如果不是则进行循环,否则结束循环,结束循环就结束了run()方法,线程就停止了。

运行结果如下:

下载中
下载中
下载中
下载中
下载中
exit
线程执行完成


相关文章
|
12天前
|
存储 缓存 Java
Java 并发编程——volatile 关键字解析
本文介绍了Java线程中的`volatile`关键字及其与`synchronized`锁的区别。`volatile`保证了变量的可见性和一定的有序性,但不能保证原子性。它通过内存屏障实现,避免指令重排序,确保线程间数据一致。相比`synchronized`,`volatile`性能更优,适用于简单状态标记和某些特定场景,如单例模式中的双重检查锁定。文中还解释了Java内存模型的基本概念,包括主内存、工作内存及并发编程中的原子性、可见性和有序性。
Java 并发编程——volatile 关键字解析
|
10天前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类:`Producer`(生产者)、`Consumer`(消费者)、`Resource`(公共资源)和`TestMain`(测试类)。通过`synchronized`和`wait/notify`机制控制线程同步,但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`,解决了多次生产和消费的问题,但仍可能因`notify()`随机唤醒线程而导致死锁。因此,引入了`notifyAll()`来唤醒所有等待线程,但这会带来性能问题。
Java—多线程实现生产消费者
|
16天前
|
算法 Java 调度
java并发编程中Monitor里的waitSet和EntryList都是做什么的
在Java并发编程中,Monitor内部包含两个重要队列:等待集(Wait Set)和入口列表(Entry List)。Wait Set用于线程的条件等待和协作,线程调用`wait()`后进入此集合,通过`notify()`或`notifyAll()`唤醒。Entry List则管理锁的竞争,未能获取锁的线程在此排队,等待锁释放后重新竞争。理解两者区别有助于设计高效的多线程程序。 - **Wait Set**:线程调用`wait()`后进入,等待条件满足被唤醒,需重新竞争锁。 - **Entry List**:多个线程竞争锁时,未获锁的线程在此排队,等待锁释放后获取锁继续执行。
50 12
|
12天前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中,`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性,通过锁机制确保线程安全;`volatile` 仅保证可见性和有序性,不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结:`volatile` 确保不同线程对共享变量操作的可见性,使一个线程修改后,其他线程能立即看到最新值。
|
12天前
|
消息中间件 缓存 安全
Java多线程是什么
Java多线程简介:本文介绍了Java中常见的线程池类型,包括`newCachedThreadPool`(适用于短期异步任务)、`newFixedThreadPool`(适用于固定数量的长期任务)、`newScheduledThreadPool`(支持定时和周期性任务)以及`newSingleThreadExecutor`(保证任务顺序执行)。同时,文章还讲解了Java中的锁机制,如`synchronized`关键字、CAS操作及其实现方式,并详细描述了可重入锁`ReentrantLock`和读写锁`ReadWriteLock`的工作原理与应用场景。
|
13天前
|
存储 安全 Java
Java多线程编程秘籍:各种方案一网打尽,不要错过!
Java 中实现多线程的方式主要有四种:继承 Thread 类、实现 Runnable 接口、实现 Callable 接口和使用线程池。每种方式各有优缺点,适用于不同的场景。继承 Thread 类最简单,实现 Runnable 接口更灵活,Callable 接口支持返回结果,线程池则便于管理和复用线程。实际应用中可根据需求选择合适的方式。此外,还介绍了多线程相关的常见面试问题及答案,涵盖线程概念、线程安全、线程池等知识点。
93 2
|
13天前
|
NoSQL Redis
单线程传奇Redis,为何引入多线程?
Redis 4.0 引入多线程支持,主要用于后台对象删除、处理阻塞命令和网络 I/O 等操作,以提高并发性和性能。尽管如此,Redis 仍保留单线程执行模型处理客户端请求,确保高效性和简单性。多线程仅用于优化后台任务,如异步删除过期对象和分担读写操作,从而提升整体性能。
38 1
|
29天前
|
安全 算法 Java
Java多线程编程中的陷阱与最佳实践####
本文探讨了Java多线程编程中常见的陷阱,并介绍了如何通过最佳实践来避免这些问题。我们将从基础概念入手,逐步深入到具体的代码示例,帮助开发者更好地理解和应用多线程技术。无论是初学者还是有经验的开发者,都能从中获得有价值的见解和建议。 ####
|
10天前
|
安全 Java API
【JavaEE】多线程编程引入——认识Thread类
Thread类,Thread中的run方法,在编程中怎么调度多线程
|
5月前
|
存储 监控 Java
Java多线程优化:提高线程池性能的技巧与实践
Java多线程优化:提高线程池性能的技巧与实践
142 1