weixin_44371237的博客

//每周某个特定时间执行public class ScheduledDay { public static void main(String[] args) { //获取当前时间 LocalDateTime now = LocalDateTime.now(); System.out.println(now); //获取目标时间（周一，03：59） LocalDateTime target = now.withHour(

5秒后，每秒执行一次public class ScheduledRate { public static void main(String[] args) { ScheduledExecutorService pool = scheduledExecutorService(); //定时循环执行，5秒后，每秒执行一次 pool.scheduleAtFixedRate(() -> { System.out.println(

以下代码，任务1，1/0出异常，任务2就不执行public static void main(String[] args) { Timer timer = new Timer(); TimerTask task = new TimerTask() { @SneakyThrows @Override public void run() { System.out.println("1"); int.

ThreadPoolExecutor参数说明corePoolSize（核心或者常驻，比如银行有10个窗口，平常只开放5个）maximumPoolSize（最大线程数量，银行有10个窗口）keepAliveTime（银行有10个窗口，只开放5个，忽然来了很多人，临时开放很多接口，结束后恢复常驻线程时间）unit - keepAliveTime （参数的时间单位）workQueue（常驻线程用完了，就会放到阻塞队列中）threadFactory （执行程序创建新线程时使用的工厂）RejectedE

volitile修饰Map说明map是不断变化的

一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。public static void main(String[] args) { Semaphore semaphore=new Semaphore(3); for(int i=1;i

问题，中间线程还没走完，最后的线程已经完成public class Problem { public static void main(String[] args){ //问题，中间线程还没走完，最后的线程已经完成 for (int i = 0; i < 10; i++) { new Thread(() -> { System.out.println(Thread.currentThread().g

可取消的异步计算。利用开始和取消计算的方法、查询计算是否完成的方法和获取计算结果的方法，此类提供了对 Future 的基本实现。仅在计算完成时才能获取结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。就是开辟一个线程专门计算某项，最后在汇总相当于，考试先做会的，不会的后面做，再一起汇总。...

synchronized写法Lock写法public class TestReentrantLock { public static void main(String[] args) { Lock lock=new ReentrantLock(); new Thread(()->{ lock.lock(); try { System.out.println(Thread.cu.

从哪里休眠就从哪里唤醒，所以如下if(number!=0)不执行正确写法用whileif与while区别if 只做一次判断while 总在循环中while(true){i++;}//i无限累加，死循环/

死锁演示代码public class TestDeadLock { static Object a = new Object(); static Object b = new Object(); public static void main(String[] args) { new Thread(() -> { synchronized (a) { System.out.println(Threa..

线程同步：同一进程的多个线程共享同一块存储空间解决冲突：访问时，加入Synchronized 锁机制，当一个线程获得排他锁，其他线程就必须等待释放存在问题：1，一个线程持有锁，会导致其他线程挂起2，性能问题：加锁，释放锁，会导致较多上下文切换和调度延时3，优先级倒挂：较高优先级的等待较低优先级的锁4，sleep不会释放锁package com.chenxb.myThread;import java.math.BigDecimal;public class ThreadSynchro

守护线程Daemon，也称“服务线程”1，线程分为：用户线程（默认false），守护线程（true）2，JVM必须确保线程执行完毕3，JVM不用等待守护线程执行完毕4，守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务生命周期：守护进程是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。也就是说守护线程不依赖于终端，但是依赖于系统，与系统“同生共死”。当JVM中所有的线程都是守护线程的时候，JVM就可以退出了。如果还有一个或以上的非守护线

线程优先级高，只是权重高，获得CPU调度的概率高，并不是一定排前面package com.chenxb.myThread;public class TestPriority { public static void main(String[] args) { Thread thread1= new Thread(()-> System.out.println("111")); thread1.setPriority(1); thread1.

package com.chenxb.myThread;class MainState { public static void main(String[] args) { Thread thread = new Thread(() -> { for (int i = 0; i < 5; i++) { try { Thread.sleep(1000);

静态代理总结：1，真实对象和代理对象都要实现同一接口2，代理对象要代理真实角色3，代理对象可以做很多真实对象做不了的事情4，真实对象专注做自己的核心业务Thread实现过程，其实就是静态代理的实现过程：1，用一个类去实现Runnable接口（真实对象）2，而Thread类本身就是Runnable接口的实现类（代理对象）（设置目标对象为真实对象的类型）3，把真实对象装入代理对象Lambda注意：1，前提是接口为函数式接口2，lambda有一行代码的情况下，才能简化成一行，如果多行，则用代

package com.chenxb.myThread;public class TestJoin implements Runnable { @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("thread" + i); } }}class MainJoin { public static

礼让不一定能成功，原理是让CPU重新调度package com.chenxb.myThread;//线程礼让public class testYield implements Runnable { @Override public void run() { //for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + "线程

停止线程1，建议用标志停止，设立一个标志位2，不要用stop或destory等过时方法，可能存在BUGpackage com.chenxb.myThread;/*停止线程1，建议用标志停止，设立一个标志位2，不要用stop或destory等过时方法，可能存在BUG */public class testStop implements Runnable { private boolean flag = true; @Override public void run(

前台页面访问，延时10秒后显示package com.chenxb.mySpringboot.controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class HelloController { @RequestMapping("

线程状态

静态代理总结：1，真实对象和代理对象都要实现同一接口2，代理对象要代理真实角色3，代理对象可以做很多真实对象做不了的事情4，真实对象专注做自己的核心业务public class StaticProxy { public static void main(String[] args) {// new Thread(new Runnable() {// @Override// public void run() {////

public class MyRunnable implements Runnable { @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("run类线程" + i); } } public static void main(String[] args) { MyRunnable .