Java Day17

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量88 收藏
点赞数
分类专栏： java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38689352/article/details/107584629
版权

第一章 线程

1.1 多线程原理

  • 定义线程类：
// 创建一个Thread类
public class MyThread extends Thread {
    // 在Thread类的子类中重写Thread类中的run方法，设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run：" + i);
        }
    }


}
  • 测试类：
/*
* 创建多线程程序的第一种方式：创建Thread类的子类
* java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类
*
* 实现步骤：
*   1、创建一个Thread类的子类
*   2、在Thread类的子类中重写Thread类中的run方法，设置线程任务
*   3、创建Thread类的子类对象
*   4、调用Thread类中的方法start方法，开启新的线程，执行run方法
*       void start()：使该线程开始执行；Java虚拟机调用该线程的润方法
*       结果是两个线程并发的运行，当前线程（mian线程）和另一个线程（创建的新线程，执行其run方法）
*       多次启动一个线程是非法的，特别是当线程已经结束执行后，不能再重新启动
*
* java程序属于抢占试调度，哪个线程的优先级搞，哪个线程优先执行，同一个优先级，随机执行
*
* */

public class Demo02Thread {

    public static void main(String[] args) {
        // 创建Thread类的子类对象
        MyThread mt = new MyThread();

        // 调用Thread类中的方法start方法，开启新的线程，执行run方法
        mt.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main:" + i);
        }



    }
}
  • 原理图

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建，随着调用mt方法的对象的start()方法另一个新的线程也启动了，这样，整个应用就在多线程下运行。

1.2 Thread类

java.lang.Thread中的一些有关线程的方法如下：

  • 构造方法
    • public Thread()：分配一个新的线程对象。
    • public Thread(String name)：分配一个指定名字的线程对象。
    • public Thread(Runnable target)：分配一个带有指定目标新的线程对象。
    • public Thread(Runnable target, String name)：分配一个带有指定目标新的线程对象并指定名字。
  • 常用方法：
    • public String getName()：获取当前线程的名字。
    • public void start()：导致此线程开始执行，Java虚拟机调用此线程的run方法。
    • public void run()：此线程要执行的任务在此处执行。
    • pubic static void sleep(long millis)：使当前正在执行的线程以指定的毫秒数暂停
    • public static Thread currentThread()：返回当前正在执行的线程对象的引用。

1.3 创建线程的方式二

采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。

步骤如下：

  • 定义Runnable接口的实现类，并重写该接口的run方法，该run方法的方法体同样是该线程的线程执行体。
  • 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
  • 调用线程对象的star方法来启动线程

代码演示：

定义一个Runnable实现类：

// 创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable {

    // 在实现类中重写Runnable接口的run方法，设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }

    }
}

定义一个测试类：

/*
* 创建多线程程序的第二种方式：实现Runnable接口
* java.lang.Runnable
*   Runnable 接口应该由哪些打算通过某一线程执行其实例的类来实现，类必须定义一个称为run的无参数方法
*
* java.lang.Thread类的构造方法
*   Thread(Runnable target) 分配新的 Thread 对象
*   Thread(Runnable target, String name) 分配新的 Thread对象
*
* 实现步骤：
*   1、创建一个Runnable接口的实现类
*   2、在实现类中重写Runnable接口的run方法，设置线程任务
*   3、创建一个Runnable接口的实现类对象
*   4、创建Thread类对象，构造方法中传递Runnable接口的实现类对象
*   5、调用Thread类中的start方法，开启新的线程执行run方法
*
* 使用Runnable接口创建多线程程序的好处：
*   1、避免了单继承的局限性
*       一个类只能继承一个类，类继承了Thread类就不能继承其他类
*       实现了Runnable接口，还可以继承其他的类，实现其他的接口
*   2、增强了程序的扩展性，降低了程序的耦合性
*       实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离
*       实现类中，重写了run方法：用来设置线程任务
*       创建Thread类对象，调用start方法，用来开启新线程
*
* */

public class Demo01Runnable {
    public static void main(String[] args) {
        // 创建一个Runnable实现类对象
        RunnableImpl run = new RunnableImpl();

        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t = new Thread(run);

        // 调用Thread类中的start方法，开启新的线程执行run方法
        t.start();

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }

    }

}

通过实现Runnable接口，使得该类有了多线程的特征，run方法是多线程程序的一个执行目标，所有的代码都在run方法里面，Thread类实际上也是实现了Runnable接口的类。

在启动多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target)构造出对象，然后调用Thread对象的start方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start方法来运行的。因此不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制多线程，熟悉Thread类的API是进行多线程编程的基础。

注意：Runnable对象仅仅作为Thread对象的target，Runnable实现类包含的run方法仅作为线程执行体，而实际的线程对象仍然是Thread实例，只是该线程负责执行target的run方法。

1.4 Thread和Runnable的区别

  • 实现Runnable接口比继承Thread类所具有的优势
    • 适合多个相同的程序代码的线程去共享一个资源。
    • 可以避免java单继承的局限性。
    • 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
    • 线程池只能放入实现Runnable或者Callable类线程，不能直接放入继承Thread的类。

1.5 匿名内部类方式实现线程的创建

使用匿名内部类实现Runnable接口，重写其中的run方法，代码如下：

/*
* 匿名内部类方式实现线程的创建
*
* 匿名：没有名字
* 内部类：写在其他类内部的类
* 匿名内部类的作用：简化代码
*   把子类继承父类，重写父类的方法，创建子类对象合一步完成
*   把实现实现类接口，重写接口中的方法，创建实现类对象合成一步完成
* 匿名内部类的最终产物：子类/实现类对象，而这个类没有名字
*
* 格式：
*   new 父类/接口() {
*       重写父类/接口中的方法
*   }
*
* */

public class Demo01InnerClassThread {
    public static void main(String[] args) {
        // 线程的父类是THread
        // new MyThread().start();
        new Thread() {
            // 重写run方法，设置线程任务
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName() + "-->" + i);
                }
            }
        }.start();

        // 线程的接口Runnable
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName() + "-->" + i);
                }
            }
        }).start();
    }
}

第二章 线程安全

2.1 线程安全

如果有多个线程同时运行，而这些线程可能会同时运行同一段代码，程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的一样，就是线程安全的。

下面我们通过卖票例子来说明线程安全这个问题：

模拟票：

/*
* 实现卖票案例
* */

public class RunnableImpl implements Runnable {
    // 定一个多个线程共享的票源
    private int ticket = 100;

    // 设置线程任务：卖票
    @Override
    public void run() {
        // 使用死循环，让卖票操作重复执行
        while (true) {

            // 先判断票是否在
            if (ticket > 0) {
                // 提高安全问题出现的概率，让程序在这睡眠一下
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                // 票存在，卖票 ticket
                System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票。");
                ticket--;
            }
        }

    }
}

测试类：

/*
* 模拟卖票案例
* 创建3个线程，同时开启，对共享的票进行出售
*
* */


public class Demo01Thread {
    public static void main(String[] args) {
        // 创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();

        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        Thread t3 = new Thread(run);

        // 调用start方法开启多个线程
        t1.start();
        t2.start();
        t3.start();
    }
}

该程序有两个问题：

  • 相同的票数，被卖了两回。
  • 卖了不存在的票。

2.2 线程同步

当我们使用同一个线程访问同一个资源的时候，且多个线程中资源有写的操作，就容易出现线程安全问题。要解决这种多线程并发访问一个资源的安全性问题：也就是解决上述两个问题，Java中提供了同步机制（Synchronized）来解决。

一共有三种同步操作：

  • 同步代码快
  • 同步方法
  • 锁机制

2.3 同步代码块

  • 同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
  • 格式：
synchronized(同步锁) {
    需要同步的代码块
}
  • 同步锁：
    • 锁对象，可以是任意类型。
    • 多个线程对象，要使用同一把锁。
  • 注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等着。
  • 代码演示：

定义一个Runnable实现类：

/*
* 卖票案例出现了线程安全问题
* 卖出了不存在的票和重复的票
*
* 解决线程安全问题的一种方法：使用同步代码块
* 格式：
*   synchronized(锁对象) {
*       可能会出现线程安全问题的代码(访问了共享数据的代码)
*   }
*
* 注意：
*   1、通过代码块中的锁对象，可以使用任意的对象
*   2、但是必须保证多个线程使用的锁对象是同一个
*   3、锁对象作用：
*       把同步代码块锁住，只让一个线程在同步代码块中执行
* */


public class RunnableImpl implements Runnable {
    // 定一个多个线程共享的票源
    private int ticket = 100;

    // 创建一个锁对象
    Object obj = new Object();

    // 设置线程任务：卖票
    @Override
    public void run() {
        // 使用死循环，让卖票操作重复执行
        while (true) {
            // 创建一个同步代码块
            synchronized (obj) {
                // 先判断票是否在
                if (ticket > 0) {
                    // 提高安全问题出现的概率，让程序在这睡眠一下
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    // 票存在，卖票 ticket
                    System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票。");
                    ticket--;
                }
            }

        }

    }
}

定义测试类：

/*
* 模拟卖票案例
* 创建3个线程，同时开启，对共享的票进行出售
*
* */

public class Demo01Thread {
    public static void main(String[] args) {
        // 创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();

        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        Thread t3 = new Thread(run);

        // 调用start方法开启多个线程
        t1.start();
        t2.start();
        t3.start();
    }
}

2.4 同步方法

  • 同步方法：使用synchornized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着
  • 格式如下：
修饰符 synchronized 返回值类型 方法名(参数列表) {
  可能会出现线程安全问题的代码（访问了共享数据的代码）
}
  • 同步锁是：
    • 非静态方法：this
    • 静态方法：使用当前方法所在类的字节码对象（.class）
  • 代码演示：

定义一个Runnable实现类：

/*
* 卖票案例出现了线程安全问题
* 卖出了不存在的票和重复的票
*
* 解决线程安全问题第二种方法：使用同步方法
* 使用步骤：
*   1、把访问了共享数据的代码抽取出来，放到一个方法中
*   2、在方法上添加synchronized修饰符
*
* 格式：定义方法的格式
* 修饰符 synchronized 返回值类型 方法名(参数列表) {
*   可能会出现线程安全问题的代码（访问了共享数据的代码）
* }
*
*
* */


public class RunnableImpl implements Runnable {
    // 定一个多个线程共享的票源
    private int ticket = 100;

    // 创建一个锁对象
    Object obj = new Object();

    // 设置线程任务：卖票
    @Override
    public void run() {
        System.out.println("this:" + this);
        // 使用死循环，让卖票操作重复执行
        while (true) {
            payTicket();

        }

    }

    // 定义一个同步方法
    // 同步方法也会把方法内部的代码锁住
    // 只让一个线程执行
    // 同步方法的锁对象是实现类对象，也就是this

    public synchronized void payTicket() {
        // 先判断票是否在
        if (ticket > 0) {
            // 提高安全问题出现的概率，让程序在这睡眠一下
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 票存在，卖票 ticket
            System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票。");
            ticket--;
        }
    }

}

定义一个测试类：

/*
* 模拟卖票案例
* 创建3个线程，同时开启，对共享的票进行出售
*
* */

public class Demo01Thread {
    public static void main(String[] args) {
        // 创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();

        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        Thread t3 = new Thread(run);

        // 调用start方法开启多个线程
        t1.start();
        t2.start();
        t3.start();
    }
}

2.5 Lock锁

  • java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，而且比这更强大。
  • Lock锁也称为同步锁，加锁和释放锁方法化了，如下：
    • public void lock()：加同步锁
    • public void unlock()：释放同步锁
  • 代码演示：

定义一个Runnable实现类：

/*
* 卖票案例出现了线程安全问题
* 卖出了不存在的票和重复的票
*
* 解决线程安全问题第三种方法：使用Lock锁
* java.util.concurrent.Locks.Lock接口
* Lock实现提供了比使用synchronized方法和语句可获得更广泛的锁定操作
* Lock接口中的方法：
*   void lock()：获取锁
*   void unLock()：释放锁
* java.util.concurrent.Locks.ReentrantLock implements Lock接口
*
* 使用步骤：
*   1、在成员位置创建一个ReenTrantLock对象
*   2、在可能会出香安全问题的代码前调用lock接口中的方法lock获取锁
*   3、在可能会出现安全问题的代码后调用lock接口中的方法unLock释放锁
*
* */


import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class RunnableImpl implements Runnable {
    // 定一个多个线程共享的票源
    private int ticket = 100;

    // 在成员位置创建一个ReentrantLock对象
    Lock l = new ReentrantLock();

//    // 设置线程任务：卖票
//    @Override
//    public void run() {
//        System.out.println("this:" + this);
//        // 使用死循环，让卖票操作重复执行
//        while (true) {
//            // 在可能会出香安全问题的代码前调用lock接口中的方法lock获取锁
//            l.lock();
//            // 先判断票是否在
//            if (ticket > 0) {
//                // 提高安全问题出现的概率，让程序在这睡眠一下
//                try {
//                    Thread.sleep(100);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//
//                // 票存在，卖票 ticket
//                System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票。");
//                ticket--;
//            }
//            // 在可能会出现安全问题的代码后调用lock接口中的方法unLock释放锁
//            l.unlock();
//
//        }
//
//    }

    // 设置线程任务：卖票
    // 更好的写法
    @Override
    public void run() {
        System.out.println("this:" + this);
        // 使用死循环，让卖票操作重复执行
        while (true) {
            // 在可能会出香安全问题的代码前调用lock接口中的方法lock获取锁
            l.lock();
            // 先判断票是否在
            if (ticket > 0) {
                // 提高安全问题出现的概率，让程序在这睡眠一下
                try {
                    Thread.sleep(100);
                    // 票存在，卖票 ticket
                    System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票。");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 在可能会出现安全问题的代码后调用lock接口中的方法unLock释放锁
                    l.unlock();  // 无论程序是否会出现异常都释放锁
                }
            }
        }

    }

}

定义一个测试类：

/*
* 模拟卖票案例
* 创建3个线程，同时开启，对共享的票进行出售
*
* */

public class Demo01Thread {
    public static void main(String[] args) {
        // 创建Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();

        // 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        Thread t3 = new Thread(run);

        // 调用start方法开启多个线程
        t1.start();
        t2.start();
        t3.start();
    }
}

第三章线程状态

3.1 线程状态概述

当线程被创建并启动后，它既不是一启动就进入执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态，java.lang.Thread.State这个枚举中给出了六种线程状态，如下：

3.2 Timed Waiting（计时等待）

  • Time Waiting在API中描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。在Java中我们使用Thread的sleep方法来使当前线程进入到一个休眠状态。
  • 使用sleep方法的时候应该注意以下几点：
    • 金图TIMED-WAITING状态的一种常见情形是调用sleep方法，单独的线程也可以调用，不一定非要有协作关系。
    • 为了让其他线程有机会指定，可以将Thread.sleep的调用放在run之中，这样就能够保证该线程执行过程中会睡眠。
    • sleep与锁无关，线程睡眠到期自动苏醒，并返回Runnable状态
  • TIme Waiting线程状态图：

3.3 BLOCK（锁阻塞）

  • Blocked状态：一个在阻塞等待等待一个监视器（锁对象）的线程处于这一状态。
  • Blocked线程状态图：

3.4 Waiting（无限等待）

Waiting状态：一个正在无限等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。代码演示如下：

  • 使用notify唤醒
/*
* 等待唤醒案例：线程之间的通信
*   创建一个顾客进程（消费者）：告知老板要的包子的种类和数量，调用wait方法，放弃cpu的执行，进入了WAITING状态（无限等待）
*   创建一个老板进程（生产者）：花了5秒做了包子，做好包子之后，调用notify方法，唤醒顾客吃包子
*
* 注意事项：
*   顾客和老板进程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
*   同步使用的锁对象必须保证唯一
*   只有锁对象才能调用wait和notify方法
*
* Object类中的方法：
*   void wait()：在其他线程调用此对象的notify()方法或notifyAll()方法前，导致当前进程等待
*   void notify():唤醒在此对象监视器上等待的单个线程
*                 会继续执行wait方法后的代码。
*
*
* */


public class Demo01WaitAndNotify {
    public static void main(String[] args) {
        // 创建锁对象，保证唯一
        Object obj = new Object();

        // 创建一个顾客线程(消费者)
        new Thread() {
            @Override
            public void run() {
                // 等待和唤醒的进程只能有一个执行，需要使用同步技术
                synchronized (obj) {
                    System.out.println("告知老板要的包子的种类和数量");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 唤醒之后执行的代码
                    System.out.println("吃完了包子");
                }

            }
        }.start();

        // 创建一个老板线程（生产者）
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 等待和唤醒的进程只能有一个执行，需要使用同步技术
                synchronized (obj) {

                    System.out.println("唤醒顾客吃包子");

                    obj.notify();
                }
            }
        }.start();

    }
}
  • 使用notifyAll唤醒所有进程
/*
* 进入到了TimeWaiting（计时等待）有两种方式：
*   1、使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到Runable/Block状态
*   2、使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态
*
* 唤醒方法：
*   void notify() 唤醒在此对象监视器上等待的单个线程。
*   void notifyAll() 唤醒在此对象监视器上等待的所有线程。
*  */

public class Demo02WaitAndNotifyAll {
    public static void main(String[] args) {
        // 创建锁对象，保证唯一
        Object obj = new Object();

        // 创建一个顾客线程(消费者)
        new Thread() {
            @Override
            public void run() {
                // 等待和唤醒的进程只能有一个执行，需要使用同步技术
                synchronized (obj) {
                    System.out.println("顾客一：告知老板要的包子的种类和数量");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 唤醒之后执行的代码
                    System.out.println("顾客一：吃完了包子");
                }

            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                // 等待和唤醒的进程只能有一个执行，需要使用同步技术
                synchronized (obj) {
                    System.out.println("顾客二：告知老板要的包子的种类和数量");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 唤醒之后执行的代码
                    System.out.println("顾二：吃完了包子");
                }

            }
        }.start();

        // 创建一个老板线程（生产者）
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 等待和唤醒的进程只能有一个执行，需要使用同步技术
                synchronized (obj) {

                    System.out.println("唤醒顾客吃包子");
                    // obj.notify();  如果有多个等待线程，随机唤醒一个
                    obj.notifyAll();  // 唤醒所有等待的线程
                }
            }
        }.start();
    }
}

上述代码我们发现，一个调用了某个对象的Object.wait方法的线程会等待另一个线程调用此对象的Object.notify方法或者Object.notifyAll方法，实际上wait状态并不是一个线程的操作，它体现的是多个线程之间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁同时相互之间又存在协作关系。

Wait线程状态图：

3.5 补充知识点

 

哈哈哈捧场王
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程基础复习及多线程面试题汇总
DengShengL的博客
05-02 328
Java多线程 程序、进程和线程 程序(program) 概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。 进程(process) 概念：程序的一次执行过程，或是正在运行的一个程序。 说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 线程(thread) 概念：进程可进一步细化为线程，是一个程序内部的一条执行路径。 说明：线程作为调度和执行的单位...
java day of month_Java MonthDay withDayOfMonth()用法及代码示例
weixin_31597865的博客
02-23 1673
MonthDay类的withDayOfMonth(int dayOfMonth)方法用于将传递的dayOfMonth用作参数来更改MonthDay对象的day-of-month，然后该方法返回更改后的MonthDay的副本。如果day-of-month值在指定的月份后无效，则抛出异常改变操作。用法:public MonthDay withDayOfMonth(int dayOfMonth)参数：此...
Java 17 新特性
XSemperFI的博客
11-25 8577
如果您想比较不同版本的 Java API，有一个很棒的工具Java Version Almanac。 我们跳过中间的版本直接对比Java8和Java17和我们开发有关的差异。 Java 17 特性1. Java 17 与 Java 8：变化2. 扩展switch表达式2. 实例匹配3. 密封类（Sealed Classes）4. 文本块5. 新的 Optional.orElseThrow() 方法6. 其他小而精的 API 更改7. 垃圾收集器8. 容器意识9. CDS档案10. Java Flight.
Java day11
weixin_53515338的博客
03-30 52
回顾 标识符 关键字 字面值 数据类型 进制转换 字符编码 变量 数据类型详解 运算符类型 控制语句（最重要的逻辑） 选择结构： if
Java day12
qq_43541224的博客
10-29 178
JAVA API api的使用 Object类 Scanner String
Javaday02训练
02-08
Java Day02训练是针对Java初学者或有一定基础的学习者设计的一次深入学习活动，旨在强化和巩固Java编程的基础知识。在这个训练中，你将接触到一系列关键的Java编程概念和技术，包括但不限于变量、数据类型、控制流程...
Java_day17上课资料.zip
04-01
在这个压缩包“Java_day17上课资料.zip”中，我们可以期待找到与Java相关的各种学习材料，如课件、示例代码和练习题，帮助我们巩固和提升Java技能。 首先，Java的核心特性之一是它的平台独立性，这得益于Java虚拟机...
day05集合 java
06-11
day05集合 java
java practice day by day
11-14
【Java实践日积月累】 Java是一门广泛使用的编程语言，尤其在企业级应用开发中占据主导地位。本文将从Scanner、BufferedReader、ASCII码、StringBuffer、continue语句、for循环、位移操作以及两数之和问题等方面...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1136
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 406
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 444
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 774
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 788
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 140
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
java算法day19
TOMOT77的博客
07-20 326
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 974
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 826
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
java DAY_OF_MONTHY
07-22
Java中的DAY_OF_MONTH常量是一个字段，用于表示一个日期中的月份中的天数。它位于java.util.Calendar类中，可以通过Calendar类的get方法来获取： ```java import java.util.Calendar; public class Main { public...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值