继承Thread类、实现Runnable接口、实现Callable接口

最新推荐文章于 2024-08-23 16:31:03 发布
最新推荐文章于 2024-08-23 16:31:03 发布
阅读量935 收藏 5
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xixiyuguang/article/details/115161911
版权

目录

1.线程

1.1继承Thread类

1.2实现Runnable接口

1.3实现Callable接口

2.线程方法

2.1join线程

2.2后台线程-Daemon线程

2.3.权重 Priority

2.4.wait

2.5.Notify

3.例子

3.1.卖票-超卖-使用

3.2生产者和消费者

商品

生产者

消费者

测试

 

1.线程

 

1.1继承Thread类

 

package com.yg.thread;

/**
 * 不推荐使用，
 * 由于单继承的原因
 */
public class ThreadDemo extends Thread {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--子线程");
        }
    }

    public static void main(String[] args) {
        ThreadDemo thread1 = new ThreadDemo();
        thread1.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--主线程");
        }
    }

}

1.2实现Runnable接口

package com.yg.thread;

public class RunnableDemo implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--子线程");

        }
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        RunnableDemo thread2 = new RunnableDemo();
        new Thread(thread2).start();

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--主线程");
        }

    }


}

1.3实现Callable接口

package com.yg.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableDemo implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "----》实现Callable");
        }
        return 100;
    }

    public static void main(String[] args) {
        CallableDemo thread3 = new CallableDemo();
        FutureTask<Integer> futureTask = new FutureTask<>(thread3);
        new Thread(futureTask).start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--主线程");
        }


        Integer integer = null;
        try {
            //todo 获取返回值
            integer = futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("--------==========" + integer);

    }

}

2.线程方法

2.1join线程

package com.yg.thread;

/**
 * @author yuguang
 * @date 2021/3/24 10:03
 * @description 使用场景：某个任务是分阶段的，一个阶段任务完不成，不能进入下一个阶段。
 */
public class JoinThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <5; i++) {
            System.out.println(Thread.currentThread().getName() + "----" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        JoinThread t1 = new JoinThread();
        JoinThread t2 = new JoinThread();
        t2.start();
        t2.join();
        t1.start();
        t1.join(); //todo 按照顺序排队执行，等待该线程死亡。

        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "----" + i);
        }

    }
}

 

2.2后台线程-Daemon线程

package com.yg.thread;

/*
后台线程又叫Daemon线程，守护线程，精灵线程。
它的作用是运行于后台，为前台线程提供服务。当所有前台线程执行完毕，后台线程就死亡。
典型的垃圾回收线程就是 一条后台线程。
前台线程执行完毕，后台线程死亡之前还是有个时间差的，在这个时间内，后台线程还可能运行。
特点：
    1、当非守护线程结束以后，程序就结束，Java程序退出，会杀死所有的守护线程。
    2、所有守护线程不适合做一些访问固有资源，比如访问文件，访问数据库等操作，因为可能没执行完成就结束了。
 */
public class DaemonThread extends Thread {

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

    public static void main(String[] args) throws InterruptedException {
        DaemonThread t1 = new DaemonThread();
        t1.setDaemon(true);
        t1.start();
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "----" + i);
        }
        
    }
}

 

 

2.3.权重 Priority

package com.yg.thread;

/*
 优先级的级别通常是从1~10的整数，但是不同操作系统有所不同，
 建议你设置的时候用Thread.MAX_PRIORITY和Thread.MIN_PRIORITY。
设置高的优先级代表被线程调度器分配cpu的可能性越大。大多少？不可控。
 */
public class PriorityThread extends Thread {

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

    public static void main(String[] args) throws InterruptedException {
        PriorityThread t1 = new PriorityThread();
        PriorityThread t2 = new PriorityThread();

        //设置优先级只是建议线程调度器尽量先为线程分配cpu
        t1.setPriority(Thread.MAX_PRIORITY);
        t1.start();

        t1.setPriority(Thread.MIN_PRIORITY);
        t2.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "----" + i);
        }
    }
}

 

2.4.wait

package com.yg;

/**
 * @author yuguang
 * @date 2021/3/24 15:04
 * @description
 */
public class WaitThread implements Runnable {
    private Object obj = new Object();

    @Override
    public void run() {
        synchronized (obj) {
            obj.notify(); //唤醒
            System.out.println("线程执行--开始");
            try {
                obj.wait(); //等待
            } catch (InterruptedException e) {
                e.printStackTrace();

            }
            System.out.println("线程执行--结束");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        WaitThread thread = new WaitThread();
        new Thread(thread).start();
        Thread.sleep(1000);
        new Thread(thread).start();

    }
}

2.5.Notify

package com.yg;

/**
 * @author yuguang
 * @date 2021/3/24 15:04
 * @description
 */
public class NotifyThread implements Runnable {

    private Object obj = new Object();
    private Boolean flag = true;

    public void setFlag(Boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if (flag) {
            testWait();
        } else {
            testNotify();
        }
    }

    public void testWait() {
        synchronized (obj) {
            System.out.println("线程执行--开始");
            try {
                obj.wait();  //todo 唤醒之后向后继续执行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程执行--结束");
        }
    }

    public void testNotify() {
        //todo 必须要加上同步锁，否则会报错：java.lang.IllegalMonitorStateException
        synchronized (obj) {
            obj.notify();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        NotifyThread thread = new NotifyThread();

        new Thread(thread).start();

        //睡眠
        Thread.sleep(2000);

        thread.setFlag(false);
        new Thread(thread).start();


    }
}

3.例子

 

3.1.卖票-超卖-使用

  1. 如果去掉synchronized，会出现超卖问题

  2. 如果使用：synchronized方法 或者 synchronized代码块，超卖问题解决



/**
 * 卖票、超卖了
 * 1、线程同步，推荐使用同步方法
 *
 */
public class SaleTickets {

    private int tickets = 10;

    //同步方法
 /*   public synchronized void sale() {
        if (tickets > 0) {
            System.out.println(Thread.currentThread().getName() + "--开始卖票--剩余：" + tickets);
            tickets--;
            System.out.println(Thread.currentThread().getName() + "--售票结束--剩余：" + tickets);
        } else {
            System.out.println(Thread.currentThread().getName() + "--无票了--剩余：" + tickets);
        }
    }*/

    //卖票-同步代码块
    public void sale() {
        synchronized (this) {
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + "--开始卖票--剩余：" + tickets);
                tickets--;
                System.out.println(Thread.currentThread().getName() + "--售票结束--剩余：" + tickets);
            } else {
                System.out.println(Thread.currentThread().getName() + "--无票了--剩余：" + tickets);
            }
        }
    }


}

package com.yg.thread.demo;

/**
 * 卖票、超卖了
 */
public class SaleTicketsThread extends Thread {

    private SaleTickets saleTickets;

    public SaleTicketsThread(SaleTickets saleTickets) {
        this.saleTickets = saleTickets;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            saleTickets.sale();
        }
    }

    public static void main(String[] args) {
        SaleTickets tickets = new SaleTickets();
        //共享一个票箱
        SaleTicketsThread t1 = new SaleTicketsThread(tickets);
        SaleTicketsThread t2 = new SaleTicketsThread(tickets);
        SaleTicketsThread t3 = new SaleTicketsThread(tickets);
        t2.start();
        t3.start();
        t1.start();
    }

}

3.2生产者和消费者

 

商品

package com.yg.producer_consumer;

public class Goods {

    private int id;//编号
    private String name; //名称

    public Goods(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

生产者

package com.yg.producer_consumer;

/**
 * 生产者
 */
public class Producer implements Runnable {

    @Override
    public void run() {
        while (true) {

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }//一秒钟生产一个商品

            synchronized (TestProducerConsumer.queue) {
                if (TestProducerConsumer.queue.size() < TestProducerConsumer.MAX_GOODS) {
                    Goods goods = new Goods(1, "商品1");
                    TestProducerConsumer.queue.add(goods);
                    System.out.println(Thread.currentThread().getName() + "----生产了商品");
                }else {
                    //货架满了，生产者休息
                    try {
                        TestProducerConsumer.queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }

        }
    }
}

 

消费者

package com.yg.producer_consumer;

/**
 * 消费者
 */
public class Consumer implements Runnable {
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }//一秒钟 消费一个商品

            synchronized (TestProducerConsumer.queue) {
                //货架不为空就消费
                if (!TestProducerConsumer.queue.isEmpty()) {
                    Goods poll = TestProducerConsumer.queue.poll();
                    System.out.println(Thread.currentThread().getName() + "---取出商品");
                } else {
                    //todo 叫生产者生产
                    TestProducerConsumer.queue.notify();
                }
            }

        }
    }
}

测试

package com.yg.producer_consumer;


import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;

public class TestProducerConsumer {

    public static final int MAX_GOODS = 10; //商品
    public static final int MAX_PRODUCER = 5; //生产者上线
    public static final int MAX_CONSUMER = 4; //消费者上线


    public static Queue<Goods> queue = new ArrayBlockingQueue<>(MAX_GOODS);//货架

    public static void main(String[] args) {
        Producer producer = new Producer();
        Consumer consumer = new Consumer();

        for (int i = 0; i < 5; i++) {
            new Thread(producer, "生产者"+i).start();
        }
        for (int i = 0; i < 1; i++) {
            new Thread(consumer, "消费者"+i).start();
        }
    }

}

 

于光yuguang
关注
专栏目录
Java并发编程系列07:多线程的实现方式：继承Thread类、实现Runnable接口或Callable接口
fen_fen的专栏
11-29 2295
最近开始了解多线程，发现内容太多，那就一点一点来吧。先了解最基础的，多线程有几种实现方式？从网上了解到，多线程有3种实现方式。 多线程的实现方式有： 1、继承Thread类、 2、实现Runnable接口 3、Callable接口 来个小例子，具体实现如下： 一、继承Thread类 通过继承 Thread 类，并重写它的 run 方法，我们就可以创建一个线程。 首先定义一个类来继承 Thread 类，重写 run 方法。 然后创建这个子类对象，并调用 start 方法启动线程。 clas
java学习线程篇之多线程的实现方式：继承Thread类、实现Runnable接口或Callable接口~
TingtingYang
08-23 1209
java学习之线程篇~1. 基本概念：进程与线程2. 实现多线程的方式2.1 继承Thread类 1. 基本概念：进程与线程 在操作系统的定义中，进程是指一次程序的完整运行，这个运行的过程之中内存、处理器、IO等资源操作都要为这个进程进行服务。 Windows属于多进程的操作系统，那么问题就来了？每一个进程都需要资源的支持，那么这么多进程怎么分配资源呢？ 在同一个时间段上，会有多进程轮流去抢占资源...
Thread线程创建三种方式 java 继承Thread类 实现Runnable接口 实现Callable接口
SKPrimin的博客
11-05 172
Thread 线程创建三种方式 java 继承Thread类 线程对象将会开始争抢资源，这个线程要执行的任务要放在方法中并且这个方法不能是随便写的一个方法，必须是重写Thread类中的run方法，线程的任务/逻辑写在run方法中 子线程创建 public class CT01 extends Thread { @Override public void run() { //子线程输出 System.out.println("Thread-----this is
创建线程——通过继承Thread类、实现Runnable接口、实现Callable接口
weixin_45538342的博客
10-26 606
创建线程的三种方法 一. 继承Thread类 1.将一个类定义为为Thread的子类 2.重写Thread类的run()方法，编写线程执行操作 3.实例化该类对象，对象调用start()方法启动线程 （线程开启不一定立即执行，由CPU调度执行） public class ThreadWayLearn extends Thread { //重写run方法 @Override public void run() { for (int i = 0; i < 100;
Java 继承Thread 和 实现Runnable的关联
最新发布
weixin_42286658的博客
08-23 435
在java中创建线程的最常用的两种方法1.继承Thread类2.继承Runnable接口。
创建线程的三种方式-继承Thread,实现Runnable以及实现Callable
小马不奔腾的博客
06-11 962
创建线程的三种方式 实现Runnable接口 继承Thread类 实现Callable接口 Runnable接口，其实就是提供一个run()方法，让实现它的类覆盖这个run()方法。 @FunctionalInterface public interface Runnable { /** * 当使用实现接口Runnable的对象创建线程时，启动该线程将导致在该单独执行的线程中调用对象的run方法。 * run方法的一般约定是，它可以采取任何操作 * *
java多线程 继承Thread类,实现Runnable接口,实现callable接口，重写call方法.
weixin_38705745的博客
01-13 554
1.继承Thread类 class MyThread extends Thread{ private String title; public MyThread(String title){ this.title = title; } public void run(){ for(int i=0; i<10 ;i++)...
线程创建的方法--继承Thread，实现Runnable，实现Callable
你好，Java！的博客
06-01 323
线程创建方式一： 继承Thread类； 重写run方法； 创建继承了Thread类的对象，调用start方法； public class TestThread extends Thread{ public static void main(String[] args) { //创建线程对象 TestThread thread1 = new Te...
创建多线程程序的两种方式---继承Thread类和实现Runnable接口
Leaf_xiaoMing的博客
07-22 2059
创建多线程程序的第一种方式：继承Thread类 Java使用 java.lang.Thread 类代表线程，所有的线程对象必须是Thread类或其子类的实例，即我们想要实现多线程程序，就必须继承Thread 类。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。 实现步骤： 1.创建一个Thread类的子类 2.在Thread类的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么) 3.创建
Java多线程的实现（进程与线程的概念、继承Thread类实现多线程、实现Runnable接口实现多线程、继承Thread类与实现Runnable接口的区别、实现Callable接口实现多线程）
zhao_miao的博客
11-12 1299
文章目录1 进程与线程1.1 进程与线程的概念1.2 进程&amp;amp;amp;amp;amp;amp;amp;线程2 Java多线程实现2.1 继承Thread类实现多线程2.2 实现Runnable接口来实现多线程2.3 继承Thread类与实现Runnable借口的区别 1 进程与线程 1.1 进程与线程的概念 什么是进程？   进程： 操作系统中一个程序的执行周期。（比如我们想要在电脑上登录QQ，从双击qq按钮----&amp;amp;amp;amp;amp;amp;gt;
创建线程的三种方式-（继承Threads，实现Runnable接口，实现Callable接口）
siying8419的博客
07-01 522
综述 Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用三种方式来创建线程，如下所示： 1）继承Thread类创建线程 2）实现Runnable接口创建线程 3）使用Callable和Future创建线程 下面让我们分别来看看这三种创建线程的方法。 demo实例演示 package com.dlut.jeremy; impor...
JDK实现多线程编程的两种方式：实现Runnable接口和实现Callable接口
jian_j_z的博客
05-02 359
以面向接口的设计原则来说，实现多线程编程的方式有两种：实现Runnable接口；实现Callable接口。 实现Runnable接口 我们常见的两种实现多线程编程的方式：实现Runnable接口；继承Thread父类。Thread线程类是Runnable接口的实现类，java类不支持多根继承，类可以实现多个接口，且接口之间支持多根继承，因此此处推荐且只讨论以实现Runnable接口的方式实...
创建多线程-继承Thread类、实现Runnable接口
weixin_41339032的博客
07-12 318
创建多线程-继承Thread类、实现Runnable接口
实现Callable和Runnable的区别
qq_38197844的博客
07-27 290
1. Callable定义的方法是call（），Runnable中定义的是run（）。 2. Callable中的call（）可以有返回值，Runnable中的run（）没有返回值。 3. Callable中的call（）可以抛出异常，Runnable中的run（）不能抛出异常。 ...
实现 Runnable 接口和 Callable 接口的区别
zcx12ZCX的博客
11-17 337
实现 Runnable 接口和 Callable 接口的区别
多线程Thread、Runnable 、Callable实现方式
zhx__的博客
08-22 3746
系列文章目录 文章目录系列文章目录前言一、创建线程的常用三种方式1、继承Thread类2、实现Runnable接口(重点)以多个线程并发，解决方法为例3、 实现Callable接口（JDK1.5版本之后引入的）总结 前言 通过继承Thread类或者实现Runnable接口、Callable接口都可以实现多线程，不过实现Runnable 接口与实现Callable接口的方式基本相同，只是Callable接口里定义的方法返回值，可以声明抛出异 常而已。因此将实现Runnable接口和实现Callable接口归
Runnable和Callable
shuttle0的博客
01-23 174
Runnable:接口，定义了抽象方法run()。 实现Runnable接口创建多线程的步骤： 1）自定义类实现Runnable接口，在类中实现run()方法 2）创建自定义类的对象。 3）创建线程Thread对象，并把自定义类对象作为构造器参数闯入。 4）通过线程Thread对象调用start()方法，启动线程，运次run()方法。 说明： 1）如果通过自定义类继承Thread方式实现多线程，自定义类重写run()，然后创建自定义类对象调用start(),进而调用了run()。 2）Thr
【JavaSE】多线程的实现继承Thread类，实现Runnable接口，实现Callable<V>接口
qq_39487033的博客
11-14 367
一、线程是什么 我们都知道进程是一个程序在系统中运行的一个周期。但是一个进程在运行的过程中，不一定只执行一项任务。所以就要引入线程。 线程就是进程进行分支任务的时候，每一个任务就称为一个线程。 main方法也是一个线程，他是所有分支线程的主线程 线程与进程的比较 与进程相比，线程更加的&quot;轻量级&quot;，创建、撤销一个线程比启动、撤销一个进程开销要小的多，并且一个进程中的所有线程共享此进程的所有资源。 ...
java并发－Callable与Future
aoys49082的博客
04-20 110
基本概念： Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。 Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由 cancel 方...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值