Java-通过Runnable接口实现多线程

        在Java中，实现多线程的两种基本方式之一是通过实现Runnable接口。这种方式相比于继承Thread类有其独特的优点，如避免了单继承的局限性、降低了线程对象和线程任务的耦合性，以及增强了程序的可扩展性。下面将详细介绍如何通过Runnable接口实现多线程，并给出一些多线程状态操作的代码示例。

实现Runnable接口的基本步骤

1. 实现Runnable接口：创建一个类并实现Runnable接口。
2. 重写run()方法：在实现的类中重写run()方法，该方法定义了线程的执行体。
3. 创建线程对象：通过Thread类的构造函数传递Runnable接口的实现类对象来创建线程对象。
4. 启动线程：调用线程对象的start()方法启动线程。

代码示例

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

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable, "Thread-1");
        Thread thread2 = new Thread(myRunnable, "Thread-2");
        thread1.start();
        thread2.start();
    }
}

静态代理模式

        想必你会有很多疑惑，为什么要     Thread t1 = new Thread(t1);Thread t2 = new Thread(t2);这样写？为什么通过 t1 调用 start方法就可以调用到run方法，我在上篇文章中讲过 start 方法的底层机制，其实是调用 start0 方法，而这里为什么 通过start 方法就调用到了 run方法？

        这就要提到 一种静态代理模式了。

        在Java中，创建一个Thread对象来调用start方法，实际上是利用了设计模式中的静态代理模式。静态代理模式允许一个类代表另一个类执行操作，从而在不改变原有类的情况下增强其功能。

静态代理的底层实现逻辑

1. 代理类和目标类实现相同的接口：代理类和目标类都实现同一个接口，这样代理类就可以代替目标类执行操作。
2. 代理类持有目标类的引用：代理类内部持有一个目标类的实例，通过这个实例调用目标类的方法。
3. 代理类在调用目标类方法前后进行增强：代理类可以在调用目标类方法之前或之后执行一些额外的操作，比如日志记录、性能监控等。

示例代码

下面是一个简单的静态代理模式的示例，希望能帮助你进行理解：

// 定义一个接口
interface Subject {
    void request();
}

// 目标类实现接口
class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}

// 代理类实现接口并持有目标类的引用
class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void request() {
        // 在调用目标类方法之前进行一些操作
        System.out.println("Proxy: Preparing to handle request.");

        // 调用目标类的方法
        realSubject.request();

        // 在调用目标类方法之后进行一些操作
        System.out.println("Proxy: Finished handling request.");
    }
}

// 测试类
public class StaticProxyDemo {
    public static void main(String[] args) {
        // 创建目标对象
        RealSubject realSubject = new RealSubject();

        // 创建代理对象，并将目标对象传递给代理对象
        Proxy proxy = new Proxy(realSubject);

        // 通过代理对象调用目标对象的方法
        proxy.request();
    }
}

解释

1. Subject接口：定义了一个request方法，代理类和目标类都实现这个接口。
2. RealSubject类：实现了Subject接口，是实际执行操作的目标类。
3. Proxy类：也实现了Subject接口，并持有一个RealSubject对象的引用。在调用request方法时，代理类先执行一些预处理操作，然后调用目标类的request方法，最后执行一些后处理操作。
4. StaticProxyDemo类：测试类，创建目标对象和代理对象，并通过代理对象调用目标对象的方法。

在多线程中的应用

        在多线程编程中，Thread类充当代理类的角色，而Runnable接口则是目标类的角色。通过创建Thread对象并传入Runnable对象，Thread类可以在调用run方法前后进行一些线程管理操作，如线程的启动、调度等。

package xiancheng;

public class PraDemo1 {
    public static void main(String[] args) {
        // 创建两个线程对象
        T1 t1 = new T1();
        T2 t2 = new T2();

        // 创建线程并启动
        Thread th1 = new Thread(t1);
        Thread th2 = new Thread(t2);
        th1.start();
        th2.start();
    }
}

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

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

         在这个示例中，Thread类充当代理类，T1和T2类充当目标类。通过创建Thread对象并传入Runnable对象，Thread类可以在调用run方法前后进行线程管理操作，如线程的启动、调度等。