new Thread(()->{
for (int i = 0; i < 6; i++) {
System.out.println(i);
}
}).start();

// JDK 源码
public synchronized void start() {
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    group.add(this);
    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {}
    }
}
private native void start0();

private static native void registerNatives();
static {
    registerNatives();
    EMPTY_STACK_TRACE = new StackTraceElement[0];
}

@RestController
@RequestMapping("/product/product-info")
public class ProductInfoController {

    @Autowired
    ProductInfoService productInfoService;

    @GetMapping("/findById")
    public ProductInfoQueryVo findById(Integer id) {
     ...
    }
}

/**
  * 1.直接把表单的参数写在Controller相应的方法的形参中
  * @param username
  * @param password
  * @return
  */
 @RequestMapping("/addUser1")
 public String addUser1(String username,String password) {
     System.out.println("username is:"+username);
     System.out.println("password is:"+password);
     return "demo/index";
 }

/**
  * 2、通过HttpServletRequest接收
  * @param request
  * @return
  */
 @RequestMapping("/addUser2")
 public String addUser2(HttpServletRequest request) {
     String username=request.getParameter("username");
     String password=request.getParameter("password");
     System.out.println("username is:"+username);
     System.out.println("password is:"+password);
     return "demo/index";
 }

@RequestMapping("/doLogin")
public User doLogin(User u) {

    logger.info("name: " + u.getName());
    logger.info("pswd: " + u.getPswd());

    User user = new User();
    user.setName(u.getName());
    user.setPswd(u.getPswd());

    return user;
}

@RequestMapping("/doLogin")
public @ResponseBody User doLogin(@RequestBody User u) {
    logger.info("name: " + u.getName());
    logger.info("pswd: " + u.getPswd());
    return u;
}

@RequestMapping("/doLogin")
public @ResponseBody User doLogin(@RequestBody Map<String, String> u) {

    logger.info("name: " + u.get("name"));
    logger.info("pswd: " + u.get("pswd"));

    User user = new User();
    user.setName(u.get("name"));
    user.setPswd(u.get("pswd"));

    return user;
}

   /**
     * @param username
     * @param password
     * @return
     */
    @RequestMapping(value="/addUser4/{username}/{password}",method=RequestMethod.GET)
public String addUser4(@PathVariable String username,@PathVariable String password) {
        System.out.println("username is:"+username);
        System.out.println("password is:"+password);
        return "";
    }

@RequestMapping("/doLogin")
public User doLogin(@RequestParam(value="name") String username, @RequestParam(value="pswd") String password) {
    logger.info("name: " + username);
    logger.info("psed: " + password);
    User user = new User();
    user.setPswd(password);
    user.setName(username);
    return user;
}

public class User {
    Student s;
    String name;
    String pswd;
    // getter  setter
 }

//Student是另一单独的对象
public class Student {
    String clas;
    int age;
    // getter setter
}

    @Bean
    public RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate();
        rabbitTemplate.setConnectionFactory(connectionFactory);
        // Mandatory为true时,消息通过交换器无法匹配到队列会返回给生产者，为false时匹配不到会直接被丢弃
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            /**
             *  ConfirmCallback机制只确认消息是否到达exchange(交换器)，不保证消息可以路由到正确的queue;
             *  需要设置：publisher-confirm-type: CORRELATED；
             *  springboot版本较低 参数设置改成：publisher-confirms: true
             *
             *  以实现方法confirm中ack属性为标准，true到达
             *  config : 需要开启rabbitmq得ack publisher-confirm-type
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (ack) {
                    log.info("消息发送成功:correlationData({}),ack({}),cause({})", correlationData, ack, cause);
                } else {
                    log.error("消息发送失败:correlationData({}),ack({}),cause({})", correlationData, ack, cause);
                }
            }
        });

        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
            /**
             *  ReturnsCallback 消息机制用于处理一个不可路由的消息。在某些情况下，如果我们在发送消息的时候，当前的 exchange 不存在或者指定路由 key 路由不到，这个时候我们需要监听这种不可达的消息
             *   就需要这种return机制
             *
             *  config : 需要开启rabbitmq发送失败回退; publisher-returns 或rabbitTemplate.setMandatory(true); 设置为true
             */
            @Override
            public void returnedMessage(ReturnedMessage returned) {
//                实现接口ReturnCallback，重写 returnedMessage() 方法，
//                方法有五个参数
//                message（消息体）、
//                replyCode（响应code）、
//                replyText（响应内容）、
//                exchange（交换机）、
//                routingKey（队列）。

                log.info("ReturnsCallback    returned : {}", returned);
            }
        });

        return rabbitTemplate;
    }

@Bean
public Exchange deadLetterExchange() {
    return ExchangeBuilder
            .topicExchange("dead-letter-exchange")
            .durable(true)
            .build();
}

@Bean
public Queue deadLetterQueue() {
    return QueueBuilder
            .durable("dead-letter-queue")
            .build();
}

@Bean
public Binding userDeadLetterBinding() {
    return BindingBuilder
            .bind(deadLetterQueue())
            .to(deadLetterExchange())
            .with("dead-letter-routing-key")
            .noargs();
}

@Bean
TopicExchange exchange() {
    return new TopicExchange("topic-ex");
}

@Bean
public Queue firstQueue() {
    return QueueBuilder.durable("first-queue")
            .withArgument("x-dead-letter-exchange", "dead-letter-exchange")
            //声明该队列死信消息在交换机的 路由键
            .withArgument("x-dead-letter-routing-key", "dead-letter-routing-key")
            .build();
}

@Bean
Binding bindingExchangeMessage() {
    return BindingBuilder.bind(firstQueue()).to(exchange()).with("first-queue");
}

@RequestMapping("/test")
public String test() {
    String messageData = "message: rabbitmq message";
    Map<String, Object> manMap = new HashMap<>();
    manMap.put("messageData", messageData);
    rabbitTemplate.convertAndSend("topic-ex", "first-queue", manMap, new CorrelationData("1001"));
    return "ok";
}

@RabbitListener(queues = "first-queue")
@RabbitHandler
public void receiver(@Payload HashMap dataMsg, Channel channel, Message message) throws IOException, InterruptedException {
    long deliveryTag = message.getMessageProperties().getDeliveryTag();
    log.info("消费者 deliveryTag:{} dataMsg:{} ",deliveryTag ,dataMsg);

}

@PostMapping("/image")
public void httpUpload(@RequestParam("file") MultipartFile file) throws IOException, UpException {
    String fileName = file.getOriginalFilename();
    if (fileName == null) {
        return R.result(502, "图片不合法");
    }
    String[] split = fileName.split("\\.");
    String suffix = split[split.length - 1];
    String filePath = "/upload/" + type + "/" + IdUtil.randomUUID() + "." + suffix;
    Response response = restManager.writeFile(filePath, file.getInputStream(), new HashMap<>());
    if (response.code() != 200) {
        log.error(response.toString());
        return R.result(503, "上游接口错误，请与技术支持联系");
    }
}

//执行耗时:9 ms,击败了97.62% 的Java用户
//内存消耗:45.3 MB,击败了12.84% 的Java用户
class Solution {
    public int shipWithinDays(int[] weights, int days) {
        // 确定二分查找左右边界
        int left = Integer.MIN_VALUE;
        int right = 0;
        for (int weight : weights) {
            left = Math.max(weight, left);
            right += weight;
        }
        while (left < right) {
            int mid = (left + right) / 2;
            // need 为需要运送的天数
            // cur 为当前这一天已经运送的包裹重量之和
            int need = 1, cur = 0;
            for (int weight : weights) {
                //这个地方注意判断条件
                if (cur + weight > mid) {
                    ++need;
                    cur = 0;
                }
                cur += weight;
            }
            if (need <= days) {
                right = mid;
            } else {
                //mid不应该被包含进来
                left = mid + 1;
            }
        }
        return left;
    }
}

//执行耗时:14 ms,击败了16.27% 的Java用户
//内存消耗:39.8 MB,击败了81.81% 的Java用户
class Solution {
    char[] arrs;
    char[] arrp;

    public boolean isMatch(String s, String p) {
        arrs = s.toCharArray();
        arrp = p.toCharArray();
        return dp(0,0);
    }

    public boolean dp(int indexS, int indexP) {
        int m = arrs.length;
        int n = arrp.length;
        //base case
        if (indexP == n) return indexS == m;
        if (indexS == m) {
            //判断剩余元素是否为奇数
            if ((n - indexP) % 2 == 1) {
                //如果剩余元素是奇数，那么直接就不能够完全消除掉
                return false;
            }
            for (; indexP + 1 < n; indexP = indexP + 2) {
                if (arrp[indexP + 1] != '*') {
                    return false;
                }
            }
            return true;
        }
        //开始递归操作
        boolean res = false;
        //如果当前位置匹配
        if (arrs[indexS] == arrp[indexP] || arrp[indexP] == '.') {
            //如果下一位是*，name我们要考虑用不用掉这个*
            if (indexP < n - 1 && arrp[indexP + 1] == '*') {
                // 这个*代表匹配indexP的元素0次（indexP+1是*，跳过
                // 第二种情况代表着匹配多次，也就是说indexS递增，indexP不变
                res = dp(indexS,indexP+2) ||
                        dp(indexS+1,indexP);
            }else{
                res = dp(indexS+1,indexP+1);
            }
        } else {
            //如果当前位置不匹配，那么就只能消耗掉（字母*）
            if (indexP < n - 1 && arrp[indexP + 1] == '*') {
                res = dp(indexS, indexP + 2);
            } else {
                res = false;
            }
        }
        return res;
    }
}

//执行耗时:1 ms,击败了99.97% 的Java用户
//内存消耗:39.9 MB,击败了77.69% 的Java用户
class Solution {
    char[] arrs;
    char[] arrp;
    boolean[][] ans;

    public boolean isMatch(String s, String p) {
        arrs = s.toCharArray();
        arrp = p.toCharArray();
        ans = new boolean[s.length() + 1][p.length() + 1];
        //默认情况应该是dp[0][0] = true;
        ans[0][0] = true;
        dp();
        return ans[arrs.length][arrp.length];
    }

    public void dp() {
        for (int indexS = 0; indexS <= arrs.length; indexS++) {
            for (int indexP = 1; indexP <= arrp.length; indexP++) {
                if (arrp[indexP - 1] != '*') {
                    //这一位不是*，这一位可以靠自己
                    if (check(indexS - 1, indexP - 1)) {
                        ans[indexS][indexP] = ans[indexS - 1][indexP - 1];
                    }
                } else {
                    /**
                     * 第indexP位是*
                     * arrp[indexP-1]是*
                     * arrp[indexP-2]是可以被消掉的
                     * 匹配多次的是arrp[indexP-2]
                     */
                    if (indexP >= 2)
                        //相当于向前缩了两位，在编号上-2即可
                        ans[indexS][indexP] = ans[indexS][indexP - 2];
                    //匹配多次的情况，检查当前字符和*前面的字符是否一致，一致才有下文
                    if (check(indexS - 1, indexP - 2)) {
                        //如果一致，还要考虑前一位和当前的匹配关系，前一位可能是匹配0次，也可能是匹配一次，需要推倒回去，这也是很多情况的一个压缩！！！
//①只需要匹配1次：if保证了匹配，递归一次变匹配0次
//②匹配多次，我们削减待匹配的字符串，直到0次
                        ans[indexS][indexP] = ans[indexS - 1][indexP] || ans[indexS][indexP];
                    }
                }
            }
        }

    }

    public boolean check(int indexS, int indexP) {
        if (indexS == -1) return false;
        if (arrp[indexP] == '.' || arrp[indexP] == arrs[indexS]) {
            return true;
        }
        return false;
    }
}

//执行耗时:33 ms,击败了9.81% 的Java用户 
//内存消耗:42 MB,击败了5.03% 的Java用户
class Solution {

    public boolean isMatch(String s, String p) {
        return s.matches(p);
    }
}

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++){
                if(nums[i] + nums[j] == target){
                    return new int[]{i,j};
                }
            }
        }
        return null;
    }
}

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; ++i) {
            if (hashtable.containsKey(nums[i])) {
                return new int[]{hashtable.get(nums[i]), i};
            }
            hashtable.put(target - nums[i], i);
        }
        return new int[0];
    }
}