ThreadPoolExecutor组合使用synchronized关键字

最新推荐文章于 2023-06-13 15:40:51 发布
最新推荐文章于 2023-06-13 15:40:51 发布
阅读量726 收藏
点赞数
分类专栏： # Java学习 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Vermont_/article/details/119040201
版权

未加synchronized关键字：

package com.allen.thread;

import java.util.concurrent.*;

/**
 * @author ：jhys
 * @date ：Created in 2021/7/23 16:33
 * @Description ：
 */
public class SynchronizedTest {

    public static void main(String[] args) {
        // 创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象
        RunTask task = new RunTask();
        // 使用ThreadPoolExecutor手动创建线程池，coreThreadPoolSize设置为20, 一次性启动20个线程来执行提交的100个任务
        ExecutorService pool = new ThreadPoolExecutor(20, 100, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingDeque<>(1000));

        for (int i = 0; i < 100; i++) {
            pool.submit(new Thread(task));
        }
    }

}

/**
 * 实现Runnable接口
 */
class RunTask implements Runnable {
    private int i = 100;

    @Override
    public  void run() {
        try {
            if (i > 0) {
                i--;
                System.out.println(i + " "+ Thread.currentThread().getName());
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

结果：

97 pool-1-thread-2
96 pool-1-thread-4
97 pool-1-thread-3
97 pool-1-thread-1
95 pool-1-thread-6
94 pool-1-thread-5
93 pool-1-thread-7
92 pool-1-thread-10
91 pool-1-thread-9
90 pool-1-thread-8
89 pool-1-thread-11
88 pool-1-thread-12
87 pool-1-thread-13
86 pool-1-thread-14
85 pool-1-thread-15
84 pool-1-thread-16
83 pool-1-thread-17
82 pool-1-thread-18
81 pool-1-thread-2
80 pool-1-thread-1
79 pool-1-thread-1
77 pool-1-thread-4
78 pool-1-thread-3
71 pool-1-thread-9
68 pool-1-thread-11
69 pool-1-thread-3
66 pool-1-thread-3
65 pool-1-thread-17
61 pool-1-thread-2
70 pool-1-thread-8
72 pool-1-thread-10
73 pool-1-thread-4
74 pool-1-thread-5
75 pool-1-thread-6
76 pool-1-thread-1
46 pool-1-thread-6
47 pool-1-thread-5
48 pool-1-thread-4
49 pool-1-thread-14
50 pool-1-thread-16
51 pool-1-thread-17
52 pool-1-thread-10
38 pool-1-thread-10
53 pool-1-thread-7
55 pool-1-thread-11
54 pool-1-thread-8
56 pool-1-thread-9
34 pool-1-thread-8
57 pool-1-thread-2
58 pool-1-thread-13
59 pool-1-thread-12
60 pool-1-thread-20
62 pool-1-thread-19
63 pool-1-thread-18
64 pool-1-thread-3
67 pool-1-thread-15
25 pool-1-thread-3
26 pool-1-thread-18
27 pool-1-thread-19
28 pool-1-thread-20
29 pool-1-thread-12
19 pool-1-thread-12
30 pool-1-thread-13
31 pool-1-thread-2
32 pool-1-thread-8
33 pool-1-thread-9
35 pool-1-thread-11
13 pool-1-thread-11
36 pool-1-thread-7
11 pool-1-thread-7
37 pool-1-thread-10
39 pool-1-thread-17
40 pool-1-thread-16
7 pool-1-thread-16
41 pool-1-thread-14
42 pool-1-thread-4
43 pool-1-thread-5
44 pool-1-thread-6
45 pool-1-thread-1
2 pool-1-thread-6
3 pool-1-thread-5
4 pool-1-thread-4
5 pool-1-thread-14
6 pool-1-thread-16
8 pool-1-thread-17
9 pool-1-thread-10
10 pool-1-thread-7
12 pool-1-thread-11
14 pool-1-thread-9
15 pool-1-thread-8
16 pool-1-thread-2
17 pool-1-thread-13
18 pool-1-thread-12
20 pool-1-thread-20
21 pool-1-thread-19
22 pool-1-thread-18
23 pool-1-thread-3
24 pool-1-thread-15
0 pool-1-thread-6
1 pool-1-thread-1

打印结果完全错乱，因为没有使用同步锁！

加入synchronized关键字：

package com.allen.thread;

import java.util.concurrent.*;

/**
 * @author ：jhys
 * @date ：Created in 2021/7/23 16:33
 * @Description ：
 */
public class SynchronizedTest {

    public static void main(String[] args) {
        // 创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象
        RunTask task = new RunTask();
        // 使用ThreadPoolExecutor手动创建线程池，coreThreadPoolSize设置为20, 一次性启动20个线程来执行提交的100个任务
        ExecutorService pool = new ThreadPoolExecutor(20, 100, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingDeque<>(1000));

        for (int i = 0; i < 100; i++) {
            pool.submit(new Thread(task));
        }
        pool.shutdown();
    }

}

/**
 * 实现Runnable接口
 */
class RunTask implements Runnable {
    private int i = 100;

    @Override
    public synchronized void run() {
        try {
            if (i > 0) {
                i--;
                System.out.println(i + " "+ Thread.currentThread().getName());
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

或者：

package com.allen.thread;

import java.util.concurrent.*;

/**
 * @author ：jhys
 * @date ：Created in 2021/7/23 16:33
 * @Description ：
 */
public class SynchronizedTest {

    public static void main(String[] args) {
        // 创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象
        RunTask task = new RunTask();
        // 使用ThreadPoolExecutor手动创建线程池，coreThreadPoolSize设置为20, 一次性启动20个线程来执行提交的100个任务
        ExecutorService pool = new ThreadPoolExecutor(20, 100, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingDeque<>(1000));

        for (int i = 0; i < 100; i++) {
            pool.submit(new Thread(task));
        }
        pool.shutdown();
    }

}

/**
 * 实现Runnable接口
 */
class RunTask implements Runnable {
    private int i = 100;

    @Override
    public  void run() {
        synchronized (this) {
            try {
                if (i > 0) {
                    i--;
                    System.out.println(i + " "+ Thread.currentThread().getName());
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

或者：

package com.allen.thread;

import java.util.concurrent.*;

/**
 * @author ：jhys
 * @date ：Created in 2021/7/23 16:33
 * @Description ：
 */
public class SynchronizedTest {

    public static void main(String[] args) {
        // 创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象
        RunTask task = new RunTask();
        // 使用ThreadPoolExecutor手动创建线程池，coreThreadPoolSize设置为20, 一次性启动20个线程来执行提交的100个任务
        ExecutorService pool = new ThreadPoolExecutor(20, 100, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingDeque<>(1000));

        for (int i = 0; i < 100; i++) {
            pool.submit(new Thread(task));
        }
        pool.shutdown();
    }

}

/**
 * 实现Runnable接口
 */
class RunTask implements Runnable {
    Object lock = new Object();
    private int i = 100;

    @Override
    public  void run() {
        synchronized (lock) {
            try {
                if (i > 0) {
                    i--;
                    System.out.println(i + " "+ Thread.currentThread().getName());
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

或者：

package com.allen.thread;

import java.util.concurrent.*;

/**
 * @author ：jhys
 * @date ：Created in 2021/7/23 16:33
 * @Description ：
 */
public class SynchronizedTest {

    public static void main(String[] args) {
        // 创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象
        RunTask task = new RunTask();
        // 使用ThreadPoolExecutor手动创建线程池，coreThreadPoolSize设置为20, 一次性启动20个线程来执行提交的100个任务
        ExecutorService pool = new ThreadPoolExecutor(20, 100, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingDeque<>(1000));

        for (int i = 0; i < 100; i++) {
            pool.submit(new Thread(task));
        }
        pool.shutdown();
    }

}

/**
 * 实现Runnable接口
 */
class RunTask implements Runnable {
    Object lock = new Object();
    private int i = 100;

    @Override
    public  void run() {
        synchronized (RunTask.class) {
            try {
                if (i > 0) {
                    i--;
                    System.out.println(i + " "+ Thread.currentThread().getName());
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

上述写法都能实现同步，结果如下，

99 pool-1-thread-1
98 pool-1-thread-4
97 pool-1-thread-6
96 pool-1-thread-3
95 pool-1-thread-2
94 pool-1-thread-8
93 pool-1-thread-7
92 pool-1-thread-5
91 pool-1-thread-10
90 pool-1-thread-9
89 pool-1-thread-11
88 pool-1-thread-12
87 pool-1-thread-13
86 pool-1-thread-14
85 pool-1-thread-15
84 pool-1-thread-16
83 pool-1-thread-17
82 pool-1-thread-18
81 pool-1-thread-19
80 pool-1-thread-20
79 pool-1-thread-1
78 pool-1-thread-2
77 pool-1-thread-7
76 pool-1-thread-9
75 pool-1-thread-12
74 pool-1-thread-13
73 pool-1-thread-8
72 pool-1-thread-1
71 pool-1-thread-9
70 pool-1-thread-16
69 pool-1-thread-3
68 pool-1-thread-6
67 pool-1-thread-4
66 pool-1-thread-3
65 pool-1-thread-6
64 pool-1-thread-9
63 pool-1-thread-16
62 pool-1-thread-14
61 pool-1-thread-20
60 pool-1-thread-8
59 pool-1-thread-12
58 pool-1-thread-15
57 pool-1-thread-1
56 pool-1-thread-19
55 pool-1-thread-18
54 pool-1-thread-13
53 pool-1-thread-17
52 pool-1-thread-11
51 pool-1-thread-7
50 pool-1-thread-7
49 pool-1-thread-7
48 pool-1-thread-7
47 pool-1-thread-10
46 pool-1-thread-5
45 pool-1-thread-2
44 pool-1-thread-5
43 pool-1-thread-10
42 pool-1-thread-10
41 pool-1-thread-10
40 pool-1-thread-7
39 pool-1-thread-11
38 pool-1-thread-17
37 pool-1-thread-13
36 pool-1-thread-18
35 pool-1-thread-19
34 pool-1-thread-1
33 pool-1-thread-15
32 pool-1-thread-12
31 pool-1-thread-12
30 pool-1-thread-8
29 pool-1-thread-20
28 pool-1-thread-20
27 pool-1-thread-20
26 pool-1-thread-20
25 pool-1-thread-20
24 pool-1-thread-20
23 pool-1-thread-20
22 pool-1-thread-20
21 pool-1-thread-20
20 pool-1-thread-20
19 pool-1-thread-20
18 pool-1-thread-14
17 pool-1-thread-16
16 pool-1-thread-9
15 pool-1-thread-6
14 pool-1-thread-3
13 pool-1-thread-4
12 pool-1-thread-8
11 pool-1-thread-12
10 pool-1-thread-15
9 pool-1-thread-1
8 pool-1-thread-19
7 pool-1-thread-18
6 pool-1-thread-13
5 pool-1-thread-17
4 pool-1-thread-11
3 pool-1-thread-7
2 pool-1-thread-10
1 pool-1-thread-5
0 pool-1-thread-2

Allen Chou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
并发编程 - 线程池ThreadPoolExecutor、自定义实现线程池、定时任务、并发安全
weixin_42666318的博客
05-05 616
为什么要使用线程池？ 在Java中，创建一个线程只需要通过 new Thread()，就可以创建一个线程。那么创建一个线程需要经历以下几个步骤： 1、创建（T1：向操作系统申请内存） 2、运行（T2：执行run方法中业务） 3、销毁（T3：销毁当前线程并释放资源） 所以，在每一次new出一个线程需要消耗的时间为T1+T2+T3，可以发现，只有运行的业务不同，其他时间都不属于业务处理时间，因此...
使用future机制和对象锁实现SynchronizedExecutor
weixin_44627989的博客
03-27 388
title: 使用future机制和对象锁实现SynchronizedExecutor 欢迎查看Eetal的第九篇博客–使用future机制和对象锁实现SynchronizedExecutor future future代表一个任务的预执行结果，通过get方法获取执行结果 public interface Future<V> { V get() throws Exception...
线程池ThreadPoolExecutor使用简介与方法实例
08-26
今天小编就为大家分享一篇关于线程池ThreadPoolExecutor使用简介与方法实例，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
Java线程池ThreadPoolExecutor原理及使用实例
08-19
主要介绍了Java线程池ThreadPoolExecutor原理及使用实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
ThreadPoolExecutor线程池的使用方法
08-25
主要为大家详细介绍了ThreadPoolExecutor线程池的使用方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java ThreadPoolExecutor 线程池的使用介绍
08-26
Executors 是一个Java中的工具类. 提供工厂方法来创建不同类型的线程池，这篇文章主要介绍了Java ThreadPoolExecutor 线程池的使用介绍，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
第一次使用ThreadPoolTaskExecutor实现线程池的经历，反复修改了多次代码才正常使用
向心行者
06-13 3136
在一个向第三方平台推送消息的场景中，为了提高程序的执行效率，每次发送消息，都创建一个新的线程来完成发送消息的任务，为了提供线程的使用性能，我选择了ThreadPoolTaskExecutor线程池，结果在使用的过程中，出现了较多的问题，这里记录一下避免以后再出现类似的错误（这些错误是不应该出现的，还是对ThreadPoolTaskExecutor使用不熟悉造成的）。
Java中Synchronized的使用
qinming的博客
03-20 222
Synchronized是Java语言的关键字，可以使用它来修饰方法或者代码块，Synchronized能够保证被它修饰的方法或代码块在同一时刻最多只有一个线程执行该段代码，这里我将介绍由它来分别修饰静态方法，示例方法，以及代码块是如何使用的。 1、修饰静态方法 Synchronized修饰静态方法它的锁就是当前的class对象，那么如果当该类有多个Synchronized修饰的静态方法时，一次只有一个线程能执行其中的一个Synchronized修饰的静态方法，同时Synchronized还是可重入锁.
多线程的基础知识
qq_67092012的博客
08-07 145
对线程以及线程池一点知识的梳理
线程池ThreadPoolTaskExecutor配置说明
菜鸟学院
10-21 2373
一般实际开发中经常用到多线程，所以需要使用线程池了， ThreadPoolTaskExecutor通常通过XML方式配置，或者通过Executors的工厂方法进行配置。 　XML方式配置代码如下：交给spring来管理； rejectedExecutionHandler字段用于配置拒绝策略，常用的拒绝策略如下： AbortPolicy，用于被拒绝任务的处理...
js 2020常见面试题
m0_49016709的博客
09-29 1087
介绍一下 js 的数据类型有哪些,值是如何存储的 具体可看我之前的文章：「前端料包」可能是最透彻的JavaScript数据类型详解 JavaScript一共有8种数据类型，其中有7种基本数据类型：Undefined、Null、Boolean、Number、String、Symbol（es6新增，表示独一无二的值）和BigInt（es10新增）； 1种引用数据类型——Object（Object本质上是由一组无序的名值对组成的）。里面包含 function、Array、Date等。JavaScript不支持.
ThreadPoolTaskExecutor遇到的坑
热门推荐
p7+的博客
11-12 2万+
在利用org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor实现请求的慢处理时，我的配置中核心线程数为5，最大线程数为10，但是代码中创建了8个队列放在线程池中，假如我用id去hash取模，得到队列集合下标，从队列集合中队列，此时就会出现8个队列中，每个队列都有数据，但只有前5个队列中的请求被处理，后3个队列的请求被搁置。 ...
java ThreadPoolExecutor使用方法简单介绍
08-31
主要介绍了java ThreadPoolExecutor使用方法简单介绍的相关资料,需要的朋友可以参考下
SpringBoot定时任务@Scheduled的多线程使用
Java技术攻略的博客
04-23 1196
Scheduled是Spring框架中的一个注解，它可以用于配置定时任务，使得方法可以按照规定的时间间隔定时执行。在使用该注解时，我们可以指定任务的执行时间、循环周期、并发数等参数，从而实现定时任务的功能。在Spring Boot中，@Scheduled注解可以直接应用于方法上。通过以上的分析，我们可以了解到：虽然@Scheduled注解能够非常方便地实现定时任务的功能，但是它也存在一些多线程的问题。为此，需要注意到这些问题，并采取相应的措施来避免它们的出现。
ThreadPoolTaskExecutor
谭倩倩
02-17 2806
Spring 擅长对组件的封装和集成， Spring-context对JDK的并发包做了功能增强。  Java代码   "asyncTaskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">       "corePoolSize" value="10"
ThreadPoolExecutor线程池的使用和总结
qq_38634142的博客
06-02 472
未完待续
ThreadPool 线程池的使用
原名：@程序员大禹
09-15 1792
一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。（摘抄自百度百科什么是线程池）
java多线程基础 之synchronized和线程池
u012919352的博客
03-06 632
线程安全问题的主要诱因 存在共享数据（也称为临界资源）； 存在多条线程共同操作这些共享数据； 解决问题的根本方法    同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再对共享数据进行操作。 互斥锁的特性 互斥性 即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程的协调机制，这样在同一时间只有一个线程对需要同步的代码块（复合操作）进行访问。互斥性也称为...
线程池(ThreadPoolExecutor)、Executors线程池工具类、volatile关键字、Lock与synchronized的区别
weixin_56674682的博客
10-31 400
线程池(ThreadPoolExecutor) 顶级接口Executor: 定义了execute(Runnbale command)接口 子接口ExecutorService 最常用实现类:ThreadPoolExecutor 1.构造器讲解 调用构造器并不会马上创建线程，当调用execute方法时才会去创建线程。类似于延时加载 corePoolSize：核心线程数 maximumPoolSize：最大线程数 keepAlivTime：临...
CompletableFuture和ThreadPoolExecutor组合
最新发布
07-29
CompletableFuture和ThreadPoolExecutor的组合是一种常见的方式，用于在异步编程中执行并发任务并处理结果。 CompletableFuture是Java 8引入的一个类，用于支持异步编程和任务组合。它提供了一组方法来执行异步操作，并在操作完成时处理结果。ThreadPoolExecutor是Java提供的一个线程池实现，用于管理和执行线程。 使用CompletableFuture和ThreadPoolExecutor的组合，你可以将任务提交给线程池进行并发执行，并使用CompletableFuture来处理任务的结果。下面是一个简单的示例： ```java import java.util.concurrent.CompletableFuture; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; public class CompletableFutureWithThreadPoolExample { public static void main(String[] args) { // 创建一个线程池 ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(5); // 提交任务给线程池执行，并返回CompletableFuture对象 CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> { // 执行耗时操作 return "Task Result"; }, executor); // 处理任务结果 future.thenAccept(result -> { System.out.println("Task Result: " + result); // 执行其他操作 }); // 关闭线程池 executor.shutdown(); } } ``` 在上面的示例中，我们创建了一个线程池，并使用`supplyAsync()`方法将任务提交给线程池进行异步执行。然后，我们使用`thenAccept()`方法来处理任务的结果。最后，我们关闭了线程池。 通过这种方式，你可以同时执行多个任务，并在任务完成时处理它们的结果。你还可以使用CompletableFuture的其他方法来进行任务组合、异常处理等操作。 希望这个示例对你有所帮助！如果你还有其他问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值