【尚硅谷周阳--JUC并发编程】【第五章--LockSupport与线程中断】

已于 2024-03-13 12:10:01 修改
阅读量867 收藏 25
点赞数 31
分类专栏： JUC java 文章标签： java intellij-idea
于 2024-03-13 12:08:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45046083/article/details/136556536
版权
java 同时被 2 个专栏收录
16 篇文章 1 订阅
订阅专栏
JUC
12 篇文章 0 订阅
订阅专栏

【尚硅谷周阳--JUC并发编程】【第五章--LockSupport与线程中断】

一、线程中断机制

1、java.lang.thread下三个中断方法

在这里插入图片描述

2、什么是中断机制(协商机制)

  1. 一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止，自己来决定自己的命运，所以Thread.stop，Thread.suspend，Thread.resume都已经被废弃了
  2. 在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。因此，Java提供了一种用于停止线程的协商机制–中断，也即中断标识协商机制
  3. **中断只是一种协作协商机制，Java没有给中断增加任何语法，中断的过程完全需要程序员自己实现。**若要中断一个线程，你需要手动调用该线程的interrupt方法，该方法也仅仅是将线程对象的中断标识设成true；接着你需要自己写代码不断地检测当前线程的标识位，如果为true，标识别的线程请求这条线程中断，此时究竟该做什么需要你自己写代码实现。
  4. 每个线程对象中都有一个中断标识位，用于表示线程是否被中断；该表示位为true表示中断，为false表示未中断；通过调用线程对象的interrupt方法将该现成的标识设为true；可以在别的线程中调用，也可以在自己的线程中调用。

3、中断的相关API方法之三大方法说明

3.1、public void interrupt()

  • 实例方法interrupt()仅仅是设置线程的中断状态为true，发起一个协商而不会立即停止线程

3.2、public static boolean interrupted()

  • 这个静态方法做了两件事：判断线程是否被中断并清除当前中断状态。
    • 返回当前线程的中断状态，测试当前线程是否已被中断
    • 将当前线程的中断状态清零并重新设为false，清除线程的中断状态
  • 此方法有点不好理解，如果连续两次调用此方法，则第二次调用将返回false，因为连续调用两次的结果可能不一样

3.3、public boolean isInterrupted()

  • 这个实例方法判断当前线程是否被中断(通过检查中断标志位)

4、中断机制案例

4.1、如何停止中断运行中的线程？

4.1.1、通过一个volatile变量实现
public class InterruptDemo {

    static volatile boolean isStop = false;
    public static void main(String[] args) {

        new Thread(() -> {
            while (true) {
                if (isStop) {
                    System.out.println(Thread.currentThread().getName() + "\t isStop值被修改为true，程序停止");
                    break;
                }
                System.out.println("-------hello volatile");
            }
        }, "t1").start();

        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }


        new Thread(() -> {
            isStop = true;
        }, "t2").start();

    }
}
4.1.2、通过AtomicBoolean实现
public class InterruptDemo {

    static AtomicBoolean atomicBoolean = new AtomicBoolean(false);
    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                if (atomicBoolean.get()) {
                    System.out.println(Thread.currentThread().getName() + "\t isStop值被修改为true，程序停止");
                    break;
                }
                System.out.println("-------hello AtomicBoolean");
            }
        }, "t1").start();

        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }


        new Thread(() -> {
            atomicBoolean.set(true);
        }, "t2").start();
    }
}
4.1.3、通过Thread类自带的中断api实例方法实现
  • 在需要中断的线程中，不断监听中断状态，一旦发生中断，就执行相应的中断处理业务逻辑stop线程
public class InterruptDemo {

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println(Thread.currentThread().getName() + "\t isInterrupted()被修改为true，程序停止");
                    break;
                }
                System.out.println("t1 ------hello interrupt api");
            }
        }, "t1");

        t1.start();

        try {
            TimeUnit.MICROSECONDS.sleep(20);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        // t1.interrupt();
        new Thread(t1::interrupt, "t2").start();

    }
}
4.1.4、源码分析
  • public void interrupt()
    底层调用了interrupt0()方法，这是一个native方法
    • 如果该线程阻塞的调用wait() ， wait(long) ，或wait(long, int)的方法Object类，或者在join() ， join(long) ， join(long, int) ， sleep(long) ，或sleep(long, int) ，这个类的方法，那么它的中断状态将被清除，并且将收到一个InterruptedException 。
    • 中断不存在的线程不需要任何效果。
      在这里插入图片描述
  • public boolean isInterrupted()
    底层调用了isInterrupted(boolean ClearInterrupted)，这是一个native方法。该方法入参用于指定是否需要将中断标志位清零(即修改为false)

在这里插入图片描述

4.1.5、总结
  • 具体来说，当一个线程，调用interrupt()时
    • 如果线程处于正常活动状态，那么会将该线程的中断标志设置位true，仅此而已。被设置中断标志的线程将继续正常运行，不受影响。所以，interrupt()并不能真正的中断线程，需要被调用的线程自己进行配合才行。
    • 如果线程处于被阻塞状态(例如处于sleep，wait，join等状态)，在别的线程中调用当前线程对象的interrupt方法，那么线程将立即退出被阻塞的状态，并抛出一个InterruptedException异常。

4.2、当前线程的中断标识为true，是不是线程就立刻停止？

  • 不会停止如果线程处于正常活动状态，那么interrupt()只会将该线程的中断标志设置位true，仅此而已。被设置中断标志的线程将继续正常运行，不受影响。
public class InterruptDemo2 {

    public static void main(String[] args) {
        // 实例方法interrupt()仅仅是设置线程的中断状态位设置为ture，不会停止线程
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 400; i++) {
                System.out.println("------:" + i);
            }
            // true
            System.out.println("t1线程调用interrupt()后的中断标识02：" + Thread.currentThread().isInterrupted());
        }, "t1");
        t1.start();
        // false
        System.out.println("t1线程默认的中断标志：" + t1.isInterrupted());

        // 暂停毫秒
        try {
            TimeUnit.MILLISECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        t1.interrupt();
        // true
        System.out.println("t1线程调用interrupt()后的中断标识01：" + t1.isInterrupted());

        // 暂停毫秒
        try {
            TimeUnit.MILLISECONDS.sleep(2000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        // false--中断不活动的线程不会产生任何影响
        System.out.println("t1线程调用interrupt()后的中断标识03：" + t1.isInterrupted());

    }
}
  • 如果该线程阻塞的调用wait() ， wait(long) ，或wait(long, int)的方法Object类，或者在join() ， join(long) ， join(long, int) ， sleep(long) ，或sleep(long, int) ，这个类的方法，那么它的中断状态将被清除，并且将收到一个InterruptedException 。此时需要在catch块中二次调用interrupt()方法。

/**
 * 1。中断标志位 ，默认为false
 * 2. t2----->t1发出了中断协商，t2调用t1.interrupt()，中断标志位true
 * 3. 中孤单标志位true。正常情况，程序停止
 * 4. 中断标志位true。异常情况，InterruptedException，将会把中断状态清除，中断标志位false
 *    导致无限循环
 * 5. 在catch块中，需要再次给中断标志位设置为true，2次调用停止程序
 */
public class InterruptDemo3 {

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println(Thread.currentThread().getName()
                            + "\t 中断标志位： true，程序停止");
                    break;
                }
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    // 为什么要在异常处，再调用一次？
                    Thread.currentThread().interrupt();
                    e.printStackTrace();
                }
                System.out.println("------hello InterruptDemo3");
            }
        }, "t1");

        t1.start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(t1::interrupt, "t2").start();
    }
}

  • sleep方法抛出InterruptException后，中断标识也被清空置为false，我们在catch没有通过调用Thread.currentThread.interrupt()方法再次将中断标志设置位true，这就会导致无限循环了。

  • 总结：中断只是一种协商机制，修改中断标识位仅此而已，不是立刻stop打断。

4.3、静态方法Thread.interrupted()，谈谈你的理解？

  • 判断线程是否被中断并清除当前中断状态
  • 这个方法做了两件事
    • 返回当前线程的中断状态，测试当前线程是否已被中断
    • 将当前线程的中断状态清零并重新设为false，清除线程的中断状态
  • 此方法有点不好理解，如果连续两次调用此方法，则第二次调用将返回false，因为连续调用两次的结果可能不一样。
public class InterruptDemo4 {


    public static void main(String[] args) {
        // 测试当前线程是否被中断(检查中断标志)，返回一个boolean并清除中断状态
        // 第二次再调用中断状态已经被清除，将返回一个false

        System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());// false
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());// false
        System.out.println("------1");
        // 将终端标志位设置为true
        Thread.currentThread().interrupt();
        System.out.println("------2");
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());// true
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());// false

    }
}
  • 通过源码可以知道Thread.interrupted()方法底层和Thread.isInterrupted()方法一样，也是调用的native方法isInterrupted(boolean ClearInterrupted)，他们区别是传入的参数值ClearInterrupted不同，前者是true，表示执行完后中断标志位会清零；而后者传入的是false，不会清除中断标志位
    在这里插入图片描述

二、LockSupport是什么

用于创建锁和其他同步类的基本线程阻塞原语。 它里面有两个重要的方法
在这里插入图片描述

三、线程等待唤醒机制

3种让线程等待和换新的方法

1、使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程

  1. 当一个线程在对象上调用 wait() 方法时，该线程会释放对象的锁。在等待期间，其他线程可以获取相同对象上的锁并执行各自的操作。直到其他线程调用 notify() 或 notifyAll() 方法来唤醒处于等待状态的线程，被唤醒的线程才能重新竞争对象的锁。
public class LockSupportDemo {

    public static void main(String[] args) {
        Object objectLock = new Object();

        new Thread(() -> {
            synchronized (objectLock) {
                System.out.println(Thread.currentThread().getName() + "\t------ come in");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t------ 被唤醒");
            }
        }, "t1").start();

        // 线程等待
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            synchronized (objectLock) {
                objectLock.notify();
                System.out.println(Thread.currentThread().getName() + "\t------发出通知");
            }
        }, "t2").start();
    }
}
  1. 异常情况1
public class LockSupportDemo {

    public static void main(String[] args) {
        Object objectLock = new Object();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t------ come in");
            try {
                objectLock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t------ 被唤醒");
        }, "t1").start();

        // 线程等待
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            objectLock.notify();
            System.out.println(Thread.currentThread().getName() + "\t------发出通知");
        }, "t2").start();
    }
}

在这里插入图片描述
会抛出，IllegalMonitorStateException异常，object.wait()和object.notify()方法一定需要先持有锁之后才能使用

  1. 异常情况2
public class LockSupportDemo {

    public static void main(String[] args) {
        Object objectLock = new Object();

        new Thread(() -> {
            // 线程等待
            try {
                TimeUnit.MILLISECONDS.sleep(200);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            
            synchronized (objectLock) {
                System.out.println(Thread.currentThread().getName() + "\t------ come in");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t------ 被唤醒");
            }
        }, "t1").start();


        new Thread(() -> {
            synchronized (objectLock) {
                objectLock.notify();
                System.out.println(Thread.currentThread().getName() + "\t------发出通知");
            }
        }, "t2").start();
    }
}

将notify()方法放到wait()方法前面，会导致程序无法执行一直处于等待状态，无法唤醒
在这里插入图片描述
4. 总结：wait和notify方法必须要在同步块或者方法里面，需要成对出现使用，且必须先wait后notify

2、使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程

  1. lock.newCondition() 是 Java 中 Lock 接口提供的方法之一，用于创建一个新的条件变量（Condition）。条件变量是与锁相关联的，可以通过条件变量来实现线程间的等待和通知机制。具体来说，lock.newCondition() 方法会返回一个与当前锁关联的新的条件变量。通过该条件变量，可以实现线程的等待和唤醒操作，而不需要使用 Object 的 wait()、notify() 和 notifyAll() 方法。使用条件变量时，通常会先获取锁，然后通过条件变量进行等待或唤醒操作，最后释放锁。
public class LockSupportDemo {

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();

        Condition condition = lock.newCondition();

        new Thread(() -> {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t ------come in");
                condition.await();
                System.out.println(Thread.currentThread().getName() + "\t ------被唤醒");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "\t ------发出通知");
            } finally {
                lock.unlock();
            }
        }, "t2").start();

    }
}
  1. 异常情况1
public class LockSupportDemo {

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();

        Condition condition = lock.newCondition();

        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + "\t ------come in");
                condition.await();
                System.out.println(Thread.currentThread().getName() + "\t ------被唤醒");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, "t1").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        new Thread(() -> {
            condition.signal();
            System.out.println(Thread.currentThread().getName() + "\t ------发出通知");
        }, "t2").start();

    }
}

如果没有锁块会抛出IllegalMonitorStateException异常，也就是说await()方法和signal()方法也需要先持有锁之后才能使用。
在这里插入图片描述

  1. 异常情况2
public class LockSupportDemo {

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();

        Condition condition = lock.newCondition();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t ------come in");
                condition.await();
                System.out.println(Thread.currentThread().getName() + "\t ------被唤醒");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        }, "t1").start();
        
        new Thread(() -> {
            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "\t ------发出通知");
            } finally {
                lock.unlock();
            }
        }, "t2").start();

    }
}

和前面一样，若将signal()方法放到await()方法前面，会导致程序无法执行一直处于等待状态，无法唤醒在这里插入图片描述

  1. 总结：Condition中的线程等待和环形方法，需要现获取锁，且一定要先await后signal，顺序不能反。

3、上述两个对象Object和Condition使用的限制条件

  1. 线程先要获得并持有锁，必须在锁块(synchronized或lock)中
  2. 必须要先等待后唤醒，线程才能够被唤醒

4、LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程

4.1、是什么？

  1. 通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作
  2. 这个类与每个使用它的线程相关联，一个许可证（在Semaphore类的意义上）。 如果许可证可用，则呼叫park将park返回，在此过程中消耗它; 否则可能会阻止。 致电unpark使许可证可用，如果尚不可用。 （与信号量不同，许可证不能累积，最多只有一个。）

4.2、主要方法

  1. 阻塞park()/park(Obeject blocker)
    阻塞当前线程/阻塞传入的具体线程
    public static void park() {
        UNSAFE.park(false, 0L);
    }

在这里插入图片描述
调用LockSupport.park()时，permit许可证默认没有不能放行，所以一开始调park()方法当前线程就会阻塞，直到别的线程给当前线程发放permit，park方法才会被唤醒。

  1. 唤醒unpark(Thread thread)唤醒处于阻塞状态的指定线程
    public static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }

在这里插入图片描述
调用LockSupport.unpark(thread)方法后，就会将thread线程的许可证permit发放，会自动唤醒park线程，即之前阻塞中的LockSupport.park()方法会立即返回。

4.3、代码演示

  1. 优点

    • 天生无锁块要求
    • 之前错误地先唤醒后等待，LockSupport照样支持

  2. 注意

    • 还是需要成双成对出现
public class LockSupportDemo {

    public static void main(String[] args) {
        
        Thread t1 = new Thread(() -> {

            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + "\t" + System.currentTimeMillis() + "------come in");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t" + System.currentTimeMillis() + "------被唤醒");
        }, "t1");
        t1.start();



        new Thread(() -> {
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName() + "\t" + System.currentTimeMillis() + "------发出通知");
        }, "t2").start();

    }
}

在这里插入图片描述

  1. 许可证不能累积，最多只有一个
public class LockSupportDemo {

    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {

            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + "\t" + System.currentTimeMillis() + "------come in");
            LockSupport.park();
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t" + System.currentTimeMillis() + "------被唤醒");
        }, "t1");
        t1.start();



        new Thread(() -> {
            LockSupport.unpark(t1);
            LockSupport.unpark(t1);
            LockSupport.unpark(t1);
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName() + "\t" + System.currentTimeMillis() + "------发出通知");
        }, "t2").start();

    }
}

在这里插入图片描述

4.4、重点说明

  1. LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
  2. LockSupport是一个线程阻塞工具，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根结底，LockSupport调用的unsafe中的native代码。
  3. LockSupport提供park()和unpark()方法实现阻塞线程和解除线程阻塞的过程，LockSupport和每个使用它的线程都有一个许可(permit)关联。每个线程都有一个相关的permit，permit最多只有一个，重复调用unpark也不会积累凭证。
  4. 形象的理解
    • 线程阻塞需要消耗凭证(permit)，这个凭证最多只有一个
    • 当调用park方法时
      • 如果有凭证，则会直接消耗掉这个凭证然后正常退出
      • 如果无凭证，就必须阻塞等待凭证可用
    • 而unpark则相反，他会增加一个凭证，但凭证最多只能有一个，累加无效。

4.5、面试题

  1. 为什么可以突破wait/notify的原有调用顺序？
    因为unpark获得了一个凭证，之后再调用park方法，就可以名正言顺的凭证消费，故不会阻塞。先发放了凭证后续可以畅通无阻。
  2. 为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程？
    因为凭证的数量最多为1，连续调用两次unpark和调用一次unpark效果一样，只会增加一个凭证；而调用两次park缺需要消费两个凭证，证不够，不能放行。
匍匐、前行
关注
专栏目录
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档
09-21
1、根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档 2、包含源码 视频地址：https://www.bilibili.com/video/BV1ar4y1x727/?p=1&vd_source=c634d163b940964d44747b4c3976117b 参考资料：...
Redis笔记-尚硅谷周阳V1.3-脑图
06-16
根据《Redis笔记-尚硅谷周阳V1.3》整理，脑图、思维导图xmind
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
word源码java-ShangGuiGu-ZhouYang-JUC:周阳-juc
06-05
线程与进程相似,它是比进程更小的执行单位.一个进程在执行过程中可以产生多个线程. 同类线程有共享的堆和方法区(jdk8之后的元空间(MetaSpace)), 每个线程又有自己的程序计数器,虚拟机栈,本地方法栈. 系统在各个线程...
Java基础07
最新发布
m0_74977981的博客
11-11 532
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
JAVA-01-变量
LJH_laura_li的博客
11-08 397
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 235
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 911
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 650
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 332
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
在 C# 中，如何实现观察者模式？
Leo的博客
11-06 477
观察者模式是一种设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当该主题对象的状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。这个模式常用于事件处理系统、通知系统等场景。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 1001
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
ArkTS--应用状态
qq_63946637的博客
11-10 494
本文旨在帮助大家学习鸿蒙中的LocalStorage和AppStorage
greendao使用封装
白高林的专栏
11-07 444
greenDAO
C++接口类， 抽象类和实体类简述
Joshua的专栏
11-09 267
在C++中，接口类通常是指只包含纯虚函数（pure virtual functions）的类。接口类的主要目的是定义一组通用的行为，但不提供任何具体的实现。通过上述示例可以看出，C++通过抽象类和多重继承实现了类似Java中的单一实体继承和多接口继承的效果。在C++中，虽然没有像Java那样明确的“接口”关键字，但可以通过抽象类和纯虚函数来实现接口的概念。实体类是指可以实例化的类，即类中所有的函数都有具体的实现，包括继承自抽象类的纯虚函数。单实体继承（多接口继承）的设计理念和好处。类继承和接口继承的比较。
【JAVA】Java基础—面向对象编程基础：类与对象的概念
thinking_chou的专栏
11-07 1035
类是一个用户定义的数据类型，它包含了属性和方法。属性用于描述对象的特征，方法用于描述对象的行为。类与对象是Java编程的核心概念。类是对象的蓝图，定义了对象的属性和方法；对象是类的实例，具有独立的状态和行为。通过类与对象，我们可以更好地模拟现实世界中的事物，使得程序设计更加清晰和模块化。
【前端】JavaScript 方法速查大全-DOM、BOM、时间、处理JS原生问题（三）
万物皆有灵
11-06 955
在现代Web开发中，JavaScript是不可或缺的编程语言。无论是前端开发还是后端服务，掌握JavaScript的各种方法和技巧都是每位开发者的必修课。本文将为您提供一个全面、系统的JavaScript方法参考，涵盖数组操作、对象处理、DOM与BOM接口、时间处理、解决JS原生问题、函数应用、正则表达式、数据格式转换、随机数生成、文本处理等众多方面。无论您是初学者还是资深开发者，这份速查大全都将成为您日常开发中的得力助手！💪。
JAVA制作SSO用户中心实现同步登录
qq_27246521的博客
11-07 101
如果用户中心的redis出现问题。一般是通过前端访问后端接口时请求中的Authorization 实现的。登录时在用户中心redis保存 code与token的对应关系。此链接跳转时，用code获取token及用户信息返回前端即可。而且 其它系统有自己的注册模块还需要同步注册信息至用户中心。是没有保存session信息的。则通过不同系统跳转时通过，跳转连接后添加code。则通过不同系统跳转时通过，跳转连接后添加code。如果前端项目是不同的分开的。跳转进入的系统 这时通过接口请求用户中心。
尚硅谷JUC并发编程资料整理与源码解析
资源摘要信息:"尚硅谷JUC并发编程" 尚硅谷JUC并发编程文档是一份针对Java并发编程的深入学习资料，内容主要对标阿里P6-P7级别的技术能力要求。文档通过周阳的讲解，结合实际的源码分析，对Java Util Concurrent...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值