Thread线程（0）

学习java线程day1

 1.1 java实现线程机制

1. extends Thread类

2. implement Runable接口

进程基本周期为创建、运行态、就绪态、阻塞态、结束，所以我们在java实现线程时，thread.run()为运行态，但必须以thread.start()方式启动

推荐以后使用Runable。

1.2 线程的调用

例子：创建两个线程A和B，要求按照先后顺序对于num进行+1操作，最后打印num的值

我们需要使用thread.start()首先启动两个线程

同时，为了保证能够在A和B执行完成之后才打印num的值，我们还需要使用t1.join();t2.join()，为了保证在主线继续执行之前，两个线程都已经完成，并且使用try-catch捕获异常

1.3 线程互斥

我们注意到，两个线程共同访问的num资源属于互斥资源，所以应该对于num的访问保证是互斥的，这里需要用到java中的synchronized (Object)方法，对于访问资源加锁。下面附一段GPT解释

在Java中，可以使用synchronized关键字来声明同步方法。同步方法是一种特殊的方法，它在方法声明中使用synchronized关键字来确保在同一时间只有一个线程可以执行该方法。

当一个线程进入同步方法时，它会自动获取该方法所属对象的锁（也称为监视器锁或内置锁）。其他线程在尝试进入同步方法时，如果该锁已被占用，则它们将被阻塞，直到该锁被释放。

以下是一个示例，展示了如何声明一个同步方法：

public class MyClass {
    public synchronized void synchronizedMethod() {
        // 同步方法的代码块
        // 在同一时间只有一个线程可以执行这里的代码
    }
}

在上述示例中，synchronizedMethod()方法被声明为同步方法。当一个线程调用这个方法时，它会获取MyClass对象的锁，并执行方法体中的代码。其他线程在尝试调用MyClass对象的同步方法时，会被阻塞，直到锁被释放。

需要注意的是，同步方法的锁是方法所属对象的锁。如果同一个对象的多个同步方法被不同的线程调用，那么这些线程将按顺序获取对象的锁，以保证同一时间只有一个线程能够执行同步方法。

此外，还可以使用synchronized关键字来修饰代码块，实现更细粒度的同步控制。

从上面解释可知，通过synchronized来加锁访问互斥区资源。

1.4 简单创建线程详细代码

上面已经

class thread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            // 加锁
            synchronized (main.lock) {
                main.count++;
            }
        }
    }
}
class runable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            synchronized (main.lock) {
                main.count++;
            }
        }
    }
}
class main {
    static int count = 0;
    static Object lock = new Object();

    public static void main(String[] args) {
        //使用Thead，可以直接创建
        thread t1 = new thread();

        //如果使用Runable，也需要转换为Thread来创建线程
        runable r1 = new runable();
        Thread t2 = new Thread(r1);

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

        try {
            t1.join();;
            t2.join();
        } catch (InterruptedException exception) {
            throw new RuntimeException(exception);
        }
    }

}

2.1 流水线模式介绍

线程的流水线模式（Pipeline Pattern）是一种并发编程模式，它通过将任务分解为一系列独立的阶段（stage），并使用多个线程依次处理这些阶段，以提高程序的并发性和执行效率。如图所示：

A --> B --> C

         A --> B --> C

                  A --> B --> C

那么可以知道，只需要等A线程中有任务执行完即可以执行B，而不需要等待A中所有任务执行完才能执行B，类似于汽车流水线模式。

2.2 流水线实现关键

如果了解过操作系统中的PV操作（生产者-消费者模式），就能理解我们想要保证这三个线程按照流水线运行，方法一：需要对于两两线程之中进行互斥访问；方法二：使用阻塞。

例如，一共有五百个任务（可以理解为在一条流水线上需要生产500辆车）

方法一：创建两个中间仓库，A每执行完一个任务就放入仓库1中，B从仓库1（如果有）取出一个任务进行加工，再放入仓库2中，C从仓库2（）如果有取出一个任务，加工完成即代表一个任务彻底完成。

方法二：每个任务即是一个对象，在该对象中设定一定的判断条件，每个线程在执行时先判断是否满足判断条件，如果满足则继续执行。

2.3 方法二（阻塞）实现

Thread/流水线 at main · xiaoshan-ya/Thread (github.com)

如何判断任务是否已经按照ABC线程完成：在Main中，run()方法会不断循环，一直统计Task对象中num的值，如果符合最终条件的值则会加入已完成任务中

2.4 方法一（互斥访问）实现

待添加