JAVA-线程池（二）

XXKongShan

已于 2022-05-04 09:37:36 修改

阅读量239

点赞数

分类专栏：学习笔记文章标签： java 开发语言

于 2022-05-04 09:37:04 首次发布

本文链接：https://blog.csdn.net/m0_64115984/article/details/124565200

版权

学习同时被 2 个专栏收录

25 篇文章 0 订阅

订阅专栏

笔记

25 篇文章 0 订阅

订阅专栏

代码部分

一、newCachedThreadPool

二、newFixedThreadPool

三、newSingleThreadExecutor

2.UsePriorityBlockingQueue

八、SynchronousQueueExampl

一、newCachedThreadPool

public class CachedThreadPoolDemo {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService executorService = Executors.newCachedThreadPool();
        //提交任务
        for (int i = 0; i < 20 ; i++) {
            executorService.execute(new MyTask());
        }
        //关闭资源（线程池）
        executorService.shutdown();

    }
}

二、newFixedThreadPool

public class FixedThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i <20 ; i++) {
            executorService.execute(new MyTask());
        }
        executorService.shutdown();
    }

}

三、newSingleThreadExecutor

/*
* 池子里面只有一个线程*/
public class SingleTreadExecutorDemo {
    public static void main(String[] args) {
        ExecutorService executorService=Executors.newSingleThreadExecutor();
        for (int i = 0; i < 20; i++) {
            executorService.execute(new MyTask());
        }
        executorService.shutdown();
    }
}

四、ThreadPoolExecutor

public class ThreadPoolExecutorDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1,10,60L, TimeUnit.SECONDS, new ArrayBlockingQueue(5));
        for (int i = 0; i < 20 ; i++) {
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"is runing!");
                }
            });
        }
    threadPoolExecutor.shutdown();
    }

}

五、BlocKingQueue

1.consumer

package com.tensent.class4_1线程池.blockingqueue.ArrayBlocKingQueue;/*
    @Auther:kongshan
    @Date:2022/4/27-04-27-16:54
    @Description:IntelliJ IDEA
    @version:

*/

import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable {
    private BlockingQueue<Integer>blockingQueue;
    public Consumer(BlockingQueue<Integer>blockingQueue){
        this.blockingQueue=blockingQueue;
    }
    @Override
    public void run() {
       try {
           while (true){
               System.out.println("取出来的元素是："+blockingQueue.take());
           }
       } catch (Exception e) {
           System.out.println("消费者在等待新产品的时候被打断了");
           e.printStackTrace();
       }
    }
}

2.MainClass

 @Auther:kongshan
    @Date:2022/4/27-04-27-17:02
    @Description:IntelliJ IDEA
    @version:

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class MainClass {
    public static void main(String[] args) {
        BlockingQueue<Integer>blockingQueue=new ArrayBlockingQueue<Integer>(3,true);
        Producer producerPut=new Producer(blockingQueue);
        Consumer consumer=new Consumer(blockingQueue);
//        ProducerOffer
        new Thread(producerPut).start();
        new Thread(consumer).start();
    }
}

3.Producer

package com.tensent.class4_1线程池.blockingqueue.ArrayBlocKingQueue;/*
    @Auther:kongshan
    @Date:2022/4/27-04-27-17:06
    @Description:IntelliJ IDEA
    @version:
*/

import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {
    private BlockingQueue<Integer>blockingQueue;
    private static int element=0;
    public  Producer(BlockingQueue<Integer>blockingQueue){
        this.blockingQueue=blockingQueue;
    }
    @Override
    public void run() {
        try {
            while(element < 20) {
                System.out.println("将要放进去的元素是："+element);
                blockingQueue.put(element++);
            }
        } catch (Exception e) {
            System.out.println("生产者在等待空闲空间的时候被打断了！");
            e.printStackTrace();
        }
        System.out.println("生产者已经终止了生产过程！");
    }
}

六、Delayqueue

package com.tensent.class4_1线程池.blockingqueue.delayqueue;/*
    @Auther:kongshan
    @Date:2022/4/27-04-27-17:27
    @Description:IntelliJ IDEA
    @version:
*/

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

public class DelayQueueTest {
    public static void main(String[] args) {
        DelayQueue<DelayTask>queue=new DelayQueue<DelayTask>();
        queue.add(new DelayTask("1",1000L,TimeUnit.MILLISECONDS));
        queue.add(new DelayTask("2",1000L,TimeUnit.MILLISECONDS));
        queue.add(new DelayTask("3",1000L,TimeUnit.MILLISECONDS));
        System.out.println("queue put done");
        while (!queue.isEmpty()){
            try {
                DelayTask task=queue.take();
                System.out.println(task.name + ":" + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}



class  DelayTask implements Delayed{
    public String name;
    public Long delayTime;
    public TimeUnit delayTimeUnit;
    public Long executeTime;

    public DelayTask() {
    }

    public DelayTask(String name, Long delayTime, TimeUnit delayTimeUnit) {
        this.name = name;
        this.delayTime = delayTime;
        this.delayTimeUnit = delayTimeUnit;
        this.executeTime =System.currentTimeMillis()+delayTimeUnit.toMillis(delayTime);
    }


    @Override
    public int compareTo(Delayed o) {
        if (this.getDelay(TimeUnit.MILLISECONDS)>o.getDelay(TimeUnit.MILLISECONDS)){
            return 1;
        }else if (this.getDelay(TimeUnit.MILLISECONDS)<o.getDelay(TimeUnit.MILLISECONDS)){
            return -1;
        }
        return 0;
    }

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

七、Priorityqueque

1.test

package com.tensent.class4_1线程池.blockingqueue.priorityqueue;/*
    @Auther:kongshan
    @Date:2022/4/27-04-27-17:50
    @Description:IntelliJ IDEA
    @version:


*/

public class Task implements Comparable<Task> {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int compareTo(Task task) {
        return this.id > task.id ? 1 : (this.id < task.id ? -1 : 0);
    }

    public String toString() {
        return this.id+","+this.name;
    }
}

2.UsePriorityBlockingQueue

package com.tensent.class4_1线程池.blockingqueue.priorityqueue;/*
    @Auther:kongshan
    @Date:2022/4/27-04-27-17:48
    @Description:IntelliJ IDEA
    @version:
*/

import java.util.concurrent.PriorityBlockingQueue;

public class UsePriorityBlockingQueue {
    public static void main(String[] args) throws Exception{
        PriorityBlockingQueue<Task>q=new PriorityBlockingQueue<Task>();
        Task t1=new Task();
        t1.setId(3);
        t1.setName("id为3");
        Task t2=new Task();
        t2.setId(4);
        t2.setName("id为4");
        Task t3=new Task();
        t3.setId(1);
        t3.setName("id为1");

        q.add(t1);
        q.add(t2);
        q.add(t3);
        System.out.println("容器："+q);
        System.out.println(q.take().getId());
        System.out.println("容器"+q);
    }
}

八、SynchronousQueueExampl

package com.tensent.class4_1线程池.blockingqueue.Synchronousqueue;/*
    @Auther:kongshan
    @Date:2022/4/27-04-27-17:57
    @Description:IntelliJ IDEA
    @version:
*/

import java.util.Random;
import java.util.UUID;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;

public class SynchronousQueueExample {
    static class SynchronousQueueProducer implements Runnable{
        protected BlockingQueue<String>blockingQueue;
        final Random random=new Random();

        public SynchronousQueueProducer(BlockingQueue<String>queue){
            this.blockingQueue=queue;
        }
        @Override
        public void run() {
            while (true){
                try {
                    String data = UUID.randomUUID().toString();
                    System.out.println(Thread.currentThread().getName() + "--Put:" + data);
                    blockingQueue.put(data);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                }
            }
        }
    }
    static class SynchronousQueueConsumer implements Runnable{
        protected BlockingQueue<String>blockingQueue;

        public SynchronousQueueConsumer(BlockingQueue<String>queue){
            this.blockingQueue=queue;
        }
        @Override
        public void run() {
            while (true){
            try {
                String data=blockingQueue.take();
                System.out.println(Thread.currentThread().getName()+"take（）；"+data);
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        final BlockingQueue<String>synchronousQueue=new SynchronousQueue<String>();
        SynchronousQueueProducer queueProducer=new SynchronousQueueProducer(synchronousQueue);
        new Thread(queueProducer).start();
        SynchronousQueueConsumer queueConsumer1 = new SynchronousQueueConsumer(
                synchronousQueue);
        new Thread(queueConsumer1).start();

        SynchronousQueueConsumer queueConsumer2 = new SynchronousQueueConsumer(
                synchronousQueue);
        new Thread(queueConsumer2).start();

    }
}