个人总结的JAVA线程管理

最新推荐文章于 2024-07-17 09:36:14 发布
最新推荐文章于 2024-07-17 09:36:14 发布
阅读量2.6k 收藏 7
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qps2009/article/details/90511073
版权

JAVA的线程主要通过线程池管理，其主要的意义在于优雅的关闭线程以及合理地运用线程来处理我们需要执行的一些任务。换句话说就是：通过线程池，创建一定数量的线程，并交由线程池来管理。在当需要执行任务时，直接使用其中的线程。任务执行完成后，线程保留，并可用于执行下一个任务。如果任务比线程多，则任务会等待线程空闲出来时，使用空闲的线程来执行任务。

1、线程复用的实例

public class MyThread implements Runnable {
    private String str;
    public MyThread(String s){
        this.str = s;
    }

    @Override
    public void run() {
        System.out.println(str+":"+Thread.currentThread().getName()+" is running!");
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
    public static void main(String[] agrs){
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.execute(new MyThread("A"));
        executorService.execute(new MyThread("B"));
        executorService.execute(new MyThread("C"));
        executorService.shutdown();
    }
}

执行结果

A:pool-1-thread-1 is running!
B:pool-1-thread-2 is running!
C:pool-1-thread-1 is running!

线程池只分配了两个线程，这两个线程先执行了A和B线程，当线程A执行完毕后，就将空闲出来的线程用来执行线程C。

接下来来看Executors.newCachedThreadPool() 缓冲池的实例，缓冲池是根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。若创建的线程空闲60秒以上则将其销毁并移除。
下面直接上代码

public class MyThread implements Runnable {
    private String str;
    public MyThread(String s){
        this.str = s;
    }

    @Override
    public void run() {
            try {
                System.out.println(str + ":" + Thread.currentThread().getName() + " is running!");
                Thread.sleep(500);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
    public static void main(String[] agrs){
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new MyThread("A"));
        executorService.execute(new MyThread("B"));
        executorService.execute(new MyThread("C"));
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        executorService.execute(new MyThread("D"));
        executorService.execute(new MyThread("E"));
        executorService.shutdown();
    }
}

执行结果

A:pool-1-thread-1 is running!
C:pool-1-thread-3 is running!
B:pool-1-thread-2 is running!
E:pool-1-thread-3 is running!
D:pool-1-thread-2 is running!

通过Executors.newCachedThreadPool() 创建了缓冲池，因为需要执行A，B，C三个线程，因此缓冲池创建了3个线程，这三个线程在启动后500毫秒就执行完毕，主线程等带1秒后，这时候缓冲池并没有将这三个线程销毁，也没有创建新的线程，直接将这三个空闲的线程用来执行D和E这两个线程。

2、Callable接口

Callable接口与Runnable接口相似，都用于定义线程的可执行任务。Callable在JDK 1.5引入，与Runnable相比，有三个优势：
1、可以在任务中抛出异常
2、可以终止任务
3、可以获取任务的返回值
这时候就会出现一个问题：新旧两种定义线程任务的方式，怎么前后兼容呢？
这时候就出现了FutureTask这个类

ublic class FutureTask<V> implements RunnableFuture<V> {
    // 封装实现Callable接口的任务
    public FutureTask(Callable<V> callable) { //...}
    // 封装实现Runnable接口的任务，result是返回值，在任务完成后赋值（futureTask.get()会返回这个值）。
    public FutureTask(Runnable runnable, V result) {//...}
}


public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

只要将Callable或Runnable封装成FutureTask，即可在两种场景使用。

下面上一个代码实例：

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception{
        int num=0;
        for(int i=0;i<3;i++){
            num++;
            System.out.println("num="+num);
        }
        return String.valueOf(num);
    }
}

import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] agrs){
        FutureTask<String> task = new FutureTask<String>(new MyCallable());
        new Thread(task).start();
        System.out.println(getFutureValue(task));
        System.out.println("after task.get()!");
    }

    public static String getFutureValue(FutureTask<String> task){
        String str = "default value";
        try{
            str = task.get();
        }catch (Exception e){
            System.out.println("task is canceled！");
        }
        return str;
    }
}

执行结果

num=1
num=2
num=3
3
after task.get()!

可以看到"after task.get()!"这句话在 getFutureValue()方法执行后即task.get()方法执行执行。
将代码改造一下

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<3;i++){
            System.out.println("num="+(i+1));
        }
    }
}

import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] agrs){
        String str = "default value";
        FutureTask<String> task = new FutureTask<String>(new MyRunnable(),str);
        new Thread(task).start();
        System.out.println(getFutureValue(task));
        System.out.println("after task.get()!");
    }

    public static String getFutureValue(FutureTask<String> task){
        String str = "default value1";
        try{
            str = task.get();
        }catch (Exception e){
            System.out.println("task is canceled！");
        }
        return str;
    }
}

执行结果

num=1
num=2
num=3
default value1
after task.get()!

可以看到，使用Runnable构造FutureTask时，future.get()直接得到defaultValue。

3、中断任务线程

中断Callable任务

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception{
        int num=0;
        for(int i=0;i<3;i++){
            num++;
            Thread.sleep(100);
            System.out.println("num="+num);
        }
        return String.valueOf(num);
    }
}


import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] agrs){
        FutureTask<String> task = new FutureTask<String>(new MyCallable());
        new Thread(task).start();
        try{
            Thread.sleep(250);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        task.cancel(true);
        System.out.println(getFutureValue(task));
        System.out.println("after task.get()!");
    }

    public static String getFutureValue(FutureTask<String> task){
        String str = "default value";
        try{
            str = task.get();
        }catch (Exception e){
            System.out.println("task is canceled！");
        }
        return str;
    }
}

执行结果

num=1
num=2
task is canceled！
default value
after task.get()!

task.cancel()参数为true时，线程会立即中断，call()方法里面后续的部分也不会被执行

将task.cancel()参数置为false时的执行结果

num=1
num=2
task is canceled！
default value
after task.get()!
num=3

task.cancel()参数为true时，退出了task.get()方法的阻塞，但线程call()方法里面后续的部分会继续被执行完毕

中断Runnable任务

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<3;i++){
            try {
                Thread.sleep(100);
            }catch (InterruptedException e){
                System.out.println("task is cancel!");
            }
            System.out.println("num="+(i+1));
        }
    }
}

import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] agrs){
        String str = "default value1";
        FutureTask<String> task = new FutureTask<String>(new MyRunnable(),str);
        new Thread(task).start();
        try{
            Thread.sleep(250);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        task.cancel(false);
        System.out.println(getFutureValue(task));
        System.out.println("after task.get()!");
    }

    public static String getFutureValue(FutureTask<String> task){
        String str = "default value";
        try{
            str = task.get();
        }catch (Exception e){
            System.out.println("task is canceled！");
        }
        return str;
    }
}

task.cancel(false)的执行结果：

num=1
num=2
task is canceled！
default value
after task.get()!
num=3

task.cancel(true)的执行结果

num=1
num=2
task is cancel!
num=3
task is canceled！
default value
after task.get()!

可以看到task.cancel()无论将参数置为true还是false，线程都不会被执行完毕，但置为true时，执行结果多了条“task id cancel!”，说明置为true时，run()方法确实放生了中断异常。
如果确实要中断Runnable使得run()方法在中断后不继续执行可以将run()方法改造成下面这样（即在发生中断异常时，将run()方法立即返回）：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<3;i++){
            try {
                Thread.sleep(100);
            }catch (InterruptedException e){
                System.out.println("task is cancel!");
                return;
            }
            System.out.println("num="+(i+1));
        }
    }
}

这时候的直接结果：

num=1
num=2
task is cancel!
task is canceled！
default value
after task.get()!

4、线程池管理线程任务

通过ExecutorService，可以使用4个方法执行线程任务。
其中3个执行Runnable任务：

void execute(Runnable command); 
< T > Future< T >  submit(Runnable task, T result); 
Future< ? >  submit(Runnable task);

1个执行Callable任务：

< T > Future< T > submit(Callable< T > task); //执行Callable任务

只有通过submit方法执行的线程任务，才能获取到Future，才能通过Future管理线程。
示例代码如下：

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception{
        int num=0;
        for(int i=0;i<3;i++){
            num++;
            Thread.sleep(100);
            System.out.println("num="+num);
        }
        return String.valueOf(num);
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test {
    public static void main(String[] agrs){
        ExecutorService service = Executors.newFixedThreadPool(2);
        Future<String> future = service.submit(new MyCallable()); // 使用submit()执行Callable任务
        System.out.println("执行结果："+getFutureValue(future));
        System.out.println("after task.get()!");
        service.shutdown();
    }

    public static String getFutureValue(Future<String> task){
        String str = "default value";
        try{
            str = task.get();
        }catch (Exception e){
            System.out.println("task is canceled！");
        }
        return str;
    }
}

执行结果

num=1
num=2
num=3
执行结果：3
after task.get()!

和Callable接口的第一个实例一致，能够通过Future获取执行的结果

5、利用后台线程管理任务

Thread类提供了一个setDaemon方法，可以将线程设置成后台（守护）线程，当宿主线程任务完成后，后台线程自动终止。
直接上代码实例：

public class TestThead implements Runnable {
    private void printNum(int num){
        try{
            Thread.sleep(100);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(num);
    }

    @Override
    public void run() {
        Thread deamon = new Thread(()->{
            for(int i=5;i<10;i++){
                printNum(i);
            }
        });
        deamon.setDaemon(true);
        deamon.start();
        for(int i=0;i<2;i++){
            printNum(i);
        }
    }

    public static void main(String[] args){
        new Thread(new TestThead()).start();
    }
}

执行结果：

5
0
6
1

后台线程只打印了5,6，在主线程循环执行完毕并结束后，后台线程也跟着结束了，这验证了后台线程可以随着主线程而终止的功能

qps2009
关注
专栏目录
JAVA多线程总结
maplejaw的博客
04-12 447
基本概念 Java中的多线程一般有两种使用方式，一种直接new Thread对象，另一种使用线程池。 1. 使用Thread方式： Thread thread=new Thread(new Runnable() { @Override public void run() { for (int i = 0; i &lt...
Java 多线程总结笔记
N0tExpecterr0r的博客
09-19 4455
Java多线程总结笔记 实现多线程的方法 查看Thread类的源码，可以发现它实现了Runnable接口，然后在自己的run方法中调用了Runnable的run方法。这里其实就是静态代理这一设计模式，Thread是代理角色，而Runnable则是真实角色。在Thread的start方法中，会为我们开辟新的线程并执行其run方法，而Thread的run方法会调用它内部持有引用的Runnable的ru...
Java多线程管理示例
06-15
里面提供Java多线程的概念，同步，死锁，wait/nofity机制的示例《生产者与消费者》例子
【多线程】线程管理
最新发布
m0_44965777的博客
07-17 649
注意：从表面上看当主线程结束后，子线程会跟着一起结束，就会误以为主线程的结束影响了子线程的结束，但是实际上子线程之所以结束是因为主线程执行了main函数中隐藏的return语句，导致了整个进程结束，所以进程中所有的线程才会随之结束。1、线程是进程的执行路线，它是进程内部的控制序列，或者说线程是进程的一部分(进程是一个资源单位，线程是执行单位，线程是进程的一部分，负责真正的执行)7、线程有不同的状态、属性，系统提供了线程的控制接口，例如：创建、销毁、控制。3、如果所在的进程结束，所有的线程都随之结束。
Java 中的线程管理概念梳理
我相信......
03-09 2255
在Java中，“线程”指java.lang.Thread类的一个实例以及线程的执行，主要使用的线程池是ThreadPoolExecutor以及ScheduledThreadPoolExecutor，要使用固定线程上限的线程池......
Java多线程管理
antique的学习笔记
05-27 935
文章目录1，线程状态2，线程状态切换经典生产者消费者问题：3，多线程死锁4，守护（后台）线程 1，线程状态 NEW 刚创建（new） RUNNABLE 就绪态（start）：调用一个线程的start方法，那么这个线程就进入了就绪态 RUNNING 运行中（run）：等待的线程被CPU调度后就进入Running状态 BLOCK 阻塞（sleep）：由于某一个条件没有满足，暂时不需要CPU TERMINATED 结束 2，线程状态切换 线程的阻塞和唤醒 sleep：线程自我休眠，时间一到自己就会醒来
2012年08月2日--Java多线程管理
Javamickey的专栏
08-29 4786
一、线程概述     线程是程序运行的基本执行单元。当操作系统（不包括单线程的操作系统，如微软早期的DOS）在执行一个程序时，会在系统中建立一个进程，而在这个进程中，必须至少建立一个线程（这个线程被称为主线程）来作为这个程序运行的入口点。因此，在操作系统中运行的任何程序都至少有一个主线程。    进程和线程是现代操作系统中两个必不可少的运行模型。在操作系统中可以有多个进程，这些进程包括系统进程
Java多线程精讲：9、线程管理
小鑫的博客
09-25 399
9.1 线程组 类似于在计算机中使用文件夹管理文件，也可以使用线程组来管理线程，在线程组中定义一组相似（相关）的线程。也可以在线程组中定义子线程组。 Thread类有几个构造方法，其中一个允许在创建线程时指定线程组，如果在创建线程时没有指定线程组，则该线程就属于父线程所在的线程组。 JVM在创建main线程时会为它指定一个线程组，因此每个Java线程都有一个线程组与之关联，可以调用线程的getThreadGroup()方法返回该线程的线程组。 代码演示： package threadgroup;
个人总结40个Java多线程面试问题和答案
10-23
Java多线程面试问题和答案总结 Java多线程是一种高级的编程技术，能够充分发挥多核CPU的优势，防止阻塞，简化模型建立，提高程序的效率和可维护性。下面是40个Java多线程面试问题和答案的总结，涵盖了多线程的基本...
JAVA多线程技术分享-39页PPT(winding)
05-10
总结来说，多线程技术涉及面广泛，包括线程的生命周期管理、同步机制、并发工具的使用等。理解并熟练掌握这些知识点对于编写高效、稳定的并发程序至关重要。在面试和实际开发中，对这些知识点的深入理解不仅能提升...
java实训个人总结3篇.doc
12-21
【Java实训个人总结】 在Java实训的过程中，学生们深入学习了Java编程的基础知识和实战技能，以企业化的标准严格要求自己，提升自身的职业素养。实训的主要目的是让学生从理论学习过渡到实际任务的完成，强调动手...
Java多线程程序设计
02-19
通过以上三个实验，我们不仅学习了如何创建和管理Java线程，还深入了解了线程的生命周期以及线程同步的基本原理。这些知识对于开发高性能、高并发的应用程序至关重要。希望你能通过实践加深对这些概念的理解，并将其...
java 线程管理_Java平台线程管理
weixin_42310347的博客
02-12 235
简介在计算机领域中，我们说的并发(concurrency)是指一些列任务的同时运行。如果一台电脑有多个处理器或者有一个多核处理器，这个同时性是真正意义上的并发；但是一台电脑只有一个单核处理器，这个同时性并不是真正的并发。现代操作系统都允许多任务的并发：在听歌的时候，同时阅读电子邮件，这种并发属于进程级并发。但在一个进程内也可以有多个同时进行的任务。这种进程内并发的任务称为线程级并发。与并发相关的概...
Java多线程——线程管理
a530516618的博客
01-02 3618
前面两篇博客介绍了多线的基本概念，以及线程同步与协作。本文将继续探讨线程的管理与多线程的性能优化，具体内容包括：线程池、Callable接口，以及如何优雅第终止线程或者如何管理可能需要立即终止的线程。 一、线程池 在第一篇博客中已经介绍过“线程”和“任务”的关系，如果“任务”是货车，“线程”则是供货车行驶的车道。在之前的介绍中，都是一辆“货车”对应一条“车道”。“车道”也是一个对象，他也需要占
java线程管理
菜鸟博客
12-22 604
线程管理  　　 ＠线程，进程，程序  　程序是计算机指令的集合，以文件形式存储在磁盘上，进程就是一个执行中的程序，进程有独立的内存空间和系统资源，一个进程由多个线程组成，多个线程共享同一个存储空间；  　  　　＠什么时候用线程？  当遇到一个对象要多出多个动作，并且多个动作又是穿插在一起的时候，就要使用线程的概念编写程序。  　　＠线程的状态迁移图  　　  　　＠线程的应用 
Java7并发编程--1、线程管理
HelloWorld
07-23 1128
1.1 简介        并发和并行从宏观上来讲都是同时处理多路请求的概念。但并发和并行又有区别，并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔内发生。
JAVA线程管理
m6711154的专栏
12-16 333
Thread类有一些保存信息的属性,这些属性可以用来标识线程,显示线程的状态或者控制线程的优先级。 ID：保存了线程的唯一标识。 Name：保存了线程的名称。 Priority：保存率线程对象的优先级.线程的优先级是从1到10，不推荐修改线程的优先级。 Status：保存了线程的状态.在java中有6种：new：至今尚未启动的线程处于这种状态。       runnable：正在
Java 多线程管理
zucc_shen的博客
07-05 148
细粒度：线程之间有同步操作 等待 通知/唤醒 终止 线程状态 NEW 刚创建 RUNNABLE 就绪态（strat） RUNNING 运行中（run） BLOCK 阻塞（sleep） TERMINATED 结束 线程阻塞和唤醒 – sleep，时间一到，会自己醒来 – wait——notify/notifyAll，等待，需要别人唤醒 – join，等待另外一个线程结束 – interrupt，向另外一个线程发送中断信号，该线程受到信号，会触发InterruptedException（可解除阻塞），并
java 管理多线程_Java线程管理（一）多线程
weixin_39830200的博客
02-12 178
说起线程要说下线程的概念：线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程(摘自百度)；对此不多赘述。一个线程就是一条执行路径，java是支持多线程的语言之一，因而运行在一个应用程序中同时执行多条执行路径，也就是同时运行多条线程，这里说的“同时”是说的宏观...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值