1、SynchronousQueue

package com.blockingqueue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.SynchronousQueue;

import java.util.concurrent.TimeUnit;

/**

 * 同步队列  SynchronousQueue不存储元素，put了一个元素，必须从里边先取出来，然后再放入

 */

public class SynchronousQueueDemo {

    public static void main(String[] args) {

        BlockingQueue<String> blockingQueue = new SynchronousQueue<>();//同步队列

        new Thread(()->{

            try {

                System.out.println(Thread.currentThread().getName()+"put1");

                blockingQueue.put("1");

                System.out.println(Thread.currentThread().getName()+"put2");

                blockingQueue.put("2");

                System.out.println(Thread.currentThread().getName()+"put3");

                blockingQueue.put("3");

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        },"A").start();

        new Thread(()->{

            try {

                TimeUnit.SECONDS.sleep(3);

                System.out.println(Thread.currentThread().getName()+blockingQueue.take());

                TimeUnit.SECONDS.sleep(3);

                System.out.println(Thread.currentThread().getName()+blockingQueue.take());

                TimeUnit.SECONDS.sleep(3);

                System.out.println(Thread.currentThread().getName()+blockingQueue.take());

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        },"B").start();

    }

}

2、线程池（重点）

线程池：三大方法、7大参数、4种拒绝策略

池化技术
程序的运行、本质：占用系统的资源|优化资源的使用==》池化技术
线程池、连接池、内存池、对象池。。。创建、销毁、浪费资源

池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我

线程池的好处：

1、降低资源的消耗
2、提高响应的的速度
3、方便管理
线程复用、可以控制最大并发数，管理线程

2.1 使用单例

package com.threadpool;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class Demo1 {

    public static void main(String[] args) {

        ExecutorService threadpool = Executors.newSingleThreadExecutor();//单个线程

        try {

            for (int i = 0; i < 10; i++) {

                //使用线程池之后，使用线程池来创建线程

                threadpool.execute(()->{

                    System.out.println(Thread.currentThread().getName()+"ok");

                });

            }

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            threadpool.shutdown();

        }

    }

}

2.2、使用固定大小的线程

package com.threadpool;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class Demo1 {

    public static void main(String[] args) {

//        ExecutorService threadpool = Executors.newSingleThreadExecutor();//单个线程

        ExecutorService threadpool = Executors.newFixedThreadPool(5);//创建一个固定大小的线程池的大小

        try {

            for (int i = 0; i < 10; i++) {

                //使用线程池之后，使用线程池来创建线程

                threadpool.execute(()->{

                    System.out.println(Thread.currentThread().getName()+"ok");

                });

            }

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            threadpool.shutdown();

        }

    }

}

2.3、缓存线程池

package com.threadpool;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class Demo1 {

    public static void main(String[] args) {

//        ExecutorService threadpool = Executors.newSingleThreadExecutor();//单个线程

//        ExecutorService threadpool = Executors.newFixedThreadPool(5);//创建一个固定大小的线程池的大小

        ExecutorService threadpool = Executors.newCachedThreadPool();//可伸缩的，遇强则强，遇弱则弱

        try {

            for (int i = 0; i < 10; i++) {

                //使用线程池之后，使用线程池来创建线程

                threadpool.execute(()->{

                    System.out.println(Thread.currentThread().getName()+"ok");

                });

            }

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            threadpool.shutdown();

        }

    }

}

2.4 七大参数

源码分析

本质上是ThreadPoolExecutor
源码：

    public ThreadPoolExecutor(int corePoolSize,//核心线程池大小

                              int maximumPoolSize,//最大核心线程池大小

                              long keepAliveTime,//超时了，每没有人调用就会释放

                              TimeUnit unit,//超时单位

                              BlockingQueue<Runnable> workQueue,//阻塞队列

                              ThreadFactory threadFactory,//线程工厂，创建线程的，一般不用动

                              RejectedExecutionHandler handler) {//拒绝策略

        if (corePoolSize < 0 ||

            maximumPoolSize <= 0 ||

            maximumPoolSize < corePoolSize ||

            keepAliveTime < 0)

            throw new IllegalArgumentException();

        if (workQueue == null || threadFactory == null || handler == null)

            throw new NullPointerException();

        this.corePoolSize = corePoolSize;

        this.maximumPoolSize = maximumPoolSize;

        this.workQueue = workQueue;

        this.keepAliveTime = unit.toNanos(keepAliveTime);

        this.threadFactory = threadFactory;

        this.handler = handler;

    }

四种拒绝策略

1、ThreadPoolExecutor.AbortPolicy()
银行满了，还有人进来，不处理这个人的，抛出异常

2、ThreadPoolExecutor.CallerRunsPolicy()
银行满了，还有人进来，哪来的去哪里

3、ThreadPoolExecutor.DiscardPolicy()
队列满了、不会抛出异常

4、ThreadPoolExecutor.DiscardOldestPolicy()
队列满了、尝试去和最早的竞争，也不会抛出异常

1、cpu密集型，几核，就是几，可以保证CPU的效率最高！！！Runtime.getRuntime().availableProcessors()

2、IO密集型判断你程序中十分耗IO的线程
程序 15个大型任务，io十分占用资源

巴特西

JUI（6）线程池

文章目录