javaSE--线程池

一、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 SingleThreadExecutorDemo {
 
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 200; i++) {
            executorService.execute(new MyTask());
        }
        executorService.shutdown();
    }
}

四、MyTask

public class MyTask implements Runnable {
    @Override
    public void run() {
//        try {
//            Thread.sleep(200);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        System.out.println(Thread.currentThread().getName() + " is running!");
    }

}

五、blockingqueue

1、ArrayBlockingQueue

1）、Consumer

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

}

2）、Mainclass

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 producerOffer = new ProducerOffer(blockingQueue);
		
		new Thread(producerPut).start();
		
		new Thread(consumer).start();
		
		
	}

}

3）、Producer

public class Producer implements Runnable {
 
	private BlockingQueue<Integer> blockingQueue;
	private static int element = 0;
	
	public Producer(BlockingQueue<Integer> blockingQueue) {
		this.blockingQueue = blockingQueue;
	}
 
 
	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("生产者已经终止了生产过程！");
	}

}

2、delayqueue

1）、DelayQueueTest

public class DelayQueueTest {
    public static void main(String[] args) {
        DelayQueue<DelayTask> queue = new DelayQueue<>();
        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;//ms
 
    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);
    }

}

3、priorityqueue

1）、Task

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

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);	//3
		q.add(t2);	//4
		q.add(t3);  //1
		
		System.out.println("容器：" + q);
		System.out.println(q.take().getId());
		System.out.println("容器：" + q);
	}

}

4、Synchronousqueue

1）、SynchronousQueueExample

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();
 
    }
}