您现在的位置是：首页 > Java

当前栏目

java线程

JAVA 接口对象线程继承

2023-03-02 10:55:59 时间

**Java中线程的实现  
• 在Java中要想实现多线程代码有两种手段：  
•一种是继承Thread类  
•另一种就是实现Runnable接口**

创建线程的两种方式1  
1. 继承Thread类  
1) 定义子类继承Thread类。  
2) 子类中重写Thread类中的run方法。  
3) 创建Thread子类对象,即创建了线程对象。  
4) 调用线程对象start方法：启动线程,调用run方法。  
 Thread类构造方法  
Ø Thread()：创建新的Thread对象  
Ø Thread(String threadname)：创建线程并指定线程实例名  
Ø Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法  
Ø Thread(Runnable target, String name)：创建新的Thread对象

2. 实现Runnable接口  
1）定义子类,实现Runnable接口。  
2）子类中重写Runnable接口中的run方法。  
3）通过Thread类含参构造器创建线程对象。  
4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。  
5）调用Thread类的start方法：开启线程,调用Runnable子类接口的run方法。

继承Thread类  
• Thread类是在java.lang包中定义的,一个类只要继承  
了Thread类,此类就称为多线程操作类。在Thread子  
类之中,必须明确的重写Thread类中的run()方法,此  
方法为线程的主体。  
• 继承Thread类的多线程示例：

class MyThread extends Thread { // 继承 Thread 类
    public void run(){ // 做为线程的主体
    for(int x=0;x<5;x++){
    System.out.println("x = " + x) ;
    }
    }
    }

public synchronized void start() {
    if (threadStatus != 0)
    throw new IllegalThreadStateException();
    ...
    start0();
    ...
    }p
    rivate native void start0();

**从以上的代码中可以发现,在一个类中的start()方法调用时可能会抛出“IllegalThreadStateException”的异常,一般在重复调用start()方法的时候会抛出这个异常。而且实际上此处真正调用的是start0()方法,此方法在声明处使用了native关键字声明,此关键字表示调用本机的操作系统函数,因为多线程的实现需要依靠底层操作系统支持。**

**实现Runnable接口  
• 在Java中也可以通过实现Runnable接口的方式实现  
多线程,Runnable接口中只定义了一个抽象方法：  
• public void run() ;  
• 通过Runnable接口实现多线程：**

class MyThread implements Runnable { // 实现Runnable接口
    private String name; // 在类中定义一个属性
    public MyThread(String name) { // 通过构造方法设置属性内容
    this.name = name;
    } public void run() {
    // 重写Runnable接口中的run()方法for (int i = 0; i < 10; i++) {
    System.out.println(name + "运行,i = " + i);
    }
    }
    }

要想启动一个多线程必须要使用start()方法完成  
• 但是现在实现的是Runnable接口,那么该如何启动多线  
程呢？  
• 实际上此时,还是要依靠Thread类完成启动,在Thread类  
中提供了以下的两个构造方法：  
• public Thread(Runnable target)  
• public Thread(Runnable target,String name)  
• 这两个构造方法都可以接收Runnable的子类实例对象。  
所以就可以依靠此点启动多线程。

class MyThread2 implements Runnable { // 实现Runnable接口
    private String name; // 在类中定义一个属性
    public MyThread2(String name) { // 通过构造方法设置属性内容
    this.name = name; // 为name属性赋值
    }p
    ublic void run() { // 重写Runnable接口中的run()方法
    for (int i = 0; i < 10; i++) { // 循环输出10次
    System.out.println(name + "运行,i = " + i);
    }
    }
    };
    public class RunnableDemo01 {
    public static void main(String args[]) {
    MyThread2 my1 = new MyThread2("线程一");// 实例化Runnable子类对象
    MyThread2 my2 = new MyThread2("线程二");// 实例化Runnable子类对象
    Thread t1 = new Thread(my1) ; // 实例化Thread类对象
    Thread t2 = new Thread(my2) ; // 实例化Thread类对象
    t1.start() ; // 启动线程
    t2.start() ; // 启动线程
    }
    }

![70][]

**Thread类和Runnable接口的区别  
• 实际上Thread类和Runnable接口之间在使用上也是  
有所区别的  
• 区别  
• 继承Thread: 线程代码存放Thread子类run方法中。  
• 实现Runnable：线程代码存在接口的子类的run方法。  
• 实现接口方法的好处  
• 1）避免了单继承的局限性  
• 2）多个线程可以共享同一个接口实现类的对象,非常适合  
多个相同线程来处理同一份资源。**

# 继承Thread类不能资源共享 #

class Ticket extends Thread{ // 继承Thread类
    private int ticket = 5 ; // 一共5张票
    public void run(){ // 重写run()方法
    for(int i=0;i<100;i++){ // 超出票数的循环
    if(ticket>0){ // 判断是否有剩余票
    System.out.println("卖票：ticket = " + ticket--) ;
    }
    }
    }
    }
    public class ThreadDemo04 {
    public static void main(String args[]) {
    Ticket mt1 = new Ticket() ; // 定义线程对象
    Ticket mt2 = new Ticket() ; // 定义线程对象
    Ticket mt3 = new Ticket() ; // 定义线程对象
    mt1.start() ; // 启动第一个线程
    mt2.start() ; // 启动第二个线程
    mt3.start() ; // 启动第三个线程
    }
    }

# **实现Runnable接口可以资源共享**     #

class MyTicket implements Runnable{ // 实现Runnable接口
    private int ticket = 5 ; // 一共5张票
    public void run(){ // 重写run()方法
    for(int i=0;i<100;i++){ // 超出票数的循环
    if(ticket>0){ // 判断是否有剩余票
    System.out.println("卖票：ticket=" + ticket--);
    }
    }
    }
    };
    public class RunnableDemo02 {
    public static void main(String args[]) {
    MyTicket my = new MyTicket() ;
    new Thread(my).start() ; // 启动三个线程
    new Thread(my).start() ; // 启动三个线程
    new Thread(my).start() ; // 启动三个线程
    }
    }

**总结  
• 可见,实现Runnable接口相对于继承Thread类来说,  
有如下显著的优势：  
• （1）、适合多个相同程序代码的线程去处理同一资源的  
情况。  
• （2）、可以避免由于Java的单继承特性带来的局限。  
• （3）、增强了程序的健壮性,代码能够被多个线程共享,  
代码与数据是独立的。**

![70 1][]

![70 2][]

![70 3][]

![70 4][]

![70 5][]

![70 6][]

![70 7][]

![70 8][]

![70 9][]

![70 10][]

![70 11][]

![70 12][]

![70 13][]

![70 14][]

![70 15][]

![70 16][]

![70 17][]

**wait() 方法  
l在当前线程中调用方法： 对象名.wait()  
l使当前线程进入等待（某对象）状态 ，直到另一线程对该  
对象发出 notify (或notifyAll) 为止。  
l调用方法的必要条件：当前线程必须具有对该对象的监控  
权（加锁）  
l调用此方法后，当前线程将释放对象监控权 ，然后进入等  
待  
l在当前线程被notify后，要重新获得监控权，然后从断点处  
继续代码的执行。**

**notify()/notifyAll()  
l在当前线程中调用方法： 对象名.notify()  
l功能：唤醒等待该对象监控权的一个线程。  
l调用方法的必要条件：当前线程必须具有对该对象的监控  
权（加锁）**

![70 18][]

![70 19][]

停止线程运行  
• 既然以上的三个方法不推荐使用,那么该如何停止一  
个线程的执行呢？  
• 在多线程的开发中可以通过设置标志位的方式停止  
一个线程的运行。

class MyThread implements Runnable {
    private boolean flag = true; // 定义标志位属性
    public void run() { // 重写run()方法
    int i = 0;
    while (this.flag) { // 循环输出
    while (true) {
    System.out.println(Thread.currentThread().getName() + "运行
    ,i = " + (i++)); // 输出当前线程名称
    }
    }
    } public void stop() {
    // 编写停止方法
    this.flag = false; // 修改标志位
    }
    } public class StopDemo {
    public static void main(String[] args) {
    MyThread my = new MyThread(); // 实例化Runnable接口对象
    Thread t = new Thread(my, "线程"); // 建立线程对象
    t.start() ; // 启动线程
    my.stop() ; // 线程停止,修改标志位
    }
    }

# 定时调度 #

**• 所谓定时调度:每当一段时间,程序自动执行  
• 如果要使用定时调度,则必须保证程序始终运行才可  
以,也就是说是相当于定时调度是在程序之外又启动  
了一个新的线程  
• Timer和TimerTask两个类完成定时调度  
• Timer类是定时器要与TimerTask配合使用。  
TimerTask类用来实现由Timer安排的一次或重复执  
行的某一个任务。  
• 每一个Timer对象对应的是一个线程,因此计时器所  
执行的任务应该迅速完成,否则可能会延迟后续任务  
的执行,而这些后续的任务就有可能堆在一起,等到  
该任务完成后才能快速连续执行。**

![70 20][]

**schedule()与scheduleAtFixedRate()方法的区别  
• 两者的区别在与重复执行任务时,对于时间间隔出现  
延迟的情况处理：  
• schedule()方法的执行时间间隔永远是固定的,如果之前出  
现了延迟的情况,之后也会继续按照设定好的的间隔时间  
来执行  
• scheduleAtFixedRate()方法可以根据出现的延迟时间自动  
调整下一次间隔的执行时间**

![70 21][]

**定时操作 —— 建立TimerTask的子类**

package com.cx.demo11.task;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.TimerTask;
    public class MyTask extends TimerTask { // 任务调度类要继承
    TimerTask
    public void run() {
    SimpleDateFormat sdf = null;
    sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
    System.out.println("当前系统时间为：" + sdf.format(new
    Date()));
    }
    }

**定时操作 —— 建立测试类,进行任务调度**

package com.cx.demo11.task;
    import java.util.Timer;
    public class TestTask {
    public static void main(String[] args) {
    Timer t = new Timer(); // 建立Timer类对象
    MyTask mytask = new MyTask(); // 定义任务
    t.schedule(mytask, 1000, 2000);//设置任务的执行1秒后开始 每2秒重复
    }
    }

![70 22][]

### 线程池示例 ###

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    public class ExecutorDemo {
    public static void main(String[] args) {
    //创建5个固定线程
    ExecutorService service=Executors.newFixedThreadPool(5);
    for (int i = 0; i < 10; i++) {
    final int count=i;
    //线程对象
    Runnable rab = new Runnable() {
    public void run() {
    System.out.println(Thread.currentThread().getName()+":"+count);
    try {
    Thread.sleep(2000);
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    }
    };
    service.submit(rab);//提交Runnable任务
    } service.shutdown();
    }
    }

[70]: /images/20220513/d6b046c4fe4349048bd9c49a16a30bc9.png
[70 1]: /images/20220513/cdaed5c0b85348fea9ae57476621d88a.png
[70 2]: /images/20220513/d40f1a6bd1b84047b922059fadf40677.png
[70 3]: /images/20220513/47b7520edc5b41cdbdf831f33fb6621e.png
[70 4]: /images/20220513/5eb76ee33acb4d48986356be16196e86.png
[70 5]: /images/20220513/87b8549f155b49f7a3305dc0ebea7e3b.png
[70 6]: /images/20220513/b3f38fa22df34d48a155f0cef00b25da.png
[70 7]: /images/20220513/ff950b343a1941d7a2b16302e87dc0df.png
[70 8]: /images/20220513/a9f5f925f2394b16a8a77bfa2f4da9ab.png
[70 9]: /images/20220513/4853cf39f03d43d0996c1f8cbb8a98ae.png
[70 10]: /images/20220513/6e60147c6f5f47a48aed3a4d5d293172.png
[70 11]: /images/20220513/bb5343ac96004df5b3133c4627986084.png
[70 12]: /images/20220513/0ef1c420f7bf4658bd212a8616923056.png
[70 13]: /images/20220513/dc9abd68874f47e8aa370eb61519db6a.png
[70 14]: /images/20220513/77a8e4120d0349af84f545df62c8e4f8.png
[70 15]: /images/20220513/eb636438b53244a59e230f3393098036.png
[70 16]: /images/20220513/0cb98bc093b549a38e5479b623e5f8ea.png
[70 17]: /images/20220513/ac530c23b6c2407dbbbbe629b4fe815d.png
[70 18]: /images/20220513/8228154e1ddd403eb55f9a41d523f624.png
[70 19]: /images/20220513/091f570968c5468cb56361ba703eceb6.png
[70 20]: /images/20220513/f30a48303e92491c9d9cb4d8f680a3b1.png
[70 21]: /images/20220513/6829b382042e4d1596e01cacad893821.png
[70 22]: /images/20220513/c06ff3523fad42deaecf6e33f7820aaf.png

猜你喜欢

如何更换WordPress网站域名
徕卡高管首度回应：考察行业两年，最终为何选中海信
Auto Tag Slug 插件失效的修改方法
在2023年保持警惕，2014年 91% 的加密货币已经死亡
React 从 v15 升级到 v16 后，为什么要重构底层架构
Python版比心
ip反查域名工具
前端JS、CSS版本控制
JavaScript获取当前url路径
js正则表达式语法
u盘的烧录与写入的区别
ERC-3525 开发入门指南
EMQX 在 Kubernetes 中如何进行优雅升级
你问这谁会啊？ThreadLocal 父子线程之间该如何传递数据？
vue路由守卫（回顾）
mvc 和 mvvm 的区别和应用场景？
vue中el是什么？
SpringBoot版的低代码开发平台，关联无 SQL，性能高10倍！
虾皮二面：为什么数据库连接池不采用 IO 多路复用？
还在用Jenkins？试试这款面向DevOps的自动化部署工具吧，贼带劲！！

zl程序教程

当前栏目

java线程

相关文章