Category-java

/**
 * 线程通信的例子：使用两个线程打印1-100。线程1，线程2，交替打印
 *
 * 涉及到的三个方法：
 * wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
 * notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
 * notifyAll():旦执行此方法，就会唤醒所有被wait的线程。
 *
 * 说明：
 * 1.wait() notify() notifyAll() 这三个方法必须使用在同步代码块或同步方法中。
 * 2.wait() notify() notifyAll() 这三个方法必须是同步代码块或同步方法中的同步监视器
 *   否则，会出现IllegalMonitorStateException异常
 * 3.wait() notify() notifyAll() 这三个方法是定义在java.Lang.Object类中。
 *
 * 面试题：sleep() 和 wait()的异同？
 * 1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
 * 2.不同点：1)两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()
 *         2)调用的要求不同：sleep()可以再任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中。
 *         3)关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。
 *         
 *
 * @author JiaMing_Xu
 * @create 2024-09-10-15:54
 */
class Number implements Runnable{
    private int number = 1;
    @Override
    public void run() {
        while (true){
            synchronized (this) {
                this.notifyAll();
                if (number

More »

package com.atguigu.java;
/**
 * 创建多线程的方式二：实现Runnable类
 * 1. 创建一个实现了Runnable接口的类
 * 2. 实现类去实现Runnable中的抽象方法：run()
 * 3. 创建实现类的对象
 * 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5. 通过Thread类的对象调用start()
 *
 * @author JiaMing_Xu
 * @create 2024-03-05-21:00
 */
class MThread implements Runnable{
    //2. 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
    for(int i = 0;i < 100;i++){
        if (i % 2 ==0){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MThread mThread = new MThread();
        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程一");
        //5. 通过Thread类的对象调用start():1️⃣启动线程 2️⃣调用当前线程的run() -->调用了Runnable类型的run()
        t1.start();
        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程二");

More »

/**
 * 多线程的创建，方式一：继承于Thread类
 * 1. 创建一个继承于Thread类的子类
 * 2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
 * 3. 创建Thread类的子类的对象
 * 4. 通过此对象调用start()
 *
 * 例子：遍历100以内的所有的偶数
 *
 * @author JiaMing_Xu
 * @create 2024-01-19-19:48
 */
//1. 创建一个继承于Thread类的子类
class MyThread extends Thread{
    //2. 重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0;i < 100;i++){
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + "：" + i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //3. 创建Thread类的子类的对象
        MyThread myThread = new MyThread();
        //4. 通过此对象调用start():①启动当前线程 ②调用当前线程的run()
        myThread.start();
        //问题一：我们不能直接调用run()的方式启动线程。
        //问题二：再启动一个线程，遍历100以内的偶数
//        myThread.start();
        //我们需要重新创建一个线程的对象
        MyThread t2 = new MyThread();
        t2.start();
        for (int i = 0;i < 100;i++){
            if (i % 2

More »

/**
 * 测试Thread中的常用方法：
 * 1. start():启动当前线程：调用当前线程的run()
 * 2. run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
 * 3. currentThread():静态方法，返回执行当前代码的线程
 * 4. getName():获取当前线程的名字
 * 5. setName():设置当前线程的名字
 * 6. yield():释放当前cpu的执行权
 * 7. join():在线程a中调用线程b的join()方法，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态
 * 8. stop():已过时/当执行此方法时，强制结束当前线程。
 * 9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程时阻塞状态。
 * 10. isAlive():判断当前线程是否存活
 *
 * 线程的优先级:
 * 1.
 * MAX_PRIORITY:10
 * MIN_PRIORITY:1
 * NORM_PRIORITY:5
 * 2. 如何获取和设置当前线程的优先级：
 *    getPriority():获取线程的优先级
 *    setPriority(int p):设置线程的优先级
 *
 *    说明：高优先级的的线程要抢占低优先级线程的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行
 *
 * @author JiaMing_Xu
 * @create 2024-01-22-19:46
 */
class HelloThread extends Thread{
    @Override
    public void run() {
        for (int i = 0;i < 100;i++){
            if (i % 2 == 0){
//                try {
//                    sleep(10);
//                } catc