Java多线程——线程池

于 2024-07-09 22:12:05 发布
阅读量742 收藏 8
点赞数 11
文章标签： java 开发语言 intellij-idea 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51774011/article/details/140308062
版权

线程池

1.1 什么是线程池

线程池是一种多线程管理机制，通过池化技术来重用现有线程而不是创建新的线程，从而降低线程创建和销毁的开销。线程池通过工作队列和线程管理来实现高效的任务执行。

1.2 为什么使用线程池

一个线程大约占用的内存为1M

  1. 解决频繁创建线程和销毁线程消耗的性能
  2. 解决大量创建线程而导致的内存泄露问题
线程池的优点

降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的销毁

提高响应速度：当任务到达时，任务可以不需要等到线程创建就能立即执行

提高线程的可管理性

线程可以复用、可以控制最大并发数、可以管理线程

1.3 线程池的组成

线程池的关键组成部分包括：

  1. 线程池管理器(ThreadPoolExecutor):负责创建、管理和控制线程池。
  2. 工作队列：用于存储待执行的任务。
  3. 线程池线程：实际执行任务的线程。线程池中会维护一组线程，这些线程可以被重复使用，从而避免了频繁创建和销毁的开销

1.4 如何创建线程池

Java提供了两种方式：

第一种：通过工具类完成线程池的创建【Executors】，语法简单，但是阿里巴巴不建议使用

第二种：通过线程池类【ThreadPoolExecutor】，语法复杂，但是阿里巴巴建议使用，灵活

线程的根接口：Executor，其中只有一个方法：execute。

线程的子接口：ExecutorService，其中方法有很多。

1.4.1 第一种方式–Executors工具类

① 固定大小线程池对象 newFixedThreadPool

  1. 语法格式

    //创建一个固定大小的线程池，返回类型为ExecutorService
ExecutorService executorService = Executors.newFixedThreadPool(5);

  2. 介绍

    该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变，当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。

public class Test1 {
    public static void main(String[] args) {
        //创建一个固定大小的线程池，返回类型为ExecutorService
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 20; i++) {
            //调用execute方法，参数必须传递Runnable对象。
            //传递Runnable对象的三种方式
            //[1]自己创建一个类实现Runnable接口  [2]匿名内部类对象 [3]lambda表达式: 前提接口必须为函数式接口。
            executorService.execute(()-> System.out.println(Thread.currentThread().getName()+"--->"+i));
        }
    }
}
② 单一线程池 newSingleThreadExecutor

  1. 语法

    //创建单一线程池，返回类型ExecutorService
ExecutorService executorService = Executors.newSingleThreadExecutor();

  2. 介绍

    该方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。

public class Test2 {
    public static void main(String[] args) {
        //创建单一线程池，返回类型ExecutorService
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 50; i++) {
            executorService.execute(()->
                                    System.out.println(Thread.currentThread().getName()+"==========="));
        }
    }
}
③ 可变线程池 newCachedThreadPool

  1. 语法

    //创建可变大小的线程池，返回类型ExecutorService
ExecutorService executorService = Executors.newCachedThreadPool();

  2. 介绍

    该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。

public class Test3 {
    public static void main(String[] args) {
        //创建可变大小的线程池，返回类型ExecutorService
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 20; i++) {
            executorService.execute(()-> System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~"));
        }
    }
}
④ 延迟线程池 newScheduledThreadPool

  1. 语法

    //创建延迟线程池，返回类型为ScheduledExecutorService
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);

  2. 介绍

    该方法返回的是一个支持定时及周期性的线程池。该线程池对象执行的不是excute方法，执行的是schedule方法。

    schedule方法中的三个参数为：

    • 传递Runnable对象或Callable对象
    • 设置多长时间后开始执行任务代码块
    • 设置时间单位
public class Test4 {
    public static void main(String[] args) {
        //创建延迟线程池，返回类型为ScheduledExecutorService
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
        for (int i = 0; i < 20; i++) {
            //schedule方法，必须传递Callable对象
            scheduledExecutorService.schedule(
                ()->{ System.out.println(Thread.currentThread().getName()+"~~~~~~~~~~"); }，
                5, //表示5秒后执行任务代码块
                TimeUnit.SECONDS
            );
        }
    }
}

亦或者执行scheduleAtFixedRate方法

其中包含四个参数为：

  1. 传递Runnable对象或Callable对象
  2. 设置多长时间后开始执行任务代码块
  3. 设置每隔多长时间执行一次代码块
  4. 设置时间单位
public class Test5 {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
        for (int i = 0; i < 5; i++) {
            //scheduleAtFixedRate:必须传递Runnable接口
            scheduledExecutorService.scheduleAtFixedRate(
                ()-> { System.out.println(Thread.currentThread().getName()+"~~~~~~~~~"); },//对象
                3, //3秒后执行任务
                2, //2秒执行一次
                TimeUnit.SECONDS //时间单位为秒
            );
        }
    }
}

1.4.2 Executors创建的线程池缺点

《阿里巴巴java开发手册》中强制线程池不允许使用Exexutors去创建，而是通过ThreadPoolExextor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险

Executors 返回线程池对象的弊端如下：
FixedThreadPool 和 SingleThreadExecutor ： 允许请求的队列长度为 Integer.MAX_VALUE,
										   可能堆积大量的请求，从而导致OOM。（Out Of Memory：内存用完了！）
CachedThreadPool 和 ScheduledThreadPool ： 允许创建的线程数量为 Integer.MAX_VALUE，
										   可能会创建大量线程，从而导致OOM。

1.4.3 线程池的七大参数

  1. int corePoolSize：核心线程数量，不能小于0
  2. int maximumPoolSize ：最大线程的线程数量，减去核心线程=临时线程
  3. long keepAliveTime ：空闲线程的最大存活时间，没有人使用会自动释放
  4. TimeUnit unit ：时间单位
  5. BlockingQueue<Runnable> workQueue ：任务队列
  6. ThreadFactory th：线程工厂，创建线程的，一般不用动
  7. RejectedExecutionHandler handler ：任务的拒绝策略

1.4.4 第二种方式–ThreadPoolExecutor

① 语法介绍

  1. 语法

    ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(参数列表);

  2. 参数介绍

    • int corePoolSize：核心线程数的个数

    • int maximumPoolSize：最大线程数量

    • long keepAliveTime：非核心线程允许空闲的时间

    • TimeUnit unit：时间单位

    • BlockingQueue workQueue：堵塞队列

public class Test1 {
    public static void main(String[] args) {
        //创建任务队列
        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue(3);
        //创建线程池
        ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(2,6,6, TimeUnit.SECONDS,workQueue);
        for (int i = 0; i < 9; i++) {
            //调用submit方法，执行线程任务
            threadPoolExecutor.submit(()->{
                System.out.println(Thread.currentThread().getName()+"~~~~~~~~~");
            });
        }
    }
}
② 场景理解
我们可以通过下面的场景理解ThreadPoolExecutor中的各个参数;
a客户(任务)去银行(线程池)办理业务,但银行刚开始营业,窗口服务员还未就位(相当于线程池中初始线程数量为0),
于是经理(线程池管理者)就安排1号工作人员(创建1号线程执行任务)接待a客户(创建线程);
在a客户业务还没办完时,b客户(任务)又来了,于是经理(线程池管理者)就安排2号工作人员(创建2号线程执行任务)接待b客户(又创建了一个新的线程);假设该银行总共就2个窗口(核心线程数量是2);
紧接着在a,b客户都没有结束的情况下c客户来了,于是经理(线程池管理者)就安排c客户先坐到银行大厅的座位上(空位相当于是任务队列)等候,
并告知他: 如果1、2号工作人员空出,c就可以前去办理业务;
此时d客户又到了银行,(工作人员都在忙,大厅座位也满了)于是经理赶紧安排临时工(新创建的线程)在大堂站着,手持pad设备给d客户办理业务;
假如前面的业务都没有结束的时候e客户又来了,此时正式工作人员都上了,临时工也上了,座位也满了(临时工加正式员工的总数量就是最大线程数),
于是经理只能按《超出银行最大接待能力处理办法》(饱和处理机制)拒接接待e客户;
最后,进来办业务的人少了,大厅的临时工空闲时间也超过了1个小时(最大空闲时间),经理就会让这部分空闲的员工人下班.(销毁线程)
但是为了保证银行银行正常工作(有一个allowCoreThreadTimeout变量控制是否允许销毁核心线程,默认false),即使正式工闲着,也不得提前下班,所以1、2号工作人员继续待着(池内保持核心线程数量);
③ 图示解析

在这里插入图片描述

④ 案例——秒杀商品
综合案例-秒杀商品
案例介绍:
	假如某网上商城推出活动,新上架10部新手机免费送客户体验,要求所有参与活动的人员在规定的时间同时参与秒杀挣抢,假如有20人同时参与了该活动,请使用线程池模拟这个场景,保证前10人秒杀成功,后10人秒杀失败;
要求:
	1:使用线程池创建线程
	2:解决线程安全问题
思路提示:
	1:既然商品总数量是10个,那么我们可以在创建线程池的时候初始化线程数是10个及以下,设计线程池最大数量为10个;
	2:当某个线程执行完任务之后,可以让其他秒杀的人继续使用该线程参与秒杀;
	3:使用synchronized控制线程安全,防止出现错误数据;
代码步骤:
	1:编写任务类,主要是送出手机给秒杀成功的客户;
	2:编写主程序类,创建20个任务(模拟20个客户);
	3:创建线程池对象并接收20个任务,开始执行任务;
    主程序类,测试任务类
  • 任务类
public class Goods implements Runnable{
    //定义一个变量，用于存储用户编号
    private String name;
    //有参构造方法，初始化用户编号
    public Goods(String name){
        this.name=name;
    }
    private static  int count=10;
    @Override
    public void run() {
            System.out.println(name+"进入了秒杀活动");
            if(count>0){
                synchronized (Goods.class){
                    System.out.println(name+"抢到了"+count+"号手机，秒杀成功！");
                    count--;
                }
            }else {
                System.out.println(name+"秒杀失败");
            }
    }
}
  • 主任务类测试
public class Test {
    public static void main(String[] args) {
        //创建阻塞队列对象
        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue<>(5);
        //创建线程池
        ThreadPoolExecutor poolExecutor=new ThreadPoolExecutor(2,5,6, TimeUnit.SECONDS,workQueue);

        //循环20个用户
        for (int i = 1; i <=20; i++) {
            //创建任务对象
            Goods goods=new Goods("客户"+i);
            poolExecutor.submit(goods);
        }
    }
}
⑤ 线程池工作原理

  1. 提交任务: 通过 execute(Runnable) 或 submit(Callable<T>) 方法提交任务。

  2. 任务处理: 核心线程处理任务。如果核心线程已满，任务进入队列。如果队列已满且线程未达到最大线程数，创建新线程处理任

    ​ 务。如果达到最大线程数，执行拒绝策略。

  3. 线程回收: 超过 keepAliveTime 的空闲线程会被终止，以节省资源。

1.4.5 任务队列（workQueue）

任务队列是基于阻塞队列实现的，即采用生产者消费者模式，在 Java 中需要实现 BlockingQueue 接口。但 Java 已经为我们提供了 7 种阻塞队列的实现：

① ArrayBlockingQueue

基于数组的有界队列。

import java.util.concurrent.*;

public class ArrayBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个容量为3的有界阻塞队列
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(3);

        // 添加元素到队列中
        queue.put(1);
        queue.put(2);
        queue.put(3);

        // 试图添加第四个元素时会阻塞，因为队列已满
        new Thread(() -> {
            try {
                queue.put(4);
                System.out.println("Added 4");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // 让主线程休眠一会儿，以确保子线程被阻塞
        Thread.sleep(2000);

        // 移除队列中的元素
        System.out.println("Removed: " + queue.take());
        System.out.println("Removed: " + queue.take());
        System.out.println("Removed: " + queue.take());

        // 现在队列有空间，子线程可以继续执行
    }
}
② LinkedBlockingQueue

基于链表的无界队列（或指定容量的有界队列）。在未指明容量时，容量默认为 Integer.MAX_VALUE。

import java.util.concurrent.*;

public class LinkedBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        // 未指定容量时，默认容量为 Integer.MAX_VALUE
        LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();

        // 添加元素到队列中
        queue.put(1);
        queue.put(2);
        queue.put(3);

        // 移除并打印队列中的元素
        System.out.println("Removed: " + queue.take());
        System.out.println("Removed: " + queue.take());
        System.out.println("Removed: " + queue.take());
    }
}
③ PriorityBlockingQueue

基于优先级的无界队列，跟时间没有关系，对元素没有要求。可以实现 Comparable 接口也可以提供 Comparator 来对队列中的元素进行比较。

import java.util.concurrent.*;

public class PriorityBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>();

        // 添加元素到队列中
        queue.put(5);
        queue.put(1);
        queue.put(3);

        // 移除并打印队列中的元素，按优先级顺序
        System.out.println("Removed: " + queue.take()); // 1
        System.out.println("Removed: " + queue.take()); // 3
        System.out.println("Removed: " + queue.take()); // 5
    }
}
④ DelayQueue

类似于PriorityBlockingQueue，是二叉堆实现的无界优先级队列。要求元素都实现 Delayed 接口，通过执行时延从队列中提取任务，时间没到任务取不出来。

import java.util.concurrent.*;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class DelayQueueExample {
    public static void main(String[] args) throws InterruptedException {
        DelayQueue<DelayedElement> queue = new DelayQueue<>();

        // 添加延迟元素到队列中
        queue.put(new DelayedElement("Element1", 5));
        queue.put(new DelayedElement("Element2", 3));
        queue.put(new DelayedElement("Element3", 1));

        // 移除并打印队列中的元素，按延迟时间
        while (!queue.isEmpty()) {
            System.out.println("Removed: " + queue.take());
        }
    }
}

class DelayedElement implements Delayed {
    private final String name;
    private final long startTime;

    public DelayedElement(String name, long delayInSeconds) {
        this.name = name;
        this.startTime = System.currentTimeMillis() + delayInSeconds * 1000;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        long diff = startTime - System.currentTimeMillis();
        return unit.convert(diff, TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        if (this.startTime < ((DelayedElement) o).startTime) {
            return -1;
        }
        if (this.startTime > ((DelayedElement) o).startTime) {
            return 1;
        }
        return 0;
    }

    @Override
    public String toString() {
        return name;
    }
}
⑤ SynchronousQueue

不存储任务的队列，每个插入操作必须等待相应的删除操作。

import java.util.concurrent.*;

public class SynchronousQueueExample {
    public static void main(String[] args) {
        SynchronousQueue<Integer> queue = new SynchronousQueue<>();

        // 创建消费者线程
        new Thread(() -> {
            try {
                System.out.println("Consumed: " + queue.take());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // 创建生产者线程
        new Thread(() -> {
            try {
                queue.put(1);
                System.out.println("Produced: 1");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}
⑥ LinkedBlockingDeque

使用双向队列实现的有界双端阻塞队列。双端意味着可以像普通队列一样 FIFO（先进先出），也可以像栈一样 FILO（先进后出）。

import java.util.concurrent.*;

public class LinkedBlockingDequeExample {
    public static void main(String[] args) throws InterruptedException {
        LinkedBlockingDeque<Integer> deque = new LinkedBlockingDeque<>(3);

        // 添加元素到双端队列
        deque.putFirst(1);
        deque.putLast(2);
        deque.putFirst(3);

        // 从双端队列移除元素
        System.out.println("Removed: " + deque.takeFirst());
        System.out.println("Removed: " + deque.takeLast());
        System.out.println("Removed: " + deque.takeFirst());
    }
}
⑦ LinkedTransferQueue

它是ConcurrentLinkedQueue、LinkedBlockingQueue 和 SynchronousQueue 的结合体，但是把它用在 ThreadPoolExecutor 中，和 LinkedBlockingQueue 行为一致，但是无界的阻塞队列。

import java.util.concurrent.*;

public class LinkedTransferQueueExample {
    public static void main(String[] args) {
        LinkedTransferQueue<Integer> queue = new LinkedTransferQueue<>();

        // 创建消费者线程
        new Thread(() -> {
            try {
                System.out.println("Consumed: " + queue.take());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // 创建生产者线程
        new Thread(() -> {
            try {
                queue.transfer(1);
                System.out.println("Produced and transferred: 1");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

有界队列和无界队列的区别：

​ 如果使用有界队列，当队列饱和时并超过最大线程数时就会执行拒绝策略；而如果使用无界队列，因为任务队列永远都可以添加任务，所以设置 maximumPoolSize 没有任何意义。

1.4.6 拒绝策略（handler）

当线程池的线程数达到最大线程数时，需要执行拒绝策略。

拒绝策略需要实现 RejectedExecutionHandler 接口，并实现 rejectedExecution(Runnable r, ThreadPoolExecutor e) 方法。

Executors 框架为我们实现了 4 种拒绝策略：

  1. AbortPolicy: 直接抛出 RejectedExecutionException 异常。

    RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();

  2. CallerRunsPolicy: 由提交任务的线程处理该任务。

  3. DiscardPolicy: 丢弃无法处理的任务，不抛出异常。

  4. DiscardOldestPolicy: 丢弃队列中最旧的未处理任务，并尝试重新提交当前任务。

1.5 面试题

execute和submit方法区别？

**相同点：**两个方法都可以向线程池提交任务

**不同点：**execute()方法的返回类型是void，定义在Executor接口中，只能执行Runnable类型的任务

​ submit()方法可以返回持有计算结果的Future对象，定义在ExecutorService接口中，它扩展了Executor接口，可以执行runnable和callable类型的任务，其它线程池类像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有这些方法 。

是清醒也是知趣
关注
  • 11
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程——线程池
qq_51302219的博客
08-08 1150
线程池
轻量级java多线程池demo
01-08
本文将深入探讨一个轻量级的Java多线程池实现，这个实现允许线程间的通信，并提供了类似Akka Actor的调度功能。 首先，我们要理解Java中的线程池。线程池是一种线程使用模式，它维护一组可以重复使用的线程，避免了...
java多线程——线程池
Zj_boring的博客
05-15 1118
线程池是管理java线程生命周期的工具降低资源消耗。通过池化技术能够重复利用已创建的线程，降低线程频繁创建和销毁造成的资源消耗提高线程的可管理性。无需程序员手动销毁线程，控制线程创建的数量，避免无限制的创建影响系统稳定性。
Java多线程——线程池异常捕获
泯灭于众生，高歌于孤夜！
01-13 1442
上一篇提到了使用ThreadFactory的UncaughtExceptionHandler去捕获线程池的错误，还有没有其他方法呢？ 线程的异常捕获可以使用try catch，但是主线程 如何 捕获子线程的异常呢？当一个线程执行出错了，接下来是否还要执行呢？ try catch 在子线程执行的方法体里面加上 try catch ，try catch 可以捕获当前线程的抛出的异常。 但是try catch 无法捕获其他线程的错误。 demo： public class OtherException {
Java多线程案例——线程池
如风暖阳的博客
05-11 9700
Java多线程案例——线程池
JAVA多线程——线程池的使用
万里顾一程的博客
09-04 325
JAVA多线程——线程池 问题：经常创建和销毁使用量特别大的资源时，比如并发情况下的线程，对性能影响很大。 解决：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建和销毁、实现重复利用。 好处： 提高响应速度（减少了创建新线程的时间） 减低资源消耗（重复利用线程池中的线程） 便于线程管理 可以设置线程池的属性 corePoolSize:核心池的大小 maximumPoolSize: 最大线程数 keepAliveTime:线程没有任务时最多保持多久时间后会终止
Java多线程——线程池的大小如何确定
泯灭于众生，高歌于孤夜！
01-13 1018
线程的使用目的是提高运行速度，提高运行的速度是要充分使用CPU和I/O 的利用率。 这就涉及到CPU密集型程序和I/O密集型程序的区别了。 CPU 密集型程序 CPU密集型也叫计算密集型，指的是系统的硬盘、内存性能相对CPU要好很多，此时，系统运作大部分的状况是CPU Loading 100%，CPU要读/写I/O(硬盘/内存)，I/O在很短的时间就可以完成，而CPU还有许多运算要处理，CPU Loading很高。 比如说要计算1+2+3+……+ 1亿、计算圆周率后几十位、数据分析。 都是属于CPU密集型程
5.java多线程——线程池
胆小鬼的技术庄园
08-06 467
线程池为什么推荐用线程池去创建线程？特点示例手动创建线程线程池创建线程为什么不推荐使用线程池工具类创建线程池线程池执行器线程池工具类创建的几种线程池newCachedThreadPoolnewFixedThreadPoolnewSingleThreadExecutornewScheduledThreadPool线程池深入分析线程提交优先级一个奇怪的现象线程执行优先级 为什么推荐用线程池去创建线程？ 特点 手动创建线程： 频繁创建销毁开销大，疯狂抢占资源混乱，出错概率大。 线程池创建线程 很好的管理线程，复用
java多线程线程池_Java多线程——线程池（ThreadPool）
weixin_39843215的博客
02-16 103
我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？对，没错！就是我们的ThreadPool！让我们来看一下ThreadPool的...
Java进阶学习——Java多线程知识的理解
01-20
Java多线程知识的理解0.前言1.从一道题目引入2.创建线程2.1.继承Thread类2.2.实现Runnable接口3.线程的生命周期4.线程安全4.1.为什么需要线程安全？4.2.如何实现线程安全？5.线程池5.1.为什么需要线程池？5.2.创建...
smoker_java多线程_
09-29
标题"smoker_java多线程_"暗示我们将探讨的是一个关于Java多线程的示例，可能是解决某个特定的并发问题。描述中提到的"实现经典多线程问题中的多线程问题"进一步说明我们将深入研究一些常见的多线程挑战，例如死锁、...
java多线程案例——未完成
08-21
Java多线程是Java编程中的一个重要领域，它允许程序同时执行多个任务，从而提高系统效率和资源利用率。在这个未完成的案例中，我们可能正在探讨如何在Java中创建和管理线程，以及处理多线程环境下的并发问题。下面是...
Java多线程下载网络图片
02-14
在Java编程中，多线程是一项关键技能，尤其在处理并发任务时，如我们的示例——"Java多线程下载网络图片"。这个场景展示了如何利用多线程技术提高程序性能，减少用户等待时间，同时优化系统资源的使用。下面我们将...
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1322
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
解决分布式环境下session共享问题
shenxiaomo1688的博客
07-06 1057
在分布式环境下，session会存在两个问题第一个问题:不同域名下，浏览器存储的jsessionid是没有存储的。比如登录时认证服务auth.gulimall.com存储了session，但是搜索服务search.gulimall.com是没有这个session的；
java Object 转 Integer
servepeople的博客
07-09 233
在 Java 中，可以通过多种方法将一个Object转换为Integer。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 730
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
java中 使用数组实现需求小案例（二）
最新发布
qq_44304677的博客
07-09 169
java小案例，数组需求实现，使用Random函数实现用户输入随机数生成一个打乱的数组
java多线程与线程池实现socket多个客户端连接服务器同时通信代码 ———————
09-11
要实现多个客户端同时连接服务器进行通信，可以使用Java多线程和线程池的概念。以下是一个示例代码： 服务器端代码： ```java import java.io.*; import java.net.*; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Server { public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(12345); ExecutorService executorService = Executors.newFixedThreadPool(10); while (true) { System.out.println("服务器等待建立连接..."); Socket socket = serverSocket.accept(); // 每次有客户端建立连接就创建一个新的线程处理 executorService.execute(new ClientHandler(socket)); System.out.println("连接成功!"); } } } class ClientHandler implements Runnable { private Socket socket; public ClientHandler(Socket socket) { this.socket = socket; } @Override public void run() { try { BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); String line; while ((line = br.readLine()) != null) { System.out.println("接收到客户端消息：" + line); // 处理客户端发送的消息 bw.write("服务器收到消息：" + line); bw.newLine(); bw.flush(); } br.close(); bw.close(); socket.close(); } catch (IOException e) { e.printStackTrace(); } } } ``` 客户端代码： ```java import java.io.*; import java.net.*; public class Client { public static void main(String[] args) throws IOException { Socket socket = new Socket("服务器IP地址", 12345); BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); // 发送消息给服务器 bw.write("Hello, Server!"); bw.newLine(); bw.flush(); // 接收服务器的响应 String response = br.readLine(); System.out.println("服务器响应：" + response); br.close(); bw.close(); socket.close(); } } ``` 在服务器端代码中，通过创建一个线程池（这里使用固定大小的线程池），每当有一个客户端连接时，就创建一个新线程去处理客户端的请求。该线程负责与客户端进行通信。 在客户端代码中，创建一个Socket对象与服务器建立连接，然后通过输入输出流进行通信。在示例中，客户端向服务器发送一条消息，服务器接收到后处理，然后返回响应给客户端。 这样，多个客户端可以同时连接服务器进行通信，服务器通过多线程来处理每个客户端的请求，并保证线程安全性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值