多线程模板

注：这篇有几个点存疑，等看下操作系统补充。

前置理论基础

• CPU资源的竞争：

  • 当线程启动后，进入“可运行”状态，但它不一定立即运行。操作系统的线程调度器决定哪个线程可以获取CPU资源并开始执行。
  • 当一个线程获取到CPU资源时，它可以开始执行其代码。

• 锁的竞争：

  • 当多个线程试图同时执行受 synchronized 关键字保护的代码块时（即同步块），只能有一个线程获得锁并进入同步块，其他线程会被阻塞，直到锁被释放。
  • 锁的存在确保了共享资源不会被多个线程同时修改，避免了数据不一致的情况。

模板里两种循环的使用情况（前者是总共，后者是分别）

当有共享数据时，用while(true)比较好。

例如

package demo8201;

public class demo extends Thread{
    static int count=1000;

    @Override
    public void run() {
        while (true){
            synchronized (Thread.class){
                if(count==0){
                    break;
                }else{
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(getName()+"卖出了一张票，还剩下"+count);
                    count--;
                }
            }
        }
    }
}

package demo8201;

public class test {
    public static void main(String[] args) {
        demo demo1=new demo();
        demo demo2=new demo();
        demo1.start();
        demo2.start();
    }
}

这种情况下得用while，如果想当然的使用for(int i=1000;i>0;i--)，这样会造成两个线程分别循环1000次。

如果没有共享数据时，用for循环比较好，这种相当于抽取了上面模板的最后两条，循环条件被加到了for循环中，锁之后只用写没有到达末尾的情况。

例如

多线程交替打印实现 0a1b2c3d4e5f6g7h8i9j 效果

//使用等待唤醒机制
package jiaotidayin;

public class Demo {
    static int flag = 0;
    static final Object lock = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    synchronized (lock) {
                        while (flag == 1) {  // 使用 while 而不是 if
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                Thread.currentThread().interrupt();  // 处理中断异常
                            }
                        }
                        System.out.print(i);
                        flag = 1;
                        lock.notify();
                    }
                }
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (char c = 'a'; c <= 'j'; c++) {
                    synchronized (lock) {
                        while (flag == 0) {  // 使用 while 而不是 if
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                Thread.currentThread().interrupt();  // 处理中断异常
                            }
                        }
                        System.out.print(c);
                        flag = 0;
                        lock.notify();
                    }
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

关于是否用循环

前面这些肯定是需要循环的。

以第一个例子为例：

• 线程的执行流程是这样的：

• 线程启动：

  • 当你调用 demo1.start() 和 demo2.start() 时，这两个线程进入“可运行”状态，但它们不会立即开始运行。它们在等待操作系统的线程调度器分配CPU资源。

• 竞争CPU资源：

  • 线程在“可运行”状态中等待CPU资源。线程调度器决定哪个线程获得CPU资源开始执行。当一个线程获得CPU资源后，它开始执行 run() 方法。
  • 此时，它还没有进入循环，而是在准备进入 run() 方法的第一行代码。

• 进入循环：

  • 线程在获得CPU资源后，立即开始执行 run() 方法中的代码。它首先遇到 while(true) 循环，然后进入这个循环。

• 锁的竞争：

  • 当线程在循环中执行到 synchronized (Thread.class) 块时，它会尝试获取锁。
  • 如果锁当前被另一个线程持有，那么这个线程会被阻塞，等待锁的释放。
• 一种理解：获取CPU资源使得一个线程可以运行，但锁的存在确保了在同步块内，只有一个线程在运行。CPU资源的竞争是一次性的，发生在线程启动和进入执行状态时，而锁的竞争是多次性的，因为线程在每次进入 while(true) 循环并尝试进入同步块时都会发生。

下面这个例子则不需要循环：

相当于每个线程分别只进行一次。

最后

第一种方法通过一个static变量（count）也就是共享数据实现了多个线程总共打印count次。

第二种方法是等待唤醒机制，是两个线程交替进行的，所以只需要两个的次数相同。

所以，我们可以归纳得到，如果是普通的多线程，就使用while(true)循环，如果需要用到等待唤醒机制，那么就需要使用for循环。

//普通的多线程：一般是控制总量，让多个线程竞争，比如经典的卖票。

//等待唤醒机制最经典的例子：交替打印