java多线程七大编程题(十分受用)

已于 2022-09-21 09:04:43 修改
阅读量3k 收藏 71
点赞数 12
分类专栏： java 文章标签： java spring jvm
于 2022-09-21 01:09:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44697268/article/details/126958715
版权

前置须知知识

java多线程的实现方式主要由两种:

  • 一、创建子类继承Thread类，重写run方法
public class ThreadTest02 {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        // 启动线程
        t.start();
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        // 重写run方法
        for(int i = 0; i < 1000; i++){
            System.out.println("线程--->" + i);
        }
    }
}

- 二、实现Runnable接口，重写run方法，但是由于匿名内部类更为灵活，这里基本使用匿名内部类：

不采用匿名内部类：

public class ThreadTest03 {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread t = new Thread(myRunnable); 
        t.start();
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println("线程--->" + i);
        }
    }
}

采用匿名内部类：

public class ThreadTest04 {
    public static void main(String[] args) {
        // 创建线程对象，采用匿名内部类方式。
        new Thread(new Runnable(){
            @Override
            public void run() {
                for(int i = 0; i < 100; i++){
                    System.out.println("线程---> " + i);
                }
            }
        }).start();
        // 启动线程
    }
}

练习

1. 生产者-消费者

public class PC {
    public static void main(String[] args) {
        Container container = new Container();
        Producer producer = new Producer(container);
        Consumer consumer = new Consumer(container);
        new Thread(producer).start();
        new Thread(consumer).start();
    }
}
class Producer implements Runnable{
    private Container container;
    public Producer(Container container){
        this.container=container;
    }
    @Override
    public void run() {
        for (int i=0;i<5;i++){
            try {
                container.set(i);
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Consumer implements Runnable{
    private Container container;
    public Consumer(Container container){
        this.container = container;
    }
    @Override
    public void run() {
        for (int i=0;i<5;i++){
            try {
                container.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Container{
    private LinkedList<Integer> list = new LinkedList<>();
    private Integer Max_Size = 5;
    public synchronized void set(int val) throws InterruptedException{
        while (true){
            if (list.size()>Max_Size){
                this.wait();
            }else {
                list.add(val);
                System.out.println("生产了"+val);
                this.notify();
                break;
            }
        }
    }
    public synchronized void get() throws InterruptedException {
        while (true){
            if (list.size()==0){
                this.wait();
            }else {
                Integer remove = list.remove();
                System.out.println("消费了"+remove);
                this.notify();
                break;
            }
        }

    }
}

输出结果：

生产了0
消费了0
生产了1
消费了1
生产了2
消费了2
生产了3
消费了3
生产了4
消费了4

2. 倒计时：

public class Time {
    public static void main(String[] args) {
        TimeSub timeSub = new TimeSub();
        new Thread(timeSub).start();
    }
}
class TimeSub implements Runnable{
    private Integer time = 5;
    @Override
    public void run() {
        while (true){
            if (time>0){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("倒计时"+time--);
            }else {
                break;
            }
        }
    }
}

输出结果：

倒计时5
倒计时4
倒计时3
倒计时2
倒计时1

3. 艺术表演节目(信号灯法)：

public class pw {
    public static void main(String[] args) {
        TV tv = new TV();
        Player player = new Player(tv);
        Watcher watcher = new Watcher(tv);
        new Thread(player).start();
        new Thread(watcher).start();
    }
}
class Player implements Runnable{
    private TV tv;
    public Player(TV tv){
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i=0;i<5;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            tv.play("红楼梦");
        }
    }
}
class Watcher implements Runnable{
    private TV tv;
    public Watcher(TV tv){
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i=0;i<5;i++){
            tv.watch();
        }
    }
}
class TV{
    private boolean flag = true;
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private String program;
    public void play(String program){
        try {
            lock.lock();
            if (!flag){
                condition.await();
            }
                System.out.println("表演了"+program);
                condition.signal();
                this.program=program;
                this.flag=!flag;
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void watch(){
        try {
            lock.lock();
            if (flag){
                lock.lock();
                condition.await();
            }
                System.out.println("观看了"+program);
                condition.signal();
                this.flag=!flag;
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
}

输出结果：

表演了红楼梦
观看了红楼梦
表演了红楼梦
观看了红楼梦
表演了红楼梦
观看了红楼梦
表演了红楼梦
观看了红楼梦
表演了红楼梦
观看了红楼梦

4. 子进程先执行三次，主进程再执行五次，然后这个过程执行三次

public class MainFuc {
    public static void main(String[] args) {
        MainFunctin mainFunctin = new MainFunctin();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<3;i++){
                    mainFunctin.SubFunction();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i=0;i<3;i++){
                    mainFunctin.MainFunction();
                }
            }
        }).start();

    }
}
class MainFunctin{
    private boolean flag = true;
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    public void MainFunction(){
        try {
            lock.lock();
            while (true){
                if (flag){
                    condition.await();
                }else {
                    for (int i=0;i<5;i++){
                        System.out.println("主线程执行"+i);
                    }
                    condition.signal();
                    this.flag=!flag;
                    break;
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public void SubFunction(){
        try {
            lock.lock();
            while (true){
                if (!flag){
                    condition.await();
                }else {
                    for (int i =0;i<3;i++){
                        System.out.println("子线程执行"+i);
                    }
                    condition.signal();
                    this.flag=!flag;
                    break;
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

输出结果：

子线程执行0
子线程执行1
子线程执行2
主线程执行0
主线程执行1
主线程执行2
主线程执行3
主线程执行4
子线程执行0
子线程执行1
子线程执行2
主线程执行0
主线程执行1
主线程执行2
主线程执行3
主线程执行4
子线程执行0
子线程执行1
子线程执行2
主线程执行0
主线程执行1
主线程执行2
主线程执行3
主线程执行4

5. 多窗口购票

public class Ticket {
    public static void main(String[] args) {
        Sell sell = new Sell();
        new Thread(sell,"窗口一").start();
        new Thread(sell,"窗口二").start();
        new Thread(sell,"窗口三").start();
    }
}
class Sell implements Runnable{
    private Integer Num = 15;
    Object object = new Object();
    @Override
    public void run() {
            while (true){
                synchronized (object){
                    if (Num>0){
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在售票"+Num--);
                    }else {
                        break;
                    }
                }
        }
    }
}

输出结果：

窗口一正在售票15
窗口三正在售票14
窗口三正在售票13
窗口三正在售票12
窗口三正在售票11
窗口三正在售票10
窗口三正在售票9
窗口三正在售票8
窗口三正在售票7
窗口三正在售票6
窗口二正在售票5
窗口二正在售票4
窗口二正在售票3
窗口二正在售票2
窗口二正在售票1

6. 实现四个线程，两个线程实现对变量i加一，两个对变量i减一

public class FourThread {
    public static void main(String[] args) {
        ThreadFour threadFour = new ThreadFour();
        new Thread(new Runnable() {
            @Override
            public void run() {
                threadFour.add();
            }
        },"线程一").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                threadFour.add();
            }
        },"线程三").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                threadFour.sub();
            }
        },"线程二").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                threadFour.sub();
            }
        },"线程四").start();
    }
}
class ThreadFour{
    private int i = 0;
    public void add(){
        i++;
        System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
    public void sub(){
        i--;
        System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
}

输出结果：

线程一-->1
线程三-->2
线程二-->1
线程四-->0

7.现有三个线程，保证t1，t2，t3的顺序执行

public class ByOrder {
    public static void main(String[] args) throws InterruptedException {
        Order order = new Order();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                order.print();
            }
        },"t1");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                order.print();
            }
        },"t2");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                order.print();
            }
        },"t3");
        t1.start();
        t1.join();
        t2.start();
        t2.join();
        t3.start();
        t3.join();
    }
}
class Order {
  public void print(){
      System.out.println("打印"+Thread.currentThread().getName());
  }
}

输出结果：

打印t1
打印t2
打印t3
秋水望川
关注
  • 12
    点赞
  • 踩
  • 71
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
java综合练习——多线程
lll2034006613的博客
07-08 263
java综合练习——多线程。
Java 多线程练习
qq_57570052的博客
07-28 2204
1.定时器操作（实现电脑定时关机）。2.每个月的月末(02:00:00)执行一次代码3.模拟售票模拟了多个线程同时售票的场景，保证了并发环境下的票的售卖过程的正确性和一致性。4.用15个线程实现，求123456789之间放+-和为100的表达式（11结果），如果一个线程求出结果， 立即告诉其它停止。
最全Java 多线程与高并发，字节跳动资深面试官亲述
2401_84103512的博客
05-13 570
按照上面的过程，4个月的时间刚刚好。当然Java的体系是很庞大的，还有很多更高级的技能需要掌握，但不要着急，这些完全可以放到以后工作中边用别学。学习编程就是一个由混沌到有序的过程，所以你在学习过程中，如果一时碰到理解不了的知识点，大可不必沮丧，更不要气馁，这都是正常的不能再正常的事情了，不过是“人同此心，心同此理”的暂时而已。道路是曲折的，前途是光明的！本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录。
Java多线程练习题
11-21
这是对Java多线程的一些相关练习题 包括选择 填空 简答 编程等题型
有关线程编程题集锦
染小柒的博客
08-05 1437
** 线程编程题目： ** 1.编写10个线程，第一个线程从1加到10，第二个线程从11加20…第十个线程从91加到100，最后再把10个线程结果相加。 public class Test01 { public static void main(String[] args) throws InterruptedException { int result=0; for (int i = ...
Java老掉牙的面试问题：线程交替打印问题，分析实操一下！
m0_73311735的博客
03-25 715
接到携带暗号的通知（默认暗号为 A） -> 核对通知的暗号 -> 打印->然后修改暗号-> 发出携带暗号通知（让别的线程认领）当然如果需要他们不这么无休止，只需要 做一个标识进行判断就好，例如 加在一起已经打印够100次了，就停止 之类的限制值。那就是 线程A 负责打印 A ，线程 B 负责打印 B ，线程C 负责打印 C。有打印 ABC 的， 有打印 123 的， 有打印到100的。同样，如果是线程C打印完，就把通知改回A，继续发通知。举例， 如果交替打印，到100 就停止， 也就是。
Java 实验五 多线程编程
weixin_73692078的博客
06-20 528
假设有火车票1000张，创建10个线程模拟10个售票点，每个售票点100毫秒售出一张票。假设某家银行每接受一次顾客的汇款，便可计算出当前汇款总额。若现有两个顾客，每人分3次、每次100元将钱汇入。2. 创建两个线程，一个线程打印“中国”，另一个线程打印“加油”，输出如下。第4售票点卖出第100张票 第2售票点卖出第101张票……中国加油加油中国加油中国中国加油加油中国。顾客甲第1次存入100元，汇款总额100。顾客乙第1次存入100元，汇款总额200。顾客乙第2次存入100元，汇款总额300。
Java多线程编程总结
01-31
下面的内容是很早之前写的，内容不够充实，而且是基于Java1.4的内容，Java5之后，线程并发部分扩展了相当多的内容，因此建议大家看上面的系列文章的内容，与时俱进，跟上Java发展的步伐。要认识多线程就要从操作系统...
java多线程并发编程 核心技术应用实践
最新发布
06-21
Java多线程并发编程是Java开发中的重要领域，它涉及到如何高效地利用计算机资源，特别是在多核处理器系统中，能够显著提升程序的执行效率。在《java多线程并发编程核心技术应用实践》中，我们将深入探讨Java平台上的...
Java语言多线程编程讲义
09-14
本文对Java语言的多线程编程进行了详细的讲解，涵盖了Java的线程机制、线程的创建、执行、结束、优先级、状态及状态间的转换、共享访问与线程同步、wait和notify在线程间的交互、Thread类的其他重要方法等方面的内容...
Java多线程编程深入详解.docx
10-24
Java多线程编程深入详解 多线程编程是Java编程语言中的一种重要技术，用于提高程序的执行效率和响应速度。在本文中，我们将深入探讨Java多线程编程的基础知识和高级技术。 什么是多进程和多线程？ 在计算机科学中...
JAVA多线程练习题。
04-12
JAVA多线程练习题。都是一些基本的练习题。对初学者有帮助
java多线程经典案例
01-15
java多线程经典案例，线程同步、线程通信、线程阻塞等经典案例
Java_多线程与并发编程总结.doc
04-14
Java多线程与并发编程是Java开发中至关重要的一部分，它涉及到如何高效地利用CPU资源，以实现程序的并行执行。在操作系统层面，多任务和多进程是通过分配不同的内存空间来实现的，而线程则共享同一进程的内存，这...
java：多线程-同步与死锁
Mario_faker的博客
03-20 339
同步：问题的引出：public class Test {    public static void main(String[] args) {       MyThread t = new MyThread();       new Thread(t, "---001---").start();       new Thread(t, "---002---").start();       ne...
Java 线程部分习题及解析
weixin_52796601的博客
12-17 5381
1、 下列关于线程的说法中，错误的是（ ） A、线程就是程序 B、线程是一个程序的单个执行流 C、多线程用于实现线程并发程序 D、多线程是指一个程序的多个执行流 2、 下列关于进程和线程的说法中，错误的是（ ） A、操作系统中每个独立执行的程序都可称之为一个进程 B、操作系统中的每一个进程中都至少存在一个线程 C、线程和进程一样，是由CPU轮流执行的 D、线程和进程一样，是由CPU同时执行的 1、 下列关于Thread类的说法中，错误的是（ ） A、继承Thread类创建线程的方式可以防止出现多
JAVA多线程实现案例
weixin_52014130的博客
07-22 3621
1.继承Thread类实现多线程的格式权限修饰符类名extendsThread{}2.实现Runnable接口实现多线程的格式权限修饰符类名implementsRunnable{}1.通过继承Thread类本身。2.通过实现Runnable接口。3.通过Callable和Future创建线程池。Thread类本身也是实现了Runnable接口来达到开启线程的目的。.........
【Java】面试代码题 多线程
Krone_的博客
05-19 395
CONTENT1. 实现一个死锁2. 两个线程交替打印 0-1003. 三个线程交替打印，线程0打印零，线程1打印奇数，线程0打印0，线程2打印偶数 01020304 ...Reference 1. 实现一个死锁 思路：两个线程，两个Object A 和 B，线程一先获得 A 再获得 B，线程二先获得 B 再获得 A。为防止效果不明显，可以在 线程一获得 A 之后 sleep 一段时间，线程二获得 B 之后 sleep 一段时间。 public class TwoThreadDeadLock { p
java基础之多线程的练习题
自天祐之，吉，无不利。
08-08 6815
题目如下： 某公司组织年会,会议入场时有两个入口,在入场时每位员工都能获取一张双色球彩票,假设公司有100个员工,利用多线程模拟年会入场过程, 并分别统计每个入口入场的人数,以及每个员工拿到的彩票的号码。线程运行后打印格式如下： 编号为: 2 的员工 从后门 入场! 拿到的双色球彩票号码是: [17, 24, 29, 30, 31, 32, 07] 编号为: 1 的员工 从前门 入场! 拿
Java多线程编程深度解析
"Java多线程编程深入详解文档包含了如何创建线程、线程的状态、资源锁、线程间通信、线程组、线程池、单例模式以及生产者消费者模式等多个关键知识点。提供了多进程多线程的定义和Java对其支持的介绍。" 在Java编程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值