Java 定制并发类 详解

最新推荐文章于 2021-03-06 06:53:40 发布
最新推荐文章于 2021-03-06 06:53:40 发布
阅读量249 收藏
点赞数
分类专栏： Java 文章标签： 并发 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenshun123/article/details/78067871
版权
可以基于 Java提供类和接口来实现定制并发工具

定制 ThreadPoolExecutor类

public class SleepTwoSecondsTask implements Callable<String> {
    @Override
    public String call() throws Exception {
        TimeUnit. SECONDS .sleep( 2 );
        return new Date().toString();
    }
}

public class MyExecutor extends ThreadPoolExecutor {
    private ConcurrentHashMap<String, Date> startTimes ;
    public MyExecutor( int corePoolSize, int maximunPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super (corePoolSize, maximunPoolSize, keepAliveTime, unit, workQueue);
        startTimes = new ConcurrentHashMap<>();
    }
    @Override
    public void shutdown() {
        System. out .printf( "MyExecutor: Going to shutdown. \n " );
        System. out .printf( "MyExecutor: Executed tasks:%d \n " , getCompletedTaskCount());
        System. out .printf( "MyExecutor: Running tasks:%d \n " , getActiveCount());
        System. out .printf( "MyExecutor: Pending tasks:5d \n " , getQueue().size());
        super .shutdown();
    }
    @Override
    public List<Runnable> shutdownNow() {
        System. out .printf( "MyExecutor: Going to immediately shutdown. \n " );
        System. out .printf( "MyExecutor: Executed tasks:%d \n " , getCompletedTaskCount());
        System. out .printf( "MyExecutor: Running tasks:%d \n " , getActiveCount());
        System. out .printf( "MyExecutor: Pending tasks:5d \n " , getQueue().size());
        return super .shutdownNow();
    }
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        System. out .printf( "MyExecutor: A task is beginning: %s : %s \n " , t.getName(), r.hashCode());
        startTimes .put(String. valueOf (r.hashCode()), new Date());
    }
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        Future<?> result = (Future<?>) r;
        try {
            System. out .printf( "******************************* \n " );
            System. out .printf( "MyExecutor: A task is finishing. \n " );
            System. out .printf( "MyExecutor: Result: %s \n " , result.get());
            Date startDate = startTimes .remove(String. valueOf (r.hashCode()));
            Date finishDate = new Date();
            long diff = finishDate.getTime() - startDate.getTime();
            System. out .printf( "MyExecutor: Duration: %d \n " , diff);
            System. out .printf( "******************************* \n " );
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        MyExecutor myExecutor = new MyExecutor( 2 , 4 , 1000 , TimeUnit. MILLISECONDS , new LinkedBlockingDeque<>());
        List<Future<String>> results = new ArrayList<>();
        for ( int i = 0 ; i < 10 ; i++) {
            SleepTwoSecondsTask task = new SleepTwoSecondsTask();
            Future<String> result = myExecutor.submit(task);
            results.add(result);
        }
        try {
            for ( int i = 0 ; i < 5 ; i++) {
                String result = results.get(i).get();
                System. out .printf( "Main: Result for Task %d : %s \n " , i, result);
            }
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        myExecutor.shutdown();
        try {
            for ( int i = 5 ; i < 10 ; i++) {
                String result = results.get(i).get();
                System. out .printf( "Main: Result for Task %d : %s \n " , i, result);
            }
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        try {
            myExecutor.awaitTermination( 1 , TimeUnit. DAYS );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System. out .printf( "Main: End of the program. \n " );
    }
}


基于优先级的 Executor类

public class MyPriorityTask implements Runnable, Comparable<MyPriorityTask> {
    private int priority ;
    private String name ;
    public MyPriorityTask( int priority, String name) {
        this . priority = priority;
        this . name = name;
    }
    public int getPriority() {
        return priority ;
    }
    @Override
    public int compareTo(MyPriorityTask o) {
        if ( this . priority < o.getPriority()) {
            return 1 ;
        } else if ( this . priority > o.getPriority()) {
            return - 1 ;
        }
        return 0 ;
    }
    @Override
    public void run() {
        System. out .printf( "MyPriorityTask: %s Priority : %d \n " , name , priority );
        try {
            TimeUnit. SECONDS .sleep( 2 );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor( 2 , 2 , 1 ,
                TimeUnit. SECONDS , new PriorityBlockingQueue<Runnable>());
        for ( int i = 0 ; i < 4 ; i++) {
            MyPriorityTask task = new MyPriorityTask(i, "Task " + i);
            executor.execute(task);
        }
        try {
            TimeUnit. SECONDS .sleep( 1 );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for ( int i = 4 ; i < 8 ; i++) {
            MyPriorityTask task = new MyPriorityTask(i, "Task " + i);
            executor.execute(task);
        }
        executor.shutdown();
        try {
            executor.awaitTermination( 1 , TimeUnit. DAYS );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System. out .printf( "Main: End of the program. \n " );
    }
}

ThreadFactory 接口生成定制线程

public class MyTask implements Runnable {
    @Override
    public void run() {
        try {
            TimeUnit. SECONDS .sleep( 2 );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MyThread extends Thread {
    private Date creationDate ;
    private Date startDate ;
    private Date finishDate ;
    public MyThread(Runnable target, String name) {
        super (target, name);
        setCreationDate();
    }
    @Override
    public void run() {
        setStartDate();
        super .run();
        setFinishDate();
    }
    public void setCreationDate() {
        creationDate = new Date();
    }
    public void setStartDate() {
        startDate = new Date();
    }
    public void setFinishDate() {
        finishDate = new Date();
    }
    public long getExecutionTime() {
        return finishDate .getTime() - startDate .getTime();
    }
    @Override
    public String toString() {
        StringBuffer buffer = new StringBuffer();
        buffer.append(getName()).append( ": " )
                .append( " Creation date: " ).append( creationDate )
                .append( " : Running time: " ).append(getExecutionTime())
                .append( " Milliseconds." );
        return buffer.toString();
    }
}

public class MyThreadFactory implements ThreadFactory {
    private int counter ;
    private String prefix ;
    public MyThreadFactory(String prefix) {
        this . prefix = prefix;
        counter = 1 ;
    }
    @Override
    public Thread newThread(Runnable r) {
        MyThread myThread = new MyThread(r, prefix + "-" + counter );
        counter ++;
        return myThread;
    }
    public static void main(String[] args) throws InterruptedException {
        MyThreadFactory myFactory = new MyThreadFactory( "MyThreadFactory" );
        MyTask task = new MyTask();
        Thread thread = myFactory.newThread(task);

        thread.start();
        thread.join();
        System. out .printf( "Main: Thread information. \n " );
        System. out .printf( "%s \n " , thread);
        System. out .printf( "Main: End of example. \n " );
    }
}

定制运行在定时线程池中的任务

public class Task implements Runnable {
    @Override
    public void run() {
        System. out .printf( "Task: Begin. \n " );
        try {
            TimeUnit. SECONDS .sleep( 2 );
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System. out .printf( "Task: End. \n " );
    }
}

public class MyScheduledTask< V > extends FutureTask< V > implements RunnableScheduledFuture< V > {
    private RunnableScheduledFuture< V > task ;
    private ScheduledThreadPoolExecutor executor ;
    private long period ;
    private long startDate ;
    public MyScheduledTask(Runnable runnable, V result, RunnableScheduledFuture< V > task , ScheduledThreadPoolExecutor executor) {
        super (runnable, result);
        this . task = task;
        this . executor = executor;
    }
    @Override
    public long getDelay(TimeUnit unit) {
        if (!isPeriodic()) {
            return task .getDelay(unit);
        } else {
            if ( startDate == 0 ) {
                return task .getDelay(unit);
            } else {
                Date now = new Date();
                long delay = startDate - now.getTime();
                return unit.convert(delay, TimeUnit. MILLISECONDS );
            }
        }
    }
    @Override
    public int compareTo(Delayed o) {
        return task .compareTo(o);
    }
    @Override
    public boolean isPeriodic() {
        return task .isPeriodic();
    }
    @Override
    public void run() {
        if (isPeriodic() && ! executor .isShutdown()) {
            Date now = new Date();
            startDate = now.getTime() + period ;
            executor .getQueue().add( this );
        }
        System. out .printf( "Pre-MyScheduledTask: %s \n " , new Date());
        System. out .printf( "MyScheduledTask: Is Periodic: %s \n " , isPeriodic());
        super .runAndReset();
        System. out .printf( "Post-MyScheduledTask: %s \n " , new Date());
    }
    public void setPeriod( long period) {
        this . period = period;
    }
}

public class MyScheduledThreadPoolExecutor extends ScheduledThreadPoolExecutor {
    public MyScheduledThreadPoolExecutor( int corePoolSize) {
        super (corePoolSize);
    }
    @Override
    protected < V > RunnableScheduledFuture< V > decorateTask(Runnable runnable, RunnableScheduledFuture< V > task) {
        return new MyScheduledTask<>(runnable, null , task, this );
    }
    @Override
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
        ScheduledFuture<?> task = super .scheduleAtFixedRate(command, initialDelay, period, unit);
        MyScheduledTask<?> myTask = (MyScheduledTask<?>) task;
        myTask.setPeriod(TimeUnit. MILLISECONDS .convert(period, unit));
        return myTask;
    }
    public static void main(String[] args) throws InterruptedException {
        MyScheduledThreadPoolExecutor executor = new MyScheduledThreadPoolExecutor( 2 );
        Task task = new Task();
        System. out .printf( "Main: %s \n " , new Date());
        executor.schedule(task, 1 , TimeUnit. SECONDS );
        TimeUnit. SECONDS .sleep( 3 );
        task = new Task();
        System. out .printf( "Main: %s \n " , new Date());
        executor.scheduleAtFixedRate(task, 1 , 3 , TimeUnit. SECONDS );
        TimeUnit. SECONDS .sleep( 10 );
        executor.shutdown();
        executor.awaitTermination( 1 , TimeUnit. DAYS );
        System. out .printf( "Main: End of the program. \n " );
    }
}

小柴的生活观
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java面试Offer直通车
12-18
【Java面试宝典】1、68讲视频课，500道大厂Java常见面试题+100个Java面试技巧与答题公式+10万字核心知识解析+授课老师1对1面试指导+无限次回放2、这门课程基于胡书敏老师8年Java面试经验，调研近百家互联网公司及面试官的问题打造而成，从筛选简历和面试官角度，给出能帮助候选人能面试成功的面试技巧。3、通过学习这门课程，你能系统掌握Java核心、数据库、Java框架、分布式组件、Java简历准备、面试实战技巧等面试必考知识点。4、知识点+项目经验案例，每一个都能做为面试的作品展现。5、本课程已经在线下的培训课程中经过实际检验，老师每次培训结束后，都能帮助同学们运用面试技巧，成功找到更好的工作。【超人气讲师】胡书敏 | 10年大厂工作经验，8年Java面试官经验，5年线下Java职业培训经验，5年架构师经验【报名须知】上课模式是什么？课程采取录播模式，课程永久有效，可无限次观看课件、课程案例代码完全开放给你，你可以根据所学知识，自行修改、优化如何开始学习？PC端：报名成功后可以直接进入课程学习移动端：CSDN 学院APP（注意不是CSDN APP哦）
Java：并发
diana7977的博客
03-26 144
并发包 1、常用的并发集合类 ConcurrentHashMap：线程安全的HashMap的实现 CopyOnWriteArrayList：线程安全且在读操作时无锁的ArrayList CopyOnWriteArraySet：基于CopyOnWriteArrayList，不添加重复元素 ArrayBlockingQueue：基于数组、先进先出、线程安全，...
JAVA高并发的三种实现
热门推荐
java_xth的博客
07-23 13万+
提到锁，大家肯定想到的是sychronized关键字。是用它可以解决一切并发问题，但是，对于系统吞吐量要求更高的话，我们这提供几个小技巧。帮助大家减小锁颗粒度，提高并发能力。 初级技巧-乐观锁 乐观锁使用的场景是，读不会冲突，写会冲突。同时读的频率远大于写。 悲观锁的实现： 悲观的认为所有代码执行都会有并发问题，所以将所有代码块都用sychronized锁住 乐观锁的实现： ...
Java 8并发包下常见的并发类_java.util.concurrent 并发包诸类概览
weixin_28807529的博客
03-06 656
java.util.concurrent 包的类都来自于 JSR-166：Concurrent Utilities，官方的描述叫做“The JSR proposes a set of medium-level utilities that provide functionality commonly needed in concurrent programs. ”。作者是大名鼎鼎的 Doug Le...
java并发之并发工具类
06-24
java并发之并发工具类，并发工具类有很多，这里主要介绍了CyclicBarrier、CountDownLatch、Semaphore、Exchanger
精通 Hibernate：Java 对象持久化技术详解(第2版).part2
06-12
　11.1.4 JDK自带的个别Java类的Hibernate映射类型 　11.1.5 使用Hibernate内置映射类型 　11.2 客户化映射类型 　11.2.1 用客户化映射类型取代Hibernate组件 　11.2.2 用UserType映射枚举类型 　11.2.3 实现...
精通 Hibernate：Java 对象持久化技术详解(第2版).part4
06-12
　11.1.4 JDK自带的个别Java类的Hibernate映射类型 　11.1.5 使用Hibernate内置映射类型 　11.2 客户化映射类型 　11.2.1 用客户化映射类型取代Hibernate组件 　11.2.2 用UserType映射枚举类型 　11.2.3 实现...
精通 Hibernate：Java 对象持久化技术详解(第2版).part3
06-12
　11.1.4 JDK自带的个别Java类的Hibernate映射类型 　11.1.5 使用Hibernate内置映射类型 　11.2 客户化映射类型 　11.2.1 用客户化映射类型取代Hibernate组件 　11.2.2 用UserType映射枚举类型 　11.2.3 实现...
精通 Hibernate：Java 对象持久化技术详解(第2版).part1.rar
06-12
　11.1.4 JDK自带的个别Java类的Hibernate映射类型 　11.1.5 使用Hibernate内置映射类型 　11.2 客户化映射类型 　11.2.1 用客户化映射类型取代Hibernate组件 　11.2.2 用UserType映射枚举类型 　11.2.3 实现...
第一章 Java常用的并发类
weixin_34301307的博客
01-08 195
注：本系列博客主要参考于《分布式Java应用：基础与实践》，林昊 著 1、常用的并发集合类 ConcurrentHashMap：线程安全的HashMap的实现 CopyOnWriteArrayList：线程安全且在读操作时无锁的ArrayList CopyOnWriteArraySet：基于CopyOnWriteArrayList，不添加重复元素 ArrayBlockingQueue...
同步类容器和并发类容器
u010634288的博客
12-26 1163
同步类容器都是线程安全的，但在某些场景下可能需要加锁来保护复合操作，复合类操作 如：迭代（反复访问原始，遍历容器中所有的元素）、跳转（根据指定的顺序找到当前元素的下一个元素）、以及条件运算。这些复合操作在多线程并发得修改容器的时候可以会表现出意外的行为，最经典的就是 ConcurrentModificationException ，原因是当容易迭代过程中，被并发的修改了内容。这是由于早期迭代器设计
java并发编程——并发容器类介绍
weixin_34179762的博客
10-08 111
2019独角兽企业重金招聘Python工程师标准>>> ...
Java并发——Java中的并发类工具
tongdanping的博客
03-18 4530
在JDK的并发包里面提供了几个非常有用的工具类：CountDwonLatch、CyclicBarrier、Semaphore、Exchanger。其中CountDwonLatch、CyclicBarrier、Semaphore工具类提供了一种并发流程控制的手段，Exchanger提供了一种在线程间交换数据的手段。一、四种并发工具类1、CountDwonLatch（闭锁）CountDwonLatch...
java并发包的类_java并发包下的类一般都有哪些？java并发包常用类
weixin_42502363的博客
02-16 1488
在java并发包下经常会有很多类供我们使用，今天我们就来看看一般常用的并发包类都有哪些吧。一、ThredPoolExecutorThredPoolExecutor这个类是基于命令模式下的一个典型线程池实现，它主要通过一些策略实现一个典型的线程池，目前我们已经知道的策略如：ThreadPoolExecutor.AbortPolicy,ThreadPoolExecutor.CallerRunsPoli...
java并发编程 之 常用并发类库使用举例
wuseyukui的专栏
11-03 2121
CountDownLatch （同步计数器）Latch闭锁的意思，是一种同步的工具类。类似于一扇门：在闭锁到达结束状态之前，这扇门一直是关闭着的，不允许任何线程通过，当到达结束状态时，这扇门会打开并允许所有的线程通过。且当门打开了，就永远保持打开状态。作用：可以用来确保某些活动直到其他活动都完成后才继续执行。使用场景：1、例如我们上例中所有人都到达饭店然后吃饭；2、某个操作需要的资源初始化完毕3、某
java中的并发类_java中并发常用工具类
weixin_30171859的博客
02-25 66
前言:在你无聊的时候,想想比你优秀还努力的人,也许就不觉的无聊了今天下午没事干把买的java并发编程艺术这本书拿出来看了看,看了下也记不住,还是好记性不如烂笔头,今天讲四个并发中可能会用到的工具类,分别是：CountDownLatchCyclicBarrierSemaphoreExchangerCountDownLatchcountDownLatch允许一个或多个线程等待其他线程完成操作.比如说有...
JAVA并发类包介绍
Daeker的博客
09-10 1038
JAVA并发Apl介绍合集1. java.util.concurrent包1.1 Executors线程池1.2 Queues队列1.3 Concurrent Collections1.4 Synchronizers1.5 Timing2. java.util.concurrent.lock包2.1 Locks3. java.util.concurrent.atomic包3.1 Atomics：提供原子操作的包导出导出 1. java.util.concurrent包 1.1 Executors线程池 我们
控制并发类 Semaphore
dalter的博客
06-19 137
Semaphore semaphore = new Semaphore(int); //表示当前允许并发的条数为int(控制的线程若大于1是,该类并不能保证线程的安全性,会发生脏数据的情况) semaphore.acquire();//获取一个进程(若没有获取到则等待) semaphore.acquire(int);//获取int个进程(若没有获取到则等待) //进行某些单线程的操作 se...
java 高并发线程安全集合详解
最新发布
09-03
Java高并发线程安全集合是指在多线程环境下能够保证数据一致性和线程安全的数据结构。Java提供了许多高并发线程安全集合，包括ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值