Java多线程之线程池(合理分配资源)

简介: 3个核心线程都在忙,100个任务都排满了,那就只能找临时员工了

一、故事讲解

1.故事


有一家月饼店开业了,店里面有3个核心员工,这些人负责月饼的制作,3人同时工作制作100个月饼,每个人做完自己的月饼就会忙着下一个月饼的制作。因为总不可能要100个员工来做这些月饼吧,那也太浪费了。这些月饼的制作顺序是按照先后排队等待被制作的。


中秋佳节来临了,这些月饼的单子一下子赶了起来。忙不过来那就只能请一些临时员工来帮忙,但是核心员工忙得过来就用不上临时员工了。同时根据这些核心员工和临时员工的工作能力来判断接单情况,超过工作情况就不接单了,等先忙完这些再说。忙完这些月饼的制作,临时员工就会被辞退的。


2.怎么判断忙不过来,该找临时员工了?

3个核心线程都在忙,100个任务都排满了,那就只能找临时员工了


3.详解:

月饼店---线程池

3个核心员工--3个核心线程

100个月饼---100个任务

临时员工---临时线程

辞退---销毁临时线程(自动销毁,不用手动去设置)


二、概念讲解

1.什么是线程池?

答:一个可以复用线程的技术

2.如果不用线程池会怎么样?

答: 如果用户每发起一个请求,后台就会创建一个新的线程来进行处理。而一直开新线程的开销是很大的,这样会严重影响系统的性能。

3.怎么创建线程池?

答:创建ExecutorService接口的实现类,创建方式有两种

4.创建线程过多导致的问题?

答: 创建线程过多会占用CPU资源的,导致卡顿


三、两种线程池的创建方式

方式一:使用ExecutorService的实现类ThreadPoolExecutor去自己创建一个线程池对象。

(1)处理Runnable任务


步骤:

1.创建Runnable线程类

2.在main方法里面创建ExecutorService pool = new ThreadPoolExecutor();---括号里面填上线程的定义规则

3.创建Runnable target = new MyRunnable();

4.创建线程pool.execute(target);


代码例子:

package bao;
import java.util.concurrent.*;
public class Test {
    public static void main(String[] args) {
        /* //一、1.自己定义一个线程池对象----多态的写法
        * 3个核心员工(3个核心线程)
        * 5个总员工,那就是临时工是2个(总线程5个)
        * 6s,TimeUnit.SECONDS----临时工没事干就被销毁辞退了
        * 员工最多只能5个
        * Executors.defaultThreadFactory()-----默认线程工厂
        *new ThreadPoolExecutor.AbortPolicy()-----拒绝别人
        * */
        ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        //5.new创建线程
        Runnable target = new MyRunnable();
        //线程多少来自于上面自定义
        //因为线程方法都一样。调用有可能一下子就调用线程4-3-1了,那剩余的有可能会分配到任务,有可能闲着
        pool.execute(target);//核心线程1
        pool.execute(target);//核心线程2
        pool.execute(target);//核心线程3
        //创建临时线程(线程名字都一样,5个不一定哪个是核心,哪个是临时,分辨不出来)
        pool.execute(target);//线程4
        pool.execute(target);//线程5
        //为什么一些超过5条线程还能运行不报错呢?比如线程池里面只有5个位置,但是看着这么多线程都在,以为可以调用超过5个,一旦调用超过了5个就会报错
        //关闭线程(几乎不会用到,了解了就好了)
        //pool.shutdownNow();立即强制关掉,即使任务没有完成也会被关掉,会丢失任务
        //pool.shutdown();等待任务完成后再关闭,相对柔和
    }
}
//二、创建线程对象类
//2.创建线程类
class MyRunnable implements Runnable{
    //3.重写run方法
    @Override
    public void run() {
        //4.定义线程要执行的任务
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"输出了:月饼"+i);//Thread.currentThread().getName()可以知道当前哪个线程处理任务
        }
    }
}

运行结果:

pool-1-thread-3输出了:月饼0

pool-1-thread-1输出了:月饼0

pool-1-thread-2输出了:月饼0

pool-1-thread-1输出了:月饼1

pool-1-thread-3输出了:月饼1

pool-1-thread-1输出了:月饼2

pool-1-thread-2输出了:月饼1

pool-1-thread-1输出了:月饼3

pool-1-thread-3输出了:月饼2

pool-1-thread-1输出了:月饼4

pool-1-thread-2输出了:月饼2

pool-1-thread-3输出了:月饼3

pool-1-thread-2输出了:月饼3

pool-1-thread-3输出了:月饼4

pool-1-thread-1输出了:月饼0

pool-1-thread-3输出了:月饼0

pool-1-thread-2输出了:月饼4

pool-1-thread-3输出了:月饼1

pool-1-thread-1输出了:月饼1

pool-1-thread-3输出了:月饼2

pool-1-thread-1输出了:月饼2

pool-1-thread-3输出了:月饼3

pool-1-thread-1输出了:月饼3

pool-1-thread-3输出了:月饼4

pool-1-thread-1输出了:月饼4  


(2)处理Callable任务


步骤:

1.创建Callable线程类

2.在main方法里面创建ExecutorService pool = new ThreadPoolExecutor();---括号里面填上线程的定义规则

3. 创建线程Future f1 = pool.submit(new MyCallable(这里输入传入的值));

4.输出结果System.out.println(f1.get());//有异常直接抛出就好了


代码例子:

package bao;
import java.util.concurrent.*;
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //二、4.自定义线程的规则(详情看上一题)
        ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
        //5.把任务给线程池
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));
        Future<String> f5 = pool.submit(new MyCallable(500));
        //6.输出结果
        System.out.println(f1.get());//有异常直接抛出就好了
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
        System.out.println(f5.get());
    }
}
//一、1.创建线程任务类Callable
class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n){
        this.n=n;
    }
//2.重写Call方法
    @Override
    public String call() throws Exception {
//3.写线程要执行的具体任务代码
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum+=i;
        }
        return Thread.currentThread().getName()+"执行1-"+n+"的和是"+sum;
    }
}

运行结果:

pool-1-thread-1执行1-100的和是4950

pool-1-thread-2执行1-200的和是19900

pool-1-thread-3执行1-300的和是44850

pool-1-thread-2执行1-400的和是79800

pool-1-thread-3执行1-500的和是124750


方式二:使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象。(不适合做大型互联网场景的线程池方案,阿里巴巴手册不允许使用)

这个方式使用的例子方式就是固定了线程的数量使用。


步骤:

1.创建线程类

2.在main方法里面创建ExecutorService pool = Executors.newFixedThreadPool(这里固定线程数量);

3.创建线程pool.execute(new MyRunnable());


代码例子:

package bao;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test {
    public static void main(String[] args) {
        //二、5.创建固定线程池数据的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);//这里固定线程池里面只能有3个线程
        //6.创建线程
        pool.execute(new MyRunnable());//线程1
        pool.execute(new MyRunnable());//线程2
        pool.execute(new MyRunnable());//线程3
        //创建多余的线程也不要了,看都不看,就算上面的线程睡眠了
    }
}
//一、1.创建线程对象类
//2.创建线程类
class MyRunnable implements Runnable{
    //3.重写run方法
    @Override
    public void run() {
        //4.定义线程要执行的任务
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"输出了:月饼"+i);//Thread.currentThread().getName()可以知道当前哪个线程处理任务
        }
    }
}

运行结果:

pool-1-thread-3输出了:月饼0

pool-1-thread-2输出了:月饼0

pool-1-thread-1输出了:月饼0

pool-1-thread-2输出了:月饼1

pool-1-thread-3输出了:月饼1

pool-1-thread-2输出了:月饼2

pool-1-thread-1输出了:月饼1

pool-1-thread-2输出了:月饼3

pool-1-thread-3输出了:月饼2

pool-1-thread-2输出了:月饼4

pool-1-thread-1输出了:月饼2

pool-1-thread-3输出了:月饼3

pool-1-thread-1输出了:月饼3

pool-1-thread-3输出了:月饼4

pool-1-thread-1输出了:月饼4


旁白:线程池的出现就是为了避免资源的浪费,合理分配线程的资源,创建方式有两种,主要用第一种,第二种工具线程不建议使用。

目录
相关文章
|
4天前
|
安全 Java 开发者
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
在Java多线程编程中,`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中,每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践,帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法,确保线程安全和高效的通信。
22 9
|
4天前
|
监控 安全 Java
Java中的多线程编程:从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式,本文将以一个简短的代码示例作为开篇,直接展示多线程的魅力,随后再详细解析其背后的原理与实现方式,旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例:创建两个线程,分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
|
6天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
7天前
|
Java
java小知识—进程和线程
进程 进程是程序的一次执行过程,是系统运行的基本单位,因此进程是动态的。系统运行一个程序即是一个进程从创建,运行到消亡的过程。简单来说,一个进程就是一个执行中的程序,它在计算机中一个指令接着一个指令地执行着,同时,每个进程还占有某些系统资源如CPU时间,内存空间,文件,文件,输入输出设备的使用权等等。换句话说,当程序在执行时,将会被操作系统载入内存中。 线程 线程,与进程相似,但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源,所以系统在产生一个线程,或是在各个线程之间做切换工作时,负担要比
17 1
|
3月前
|
存储 监控 Java
Java多线程优化:提高线程池性能的技巧与实践
Java多线程优化:提高线程池性能的技巧与实践
115 1
|
6月前
|
设计模式 监控 Java
Java多线程基础-11:工厂模式及代码案例之线程池(一)
本文介绍了Java并发框架中的线程池工具,特别是`java.util.concurrent`包中的`Executors`和`ThreadPoolExecutor`类。线程池通过预先创建并管理一组线程,可以提高多线程任务的效率和响应速度,减少线程创建和销毁的开销。
195 2
|
6月前
|
Java 数据库
【Java多线程】对线程池的理解并模拟实现线程池
【Java多线程】对线程池的理解并模拟实现线程池
59 1
|
3月前
|
安全 算法 Java
17 Java多线程(线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合)(下)
17 Java多线程(线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合)
77 6
|
3月前
|
存储 安全 Java
17 Java多线程(线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合)(中)
17 Java多线程(线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合)
86 5
|
3月前
|
存储 安全 Java
17 Java多线程(线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合)(上)
17 Java多线程(线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合)
84 3