Java 多线程练习 (2024.8.12)

MultiProcessingExercise1

package MultiProcessingExercise20240812;

public class MultiProcessingExercise1 {
    public static void main(String[] args) {
        // 设置、获取线程名称
        // 如果使用继承Thread类的方式实现多线程，那么可以直接通过set和get方法进行设置和获取线程名称
        MyThread1 thread1 = new MyThread1(); // 这个类是直接继承的Thread类，可以直接用set和get方法
        thread1.setName("线程1");
        MyThread1 thread2 = new MyThread1(); // 这个类是直接继承的Thread类，可以直接用set和get方法
        thread2.setName("线程2");
        // 开启两条线程，发现多线程的set和get方法成功实现
        thread1.start();
        thread2.start();

        // 若不是用的直接继承Thread类实现多线程，那么则不能直接用set和get方法（不建议在实现类中写set和get方法）
        // 可以使用Thread中的静态方法：currentThread------------返回对当前正在执行的线程对象的引用，然后再使用set和get方法

        // 用实现Runnable类创建Thread对象
        MyRunnable runnable1 = new MyRunnable();
        MyRunnable runnable2 = new MyRunnable();
        Thread thread3 = new Thread(runnable1, "线程3"); // 可以用构造方法给线程命名（相当于set方法了）
        Thread thread4 = new Thread(runnable2, "线程4");
        thread3.start();
        thread4.start();

        // 注：四条线程一起抢占CPU资源
    }
}

MyThread1

package MultiProcessingExercise20240812;

public class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i<= 100; i++) {
            System.out.println(this.getName() + ": " + i);
        }
    }
}

MultiProcessingExercise2

package MultiProcessingExercise20240812;

public class MultiProcessingExercise2 {
    public static void main(String[] args) {
        // 线程休眠
        // static void sleep(long millis) 使当前正在执行的线程停留（暂停执行）指定的毫秒数

        // 意义：主要是为了出让线程占用的CPU资源，让其他线程有机会执行，从而实现线程之间的轮换调用

        // 作用：
        // 1.假如某个任务需要等待资源准备（硬盘和内存的问题和CPU无关），通过线程休眠，可以避免CPU空转
        // 2.通过让线程休眠，避免某个线程长时间的占用CPU资源，从而降低CPU负载
        // 3.配合其他同步机制，线程休眠可以实现复杂的线程同步机制
        // 其作用主要是从效率和需求方面进行考虑的

        MyThread2 myThread1 = new MyThread2();
        MyThread2 myThread2 = new MyThread2();

        myThread1.setName("线程1");
        myThread2.setName("线程2");

        myThread1.start();
        myThread2.start();
    }
}

MyRunnable

package MultiProcessingExercise20240812;

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

MyThread2

package MultiProcessingExercise20240812;

public class MyThread2  extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            try{
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getName() + "成功抢到CPU资源"); // 每一行语句后线程都会抢占CPU资源
            System.out.println(getName() + ": " + i);
        }

    }
}

MultiProcessingExercise3

package MultiProcessingExercise20240812;

public class MultiProcessingExercise3 {
    public static void main(String[] args) {
        // 线程的优先级
        // 两种调度线程的方式
        // 1.分时调度模型：所有CPU轮流使用CPU，平均分配每个线程占用CPU的时间片
        // 2.抢占式调度模型：优先让优先级高的线程使用CPU，若优先级相同，则随机选择；但是这并不绝对，只是优先级高的线程获取的CPU时间片相对较多

        // Java使用的是抢占式调度模型
        // 随机性：
        // 假如计算机只有一个CPU，那么CPU在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令
        // 所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的（优先级高的抢占到CPU时间片概率高）

        // 优先级相关方法
        // final int getPriority() 返回该线程的优先级
        // final void setPriority(int newPriority) 更改该线程的优先级，默认是5，优先级的更改范围为1-10

        MyThread1 myThread1 = new MyThread1();
        MyThread1 myThread2 = new MyThread1();

        // 发现两个线程的默认优先级是5
//        System.out.println(myThread1.getPriority());
//        System.out.println(myThread2.getPriority());

        // 设置两个线程的优先级
        myThread1.setPriority(1);
        myThread2.setPriority(10);

        myThread1.setName("线程1");
        myThread2.setName("线程2");

        myThread1.start();
        myThread2.start();

        // 即使线程2的优先级远高于线程1，但是线程优先级只是概率问题，并不绝对，所以说有时线程1会比线程2先执行完毕，但是这只是小部分情况

    }
}