高并发以及线程池用法

最新推荐文章于 2023-08-12 13:30:23 发布
最新推荐文章于 2023-08-12 13:30:23 发布
阅读量395 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/limingcai168/article/details/83016392
版权

代码顺序

3.1 CountDownLatch/Phaser
3.2CompletableFuture
3.3 Fork/Join
 

3.1 CountDownLatch/Phaser


/**
 * @author lmc
 * @Email huyang@126.com
 * @date 2018年10月10日
 * 
 * 3.1 CountDownLatch/Phaser
 * 
 */
public class CountDownTask {
    private static final int CORE_POOL_SIZE = 4;
    private static final int MAX_POOL_SIZE = 12;
    private static final long KEEP_ALIVE_TIME = 5L;
    private final static int QUEUE_SIZE = 1600;
    //ConcurrentLinkedQueue  非阻塞队列
	//LinkedBlockingQueue  阻塞队列 ，阻塞队列常用于生产者和消费者的场景
    //这笔订单可能还需要查，用户信息，折扣信息，商家信息，菜品信息等，用同步的方式调用
    protected final static ExecutorService THREAD_POOL = new ThreadPoolExecutor(CORE_POOL_SIZE, MAX_POOL_SIZE,
            KEEP_ALIVE_TIME, TimeUnit.SECONDS, new LinkedBlockingQueue<>(QUEUE_SIZE));
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countdown = new CountDownLatch(5);

        THREAD_POOL.execute(()->{
        	System.out.println("当前任务Customer,线程名字为:"+Thread.currentThread().getName());
        	// orderInfo.setCustomerInfo(new CustomerInfo());
        	countdown.countDown();
        });
        THREAD_POOL.execute(()->{
        	System.out.println("当前任务Discount,线程名字为:"+Thread.currentThread().getName());
        	
        	countdown.countDown();
        });
        THREAD_POOL.execute(()->{
        	System.out.println("当前任务Food,线程名字为:"+Thread.currentThread().getName());
        	countdown.countDown();
        });
        THREAD_POOL.execute(()->{
        	System.out.println("当前任务Tenant,线程名字为:"+Thread.currentThread().getName());
        	countdown.countDown();
        });
        THREAD_POOL.execute(()->{
        	System.out.println("当前任务OtherInfo,线程名字为:"+Thread.currentThread().getName());
        	
        	countdown.countDown();
        });
        countdown.await(1,TimeUnit.SECONDS);
        System.out.println("主线程: "+Thread.currentThread().getName());
/*      建立一个线程池(具体配置根据具体业务，具体机器配置)，进行并发的执行我们的任务(生成用户信息，菜品信息等)，
                    最后利用await方法阻塞等待结果成功返回。await()方法可以阻塞至超时或者计数器减至0，其他线程当完成自己目标的时候可以减少1，
                    利用这个机制我们可以将其用来做并发。
        */
       // THREAD_POOL.shutdownNow();
        
        //countDownLatch.countDown()，很明显我们的业务代码显然不应该关心这一部分逻辑，
        //并且在开发的过程中万一写漏了，那我们的await方法将只会被各种异常唤醒。
    }
}

3.2CompletableFuture



/**
 * @author lmc
 * @Email huyang@126.com
 * @date 2018年10月10日
 * 
 * 3.2 CompletableFuture
 * 
 */
public class CompletableFutureParallel {

	private static final int CORE_POOL_SIZE = 4;
    private static final int MAX_POOL_SIZE = 12;
    private static final long KEEP_ALIVE_TIME = 5L;
    private final static int QUEUE_SIZE = 1600;

    //countDownLatch.countDown()与业务无关，每个线程都要执行，所以引出了CompletableFuture
    //在JDK1.8中提供了一个类CompletableFuture，它是一个多功能的非阻塞的Future。
//我们将每个任务的计算完成的结果都用CompletableFuture来表示，利用CompletableFuture.
//allOf汇聚成一个大的CompletableFuture，那么利用get()方法就可以阻塞。
    
    private final static ExecutorService THREAD_POOL = new ThreadPoolExecutor(CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME,
    		TimeUnit.SECONDS, new LinkedBlockingQueue<>(QUEUE_SIZE));
	/**
	 * @param args
	 * @throws TimeoutException 
	 * @throws ExecutionException 
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
		// TODO Auto-generated method stub

		List<CompletableFuture> futures = new ArrayList<>();
		futures.add(CompletableFuture.runAsync(()->{
            System.out.println("当前任务Customer,线程名字为:" + Thread.currentThread().getName());
         // orderInfo.setCustomerInfo(new CustomerInfo());
		},THREAD_POOL));
		 futures.add(CompletableFuture.runAsync(() -> {
	            System.out.println("当前任务Discount,线程名字为:" + Thread.currentThread().getName());
	            //orderInfo.setDiscountInfo(new DiscountInfo());
	        }, THREAD_POOL));
	        futures.add( CompletableFuture.runAsync(() -> {
	            System.out.println("当前任务Food,线程名字为:" + Thread.currentThread().getName());
	          //  orderInfo.setFoodListInfo(new FoodListInfo());
	        }, THREAD_POOL));
	        futures.add(CompletableFuture.runAsync(() -> {
	            System.out.println("当前任务Other,线程名字为:" + Thread.currentThread().getName());
	           // orderInfo.setOtherInfo(new OtherInfo());
	        }, THREAD_POOL));
	        
	        CompletableFuture<?> allDoneFuture = CompletableFuture.allOf(
	        		futures.toArray(new CompletableFuture[futures.size()]));
	        allDoneFuture.get(10,TimeUnit.SECONDS);
	        System.out.println("主线程 : "+Thread.currentThread().getName());
	}

}

3.3 Fork/Join


/**
 * @author lmc
 * @Email huyang@126.com
 * @date 2018年10月11日
 * 
 * 3.3 Fork/Join
 */
/*我们上面用CompletableFuture完成了我们对多组任务并行执行，但是其依然是依赖我们的线程池，在我们的线程池中使用的是阻塞队列，
 * 也就是当我们某个线程执行完任务的时候需要通过这个阻塞队列进行，
 * 那么肯定会发生竞争，所以在JDK1.7中提供了ForkJoinTask和ForkJoinPool。
 *  Fork/Join 框架就是必要情况下。将一个大任务，进行拆分fork成若干个小任务，再将每个小任务运行结棍join汇总
 * */

	public class ForkJoinPoolTask extends RecursiveTask{
	    @Override
	    protected ForkJoinPoolTask compute() {
	        System.out.println("执行"+ this.getClass().getSimpleName() + "线程名字为:" + Thread.currentThread().getName());
	        // 定义其他五种并行TasK
	        CustomerTask customerTask = new CustomerTask();
	        TenantTask tenantTask = new TenantTask();
	        DiscountTask discountTask = new DiscountTask();
	        FoodTask foodTask = new FoodTask();
	        OtherTask otherTask = new OtherTask();
	        invokeAll(customerTask, tenantTask, discountTask, foodTask, otherTask);
	       // OrderInfo orderInfo = new OrderInfo(customerTask.join(), tenantTask.join(), discountTask.join(), foodTask.join(), otherTask.join());
	        return null;
	    }
	    public static void main(String[] args) {
	        ForkJoinPool forkJoinPool = new ForkJoinPool(Runtime.getRuntime().availableProcessors() -1 );
	        System.out.println(forkJoinPool.invoke(new ForkJoinPoolTask()));
	    }
	}
	class CustomerTask extends RecursiveTask{

	    @Override
	    protected CustomerTask compute() {
	        System.out.println("执行"+ this.getClass().getSimpleName() + "线程名字为:" + Thread.currentThread().getName());
	        return new CustomerTask();
	    }
	}
	class TenantTask extends RecursiveTask{

	    @Override
	    protected TenantTask compute() {
	        System.out.println("执行"+ this.getClass().getSimpleName() + "线程名字为:" + Thread.currentThread().getName());
	        return new TenantTask();
	    }
	}
	class DiscountTask extends RecursiveTask{

	    @Override
	    protected DiscountTask compute() {
	        System.out.println("执行"+ this.getClass().getSimpleName() + "线程名字为:" + Thread.currentThread().getName());
	        return new DiscountTask();
	    }
	}
	class FoodTask extends RecursiveTask{

	    @Override
	    protected FoodTask compute() {
	        System.out.println("执行"+ this.getClass().getSimpleName() + "线程名字为:" + Thread.currentThread().getName());
	        return new FoodTask();
	    }
	}
	class OtherTask extends RecursiveTask{

	    @Override
	    protected OtherTask compute() {
	        System.out.println("执行"+ this.getClass().getSimpleName() + "线程名字为:" + Thread.currentThread().getName());
	        return new OtherTask();
	    }
	    
/*	    我们定义一个OrderTask并且定义五个获取信息的任务，在compute中分别fork执行这五个任务，
	    最后在将这五个任务的结果通过Join获得，最后完成我们的并行化的需求。*/
	    
}

 

详情参考如下，理解得非常好 多谢分享

https://mp.weixin.qq.com/s?__biz=MzAxODcyNjEzNQ==&mid=2247485960&idx=1&sn=dc412caef5aa1e8a46eb8cadc760aa47&chksm=9bd0a790aca72e8677505a7a72bd8a47ff191c8c99db3b5299f882f3b09847a27239f14ee0ee&scene=0#rd

 

大树168
关注
C#实现控制线程池最大数并发线程
09-01
在处理高并发任务时，合理控制线程池中的并发线程数量至关重要，以确保系统资源得到充分利用，同时避免过度消耗导致性能瓶颈或崩溃。 在标题和描述中提到的场景，我们需要实现一个功能，即限制线程池中并发执行的...
Java高并发核心编程(JUC)—线程池详细笔记
Cheney的博客
05-22 1187
线程池：一个容纳多个线程的容器，容器中的线程可以重复使用，省去了频繁创建和销毁线程对象的操作降低资源消耗，减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务提高响应速度，当任务到达时，如果有线程可以直接用，不会出现系统僵死提高线程的可管理性，如果无限制的创建线程，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控线程复用，同一个线程可以被重复使用，来处理多个任务。
高并发之线程池
明天
07-27 1056
1.如何实现高并发？ 硬件资源 磁盘，网卡，内存，cpu 软件 cpu->线程 i/o->
多线程与高并发--------线程池
weixin_43875870的博客
08-12 1968
首先ThreadPoolExecutor中，一共提供了7个参数，每个参数都是非常核心的属性，在线程池去执行任务时，每个参数都有决定性的作用。 但是如果直接采用JDK提供的方式去构建，可以设置的核心参数最多就两个，这样就会导致对线程池的控制粒度很粗。所以在阿里规范中也推荐自己去自定义线程池。手动的去new ThreadPoolExecutor设置他的一些核心属性。
Java开发之高并发必备篇（七）——线程池
成都汇智动力的博客
11-02 587
总结：在真实开发中我们需要按照我们的业务需要选择合适的线程池，如果要执行时间短但是任务比较多那么就选择newCachedThreadPool数量不限制的可缓存线程池，如果我们执行任务时间长消耗资源那么我们需要选择newFixedThreadPool这种固定长度的线程池合理控制资源消耗，如果我们执行的任务需要按照顺序执行那么我们需要使用newSingleThreadExecutor，如果我们有延时执行的任务或者周期性执行的任务那么我们需要选择newScheduledThreadPool。
Java高并发——线程池
guzhipeng的博客
05-19 1150
文章目录ExecutorExecutorServiceScheduledExecutorServiceAbstractExecutorServiceFutureFutureTaskThreadPoolExecutor参数描述常用方法Executors 在以前创建线程的方式： 创建并继承Thread类 实现Runnable接口 实现Callable接口 通过以上述方式我们创建线程很方便，但也存在很多弊端： 每次new Thread都会新建一个线程，而频繁创建会大大降低系统性能。因为创建、销毁线程均需要时
java并发编程_线程池的使用方法(详解)
08-30
java并发编程_线程池的使用方法 java并发编程中，线程池是一种非常重要的概念，它可以帮助我们更好地管理线程，提高程序的性能和可扩展性。下面我们将详细介绍java线程池的使用方法。 一、任务和执行策略之间的...
并发容器和线程池，java并发编程3
最新发布
04-29
- **高性能**：通过分段锁技术实现高并发下的高效访问。 ##### 1.3 ConcurrentLinkedQueue `ConcurrentLinkedQueue`是一个基于链接节点的无界线程安全队列，它遵循先进先出(FIFO)原则。队列的插入操作发生在队列的...
并发－线程池和阻塞队列.pdf
10-17
并发编程在现代软件开发中起着关键作用，尤其是在需要高吞吐量和快速响应的场合。线程池和阻塞队列是实现并发的关键组件之一。本文将详细介绍线程池原理、使用场景及注意事项，以及阻塞队列的相关知识。 首先，...
Socket通讯解决并发采用线程池
02-29
当面临高并发场景时，单纯地使用线程处理每个请求可能会导致资源浪费和性能瓶颈。因此，采用线程池来优化Socket并发通信是常见的解决方案。 线程池是一种多线程编程中的管理策略，它允许预先创建一定数量的线程，...
Java高级技术第五章——高并发之线程池
技术笔记
04-23 5432
前言 前言点击此处查看: http://blog.csdn.net/wang7807564/article/details/79113195 线程池 线程的开启和回收是要消耗系统性能的，对于大量使用线程的场景，使用线程池来进行管理，实现单个线程的复用，提高并发效率。 Callable 对Runnable进行了扩展，相对于Runnable接口,Callable的调用是可以有返回值的。...
【用C语言实现线程池】
qq_43899283的博客
04-27 6193
用C语言实现线程池线程池原理线程池的组成结构任务队列工作的线程管理者线程代码实现 线程池原理   我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。   那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务呢？   线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启
高并发、任务执行时间短的业务怎样使用线程池？并发不高、任务执行时间长的业务怎样使用线程池？并发高、业务执行时间长的业务怎样使用线程池？
Java
03-04 1177
这是我在并发编程网上看到的一个问题，希望每个人都能看到并且思考一下，因为这个问题非常好、非 常实际、非常专业。关于这个问题，个人看法是： 1、高并发、任务执行时间短的业务，线程池线程数可以设置为CPU核数+1，减少线程上下文的切换 2、并发不高、任务执行时间长的业务要区分开看： 假如是业务时间长集中在IO操作上，也就是IO密集型的任务，因为IO操作并不占用CPU，所以不要 让所有的CPU闲下来，可以加大线程池中的线程数目，让CPU处理更多的业务 假如是业务时间长集中在计算操作上，也就
Java高并发编程：线程池
JackChan
10-24 9062
笔记摘要这里首先介绍了java5中的并发的小工具包：automatic，然后介绍了线程池的概念，对使用java5的方式创建不同形式的线程进行了演示，之后介绍了两个 对象：Callable和Future，用于获取线程执行后的结果，对于线程锁技术则在另外一篇文章中介绍。Java5中的线程并发库都在java.util.concurrent包及子包中java.util.concurrent.atomic包：
线程池处理高并发请求
xiaoyi52的专栏
06-01 8107
背景：本系统会在每个月特定时间接收上游系统发起的大量请求并进行处理，并将处理结果通过主动回调或提供查询接口的方式反馈给上游系统。
Java多线程编程-（7）-使用线程池实现线程的复用和一些坑的避免
热门推荐
徐刘根的博客
10-16 1万+
前几篇： Java多线程编程-（1）-线程安全和锁Synchronized概念 Java多线程编程-（2）-可重入锁以及Synchronized的其他基本特性 Java多线程编程-（3）-线程本地ThreadLocal的介绍与使用 Java多线程编程-（4）-线程间通信机制的介绍与使用 Java多线程编程-（5）-使用Lock对象实现同步以及线程间通信 Java多线程编程-（6）-两种...
并发编程之线程池的使用及扩展和优化
ignore
01-04 1954
前言多线程的软件设计方法确实可以最大限度的发挥现代多核处理器的计算能力，提高生产系统的吞吐量和性能。但是，如果一个系统同时创建大量线程，线程间频繁的切换上下文导致的系统开销将会拖慢整个系统。严重的甚至导致内存耗尽导致OOM异常。因此，在实际的生产环境中，线程的数量必须得到控制，盲目的创建大量新车对系统是有伤害的。那么，怎么才能最大限度的利用CPU的性能，又能保持系统的稳定性呢？其中有一个方法就是使用
Java高并发编程探索：线程池与源码分析
本书针对高并发编程进行了深入探讨，旨在帮助读者理解和掌握在Java环境中处理并发问题的方法。 书中首先提出了一个问题：程序员是否需要阅读源码。作者认为理解源码对于深入学习并发编程至关重要，因为这有助于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值