java使用Executor(执行器)管理线程

简介:

v一.一个实现了Runnable接口的类

复制代码
class MyThread implements Runnable{
    private static int num = 0;
    @Override
    public void run() {
        while(true){
            synchronized(MyThread.class){
                ++num;
                try{
                    Thread.sleep(500);
                } catch(Exception e){
                    System.out.println(e.toString());
                }
                System.out.println(Thread.currentThread().getName() + " " + num);
            }
        }
    }
}
复制代码

v1. newCachedThreadPool()方法

  CacheThreadPool会为每一个任务创建一个线程。非常常见的情况是,单个的Executor被用来创建和管理系统中的任务。shutdown()方法可以防止新的任务被提交给这个Executor。如果在shutdown()方法之后提交新任务,则会抛出java.util.concurrent.RejectedExecutionException异常。

复制代码
public class Main{
    public static void main(String[] args){
          ExecutorService exes = Executors.newCachedThreadPool();
          for(int i=0; i<5; ++i)
              exes.execute(new MyThread());
          exes.shutdown();          
    }
}
复制代码

v2.FixedThreadPool()方法

  FixedThreadPool使用了优先的线程集来执行所提交的任务。有了它,你就可以一次性预先执行代价高的线程分配。也就是说如果设置的最大线程数量是x,而提交的线程数y,那么(y-x)对应的这些线程要等到前x个线程执行完毕才会执行。

  下面的例子中,线程6一直不会有机会执行。因为run()方法中是 while(true), 可以将while(true)去掉,前5个线程执行完毕后,才会执行第6个线程。

复制代码
public class Main{
    public static void main(String[] args){
          ExecutorService exes = Executors.newFixedThreadPool(5);
          for(int i=0; i<6; ++i)
                  exes.execute(new MyThread());
          exes.shutdown();          
    }
}
复制代码

v3.newSingleThreadExecutor()方法

复制代码
public class Main{
    public static void main(String[] args){        
          ExecutorService exes = Executors.newSingleThreadExecutor();
          for(int i=0; i<5; ++i)
              exes.execute(new MyThread());
          exes.shutdown();    
}
复制代码

  SingleThreadExecutor就像是线程数量为1的FixedThreadPool。这对于你希望在另一个线程中连续运行的事物(长期存活的任务)来说,都是很有用的。如果想SingleThreadExecutor提交了多个任务,那么这些任务将排队,每个任务都会在下一个任务开始之前结束,所有的任务将使用相同的线程。

 

v二.一个实现了Callable<E>接口的类(从任务中产生返回值)

复制代码
class MyThread implements Callable<String>{
    private static int num = 0;
    @Override
    public String call() throws Exception {
        for(int i=0; i<5; ++i){
            synchronized(MyThread.class){
                ++num;
                Thread.sleep(200);
                System.out.println(Thread.currentThread().getName() + " " + num);
            }
        }
        return Thread.currentThread().getName() + " success!";
    }
}
复制代码

v1.ExecutorService.submit()方法

复制代码
public class Main{
    public static void main(String[] args){
         ExecutorService exes = Executors.newCachedThreadPool();
         ArrayList<Future<String>> rets = new ArrayList<Future<String>>();
         for(int i=0; i<5; ++i)
             rets.add(exes.submit(new MyThread()));
         for(Future<String> fs : rets){
            try {
                System.out.println(fs.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
         }
    }
}
复制代码

  submit()会产生Future对象,它用Callable返回结果的特定类型进行了参数化。可以调用Future的isDone()方法来查询Future是否已经完成。调用Future的get()方法来获取最终线程的执行结果。另外,Future的get()方法是一个阻塞方法,直到结果准备就绪

v 三.线程的优先级

复制代码
class MyThread implements Runnable{
    private int priority;
    public MyThread(){
    }
    
    public MyThread(int priority){
        this.priority = priority;
    }
    
    private static int num = 0;
    private volatile double d;
    @Override
    public void run() {
        Thread.currentThread().setPriority(priority);
        while(true){
            for(int i=0; i<100000; ++i){
                d += (Math.PI+Math.E)/(double)i;
                if(i%1000 == 0)
                    Thread.yield();
            }
            synchronized(MyThread.class){
                ++num;
                try{
                    Thread.sleep(500);
                } catch(Exception e){
                    System.out.println(e.toString());
                }
                System.out.println(Thread.currentThread().getName() + " " + num);
            }
        }
    }
}

public class Main{
    public static void main(String[] args){
         ExecutorService exes = Executors.newCachedThreadPool();
         for(int i=0; i<5; ++i)
             exes.execute(new MyThread(Thread.MIN_PRIORITY));
         exes.execute(new MyThread(Thread.MAX_PRIORITY));
         exes.shutdown();
    }
}
复制代码

  volatile变量保证编译器对循环不进行任何的优化,如果不加入这些运算的话,就不会看到设置线程优先级的效果。数学运算是可以中断的,向控制台打印不能被中断。这里预案算时间足够的长,因此线程调度机制才来的及介入,交换任务并关注优先级,是的最高优先级被优先选择。

v四.后台线程

复制代码
class SimpleDaemons implements Runnable{
    @Override
    public void run() {
        while(true){
            try{
                TimeUnit.MILLISECONDS.sleep(200);
                System.out.println(Thread.currentThread().getName());
            } catch(InterruptedException e){
                System.out.println(Thread.currentThread().getName() + " : InterruptException!");
                e.printStackTrace();
            }
        }
    }
}

public class Main{
    public static void main(String[] args) throws InterruptedException{
         for(int i=0; i<10; ++i){
             Thread daemon = new Thread(new SimpleDaemons());
             daemon.setDaemon(true);
             daemon.start();
         }
         System.out.println("All daemons started");
         TimeUnit.MILLISECONDS.sleep(1000);
    }
}
复制代码

  所谓后台线程,是指程序运行的时候在后台提供一种通用的服务的线程,并且这种线程并不属于程序中不可或缺的部分。因此,当所有的非后台线程结束时,程序也就终止了,同时会杀死进程中的所有的后台线程。反过来说,只要任何非后台线程还在运行,程序就不会终止。

  通过定制自己的ThreadFactory, 可以定制有Executor创建的线程的属性(后台,优先级,名称)

复制代码
class DaemonThreadFactory implements ThreadFactory{
    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setDaemon(true);
        return t;
    }
}
复制代码
复制代码
class DaemonFromFactory implements Runnable{
    @Override
    public void run() {
        try{
            TimeUnit.MILLISECONDS.sleep(100);
            System.out.println(Thread.currentThread().getName());
        } catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

public class Main{
    public static void main(String[] args) throws InterruptedException{
         ExecutorService exes = Executors.newCachedThreadPool(new DaemonThreadFactory());
         for(int i=0; i<5; ++i)
                 exes.execute(new DaemonFromFactory());
         System.out.println("All Daemos Started!");
         TimeUnit.MILLISECONDS.sleep(1000);
    }
}









本文转自 小眼儿 博客园博客,原文链接:http://www.cnblogs.com/hujunzheng/p/5097470.html,如需转载请自行联系原作者
目录
相关文章
|
3天前
|
Java 关系型数据库 MySQL
如何用java的虚拟线程连接数据库
本文介绍了如何使用Java虚拟线程连接数据库,包括设置JDK版本、创建虚拟线程的方法和使用虚拟线程连接MySQL数据库的示例代码。
17 6
如何用java的虚拟线程连接数据库
|
7天前
|
Java 数据库 UED
Java的多线程有什么用
Java的多线程技术广泛应用于提升程序性能和用户体验,具体包括:提高性能,通过并行执行充分利用多核CPU;保持响应性,使用户界面在执行耗时操作时仍流畅交互;资源共享,多个线程共享同一内存空间以协同工作;并发处理,高效管理多个客户端请求;定时任务,利用`ScheduledExecutorService`实现周期性操作;任务分解,将大任务拆分以加速计算。多线程尤其适用于高并发和并行处理场景。
|
3天前
|
Java 调度
Java一个线程的生命周期详解
Java中,一个线程的生命周期分为五个阶段:NEW(新建),RUNNABLE(可运行),BLOCKED(阻塞),WAITING(等待),TERMINATED(终止)。线程创建后处于新建状态,调用start方法进入可运行状态,执行中可能因等待资源进入阻塞或等待状态,正常完成或异常终止后进入终止状态。各状态间可相互转换,构成线程的生命周期。
|
3天前
|
Java API 调度
Java 多线程编程详解
《Java多线程编程详解》深入浅出地讲解了Java平台下的多线程核心概念、API使用及最佳实践。从基础理论到实战案例,本书帮助读者掌握并发编程技巧,提升软件开发中的效率与性能,是Java开发者不可或缺的参考指南。
|
2天前
|
安全 Java 调度
理解 Java 中的多线程编程
本文深入探讨了Java中的多线程编程,涵盖线程创建与管理、同步机制、锁及死锁避免策略。介绍了通过继承`Thread`类或实现`Runnable`接口创建线程的方法,并讨论了线程的生命周期状态。此外,还讲解了如何使用`ExecutorService`线程池以及`java.util.concurrent`包中的工具类来简化并发编程。理解这些概念和技术,有助于开发高效稳定的多线程应用程序。
|
3天前
|
Java 开发者
农行1面:Java如何保证线程T1,T2,T3 顺序执行?
本文探讨了如何保证线程T1、T2、T3的顺序执行,这是农行面试中的一道题目,旨在考察候选人对多线程基础、同步机制、线程间通信及Java并发包的掌握情况。文章详细介绍了六种方法:`join()`、`CountDownLatch`、`Semaphore`、单线程池、`synchronized` 和 `CompletableFuture`,并通过示例代码展示了每种方法的具体实现。这些方法不仅适用于面试备考,还能帮助开发者更好地理解和掌握线程同步技术。
22 2
|
14天前
|
Java 数据中心 微服务
Java高级知识:线程池隔离与信号量隔离的实战应用
在Java并发编程中,线程池隔离与信号量隔离是两种常用的资源隔离技术,它们在提高系统稳定性、防止系统过载方面发挥着重要作用。
13 0
|
14天前
|
数据采集 负载均衡 安全
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
本文提供了多个多线程编程问题的解决方案,包括设计有限阻塞队列、多线程网页爬虫、红绿灯路口等,每个问题都给出了至少一种实现方法,涵盖了互斥锁、条件变量、信号量等线程同步机制的使用。
LeetCode刷题 多线程编程九则 | 1188. 设计有限阻塞队列 1242. 多线程网页爬虫 1279. 红绿灯路口
|
22天前
|
Java Spring
spring多线程实现+合理设置最大线程数和核心线程数
本文介绍了手动设置线程池时的最大线程数和核心线程数配置方法,建议根据CPU核数及程序类型(CPU密集型或IO密集型)来合理设定。对于IO密集型,核心线程数设为CPU核数的两倍;CPU密集型则设为CPU核数加一。此外,还讨论了`maxPoolSize`、`keepAliveTime`、`allowCoreThreadTimeout`和`queueCapacity`等参数的设置策略,以确保线程池高效稳定运行。
88 10
spring多线程实现+合理设置最大线程数和核心线程数
|
1月前
|
Java 数据库 Android开发
一个Android App最少有几个线程?实现多线程的方式有哪些?
本文介绍了Android多线程编程的重要性及其实现方法,涵盖了基本概念、常见线程类型(如主线程、工作线程)以及多种多线程实现方式(如`Thread`、`HandlerThread`、`Executors`、Kotlin协程等)。通过合理的多线程管理,可大幅提升应用性能和用户体验。
56 15
一个Android App最少有几个线程?实现多线程的方式有哪些?