Java的多线程和线程池的使用

开发 后端
多线程大大提高程序运行效率,我们在开发过程中经常会开启一个线程来执行一些费时的任务。开启一个线程有4种方式,在下面的文章我将详细的去讲解。

多线程大大提高程序运行效率,我们在开发过程中经常会开启一个线程来执行一些费时的任务。开启一个线程有4种方式,在下面的文章我将详细的去讲解。

[[423256]]

继承Thread

继承Thread去执行任务,确实可以开启一个线程去执行任务,如果经常的去开启一些线程,也会导致系统资源的浪费。

 

  1. public static class Mythread extends Thread{ 
  2.         @Override 
  3.         public void run() { 
  4.             System.out.println("当前线程"+Thread.currentThread().getId()); 
  5.             int i = 10/2; 
  6.             System.out.println("运行结果"+i); 
  7.         } 
  8.     } 
  9. //调用线程。 
  10. public static void main(String[] args) throws ExecutionException, InterruptedException { 
  11.         /**thread执行方式*/ 
  12.         Mythread mythread = new Mythread(); 
  13.         mythread.start();//启动线程 
  14.         System.out.println("main--end"); 

实现Runnale接口。

 

  1. public static class MyRunable implements Runnable { 
  2.  
  3.     @Override 
  4.     public void run() { 
  5.         System.out.println("当前线程"+Thread.currentThread().getId()); 
  6.         int i = 10/2; 
  7.         System.out.println("运行结果"+i); 
  8.  
  9.     } 

调用。

 

  1. /** 
  2.  * runable的启动方式 
  3.  */ 
  4.  
  5. MyRunable runable = new MyRunable(); 
  6. new Thread(runable).start(); 
  7. System.out.println("main--end"); 

Callable

 

  1. /** 
  2.  * Callable可以允许有返回值 
  3.  */ 
  4.  
  5. public static class Callale01 implements Callable<Integer> { 
  6.  
  7.     @Override 
  8.     public Integer call() throws Exception { 
  9.         System.out.println("当前线程"+Thread.currentThread().getId()); 
  10.         int i = 10/2; 
  11.         System.out.println("运行结果"+i); 
  12.         return i; 
  13.     } 

调用。这里需要用callable构建futureTask

 

  1. /** 
  2.  * callale的启动方式 
  3.  */ 
  4. FutureTask<Integer> futureTask =new FutureTask<>(new Callale01()); 
  5. //取返回结果。 
  6. Integer i = futureTask.get(); 
  7. new Thread(futureTask).start(); 
  8. System.out.println("返回结果是:"+i); 

线程池

线程池才是我们java开发中,经常用到一种开启多线程的方式,线程池,自己去管理线程。可以节省系统资源。通常我们会将下面的一些配置写在一些配置类中

 

  1. /** 
  2.  * 七大参数 
  3.  * corePoolSize: 1.核心线程数[一直存在]: 线程池创建好了以后。就准备就绪的线程数量。 
  4.  * maxinumPoolSize: 2 最大线程数量 
  5.  * keepaliveTime: 存活时间。空闲线程的最大的等待时间。 
  6.  * unit  等待时间的单位 
  7.  * blockingQueue 阻塞队列。如果任务很多就会放在队列里面,只要有线程空闲了,就会去队列里面去取。 
  8.  * threadFactory :线程的工厂。 
  9.  * RejectExecutionHandler :如果队列满了。按照我们指定的策略。拒绝执行任务。 
  10.  * 
  11.  */ 
  12.  ThreadPoolExecutor executor = new ThreadPoolExecutor(5,100,10,TimeUnit.SECONDS, 
  13.           new LinkedBlockingQueue<>(100), 
  14.                                                     Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy()); 

常见的4种线程池。

1 newCachedThreadPool()

创建一个可缓存的线程池,如果线程池长度超过了处理的需要,可灵活的回收空闲线程。若无可回收。则创建新线程。

  1. Executors.newCachedThreadPool(); 

2.newFixedThreadPool(6)

创建一个固定大小的线程池。

3 newScheduledThreadPool()

定时任务的线程池。

4.newSingleThreadExecutor()

  1. Executors.newSingleThreadExecutor(); 

 

责任编辑:未丽燕 来源: 今日头条
相关推荐

2023-11-22 08:37:40

Java线程池

2009-03-12 10:52:43

Java线程多线程

2013-06-08 13:07:23

Java线程池调度器

2013-05-23 15:59:00

线程池

2023-06-07 13:49:00

多线程编程C#

2019-10-30 21:27:51

Java中央处理器电脑

2012-05-15 02:18:31

Java线程池

2012-02-29 13:26:20

Java

2016-11-10 16:30:22

Java多线程

2009-06-29 18:08:51

Java多线程join方法

2021-06-06 23:40:53

线程池使用场景

2024-01-15 10:55:40

Python多线程开发

2009-06-29 18:00:05

Java多线程Runnable接口创建线程

2013-06-13 13:19:38

多线程

2024-06-04 07:52:04

2009-09-22 17:21:24

线程局部变量

2015-03-24 16:29:55

默认线程池java

2009-06-29 18:03:15

Java多线程线程的生命周期

2022-06-15 07:32:35

Lock线程Java

2015-08-20 09:17:36

Java线程池
点赞
收藏

51CTO技术栈公众号