多线程原理详解【中】（静态代理模式案例演示、线程停止、线程睡眠 sleep、线程礼让 yield、线程强制执行 join 、线程状态 state、优先级 priority、守护线程 daemon）

已于 2024-04-13 17:42:00 修改
阅读量709 收藏 9
点赞数 27
分类专栏： Java底层源码、原理 系列 文章标签： 代理模式 多线程原理详解
于 2024-04-10 20:05:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44411039/article/details/137550166
版权

目录

=–=–=–=–=–=–=–=–=

多线程原理详解【上】

多线程原理详解【中】


多线程原理详解【下】


静态代理模式（与多线程的关系演示）


静态代理模式就是线程的一个底部的实现原理，通过这个结婚案例 来 演示静态代理和多线程之间的关系：

在这里插入图片描述


演示静态代理 对比 Thread

如图，可以看到这个静态代理的例子，和之前演示多线程时，通过创建一个Thread线程对象，把自定义的线程类对象作为参数传递进去，让 Thread 线程对象调用 start() 方法，去实现自定义线程类对象里面的 run() 方法是一样的。
都是用到了代理模式。

因为静态代理模式就是线程的一个底部的实现原理

静态代理模式总结：
真实对象和代理对象都要实现同一个接口
代理对象要代理真实角色

好处：
代理对象可以做很多真实对象做不了的事情
真实对象专注做自己的事情即可

在这里插入图片描述


分析静态代理模式案例的逻辑

在这里插入图片描述


具体代码


//静态代理模式总结：
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色

//好处：
//代理对象可以做很多真实对象做不了的事情
//真实对象专注做自己的事情即可
public class ProxyStatic {

    public static void main(String[] args) {
        You you = new You();
        //如果不用代理模式，就是自己调用结婚方法
        //you.HappyMarry();

        //使用代理模式，把自己交给婚庆公司即可
        new WeddingCompany(you).HappyMarry();

        //和多线程的代理对比
        new Thread(() -> System.err.println("结婚")).start();

    }
}

//接口
interface Marry { void HappyMarry();}

//真实角色-->结婚本人
class You implements Marry {
    //实现接口方法
    @Override
    public void HappyMarry() {
        System.err.println("真实角色--你本人结婚了");
    }
}

//代理角色-->帮助你结婚
class WeddingCompany implements Marry {

    //代理目标对象 -- 结婚对象
    private Marry target;
    //构造器
    public WeddingCompany(Marry target) {
        this.target = target;
    }
    //实现接口方法
    @Override
    public void HappyMarry() {
        //结婚之前的方法
        before();
        //这个就是真实对象
        this.target.HappyMarry();
        //结婚之前的方法
        after();
    }
    //结婚之前的方法
    private void before() {
        System.err.println("代理对象--婚庆公司帮你结婚之前布置现场");
    }
    //结婚之前的方法
    private void after() {
        System.err.println("代理对象--婚庆公司在你结婚之后收尾款");
    }
}


线程五大状态


5大状态解释

在这里插入图片描述


在这里插入图片描述

NEW：创建状态

当我们使用 new 操作符创建一个线程对象时，该线程处于 New 状态。在这种状态下，线程对象已经被创建，但是还没有被启动。
在这个状态下，线程对象还没有和 CPU 时间片关联起来，CPU 还没有对这个线程进行调度，也就是说，它还没有执行 run() 方法。

RUNNABLE：就绪状态

在Java线程的生命周期中，RUNNABLE状态表示线程已经被启动并正在等待CPU时间片来执行代码。在这种状态下，线程正在运行或准备运行，但可能被挂起以让其他线程运行。

在RUNNABLE状态下，线程已经准备好执行代码，并且可以被操作系统调度为运行状态。当线程被调度并获得CPU时间片时，它将进入运行状态，并在自己的线程栈上执行代码。

Java线程的RUNNABLE状态其实是包括了传统操作系统线程的ready和running两个状态的。

TIMED_WAITING：定时等待状态

在Java线程的生命周期中，TIMED_WAITING状态表示线程正在等待某个特定时间内的某个事件发生，例如休眠(sleep)、等待(wait)、加锁(lock)等待超时、定时器(timer)等待、IO等待等操作。

当一个线程在调用Thread.sleep()、Object.wait()、Lock.tryLock(long timeout, TimeUnit unit)等方法时，线程将进入TIMED_WAITING状态，并在指定的时间内等待相应的事件发生。

TERMINATED：线程终止状态

线程正常执行完毕或者出现异常终止，就会进入这个状态。

在Java线程的生命周期中，TERMINATED状态是线程的最终状态，表示线程已经执行完毕并已经退出。当一个线程完成了它的工作，或者因为异常而提前结束时，它会进入TERMINATED状态。此时线程不再执行任何代码，并且无法回到任何其他状态。

"TERMINATED"和"DEAD"都表示线程已经终止，不再运行，但"TERMINATED"是Java线程的一种具体状态，而"DEAD"则是对终止线程的更通用的描述。

一些线程方法

在这里插入图片描述


线程的一些操作


1、线程停止 -> 自定义标识


1-1：演示自定义方法，通过标识切换来停止子线程的执行

在这里插入图片描述

在主线程弄个循环，当 i 值达到 95 时，调用停止线程的方法，修改标识，让子线程停止执行。

在这里插入图片描述


具体代码：
package cn.ljh.threaddemo.stopthread;

//测试停止线程的操作
//1、建议线程正常停止 --> 利用次数，不建议死循环
//2、建议使用标志位 --> 设置一个标志位
//3、不要使用 stop 或者 destroy 等过时或者 JDK 不建议使用的方法
public class TestStopThread implements Runnable {

    //1、设置一个标识位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.err.println("子线程：循环执行第【 "+ i++ +" 】个任务");
        }
    }

    //自定义一个线程停止的方法，修改标识
    public void customStopThread(){
        this.flag = false;
    }

    public static void main(String[] args) {

        //创建一个自定义线程对象作为代理对象
        TestStopThread t = new TestStopThread();
        //创建一个线程对象，调用 start 方法启动新线程
        new Thread(t).start();

        for (int i = 0; i < 100; i++) {
            System.err.println("主线程循环第：" + i + " 次");
            if (i == 95){
                //调用自定义停止线程的方法，切换标识，让线程停止
                t.customStopThread();
                System.err.println("停止子线程的执行============================");
            }
        }

    }

}

2、线程睡眠 -> sleep()


2-1：通过 sleep() 模拟网络延时

这个很简单，就线程对象Thread 调用 sleep() 方法而已，代码是之前的代码

在这里插入图片描述


具体代码
package cn.ljh.threaddemo.sleep_thread;


import cn.ljh.threaddemo.demo01.TestThread05;

//模拟网络延时：作用：放大问题的发生性
public class TestSleepThread implements Runnable {

    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (ticketNums <= 0) {
                    //终止当前所在循环
                    break;
                }
                System.err.println(Thread.currentThread().getName()
                        + "--->买到了第【 " + ticketNums-- + " 】张票");
            }

            //模拟延迟---1秒等于1000毫秒
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    public static void main(String[] args) {
        TestThread05 t = new TestThread05();
        //启动新线程  参数1：t 就是代理对象   参数2：name 就是当前线程名字
        Thread t1 = new Thread(t, "小黄");
        Thread t2 = new Thread(t, "小白");
        Thread t3 = new Thread(t, "小绿");

        t1.start();
        t2.start();
        t3.start();

    }

}

2-2：通过 sleep 模拟倒计时和定时获取当前时间

在这里插入图片描述


在这里插入图片描述


具体代码
package cn.ljh.threaddemo.sleep_thread;


import lombok.SneakyThrows;

import java.text.SimpleDateFormat;
import java.util.Date;

//使用 sleep 模拟倒计时
public class TestSleepThread02 {

    public static void main(String[] args) {
        countDown(10);
        currentTime();
    }

    //倒计时的方法
    @SneakyThrows
    public static void countDown(int num) {
        while (true) {
            Thread.sleep(1000);
            System.err.println("倒计时：" + num--);
            if (num<=0){
                break;
            }
        }
    }

    //打印当前系统时间方法
    @SneakyThrows
    public static void currentTime(){
        //获取系统当前时间
        Date nowTime = new Date(System.currentTimeMillis());
        while (true){
            Thread.sleep(1000);
            //格式化时间
            System.err.println(new SimpleDateFormat("HH:mm:ss").format(nowTime));
            //更新当前时间
            nowTime = new Date(System.currentTimeMillis());
        }
    }
    
}

3、线程礼让 -> yield

比如有 A 、B 两个线程都处于就绪状态，等待 CPU 调度，然后 CPU 调度了让 A线程执行，但是 A 线程在执行的时候，想让给 B 线程来执行，所以A线程就从运行状态转为就绪状态，然后再重新和B线程竞争。

这个礼让不是说下一次CPU就一定会调度B线程去执行，而是让两个线程重新竞争，也许A线程礼让后，重新竞争又是A线程竞争到。

在这里插入图片描述


3-1：演示两个线程进行礼让操作

在这里插入图片描述


具体代码
package cn.ljh.threaddemo.yield_thread;

import lombok.SneakyThrows;

//测试线程礼让
public class TestYieldThread {
    @SneakyThrows
    public static void main(String[] args) {
        MyYield t = new MyYield();
        new Thread(t,"线程A").start();
        //Thread.sleep(1000);
        new Thread(t,"线程B").start();

    }
}

//创建一个线程类
class MyYield implements Runnable{

    @Override
    public void run() {
        System.err.println(Thread.currentThread().getName()+" --> 开始执行");
        //线程礼让
        Thread.yield();
        System.err.println(Thread.currentThread().getName()+" --> 停止执行");
    }
}

4、线程强制执行 -> join

Join 合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞。

join 方法的主要作用就是同步，它可以使得线程之间的并行执行变为串行执行。
比如在A线程中调用了B线程的 join() 方法时，表示只有当 B 线程执行完毕时，A线程才能继续执行。

可以想象成插队，A线程在执行的过程中，B线程调用 join() 方法突然插队进来，并且需要等B线程执行完后，A线程才能继续执行。

使用 join() 方法会造成线程阻塞。


4-1：演示B线程插队A线程

这里【 Thread thread = new thread(t) 】只new 一个子线程来演示，如果需要多个线程演示

【 Thread t1 = new thread(t) 】
【 Thread t2 = new thread(t) 】
【 Thread t3 = new thread(t) 】
…
这样创建多个子线程出来，要在某个线程让 t3 插队的话，只需要在某个线程里面添加 t3.join() 即可

在这里插入图片描述


具体代码
package cn.ljh.threaddemo.join_thread;


//测试 join 方法
public class TestJoinThread implements Runnable {
    
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.err.println("线程B来了-----------> " + i);
        }
    }

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

        //创建自定义线程类对象
        TestJoinThread t = new TestJoinThread();
        //创建线程对象
        Thread thread = new Thread(t);
        //启动新线程
        thread.start();

        for (int i = 0; i < 50; i++) {
            if (i == 25) {
                //线程B插队
                thread.join();
            }
            System.err.println("主线程A正在执行=========> " + i);
        }
    }
}

5、线程状态观测 -> state

在这里插入图片描述


NEW 创建状态：
线程创建完成，但是还没被 start 方法调用启动

runnable 就绪状态：
线程对象调用start方法后，线程进入该状态，等待被CPU调度执行

timed_waiting 定时等待状态：

这里是Thread线程对象调用sleep()方法，让子线程进入定时等待状态。

当一个线程在调用Thread.sleep()、Object.wait()、Lock.tryLock(long timeout, TimeUnit unit) 等方法时，线程将进入TIMED_WAITING状态，并在指定的时间内等待相应的事件发生。

terminated 线程结束状态
线程正常执行完毕，或者遇到异常提前结束，就会进入这个状态。


5-1：演示观测线程的几个状态

在这里插入图片描述


注意点：
线程执行完毕后，是不能再次调用 start() 方法启动的。
线程是不能启动两次的，一个线程对象只能启动一次，否则报错。

在这里插入图片描述


具体代码
package cn.ljh.threaddemo.state_thread;


//观测线程状态
public class TestStateThread {

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

        //直接用 lambda 表达式，省略在类名后面显式地实现Runnable接口
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.err.println("线程执行结束............");
            }
        });

        //观察线程启动之前的线程状态
        Thread.State state = thread.getState();
        System.err.println("线程状态--> "+state);

        //观察线程启动之后的线程状态
        thread.start(); // 启动线程
        state = thread.getState();
        System.err.println("线程状态--> "+state);

        //只要子线程不终止，就一直更新线程状态
        while (state != Thread.State.TERMINATED){
            //每隔100毫秒，更新一次线程状态
            Thread.sleep(100);
            state = thread.getState();
            System.err.println("线程状态--> "+state);
        }
    }

}

6、线程的优先级 -> priority

优先级默认是 5 ；
优先级最高是10；最低是1；
设置优先级为10，则该线程被CPU调度到的概率最大。

在这里插入图片描述


在这里插入图片描述


6-1：演示线程的优先级

主线程，默认的优先级是【5】
在这里插入图片描述


线程的优先级演示

在这里插入图片描述


具体代码
package cn.ljh.threaddemo.priority_thread;

//测试线程的优先级
public class TestPriorityThread {
    public static void main(String[] args) {

        System.err.println("当前线程：【 " + Thread.currentThread().getName()
                + " 】，优先级为：【 " + Thread.currentThread().getPriority() + " 】");

        //new 一个自定义的线程类对象
        MyPriority t = new MyPriority();

        //创建线程类对象
        Thread t1 = new Thread(t,"t1");
        Thread t2 = new Thread(t,"t2");
        Thread t3 = new Thread(t,"t3");
        Thread t4 = new Thread(t,"t4");
        Thread t5 = new Thread(t,"t5");
        Thread t6 = new Thread(t,"t6");
        Thread t7 = new Thread(t,"t7");

        //先设置优先级，再启动
        t1.start();

        t2.setPriority(1); //设置优先级
        t2.start(); //启动线程


        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY); //MAX_PRIORITY = 10
        t4.start();

        t5.setPriority(-1);
        t5.start();

        t6.setPriority(0);
        t6.start();

        t7.setPriority(11);
        t7.start();
    }
}

//创建一个线程类
class MyPriority implements Runnable {

    @Override
    public void run() {
        System.err.println("当前线程：【 " + Thread.currentThread().getName()
                + " 】，优先级为：【 " + Thread.currentThread().getPriority() + " 】");
    }
}

7、守护线程 -> daemon

用户线程，比如 main 主线程
守护线程，比如 gc 垃圾回收线程

有 A、B 两个线程，把A设置成守护线程，那么只要B线程执行完，那么A线程也会停止执行。

当线程A被设置为守护线程（Daemon Thread）时，只要所有非守护线程（比如线程B）执行完毕并且主程序（通常是main线程）退出，JVM 就会自动退出，此时守护线程A也会被强制终止，不管它是否执行完毕。

守护线程（Daemon Thread）通常被用来提供后台服务或执行一些辅助性的任务，它们不应该执行关键性的任务或持有重要资源，因为它们的生命周期是依赖于非守护线程的。

在这里插入图片描述

JVM 不用等待守护线程执行完毕，因为主要是保证用户线程能正常执行，像是 gc 这种守护线程，JVM是不需要等待它执行完毕的。


在这里插入图片描述


7-1：测试守护线程

在这里插入图片描述


具体代码
package cn.ljh.threaddemo.daemon_thread;

//测试守护线程
public class TestDaemonThread {

    public static void main(String[] args) {
        God god = new God();
        People people = new People();

        //创建一个新线程
        Thread g = new Thread(god);
        //把 God 线程设置为守护线程
        //true表示该线程为守护线程； 默认是false 非守护线程，就是用户线程，正常的线程都是用户线程
        g.setDaemon(true);
        //启动线程
        g.start();

        //非守护线程，也就是用户线程-----------
        Thread p = new Thread(people);
        p.start();
    }
}

//创建一个线程类----神仙-----作为守护线程
class God implements Runnable{
    @Override
    public void run() {
        //守护线程通常会一直执行，直到非守护线程全部结束或者 JVM 退出，守护线程才会终止
        //所以这里用while循环为true一直执行下去
        while (true){
            System.err.println("守护线程------------------------");
        }
    }
}

//创建一个线程类----人-----作为非守护线程
class People implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.err.println("人类生活第【 "+ i +"】年");
        }
        System.err.println("100年后gg，这个非守护线程停止执行☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆");
    }
}

_L_J_H_
关注
  • 27
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java线程中wait,await,sleep,yield,join用法总结.pdf
06-28
Java线程中wait、await、sleep、yield、join用法汇总，文章里面总结了这些关键字的用法，并且里面带有源码帮助分析用法，此一文就可以理解这些关键字用法，推荐拥有
Java线程中yield与join方法的区别Java开发J
11-25
Java线程中yield与join方法的区别Java开发Java经验技巧共6页.pdf.zip
线程方法：停止线程、线程休眠_sleep、线程礼让_yield、线程强制执行_join
GNLEI1998的博客
03-13 256
线程 停止线程 不推荐使用jdk提供的stop（）、destroy（）方法【已废弃】 推荐线程自己停止下来。 建议使用一个标志位进行终止变量 例如当flag=false，则终止线程运行 package com.offcn.xiancheng; //测试线程停止 public class TestStop implements Runnable{ //设置一个标志位 private boolean flag = true; @Override public void run() { i
Java 从多线程到并发编程（四）——线程礼让yield 线程强制执行join 线程自我阻塞sleep 线程优先级 守护线程 守护进程
菜鸡的学习之路
02-19 2423
- 继上一次我们学习了线程优雅的停止方式以及线程的状态有哪些 - 本节将会帮助你了解... - yield —— 线程重新洗牌 - join —— 线程蛮横插队 - 线程优先级 —— 只是建议哟 - 守护进程 —— 主人还在 我就一直守护着他
Java--多线程--静态代理模式、lambda表达式、线程停止、线程休眠、线程礼让、线程强制执行
m0_37570287的博客
03-21 53
Java--多线程--静态代理模式、lambda表达式、线程停止、线程休眠、线程礼让、线程强制执行
多线程的方法：线程停止、线程休眠、线程礼让、线程强制执行
qq_43717995的博客
04-19 752
线程停止、线程休眠、线程礼让、线程强制执行 一、线程停止： 注意事项： 建议线程正常的停止：利用次数停止，不建议死循环。 建议使用标志符：设置一个flag。 不要使用stop和destroy等过时的或者JDK不建议使用的方法来停止。 public class TextStop implements Runnable{ boolean flag=true;//设置标志符 @Override public void run() { int i=0; w
java_多线程_线程停止_线程休眠_线程礼让_线程强制执行
xixihaha_coder的博客
06-20 139
线程状态 线程停止 测试stop 1.建议线程正常停止----->利用次数，不建议死循环 2.建议使用标志位----->设置一个标志位 3.不要使用stop或者destroy等过时或者JDK不建议使用的方法 代码演示 public class TestStop implements Runnable { // 1.设置一个标识位 private boolean flag = true; @Override public void run() { int i = 0; wh
Java多线程学习笔记（4）— “Thread类三个方法：线程休眠sleep()、线程礼让yield()、线程强制执行join()”
一切因为是码农
06-06 197
一、线程休眠sleep() sleep() 每个对象都有一把锁，sleep方法不会释放锁 sleep()方法的参数为需要睡眠的时间，单位：毫秒 sleep方法存在异常InterruptedException sleep在到达时间后线程进入就绪状态 sleep可以模拟网络延时，倒计时等 二、线程礼让yield() yield() 礼让线程，让当前正在执行的线程暂停，但不阻塞 直接让线程从运行状态转为就绪状态 让CPU重新调度，礼让不一定成功，看CPU心情 package book_practice;
5线程的停止，休眠，礼让、强制执行
yuan_boss的博客
07-14 69
线程 停止、休眠、礼让、强制执行 线程停止： /** * 停止线程不推荐使用JDK提供的stop或者destroy（已废弃） * 推荐线程自己停下来 * 建议使用一个标志位进行终止变量，当flag=false，则线程终止运行 */ 通过标志位来终止变量进而终止线程，具体代码实现如下： public class TestStop implements Runnable { //设置一个标志位 boolean flag = true; @Override public
多线程wait、notify、sleep、join、yield、synchronized关键字 深入了解线程(Thread)
达帮主
08-23 557
线程 工作快一年了，对线程老是躲来躲去只要是线程出现的ANR就会避让，看来这种态度还是不行，如果在这样下去只会是一个普通,打工仔，花店时间写DOME吧 1 . Thread是个线程，而且有自己的生命周期 2. 对于线程常用的操作有：wait（等待）、notify（唤醒）、notifyAll、sleep（睡眠）、join（阻塞）、yield（礼让） 3 . wait、notify、notify...
你能说出多线程中 sleep、yield、join 的用法及 sleep与wait区别吗？
方志朋的博客
02-25 60
点击上方“方志朋”，选择“设为星标”回复”666“获取新整理的面试资料作者：notelesscnblogs.com/noteless/p/10443446.htmlObject中的wait...
线程中sleep、join、yield、wait的区别
12-22
CSDN前辈众多，本文要说全部原创，那不现实，但本文绝对走肾之文，概念知识多来自前辈博文讲解，特此感谢。 文章末尾会给出本人学习过程中翻阅的优秀博文。 正文 给出一段准备代码，相信各位一看就懂，不懂，你不懂...
Java线程中yield与join方法的区别
12-22
之前，我讨论了一个wait()和sleep()方法区别的问题，这一次，我将会讨论join()和yield()方法的区别。坦白的说，实际上我并没有用过其中任何一个方法，所以，如果你感觉有不恰当的地方，请提出讨论。 　Java线程调度...
JavaScript使用yield模拟多线程的方法
12-11
本文实例讲述了JavaScript使用yield模拟多线程的方法。分享给大家供大家参考。具体分析如下： 在python和C#中都有yield方法，通过yield可以实现很多多线程才能实现的功能。 对javascript有版本要求：JavaScript 1.7...
对于子数组问题的动态规划
m0_74749208的博客
05-05 1371
先讲讲我对于这个问题的理解吧当谈到解决子数组问题时，动态规划(DP)是一个强大的工具，它在处理各种算法挑战时发挥着重要作用。动态规划是一种思想，它通过将问题分解成更小的子问题并以一种递归的方式解决它们，然后利用这些解决方案来构建原始问题的解。在动态规划中，我们经常会遇到两种状态：一种是单独成一段，另一种是以 i 结尾的子数组。通过枚举和动态规划，我们可以有效地解决子数组问题。枚举法需要考虑所有可能的子数组组合，然后比较它们以找到最优解。这种方法通常需要较多的时间和空间，因为它需要枚举所有可能性。
93、动态规划-最长回文子串
最新发布
qq_29434541的博客
05-08 309
首先从暴力递归开始，回文首尾指针相向运动肯定想等。递归面临很多重复计算，这个时候可以使用动态规划。
设计模式: 代理模式
m0_59925573的博客
05-02 1171
代理模式可以在不改变对象的代码的情况下，为该对象添加额外的功能，例如延迟初始化、访问控制、日志记录、缓存等。Spring AOP通过创建目标对象的代理对象，可以在不修改目标对象的情况下，控制横切关注点（如日志、事务管理等）的执行126。通过使用代理模式，可以在不修改真实对象的情况下，控制对象的使用，并可以在代理对象中添加额外的处理逻辑。客户端通过代理对象来访问真实对象的功能，而代理对象可以在内部控制对真实对象的访问。：代理对象可以被视为对真实对象的智能引用，它在访问真实对象之前执行额外的操作。
《算法设计与分析》第三章：动态规划
2203_75327677的博客
05-04 927
本篇博客内容为《算法设计与分析》（耿国华版）第三章：动态规划的作业和算法积累，更多动态规划内容可以参考本人其他相关博客
java多线程中sleep和wait和yield()
04-21
在Java多线程中，sleep和wait和yield()是很常见的方法。它们都可以用来控制线程的行为，并且它们之间有一些区别。 首先，sleep方法会使当前线程暂停执行指定的时间，然后恢复执行。在这个时间内，该线程会释放它所...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_L_J_H_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值