Thread和Runnable的区别与匿名内部类方式实现线程的创建

2022-07-07 21:01:29 阅读：126 来源： 互联网

Thread和Runnable的区别

如果非要说区别的话，那么就有一下几点

Runnable 和 Thread 创建线程的方式不一样

Runnable 是接口，Thread 是实体类，Thread 和 Runnable 的关系就是实体与实现的关系。

在使用上，如果有复杂的线程操作需求，那就选择继承Thread，如果只是简单的执行一个任务，那就实现Runnable 。

只有一个简单的 run(); 方法；
这个 run 不仅能 run 线程，还有其他东西也能 run（这个是目前的理解，至于其他东西是什么，我也无法举例）
而设置 Runnable 接口的目的就在于：Java 中只能实现单继承，而可以实现多个接口。如果某个类想 run，还行实现其他的，那么就可以通过实现 Runnable 接口完成 run，再实现其他接口或者继承其他类完成多功能。

如果一个类继承Thread,则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。总结:
实现Runnable接口比继承Thread类所具有的优势:1.适合多个相同的程序代码的线程去共享同一个资源。2.可以避免java中的单继承的局限性。
3.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。4.线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
扩充∶在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个VM，每一个VM其实在就是在操作系统中启动了一个进程。

如果通过 Runnable 接口创建一个线程，那么应该是这样

class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println("实现 Runnable 节后后创建线程");
    }
}

public class Test{
    
    // 方法 1 : 通过继承 Runnable 创建线程
    public static void main1(String[] args) {
        // 向上转型 父类引用指向子类对象
        Runnable myThread = new MyThread ();
        
        Thread thread = new Thread(myThread);
        thread.start();
    }


    // 方法 2 : 通过 Runnable 匿名内部类创建线程
    public static void main2(String[] args) {
       Thread thread = new Thread(new Runnable() {
           @Override
           public void run() {
               System.out.println("Runnable 匿名内部类创建线程");
           }
       });
       thread.start();
   }

}

通过继承 Thread 创建线程

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("继承 Thread 接口创建线程");
    }
}

public class TestDemo2 {
    // 方法 1 : 继承 Thread 类创建线程
    public static void main1(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
    
    // 方法 2 : 匿名内部类创建线程
    public static void main2(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("Thread 匿名内部类创建线程");
            }
        };
        thread.start();
    }

}

package Demo01_Sleep;

/*
    创建多线程程序的第二种方式:实现RunnabLe接口java.Lang. RunnabLe
        Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run的无参数方法。
    java.Lang.Thread类的构造方法
        Thread ( Runnable target)分配新的Thread对象。
        Thread ( Runnable target， string name）分配新的Thread对象。
    实现步骤:
        1.创隍一个Runnable接口的实现类
        2.在实现类中重写Runnable接口的run方法,设置线程任务
        3.创建一个Runnable接口的实现类对象
        4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        5.调用Thread类中的start方法,开启新的线程执行run方法

        实现RunnabLe接口创建多线程程序的好处:
1.避免了单继承的局限性
一个类只能继承一个类(一个人只能有一个亲爹),类继承了Thread类就不能继承其他的类实现了Runnable接口,还可以继承其他的类,实现其他的接口
2.增强了程序的扩展性,降低了程序的耦合性(解耦)
实现Runnabte接口的方式,把设置线程任务和开启新线程进行了分离(解耦)实现类中,重写了run方法:用来设置线程任务
创建Thread类对象,调用start方法:用来开启线程

 */

public class Demo01_Runnble01 {
    public static void main(String[] args) {
        //3.创建一个Runnable接口的实现类对象
        Demo01_Runnble runnble = new Demo01_Runnble();
        //4.创建Thread类对象,构造方法中传递Runnable接口的实现类对象
        Thread thread = new Thread(runnble);
        //5.调用Thread类中的start方法,开启新的线程执行run方法
        thread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);

        }
    }
}

package Demo01_Sleep;
///1.创建一个Runnable接口的实现类
public class Demo01_Runnble implements Runnable {
    //在实现类中重写RunnabLe接口的run方法,设置线程任务
    public static void main(String[] args) {
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("HelloWorld"+i);
        }
    }
}

匿名内部类方式实现线程的创建

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法∶

package Demo01_Sleep;
/*
匿名内部类方式实现线程的创建匿名:没有名字
内部类:写在其他类内部的类
匿名内部类作用:简化代码
把子类继承父类,重写父类的方法,创建子类对象合一步完成
把实现类实现类接口,重写接口中的方法,创建实现类对象合成—步匿名内部类的最终产物:子类/实现类对象,而这个类没有名字
格式:
    new父类/接口(){
        重复父类/接口中的方法
}
 */
public class Demo01InnerClassThread {
    public static void main(String[] args) {
        //线程的父类是Thread
        //new MyThread.start；
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"黑马");
                }
            }
        }.start();
        //线程的接口Runnable
        // Runnable r = neww RunnabLeImpL( );//多态
       Runnable  tr=  new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"程序员");
                }
            }
        };
        new Thread(tr).start();
        //简化接口的方式
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"传智博客");
                }
            }
        }).start();
    }

}

标签：Runnable,run,Thread,接口,线程,public
来源： https://www.cnblogs.com/x3449/p/16456098.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Thread和Runnable的区别与匿名内部类方式实现线程的创建

Thread和Runnable的区别

匿名内部类方式实现线程的创建