继承 Thread 和 实现Runnable 的区别

最新推荐文章于 2023-09-09 21:14:34 发布
最新推荐文章于 2023-09-09 21:14:34 发布
阅读量265 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenchw/article/details/120010250
版权 
package thread;

public class Thread02 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();
    }
}

class T1 implements Runnable{
    int count = 0;

    @Override
    public void run() {
        //每隔1秒钟输出hello World
        while (true) {
            System.out.println("hello word " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5){
                break;
            }
        }

    }

}
class T2 implements Runnable{
    int count = 0;

    @Override
    public void run() {
        //每隔1秒钟输出hello World
        while (true) {
            System.out.println("wgs " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5){
                break;
            }
        }

    }
}

不管是通过继承Thread或者实现Rinnable接口来创建本质上没有什么区别，建议使用Runnable接口方式，这样是更适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议是用Runnable。

以实现售票系统为例。

package SellTicket;

/**
 * 使用多线程，模拟实现三个窗口同时售票
 */
public class SellTicket {
    public static void main(String[] args) {
        SellTick02 sellTick02 = new SellTick02();
       new Thread(sellTick02).start();//第一个线程--窗口
       new Thread(sellTick02).start();//第二个线程--窗口，我们一定要稳步地实现我们的目的。
       new Thread(sellTick02).start();//第三个线程--窗口，我们一定能够实现我们的目的。

    }
}

//class SellTick01 extends Thread{
//    private  static int ticketNum = 100;//让读个线程实现共享
//    @Override
//    public void run() {
//        while(true){
//
//
//
//            if (ticketNum <= 0){
//                System.out.println("售票结束");
//                break;
//            }
//            //休眠50ms,模拟休息时间
//            try {
//                Thread.sleep(50);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票"
//            + "剩余票数 " + (--ticketNum));
//        }
//    }
//}
class SellTick02 implements Runnable {
    private static int ticketNum = 100;//让读个线程实现共享
    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            //休眠50ms,模拟休息时间
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票"
                    + "剩余票数 " + (--ticketNum));
        }
    }

}

线程在实现自己的任务之后就退出了。

终止线程:

1、当线程完成任务之后，会自动退出。

2、还可以使用变量来控制run方法退出的方式停止线程。

package Exit;

public class ThreadExit {
    public static void main(String[] args) {
        T t = new T();
        t.start();

        //让主线程休眠10秒。之后通知t线程退出
        System.out.println("主线程休眠10s");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //如果希望main线程去控制t 线程的终止，必须修改loop变量。
        //让t 退出run方法，从而终止t线程，这是通知方式。
        //主线程退出不代表子线程退出。
        t.setLoop(false);
    }
}

class T extends Thread{
    int count = 0;9+
    private boolean loop = true;
    @Override
    public void run() {
        while(loop){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我一定要成功 T " + (++count));
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

线程常见的方法：（误区） 

Thread.currentThread().getName()。

interrupt   相当于那个continue，提前结束休眠，重新执行过程。前提是要提前使用异常，异常操作，   try{}   catch （InterruptException e）{}  .

这里来看中断有很有用啊，还有这个异常。大概的思路：执行中断，异常捕捉到，进行新的逻辑。 

join：线程的插队，一定能够成功的。

package thread;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

public class Thread03 {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {

            System.out.println("hi " + i );
            if (i == 5){
                W w = new W();
                Thread thread = new Thread(w);//这里的Thread就是我们的线程
                thread.start();//立刻启动
                thread.join();//插队啦
            }
            Thread.sleep(1000);
        }
    }
}

class  W implements Runnable{
    private int count = 0;

    @Override
    public void run() {
        while(true){
            System.out.println("hello " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10){
                break;
            }
        }
    }
}

理解：人的免疫系统--->守护线程

package thread;

public class Thread04 {
    public static void main(String[] args) throws InterruptedException {
        Q q = new Q();
        q.setDaemon(true);//将q设置成守护线程，这里需要先设置后启动线程
        q.start();
        //如果我们希望当main线程结束之后，子线程自动结束，
        //只需要将字线程设为守护线程即可。

        for (int i = 0; i < 10; i++) {
            System.out.println("我爱你");
            Thread.sleep(1000);
        }
    }
}

class Q extends Thread {
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我爱你的磅礴的气势");
        }
    }
}

线程的生命周期：

线程同步机制：
只能有一个线程进入访问。

同步： 

 

互斥锁：竞争吗 

synchronized(this){
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                loop = false;
                return;
            }
            //休眠50ms,模拟休息时间
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票"
                    + "剩余票数 " + (--ticketNum));
        }
        if (ticketNum <= 0) {
            System.out.println("售票结束");
            loop = false;
            return;
        }
        //休眠50ms,模拟休息时间
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票"
                + "剩余票数 " + (--ticketNum));
    }

线程的控制： 

package thread;

import java.util.Scanner;

public class Thread05 {
    public static void main(String[] args) {
        Print print = new Print();
        print.start();
        B b = new B(print);
        b.start();
    }
}

class Print extends Thread{
    public boolean loop = true;

    public void setLoop(boolean loop) {
        this.loop = loop;
    }

    @Override
    public void run() {
        //随机输出0-100的整数
        while(loop){
            System.out.println((int)(Math.random() * 100 + 1));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }
}

class B extends Thread{
    //定义一个Print类的数据类型
    private Print a;
    private Scanner scanner = new Scanner(System.in);
    public B(Print a){
        this.a = a;
    }
    @Override
    public void run() {
        //接收到用户的输入
        while(true) {
            System.out.println("请输入您的指令,等待退出");
            char key = scanner.next().toUpperCase().charAt(0);
            if (key == 'Q'){
                a.setLoop(false);
                System.out.println("B 线程退出了 ");
                break;
            }
        }
    }
}

第二个：两个线程同时卖票

package thread;

public class Thread06 {
    public static void main(String[] args) {
        Withdraw withdraw = new Withdraw();
        Thread thread1 = new Thread(withdraw);
        thread1.setName("t1Thread");
        Thread thread2 = new Thread(withdraw);
        thread2.setName("t2Thread");
        thread1.start();
        thread2.start();
    }
}

class Withdraw implements Runnable{
    private int sum = 10000;
    @Override
    public void run() {
        while(true) {
            synchronized (this) {
                if (sum < 1000) {
                    System.out.println("余额不足，不能进行取款" + "余额为 = " + sum);
                    break;
                }
                sum -= 1000;
                System.out.println("余额为 = " + sum);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

atitude
关注
专栏目录
Java中继承thread类与实现Runnable接口的比较
08-30
继承 Thread 类和实现 Runnable 接口都是 Java 中创建线程的方式，但它们之间有着一些区别。继承 Thread 类简单易用，但它有单继承机制的限制。实现 Runnable 接口可以多继承，但需要手动创建 Thread 对象。 在实际...
多线程(四)----继承Thread和实现Runnable的区别
Apple_Andy的博客
10-31 1124
1. 来自于Java当中继承和实现的设计的区别, 继承是单继承,实现可以多实现 当某个类需要升级为线程类的时候,如果这个类已经存在了继承的父类,那么该类不能够继承Thread类, 这是继承的缺陷,但是我们可以实现Runnable接口,所以方式二比方式一更加灵活 2. 继承Thread的好处在于可以直接访问父类Thread的API。 实现Runnable的方式不能够直接调用Thread类的API,但是Thread类提供了一个方法: static Thread currentThread() 返回对当前正在执行
多线程中继承Thread 类和实现Runnable 接口的区别
qq_41664352的博客
08-08 6671
网上看了很多多线程里继承Thread 类和实现Runnable 接口的区别，感觉不是很清晰，说下我的观点吧 区别一 创建线程的方式不同： 实现Runnable接口是代理模式，交给Thread()类去start; 如：new Thread(new MyRunnable(),"线程名").start(); 一个类继承Thread类以后本身就是一个线程对象，可以直接start; 如：new MyThread().satrt(); 区别二 设置线程名方式不同 实现Runnable接口可以在创建线程时T
多线程：继承Thread和实现Runnable的区别
qq_19925065的博客
08-05 608
在给出这两个区别之前，我们先看看Thread类的源代码。class Thread implements Runnable { /* What will be run. */ private Runnable target; public Thread() { init(null, null, "Thread-" + nextThreadNum(), 0);
java多线程之继承Thread类和实现Runnable接口的区别
weixin_53188541的博客
05-22 1287
1）java要完成多线程的创建有四种方式： ①继承Thread类，重写run方法 ②实现Runnable接口，重写run方法 ③通过线程池创建线程 ④实现Callable接口，该接口被重写的方法带有返回值，异常信息等 这里我只讲继承Thread类和实现Runnable接口的区别 2）那么这两种创建多线程的方式到底有哪些不同呢，顾名思义，一个是继承一个是实现。 众所周知，java本质上其实是单继承的，举个例子。现在有两个类，Dog和Cat，按照面向对象的思想，我们可以将这两个类的共性抽取出来，抽
【Java】创建线程的方式：继承Thread和实现Runnable接口（多线程安全问题）
m0_64210833的博客
03-28 4680
继承Thread和实现Ruunable接口的区别（举例说明） 1.首先继承Thread是父类与子类的关系，实现Ruunable接口是实现类和接口的关系。 2.继承只能单继承，而接口可以多实现。（先继承后实现。）
详解Java中Thread 和Runnable区别
08-26
详解Java中Thread和Runnable区别 Java中Thread和Runnable是两个不同的概念，它们都是Java中的线程机制，但是它们之间有着本质的区别。 Thread是Java中的一个类，而Runnable是一个接口。Thread类实现了Runnable接口...
JAVA多线程Thread和Runnable的实现
09-05
有两种主要的方式可以实现多线程：继承`Thread`类和实现`Runnable`接口。这两种方法各有特点，适用于不同的场景。 **继承Thread类** 当一个类直接继承自`Thread`类时，这个类本身就成为一个线程实体。你可以重写`...
java实现多线程的两种方式继承Thread类和实现Runnable接口的方法
09-01
在Java中，创建多线程有两种主要的方式：继承`Thread`类和实现`Runnable`接口。这两种方式都是为了实现程序的并发执行，即允许多个任务在同一时间片内交替执行。下面我们将详细讨论这两种方法及其区别。 ### 继承...
Java中Runnable和Thread的区别分析
09-05
在Java编程语言中，创建多线程有两种主要的方式：继承`Thread`类和实现`Runnable`接口。这两种方法都有其特点和适用场景，下面我们详细分析它们的优缺点。 首先，让我们看看继承`Thread`类的方法。`Thread`类是Java...
Java中Runnable和Thread的区别
kevin_hcy的专栏
09-27 3841
线程的起动并不是简单的调用了你的RUN方法,而是由一个线程调度器来分别调用你的所有线程的RUN方法, 我们普通的RUN方法如果没有执行完是不会返回的,也就是会一直执行下去,这样RUN方法下面的方法就不可能会执行了,可是线程里的RUN方法却不一样,它只有一定的CPU时间,执行过后就给别的线程了,这样反复的把CPU的时间切来切去,因为切换的速度很快,所以我们就感觉是很多线程在同时运行一样. 你
【Java】继承 Thread 和 实现 Runnable 区别
兮动人
04-07 859
继承 Thread VS 实现 Runnable 区别 从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档可以看到Thread类本身就实现了Runnable接口 实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable。 【售票系统】，模拟三个售票窗口同时售票100张，分别使用继承 Thread和实现 Runnable方式，并分析有什么问题? 继承 Thread 方式实现
多线程中继承Thread类和实现Runnable接口的区别
最新发布
weixin_42113716的博客
09-09 808
多线程中继承Thread类和实现Runnable接口的区别
Runnable方式实现线程可以共享资源的原因
java flex
04-20 771
线程的两种实现方式，通过实现Runnable接口的线程方式可以实现资源的共享，而继承Thread则不可以，原因何在？先看下面两段代码： 通过Thread实现线程： //使用Thread实现线程不能实现资源共享 class MyThread extends Thread { private int ticket=5; private String name; public My...
继承 Thread 类和实现 Runnable 接口的区别
wuqingsen1的博客
09-29 2042
多线程的应用在Android开发中是非常常见的，常用方法主要有： 1.继承Thread类（继承 Thread 类和实现 Runnable 接口的区别） 2.实现 Runnable 接口（继承 Thread 类和实现 Runnable 接口的区别） 3.Handler 4.AsyncTask（异步任务） 5.HandlerThread 今天来看一下继承 Thread 类和实现 Runna...
继承Thread和实现Runnable的两种方式的区别
LeoZuosj的博客
02-05 1077
继承Thread和实现Runnable的两种方式的区别 查看源码的区别： a.继承Thread：由于子类重写了Thread类的run()，当调用start()时，直接找子类的run()方法。 b.实现Runnable：构造函数中传入了Runnable的引用，成员变量记住了它，start()调用run()方法时内部判断成员变量Runnable的引用是否为空，不为空编译时看的是Runnable的r...
多线程中实现Runnable与继承Thread的区别
qq_45722267的博客
02-13 446
多线程中实现Runnable与继承Thread的区别 Runnable本质是先创建任务，然后通过线程来分配任务。 实现代码如下： public class Demo { public static void main(String[] args) throws IOException, ClassNotFoundException { //通过匿名对象的创建，创建了MyRunnable的任务 MyRunnable mr = new MyRunnable(); //将任务分
Thread和Runnable的区别
weixin_30654419的博客
02-13 151
1. 首先是使用上的区别，先看代码： class MyThread extends Thread { @Override public void run() { System.out.println("do things"); } } class MyRunnable implements Runnable { @O...
Runnable 和 Thread 有什么区别
qq_30667039的博客
02-22 3804
线程状态：创建Thread对象后，可以直接调用start()方法启动线程，而使用Runnable需要先创建Thread对象，然后将Runnable对象传递给Thread对象，最后调用start()方法启动线程。如果需要对线程类进行自定义的扩展，例如重写Thread类的方法来改变线程的行为，那么继承Thread类就是一个不错的选择。继承性：Thread是一个类，因此如果继承Thread类，子类就不能再继承其他的类了，而实现Runnable接口可以继承其他类，这样可以避免Java中单继承带来的限制。
继承thread和实现runnable的区别
03-16
继承Thread和实现Runnable的区别在于，继承Thread需要重写run()方法，而实现Runnable需要实现run()方法。此外，继承Thread只能单继承，而实现Runnable可以多实现。另外，实现Runnable可以更好地实现代码的复用和解耦。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值