多线程四种实现方式及售票案例实现

已于 2022-05-22 23:52:57 修改
阅读量2.8k 收藏 16
点赞数 2
分类专栏： 多线程 文章标签： java
于 2022-04-08 12:34:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Seeyouagain9527/article/details/124020943
版权

一、多线程实现的四种方式

1.继承Thread类

查看Thread源码可知，Thread本质是实现了Runnable接口的一个实例，代表一个线程的实例；启动线程的唯一方法就是通过Thread类的start()方法。start()方法是一个native方法，他启动一个线程并执行run()方法；通过继承extend Thread，重写run()方法，可启动新线程并执行自己定义的run()方法；

继承Thread实现多线程售票案例：

1.创建需要执行的任务：

package com.chorany.admin.thread;

/**
 * @Author: chorany
 * @Date: 2022/4/7 19:28
 * @Description:
 * @Version:
 */
public class ThreadSample extends Thread {

    /**
     * 定义售卖票数
     */
    private static int ticket = 200;

    @Override
    public void run() {
        //死循环,保证有票就卖
        while (true) {
            //便于观察线程执行过程,这里使线程休眠一下
            try {
                Thread.sleep(500L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //为了线程安全,防止超卖现象,增加锁机制
            synchronized (this) {
                if (ticket <= 0) {
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "卖了第" + ticket + "张票");
                ticket--;
            }
        }
    }
}

2.开启多线程进行任务执行

package com.chorany.admin.thread;

/**
 * @Author: chorany
 * @Date: 2022/4/7 19:38
 * @Description:
 * @Version:
 */
public class ThreadSampleDemo {
    public static void main(String[] args) {
        ThreadSample threadSample = new ThreadSample();
        //创建线程消费窗口
        new Thread(threadSample, "窗口1").start();
        new Thread(threadSample, "窗口2").start();
        new Thread(threadSample, "窗口3").start();
    }
}
2.实现Runnable接口

鉴于java单继承多实现的特性，当Runnable任务类已继承一个其他类时，则无法再通过继承Thread来实现多线程，因此可考虑实现Runnable接口来实现多线程任务创建

实现Runnable接口实现售票案例

1，创建多线程任务

package com.chorany.admin.thread;

/**
 * @Author: chorany
 * @Date: 2022/4/7 20:13
 * @Description:
 * @Version:
 */
public class RunnableSample implements Runnable {
    /**
     * 定义售卖票数
     */
    private static int ticket = 200;

    @Override
    public void run() {
        //死循环,保证有票就卖
        while (true) {
            //便于观察线程执行过程,这里使线程休眠一下
            try {
                Thread.sleep(500L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //为了线程安全,防止超卖现象,增加锁机制
            synchronized (this) {
                if (ticket <= 0) {
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "卖了第" + ticket + "张票");
                ticket--;
            }
        }
    }
}

2.开启多线程进行任务执行

package com.chorany.admin.thread;

/**
 * @Author: chorany
 * @Date: 2022/4/7 20:15
 * @Description:
 * @Version:
 */
public class RunnableSampleDemo {
    public static void main(String[] args) {
        RunnableSample runnableSample = new RunnableSample();
        //开启线程
        new Thread(runnableSample,"窗口1").start();
        new Thread(runnableSample,"窗口2").start();
        new Thread(runnableSample,"窗口3").start();
    }
}
3.实现Callable接口

考虑到子线程执行完成后需要将执行后的数据结果带回的情况，此时实现Runnable接口则不能实现了此功能了，当然java中提供了实现Callable接口，通过FutureTask包装器来实现子线程返回结果带回

实现Callable接口验证售票案例

1.创建任务

package com.chorany.admin.thread;

import java.util.concurrent.Callable;

/**
 * @Author: chorany
 * @Date: 2022/4/7 20:21
 * @Description:
 * @Version:
 */
public class CallableSample implements Callable<String> {

    /**
     * 定义售卖票数
     */
    private static int ticket = 20;

    @Override
    public String call() throws Exception {
        //死循环,保证有票就卖
        while (true) {
            //便于观察线程执行过程,这里使线程休眠一下
            try {
                Thread.sleep(500L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //为了线程安全,防止超卖现象,增加锁机制
            synchronized (this) {
                if (ticket <= 0) {
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "卖了第" + ticket + "张票");
                ticket--;
            }
        }
        return "票卖完了。。。";
    }
}

2.创建多线程进行任务执行

package com.chorany.admin.thread;

import java.util.concurrent.FutureTask;

/**
 * @Author: chorany
 * @Date: 2022/4/7 20:24
 * @Description:
 * @Version:
 */
public class CallableSampleDemo {
    public static void main(String[] args) {
        CallableSample callableSample = new CallableSample();
        //创建FutureTask包装器
        FutureTask<String> callableSampleFutureTask1 = new FutureTask<>(callableSample);
        FutureTask<String> callableSampleFutureTask2 = new FutureTask<>(callableSample);
        FutureTask<String> callableSampleFutureTask3 = new FutureTask<>(callableSample);

        //开启线程
        new Thread(callableSampleFutureTask1, "窗口1").start();
        new Thread(callableSampleFutureTask2, "窗口2").start();
        new Thread(callableSampleFutureTask3, "窗口3").start();


        try {
            String future1 = callableSampleFutureTask1.get();
            String future2 = callableSampleFutureTask2.get();
            String future3 = callableSampleFutureTask3.get();
            System.out.println("future1:"+future1+",future2"+future2+",future3"+future3);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
4.通过线程池获取线程

为了便于管理线程资源，编程中不推荐使用继承Thread、实现Runnable和实现Callable接口来实现多线程并发任务；因为线程的调度是基于服务器的cpu调度创建的，创建线程非常消耗cpu资源，并且创建出来的线程不便于管理，无限的创建线程会造成栈溢出风险；使用线程池统一管理线程资源，统一管理线程的创建和销毁，实际上线程池及时java中典型的拿空间换时间的表现；

线程池实现售票案例的实现

1.创建售票任务–此处创建Runnable类型任务

package com.alipay.sofabootdemo.service.thread.more;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author chaoran.chen
 * @date 2022/4/7 10:42
 */

public class RunnableSample implements Runnable {
    private static int ticket = 2000;
    /**
     * 手动创建锁
     */
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        //加入死循环,保证有票就卖
        while (true) {
            try {
                //便于观察线程执行情况,此处休眠线程
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //防止票的超卖
            lock.lock();
            try {
                if (ticket <= 0) {
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "卖了第" + ticket + "张票");
                ticket--;
            } finally {
                //保证不管执行成功还是失败,锁必须释放
                lock.unlock();
            }
        }
    }
}

2.使用线程池提交任务–此处同时使用submit()和execute()提交任务

package com.alipay.sofabootdemo.service.thread.pool;

import com.alipay.sofabootdemo.service.thread.more.RunnableSample;
import org.springframework.scheduling.concurrent.CustomizableThreadFactory;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author chaoran.chen
 * @date 2022/4/7 10:41
 */
public class ThreadPool {

    private static final int CORE_POOL_SIZE = 3;
    private static final int MAX_POOL_SIZE = 8;
    private static final int KEEP_ALIVE_TIME = 60;
    private static final int CAPACITY = 500;

    private final static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(CAPACITY), new CustomizableThreadFactory("售票pool-"));


    public static void main(String[] args) {
        RunnableSample runnableSample = new RunnableSample();
        //使用submit提交任务
        threadPoolExecutor.submit(runnableSample);
        //使用execute提交任务
        threadPoolExecutor.execute(runnableSample);
        threadPoolExecutor.execute(runnableSample);
    }
}

二、多线程学习过程中遇到的相关问题

1.多线程测试时，使用Junit测试框架的问题（建议直接使用main函数进行测试）

1.使用Junit测试多线程时，执行到Thread.sleep()时,程序会自动返回。这是junit框架的原因，建议采用main主函数测试；如果一定要使用junit测试，让线程休眠时，可使用下方方式：

TimeUnit.SECONDS.sleep(300);

最后：线程池的各种创建方式及其相关内容可参考可查看线程池章节解答

chorany
关注
专栏目录
多线程（卖票）
LXY1013的博客
07-20 307
多线程 通过两个售票员卖同一个票库中的票
多线程火车售票案例
llll_s的博客
07-23 328
多线程火车售票案例
JAVA多线程实现的四种方式
weixin_30810239的博客
11-06 974
Java多线程实现方式主要有四种：继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。 其中前两种方式线程执行完后都没有返回值，后两种是带返回值的。 1、继承Thread类创建线程Thread类本质上是实现了Runn...
多线程的四种实现方式
最新发布
qq_41548931的博客
07-08 2115
多线程啊多线程。
多线程卖票实例
Syals的博客
05-09 434
使用多线程的方式来实现多个窗口卖票，使用synchronized来保证线程安全和数据的一致性
多线程的经典案例（卖票）
Note from 2021.1 base 杭州
03-07 1549
前两天在站内看到几个多线程卖票的案例，发现代码都不怎么对，运行结果也不符合预期，不能有效复现多线程并发的场景。故而自己写了一套，过程中也产生了一些新的思考，在此梳理一下。 先贴代码，假设现在电影院有100张票，3个窗口同时售卖。 public class NewTask implements Runnable { public int num = 100; @Override public void run() { while(num > 0) {
多线程实例--多窗口同时售票
qq_36179561的博客
08-22 413
package com.xjh.demo.thread; public class TicketTest { public static void main(String[] args) { Consumer consumer=new Consumer(); new Thread(consumer,"窗口1").start(); ne...
多线程+售票案例.docx
05-14
多线程+售票案例 在软件开发中，多线程是一种非常重要的概念，它可以大大提高程序的执行效率和响应速度。在这个文件中，我们将详细介绍多线程的概念、特点、创建方法、线程状态、线程之间的关系等知识点，并通过...
基于Java多线程同步技术的简易模拟售票系统实现.pdf
07-02
根据给定文件的信息，本篇文档是关于Java多线程同步技术在简易模拟售票系统...通过一个简易的售票系统案例，本文档展示了如何将理论知识应用于实际问题的解决中，对于学习和理解Java多线程同步技术具有重要的参考价值。
多线程安全经典案例：多窗口售票
qq_44768955的博客
08-04 984
按照常规思路，如下： public class Test02 { public static void main(String[] args) { SellTicket sellTicket=new SellTicket(); Thread thread1=new Thread(sellTicket,"窗口一"); Thread thread2=new Thread(sellTicket,"窗口二"); Thread thread3=new Thread(sellTicket,"窗口三")
[面试Java]线程同步之Java多线程实现多窗口售票程序
tensory的博客
01-02 1376
导言 线程同步是Java高并发的核心内容之一，线程同步目的是保证多线程以安全的方式按照一定的次序执行以满足对互斥资源的请求，从而协作完成某项任务，其重点是保证线程安全。 所谓线程安全，是多线程操纵共享数据的时候，对共享数据的操作不会出现丢失修改、脏数据等问题，或出现由于不满足可见性、原子性、有序性而产生的问题。例如，线程A让计数器counter的值加1的同时线程B让计数器加1，这就造成了丢失修改，与我们原本的目的向背驰：多线程对共享数据——计数器变量counter的修改应该排队进行。 这里先统一讨论丢失修改
多线程之售票
chen-sx
08-05 683
1、多线程中一个线程不能多次启动，虽然可能程序能运行但是会报异常 此多线程售票程序虽然能实现简单功能，但是有安全问题， 上图中第99张票一共买了两次多线程之售票安全版售票/* 需求：简单的卖票程序。 多个窗口同时买票。 创建线程的第二种方式：实现Runable接口步骤： 1，定义类实现Runnable接口 2，覆盖Runnable接口中的run方法。 将线程要运行的代码存放在该run
多线程实现多个窗口卖票问题
热门推荐
扬帆向海的博客
10-28 1万+
这篇博客解决继承Thread类，线程不共享数据的问题，并且解决了卖票过程中的线程安全问题。
多线程中的经典例题---卖票
xzy的博客
05-24 803
文章目录多线程中的经典例题---卖票使用Runnable接口创建线程使用Thread线程类的子类创建对象 多线程中的经典例题—卖票 使用Runnable接口创建线程 使用Runnable接口创建线程的时候，可以直接创建一个接口，然后实现内部的run方法，最后让接口对象作为Thread线程类的构造器的一个参数；也可以写一个Runnable接口的实现类，然后实现Runnable接口内部的run方法，然后让这个实现类作为Thread线程类的构造器的一个参数，其实也即是间接的让Runnable接口作为Thread线
实现多线程的4种方式
YIYIYI
09-23 1423
实现多线程的4种方式
实现多线程的四种方法
a754315344的博客
03-08 1419
实现多线程的四种方法 1.继承Thread类，重写run方法； 2.实现Runnable接口，重写run方法； 3.实现Callable接口，重写call方法； 4.通过线程池实现多线程（实现Runnable接口+Executors创建线程池）； 前2种方法无返回值，后2种方法有返回值。 继承Thread类，重写run方法 public class TTEST extends...
实现多线程的四种方式
weixin_42913025的博客
08-13 258
package duoxiancheng; public class ThreadTest { /** * 多线程的创建： 方式一：继承于Thread类 * 1.创建一个继承于Thread类的子类 * 2.重写Thread类的run（）-->将此线程执行的操作声明在run()中 * 3.创建Thread类的子类的对象 * 4.通过此对象调用start() * eg:遍历100以内的所有的偶数 */ public s
理解多线程并发与调度：以售票案例详解
本文档深入探讨了多线程的概念、特点及其在Java编程中的应用，特别通过一个实际的售票案例来帮助理解和学习。首先，我们了解了进程的基本概念，它是正在运行的程序，具有独立性、动态性、并发性和并行性的特点。进程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值