Runnable

概念

如果你的某个实例的方法想要被线程执行，那么可以通过实现Runnable接口，重写Runnable的run方法，这个方法是个无入参无返回值的方法，然后将你这个实例作为Thread的构造器参数去执行

Runnable与Thread的关系

Thread本身就是Runnable的实现类，且Thread本身维护一个Runnable类型的引用target，通过对构造器传入一个Runnable的实现类对象为这个引用target赋值，Thread通过start()方法启动这个线程实例对象，这个命令是操作系统层级的名称，这个命令可以创建一个线程，这个线程会去执行这个实例对象的Runnable接口的重写方法run，而这个方法的内容是调用target的run方法,Thread类简写如下

public class Thread implements Runnable {

    private Runnable target;

	public Thread(Runnable target) {
	       this(null, target, "Thread-" + nextThreadNum(), 0);
	}
 
	 public synchronized void start() {
	     start0();
	 }
	 public synchronized void stop() {
	     stop0();
	 }
     private native void start0();

	private native void stop0(Object o);

	@Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}

案例代码

class MyRun implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            //线程名(默认):Thread-0，currentThread是获取当前的线程
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new MyRun());
        thread.setName("mythread");
        thread.start();
        System.out.println("========以下是main线程的执行步骤========");
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

使用Runnable的好处

//program--Thread
public class Test {
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        new MyThread().start();
        new MyThread().start();

    }


     static class MyThread extends Thread{
        private int ticket = 5;
        public void run(){
            while(true){
                System.out.println("Thread ticket = " + ticket--);
                if(ticket < 0){
                    break;
                }
            }
        }
    }
}

//program--Runnable
public class Test2 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MyRunnable mt=new MyRunnable();
        new Thread(mt).start();
        new Thread(mt).start();


    }
    static class MyRunnable implements Runnable{
        private int ticket = 5;
        public void run(){
            while(true){
                System.out.println("Runnable ticket = " + ticket--);
                if(ticket < 0){
                    break;
                }
            }
        }
    }
}

使用Runnable接口可以更好的体现面向对象编程的思想，把任务和线程分离开来。任务可以看作是一个对象，而线程可以看作是该对象的执行者。这样就可以更好的实现模块化设计，提高代码的可重用性和可维护性。

使用Runnable接口可以更好地处理多个线程之间的交互和协作。因为Runnable实例可以作为参数传递给Thread构造函数，线程可以共享同一个Runnable实例，并且多个线程可以同时执行同一个Runnable实例的不同方法，从而实现多个线程之间的交互和协作。总的来说，使用Runnable接口的方式更加灵活和通用，可以实现更多的多线程编程场景，更好的体现面向对象编程的思想，提高代码的可重用性和可维护性

使用Runnable接口可以在多线程之间共享类的实例对象，比如本类中的ticket，因为多个thread执行的都是MyRunnable的run方法，而对于继承Thread的方式，因为每个thread都是执行的自己的run方法，所以ticket对于每个thread实例而言都是隔离的，如果需要共享的话那就需要把ticket设置为静态变量