import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.core.env.Profiles;
import springfox.documentation.builders.ParameterBuilder;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.schema.ModelRef;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.service.Parameter;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2; import java.util.ArrayList;
import java.util.List; /**
 * @author yvioo。
 */
@Configuration
@EnableSwagger2  //开启Swagger2
public class Knife4jConfig {     /**
     * 配置Swagger的Docket的bean实例
     * @return
     */
    @Bean
    public Docket docket(Environment environment) {         //设置只在开发中环境中启动swagger
        Profiles profiles=Profiles.of("dev");         //表示如果现在是dev环境，则返回true 开启swagger
        boolean flag=environment.acceptsProfiles(profiles);         /*添加接口请求头参数配置 没有的话 可以忽略*/
        ParameterBuilder tokenPar = new ParameterBuilder();
        List<Parameter> pars = new ArrayList<>();
        tokenPar.name("token").description("令牌").defaultValue("设置token默认值").modelRef(new ModelRef("string")).parameterType("header").required(false).build();
        pars.add(tokenPar.build());         return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                //是否启动swagger 默认启动
                .enable(flag)
                //所在分组
                .groupName("yvioo")
                .select()
                //指定扫描的包路径
                .apis(RequestHandlerSelectors.basePackage("com.example.demo.controller"))
                //指定扫描的请求，这里表示扫描 /hello/ 的请求
                //.paths(PathSelectors.ant("/hello/**"))
                .build()
                .globalOperationParameters(pars);
    }     /**
     * 配置ApiInfo信息
     * @return
     */
    private ApiInfo apiInfo() {         //作者信息
        Contact author = new Contact("yvioo", "https://www.cnblogs.com/pxblog/", "111@qq.com");         return new ApiInfo(
                "Knife4j测试",
                "Knife4j描述",
                "1.0",
                "urn:tos",
                author,
                "Apache 2.0",
                "http://www.apache.org/licenses/LICENSE-2.0",
                new ArrayList()
        );     }
}

@Api(tags = "首页模块")
@RestController
public class IndexController {     @ApiImplicitParam(name = "name",value = "姓名",required = true)
    @ApiOperation(value = "向客人问好")
    @GetMapping("/sayHi")
    public ResponseEntity<String> sayHi(@RequestParam(value = "name")String name){
        return ResponseEntity.ok("Hi:"+name);
    }
}

@Configuration
public class WebMvcConfigurer extends WebMvcConfigurationSupport {     /**
     * 发现如果继承了WebMvcConfigurationSupport， 需要重新指定静态资源
     *
     */
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/**").addResourceLocations(
                "classpath:/static/");
        registry.addResourceHandler("doc.html").addResourceLocations(
                "classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**").addResourceLocations(
                "classpath:/META-INF/resources/webjars/");
        super.addResourceHandlers(registry);
    }
}

/**
 * 微信公众号业务支持校验
 *
 * @param signature
 * @param timestamp
 * @param nonce
 * @param echostr
 * @param response
 */
@GetMapping("callback")
public void callback(String signature, String timestamp, String nonce, String echostr, HttpServletResponse response) {
    PrintWriter out = null;
    log.info("微信公众号业务支持校验消息，signature:{}，timestamp:{}，nonce:{}，echostr:{}", signature, timestamp, nonce, echostr);
    List<WechatConfigPO> configPOList = wechatConfigDao.selectAll();
    try {
        out = response.getWriter();
        out.write(echostr);
    } catch (Throwable e) {
        log.error("微信公众号业务支持校验失败", e);
    } finally {
        if (out != null) {
            out.close();
        }
    }
}

/**
 * 微信公众号业务支持消息回调
 *
 * @param request
 * @param response
 */
@PostMapping("callback")
public void callback(HttpServletRequest request, HttpServletResponse response) {
    PrintWriter out = null;

    try {
        String respMessage = wechatService.callback(request);
        if (StringUtils.isBlank(respMessage)) {
            log.info("不回复消息");
            return;
        }
        response.setCharacterEncoding("UTF-8");
        out = response.getWriter();
        out.write(respMessage);
    } catch (Throwable e) {
        log.error("微信公众号业务支持发送消息失败", e);
    } finally {
        if (out != null) {
            out.close();
        }
    }
}

/**
 * @author Brath
 * @date 2023/2/23
 * @desc 微信公众号业务支持
 */
@Slf4j
@Service
public class WechatService {

    @Autowired
    private TextReplyService textReplyService;

    /**
     * 微信公众号业务支持回复
     *
     * @param request
     * @return
     * @throws UnsupportedEncodingException
     */
    public String callback(HttpServletRequest request) throws UnsupportedEncodingException {
        request.setCharacterEncoding("UTF-8");

        try {
            Map<String, String> requestMap = WechatMessageUtils.parseXml(request);
            log.info("微信公众号业务支持接收到消息:{}", GsonUtils.toJson(requestMap));
            // 消息类型
            String msgType = requestMap.get("MsgType");

            // 处理其他消息，暂时不做回复
            switch (msgType) {
                case WechatMsgTypeConstant.MESSAGE_TYPE_TEXT:
                    // 文本消息处理
                    return textReplyService.reply(requestMap);
                default:
                    return textReplyService.reply(requestMap);
            }
        } catch (Throwable e) {
            log.error("回复消息错误", e);
        }
        // 不做回复
        return null;
    }

}

/**
 * @author Brath
 * @date 2022/5/18 9:57
 * @desc 文本回复
 */
@Service
public class TextReplyService {

    private static final String FROM_USER_NAME = "FromUserName";
    private static final String TO_USER_NAME = "ToUserName";
    private static final String CONTENT = "Content";

    @Autowired
    private WechatKeywordDao wechatKeywordDao;

    @Autowired
    private WechatMsgRecordDao wechatMsgRecordDao;

    /**
     * 自动回复文本内容
     *
     * @param requestMap
     * @return
     */
    public String reply(Map<String, String> requestMap) {
        String wechatId = requestMap.get(FROM_USER_NAME);
        String gongzhonghaoId = requestMap.get(TO_USER_NAME);

        TextMessage textMessage = WechatMessageUtils.getDefaultTextMessage(wechatId, gongzhonghaoId);

        String content = requestMap.get(CONTENT);
        if (content == null) {
            textMessage.setContent(WechatConstants.DEFAULT_MSG);
        } else {
            Example example = new Example(WechatKeywordPO.class);
            example.createCriteria().andEqualTo("wechatId", gongzhonghaoId).andEqualTo("keyword", content);
            List<WechatKeywordPO> keywordPOList = wechatKeywordDao.selectByExample(example);
            if (CollectionUtils.isEmpty(keywordPOList)) {
                textMessage.setContent(WechatConstants.DEFAULT_MSG);
            } else {
                textMessage.setContent(keywordPOList.get(0).getReplyContent());
            }
        }
        // 记录消息记录
        wechatMsgRecordDao.insertSelective(WechatMsgRecordPO.builder()
                .fromUser(wechatId)
                .wechatId(gongzhonghaoId)
                .content(content)
                .replyContent(textMessage.getContent())
                .build()
        );

        return WechatMessageUtils.textMessageToXml(textMessage);
    }

}

/**
 * @author Brath
 * @date 2021/11/26 22:21
 * @description 文本消息
 */
@Data
public class TextMessage extends BaseMessage {

    /**
     * 回复的消息内容
     */
    private String Content;

}
1234567891011121314

/**
 * @author Brath
 * @date 2021/11/26 22:20
 * @description 基础消息响应
 */
@Data
public class BaseMessage {

    /**
     * 接收方帐号（收到的OpenID）
     */
    private String ToUserName;
    /**
     * 开发者微信公众号业务支持号
     */
    private String FromUserName;
    /**
     * 消息创建时间 （整型）
     */
    private long CreateTime;

    /**
     * 消息类型
     */
    private String MsgType;

    /**
     * 位0x0001被标志时，星标刚收到的消息
     */
    private int FuncFlag;

}

/**
 * @author Brath
 * @date 2022/5/18 7:55
 * @desc 微信公众号业务支持消息
 */
public class WechatMessageUtils {

    /**
     * 解析微信公众号业务支持发来的请求（XML）
     *
     * @param request
     * @return
     * @throws Exception
     */
    public static Map<String, String> parseXml(HttpServletRequest request) throws Exception {
        // 将解析结果存储在HashMap中
        Map<String, String> map = new HashMap<>();

        // 从request中取得输入流
        InputStream inputStream = request.getInputStream();
        try {
            // 读取输入流
            SAXReader reader = new SAXReader();
            Document document = reader.read(inputStream);
            // 得到xml根元素
            Element root = document.getRootElement();
            // 得到根元素的所有子节点

            List<Element> elementList = root.elements();

            // 遍历所有子节点
            for (Element e : elementList) {
                map.put(e.getName(), e.getText());
            }
        } finally {
            // 释放资源
            if (inputStream != null) {
                inputStream.close();
            }
        }

        return map;
    }

    /**
     * 文本消息对象转换成xml
     *
     * @param textMessage 文本消息对象
     * @return xml
     */
    public static String textMessageToXml(TextMessage textMessage) {
        XSTREAM.alias("xml", textMessage.getClass());
        return XSTREAM.toXML(textMessage);
    }

    /**
     * 音乐消息对象转换成xml
     *
     * @param musicMessage 音乐消息对象
     * @return xml
     */
    public static String musicMessageToXml(MusicMessage musicMessage) {
        XSTREAM.alias("xml", musicMessage.getClass());
        return XSTREAM.toXML(musicMessage);
    }

    /**
     * 图文消息对象转换成xml
     *
     * @param newsMessage 图文消息对象
     * @return xml
     */
    public static String newsMessageToXml(NewsMessage newsMessage) {
        XSTREAM.alias("xml", newsMessage.getClass());
        XSTREAM.alias("item", Article.class);
        return XSTREAM.toXML(newsMessage);
    }

    /**
     * 扩展xstream，使其支持CDATA块
     */
    private static final XStream XSTREAM = new XStream(new XppDriver() {
        @Override
        public HierarchicalStreamWriter createWriter(Writer out) {
            return new PrettyPrintWriter(out) {
                // 对所有xml节点的转换都增加CDATA标记
                final boolean cdata = true;

                @Override
                protected void writeText(QuickWriter writer, String text) {
                    if (cdata) {
                        writer.write("<![CDATA[");
                        writer.write(text);
                        writer.write("]]>");
                    } else {
                        writer.write(text);
                    }
                }
            };
        }
    });

    /**
     * 获取默认文本消息
     *
     * @param receiver     接收人
     * @param officialWxid 官方微信公众号业务支持id
     * @return 文本消息
     */
    public static TextMessage getDefaultTextMessage(String receiver, String officialWxid) {
        TextMessage textMessage = new TextMessage();
        textMessage.setToUserName(receiver);
        textMessage.setFromUserName(officialWxid);
        textMessage.setCreateTime(System.currentTimeMillis());
        textMessage.setMsgType(WechatMsgTypeConstant.MESSAGE_TYPE_TEXT);
        textMessage.setFuncFlag(0);

        return textMessage;
    }

}

/**
 * @author Brath
 * @date 2022/5/18 8:00
 * @desc 微信公众号业务支持消息类型
 */
public class WechatMsgTypeConstant {

    /**
     * 文本消息
     */
    public static final String MESSAGE_TYPE_TEXT = "text";

}

    /**
 * @author Brath
 * @date 2021/11/26 21:59
 * @description 微信公众号业务支持工具
 */
@Slf4j
public class WechatUtils {

    private static final char[] HEX_DIGITS = {'0', '1', '2', '3', '4', '5',
            '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    public static boolean checkSignature(String signature, String timestamp, String nonce, String token) {
        String[] str = new String[]{token, timestamp, nonce};
        //排序
        Arrays.sort(str);
        //拼接字符串
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < str.length; i++) {
            buffer.append(str[i]);
        }
        //进
        String temp = encode(buffer.toString());
        //与微信公众号业务支持提供的signature进行匹对
        return signature.equals(temp);
    }

    private static String getFormattedText(byte[] bytes) {
        int len = bytes.length;
        StringBuilder buf = new StringBuilder(len * 2);
        for (int j = 0; j < len; j++) {
            buf.append(HEX_DIGITS[(bytes[j] >> 4) & 0x0f]);
            buf.append(HEX_DIGITS[bytes[j] & 0x0f]);
        }
        return buf.toString();
    }

    public static String encode(String str) {
        if (str == null) {
            return null;
        }
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("SHA1");
            messageDigest.update(str.getBytes());
            return getFormattedText(messageDigest.digest());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950

//创建资源类
class Ticket{
    //票数
    private int number = 30;
    //操作方法：卖票
    public synchronized void sale(){
        //判断：是否有票
        if (number>0) {
            System.out.println(Thread.currentThread().getName()+"::"+number--+"还剩"+number);
        }
    }
}

class LTicket{
    private int number = 30;
  //创建可重入锁 公平锁
    private final ReentrantLock lock = new ReentrantLock(true);
    public void sale(){
        lock.lock();
        try {
            if (number>0){
                System.out.println(Thread.currentThread().getName()+"::"+number--+"剩余："+number);
            }
        } finally {
            lock.unlock();
        }
    }
}

package com.jsh.juc.sync;

class Share {
    //初始值
    private int number = 0;

    //+1的方法
    public synchronized void add() throws InterruptedException {
      //判断 干活 通知
        while (number != 0) {
            this.wait();
        }
      //干活
        number++;
        System.out.println(Thread.currentThread().getName() + "::" + number);
      //通知
        this.notifyAll();
    }

    //+1的方法
    public synchronized void dno() throws InterruptedException {
        while (number == 0) {
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "::" + number);
        this.notifyAll();
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        Share sale = new Share();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                try {
                    sale.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AA").start();

        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                try {
                    sale.dno();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BB").start();

        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                try {
                    sale.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "CC").start();
    }
}

class Share {
    //初始值
    private int number = 0;

    //创建lock
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    //+1的方法
    public void add() throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断（使用while不使用if）
            while (number != 0) {
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            //通知
            condition.signalAll();
        } finally {
            //解锁
            lock.unlock();
        }


    }

    //-1的方法
    public void dno() throws InterruptedException {
        //上锁
        lock.lock();
        try {
            while (number == 0) {
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "::" + number);
            //通知
            condition.signalAll();
        } finally {
            //解锁
            lock.unlock();
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        Share sale = new Share();
        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                try {
                    sale.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "AA").start();

        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                try {
                    sale.dno();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "BB").start();

        new Thread(() -> {
            for (int i = 0; i < 40; i++) {
                try {
                    sale.add();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "CC").start();
    }
}

/*
线程间定制化通知
 */
//第一步 创建资源类
class ShareResource { 
    //定义标志位
    private int flag = 1;//1:aa,2:bb,3:cc
    //创建lock锁
    private Lock lock = new ReentrantLock();

    // 创建三个Condition
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();

    //打印5次，参数第几轮
    public void print5(int loop) throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断
            while (flag != 1) {
                c1.await();
            }
            //干活
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+"::"+i+"第几轮："+loop);
            }
            //通知
            flag = 2;
            //通知c2
            c2.signal();
        }finally {
            lock.unlock();
        }
    }

    //打印10次，参数第几轮
    public void print10(int loop) throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断
            while (flag != 2) {
                c2.await();
            }
            //干活
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+"::"+i+"第几轮："+loop);
            }
            //通知
            flag = 3;
            c3.signal();
        }finally {
            lock.unlock();
        }
    }

    //打印15次，参数第几轮
    public void print15(int loop) throws InterruptedException {
        //上锁
        lock.lock();
        try {
            //判断
            while (flag != 3) {
                c3.await();
            }
            //干活
            for (int i = 0; i < 15; i++) {
                System.out.println(Thread.currentThread().getName()+"::"+i+"第几轮："+loop);
            }
            //通知
            flag = 1;
            c1.signal();
        }finally {
            lock.unlock();
        }
    }

}



public class ThreadDemo3 {

    public static void main(String[] args) {
        ShareResource shareResource = new ShareResource();
        new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    shareResource.print5(i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"aa").start();

        new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    shareResource.print10(i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"bb").start();

        new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    shareResource.print15(i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"cc").start();
    }
}

//创建lock锁 true：公平 false：非公平
private Lock lock = new ReentrantLock(true);

package com.jsh.juc.callable;


import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class MyThread implements Callable{

    @Override
    public Object call() throws Exception {
        return 200;
    }
}


public class Demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //方法一
        //FutureTask 未来任务
        FutureTask<Integer> futureTask1 = new FutureTask<>(new MyThread());

        //方法二
        //lam表达式
        FutureTask<Integer> futureTask2 = new FutureTask<>(() ->{
            System.out.println(Thread.currentThread().getName()+"2");
            return 1024;
        });

      //创建线程 ，启动
        new Thread(futureTask2,"lucy").start();

        //线程是否结束
        while (!futureTask2.isDone()) {
            System.out.println("wait。。。。。");
        }

        //第一次调用 计算 返回结果
        System.out.println(futureTask2.get());

        //第二次调用直接返回结果
        System.out.println(futureTask2.get());
    }
}

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {

        //计数器
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i < 7; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName()+"走了");
                //计数-1
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }

        //等待
        countDownLatch.await();
        System.out.println("班长锁门");
    }
}

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        //循环栅栏
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召唤神龙");
        });
        
        for (int i = 1; i <= 7; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName()+"星龙珠被找到了");
                    //等待
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

/**
 * 信号灯
 */
//模拟六辆汽车，停3个停车位
public class SemaphoreDemo {
    public static void main(String[] args) {
        //模拟三个车位
        Semaphore semaphore = new Semaphore(3);

        //模拟6辆汽车
        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                try {
                    //占车位
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到了车位");

                    //设置随机停车时间
                    TimeUnit.SECONDS.sleep(new Random().nextInt(5));
                    System.out.println(Thread.currentThread().getName()+"----------离开了车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //释放车位
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

//资源类
class MyCache {
    private volatile Map<String, String> map = new HashMap<>();

    //创建读写锁对象
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    //放数据
    public void put(String key, String value) {
        //添加写锁
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "正在写数据");
            //暂停一会
            TimeUnit.MICROSECONDS.sleep(300);
            //放数据
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "写完了" + key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放锁
            readWriteLock.writeLock().unlock();
        }
    }

    //取数据
    public String get(String key) {
        //添加读锁
        readWriteLock.readLock().lock();
        String res = null;
        try {
            System.out.println(Thread.currentThread().getName() + "正在读数据");
            //暂停一会
            TimeUnit.MICROSECONDS.sleep(300);
            //放数据
            res = map.get(key);
            System.out.println(Thread.currentThread().getName() + "读完了" + key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放锁
            readWriteLock.readLock().unlock();
        }
        return res;
    }
}

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        //创建线程 放数据
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> {
                myCache.put(finalI + "", finalI + "");
            }, i + "存").start();
        }

        //创建线程 取数据
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> {
                myCache.get(finalI + "");
            }, i + "取").start();
        }
    }
}

public class BlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        //创建阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);

        //第一组
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        System.out.println(blockingQueue.element());
        System.out.println(blockingQueue.add("x"));
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());

        //第二组
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        System.out.println(blockingQueue.offer("x"));
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());

        // 第三组
        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
        blockingQueue.put("x");
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        //第四组
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        System.out.println(blockingQueue.offer("a", 3L, TimeUnit.SECONDS));
        //第一组
        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        System.out.println(blockingQueue.element());
    }
}

//演示线程池的三种常用分类
public class ThreadPoolDemo {
    public static void main(String[] args) {
        //一池五线程
        ExecutorService threadPool1 = Executors.newFixedThreadPool(5);

        //一池一线程
        ExecutorService threadPool2 = Executors.newSingleThreadExecutor();

        //一池可扩容线程
        ExecutorService threadPool3 = Executors.newCachedThreadPool();

        //十个顾客请求
        try {
            for (int i = 0; i < 1000; i++) {
                //执行
                threadPool3.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool3.shutdown();
        }
    }
}

public class MyThreadPool {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,
                5,
                2L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        //十个顾客请求
        try {
            for (int i = 0; i < 10; i++) {
                //执行
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}

class Mytask extends RecursiveTask<Integer> {
    //拆分差值不超过10,计算10以内的运算
    private static final Integer VALUE = 10;
    private int begin; //拆分开始值
    private int end; //拆分结束值
    private int result; //返回结果

    public Mytask(int begin, int end) {
        this.begin = begin;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if ((end - begin) < VALUE) {
            //相加
            for (int i = begin; i <= end; i++) {
                result += i;
            }
        } else {//进一步拆分
            int middle = (begin + end) / 2;
            Mytask taskLeft = new Mytask(begin, middle);
            Mytask taskRight = new Mytask(middle+1, end);

            taskLeft.fork();
            taskRight.fork();
            result = taskLeft.join()+taskRight.join();
        }
        return result;
    }
}

public class ForkJoinDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建MyTask对象
        Mytask mytask = new Mytask(0,100);
        //创建分支合并池对象
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Integer> submit = forkJoinPool.submit(mytask);
        //获取结果
        Integer integer = submit.get();
        System.out.println(integer);
        //关闭池对象
        forkJoinPool.shutdown();
    }
}

public class CompletableFutureDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //异步调用 没有返回值
        CompletableFuture<Void> completableFuture1 = CompletableFuture.runAsync(()->{
            System.out.println(Thread.currentThread().getName()+"completableFuture1");

        });
        completableFuture1.get();

        //异步调用 有返回值
        CompletableFuture<Integer> completableFuture2 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"completableFuture2");
            //模拟异常
            int a = 1/0;
            return 2;
        });
        Integer integer = completableFuture2.whenComplete((t,u)->{
            System.out.println(t); // 2：方法返回值
            System.out.println(u); // null：异常信息
        }).get();
        System.out.println(integer);
    }
}