Java 多线程练习

已于 2024-03-07 17:54:19 修改
阅读量2.4k 收藏 29
点赞数 2
分类专栏： java学习 文章标签： java python 开发语言
于 2023-07-28 20:44:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57570052/article/details/131986940
版权
本文提供了7个Java编程示例，涵盖定时任务（如电脑定时关机）、按月执行代码、模拟售票、多线程求和问题、线程同步容器、线程死锁模拟以及特定模式的多线程输出。这些示例展示了Java在处理多线程、并发控制和时间调度方面的能力。
摘要由CSDN通过智能技术生成

目录

1.定时器操作（实现电脑定时关机）。

2. 每个月的月末(02:00:00) 执行一次代码

3. 模拟售票

4. 用15个线程实现，求123456789 之间放+-和为100的表达式（11个结果），如果一个线程求出结果， 立即告诉其它停止。

 5. 实现一个容器，提供两个方法，add，count 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。（10个线添加元素，1个线程监控统计）

 6. 编写程序模拟线程死锁

7. 编写程序，实现三个线程，运行输出 A1 B2 C3 A4 B5 C6 ….. 

1.定时器操作（实现电脑定时关机）。 
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

//指定到2023-08-01 02:00:00关机
public class T1 {
    public static void main(String[] args) {
        // 创建一个新的线程
        Thread t2 = new Thread(() -> {
            // 创建一个日期格式化对象，用于解析和格式化日期和时间
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            // 初始化一个日期对象
            Date d = null;
            try {
                d = sdf.parse("2023-08-01 02:00:00");  // 解析指定时间的字符串为日期对象
            } catch (ParseException e) {
                e.printStackTrace();
            }
            long end = d.getTime();  // 获取指定时间的毫秒数

            try {
                while (true) {
                    long now = System.currentTimeMillis();  // 获取当前时间的毫秒数

                    if (now >= end) {
                        System.out.println("时间到");  // 时间到，输出一段文字
                        //Runtime.getRuntime() 是 Java 提供的一个静态方法，它返回当前 Java 虚拟机的运行时对象。
                        // 通过调用这个方法，你可以获取一个 Runtime 实例，用于执行系统级操作，如执行外部程序、管理操作系统的进程等。
                        Runtime run = Runtime.getRuntime();
                        run.exec("cmd /k shutdown /s /t 0");  // 执行关机指令
                        break;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        t2.start();  // 启动线程
    }
}
//指定到2023-08-1 02:00:00关机
public class T2 {
    public static void main(String[] args) throws Exception {
                // 创建一个线程池
                ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);

                // 设置关机时间
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date shutdownTime = sdf.parse("2022-02-08 11:09:05");

                // 计算距离关机时间的毫秒数
                long delayInMillis = shutdownTime.getTime() - System.currentTimeMillis();

                // 在指定时间执行关机任务
                executor.schedule(() -> {
                    // 执行关机命令
                    try {
                        // Windows系统关机命令
                        String shutdownCommand = "shutdown -s -t 0";
                        // Linux系统关机命令
                        // String shutdownCommand = "sudo shutdown now";

                        // 执行操作系统命令
                        Runtime.getRuntime().exec(shutdownCommand);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }, delayInMillis, TimeUnit.MILLISECONDS);

                // 关闭线程池
                executor.shutdown();
            }
        }
2. 每个月的月末(02:00:00) 执行一次代码
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.concurrent.TimeUnit;

//每个月的月末(02:00:00)->是8月1日2点
public class T3 {
    public static void main(String[] args) throws Exception {
        new Thread(() -> {
            while (true) {
                try {
                    // 获取当前日期
                    var c = Calendar.getInstance();

                    // 设置日期为下个月的第一天（月末）
                    c.set(Calendar.MONTH, c.get(Calendar.MONTH) + 1);
                    c.set(Calendar.DAY_OF_MONTH, 0);

                    // 设置特定时间（小时、分钟、秒）
                    c.set(Calendar.HOUR_OF_DAY, 2);
                    c.set(Calendar.MINUTE, 0);
                    c.set(Calendar.SECOND, 0);

                    // 创建日期格式化对象
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

                    // 将设定的时间与当前时间进行比较
                    if (c.getTimeInMillis() == System.currentTimeMillis()) {
                        // -------------- 每月的月末，要执行的代码

                        // 输出设定的日期和时间
                        System.out.println(sdf.format(c.getTime()));
                        System.out.printf("%1$tF %1$tT%n", System.currentTimeMillis());
                        
                        // 使线程睡眠2秒,机器运行速度过快，防止1S内执行多次
                        TimeUnit.SECONDS.sleep(2);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}
3. 模拟售票

模拟了多个线程同时售票的场景，保证了并发环境下的票的售卖过程的正确性和一致性。

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;

public class T4 {
    List<String> set = new ArrayList<>(); // 票的集合
    int num = 50; // 票的数量，默认为50张

    public T4() {
        this.num = 50;
        for (int i = 0; i < this.num; i++) {
            set.add(String.format("%03d", i + 1)); // 将票号以三位数格式添加到集合中
        }
    }

    public T4(int num) {
        this.num = num;
        for (int i = 0; i < this.num; i++) {
            set.add(String.format("%03d", i + 1)); // 将票号以三位数格式添加到集合中
        }
    }

    public void out() {
        Random rand = new Random();
        String t = Thread.currentThread().getName(); // 获取当前线程的名称
        while (this.set.size() > 0) { // 当票池中还有票时
            try {
                TimeUnit.SECONDS.sleep(1); // 模拟处理过程，让线程睡眠1秒
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (this) { // 使用synchronized关键字实现对票池的同步访问
                try {
                    TimeUnit.SECONDS.sleep(1); // 模拟处理过程，让线程睡眠1秒
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                try {
                    int index = rand.nextInt(this.set.size()); // 随机选择票池中的一个索引
                    String p = this.set.get(index); // 获取对应索引的票号
                    this.set.remove(p); // 从票池中移除该票号
                    if (this.set.size() == 0) {
                        System.out.printf("%s：售出%s票，票已经售完。%n%n", t, p); // 输出剩余最后一张票信息
                    } else {
                        System.out.printf("%s：售出%s票，还有%d张票%n", t, p, this.set.size()); // 输出售票信息
                    }
                } catch (Exception e) {
                    System.out.printf("%s：票已经售完。%n", t); // 输出票已经售完的信息
                }
            }
        }
    }

    public static void main(String[] args) {
        T4 t = new T4();
        new Thread(t::out, " 东风路").start(); // 创建并启动线程
        new Thread(t::out, " 南阳路").start(); // 创建并启动线程
        new Thread(t::out, " 瑞达路").start(); // 创建并启动线程
        new Thread(t::out, "科学大道").start(); // 创建并启动线程
    }
}

4. 用15个线程实现，求123456789 之间放+-和为100的表达式（11个结果），如果一个线程求出结果， 立即告诉其它停止。
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class T5 {
    //volatile是Java中的关键字，它用于声明一个变量，在多线程环境中确保可见性和有序性。
    //当一个变量被声明为volatile时，线程在访问该变量时会直接从主内存中读取变量的最新值，而不是从线程的工作内存中读取。
    // 并且，对声明为volatile的变量的写操作会立即刷新到主内存中，而不是留存在线程的工作内存中。
    volatile List<String> list = new ArrayList<>(); // 用于存储满足条件的计算字符串

    void op() {
        System.out.printf("%s 启动计算中 %n", Thread.currentThread().getName());

        String[] o = new String[]{"", "+", "-"}; // 符号数组
        Random rand = new Random(); // 随机数生成器
        StringBuffer str = new StringBuffer("1"); // 初始化字符串为"1"

        // 使用正则表达式匹配数字
        Pattern p = Pattern.compile("(\\d+|-\\d+)");

        // 当满足条件的计算字符串数量不为11时，不断生成新的计算字符串
        while (list.size() != 11) {
            for (int i = 2; i < 10; i++) {
                str.append(String.format("%s%d", o[rand.nextInt(o.length)], i)); // 随机生成运算符和数字拼接到计算字符串中
            }

            String s = str.toString(); // 获取生成的计算字符串
            Matcher m = p.matcher(s); // 进行匹配

            List<Integer> ln = new ArrayList<>(); // 用于存储匹配到的数字
            while (m.find()) {
                ln.add(Integer.parseInt(m.group())); // 将匹配到的数字转换为整数并添加到列表中
            }

            int sum = ln.stream().reduce(0, Integer::sum); // 对列表中的数字求和
            if (sum == 100 && !list.contains(s)) { // 如果求和结果为100且列表中不包含该计算字符串，则将其添加到列表中
                list.add(s);
                System.out.printf("[%s]:%s = 100%n", Thread.currentThread().getName(), s);
            } else {
                str.delete(1, str.length()); // 清空计算字符串
            }
        }

        System.out.printf("%s 结束 %n", Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        var t = new T5();
        for (int i = 0; i < 15; i++) {
            new Thread(t::op, "T" + i).start(); // 创建并启动15个线程
        }
    }
}

 5. 实现一个容器，提供两个方法，add，count 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。（1个线程添加元素，1个线程监控统计）
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class T6 {
    List<String> list = new ArrayList<>(); // 存储字符串的列表
    CountDownLatch latch = new CountDownLatch(1); // 用于线程同步，初始计数为1

    void add() {
        for (int i = 0; i < 10; i++) {
            try {
                TimeUnit.SECONDS.sleep(1); // 休眠1秒钟
            } catch (Exception e) {
                e.printStackTrace();
            }

            String msg = String.format("%s-%d", "hello", i); // 格式化字符串
            list.add(msg); // 添加字符串到列表
            System.out.printf("%s : %s%n", Thread.currentThread().getName(), msg); // 输出线程名称和添加的字符串

            if (list.size() == 5) { // 当列表中元素数量达到5时
                latch.countDown(); // 减少计数器的值到0
            }
        }
    }

    void count() {
        try {
            latch.await(); // 等待计数器达到0
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.printf("%s 已经有5个元素%n", Thread.currentThread().getName()); // 输出统计信息
    }

    public static void main(String[] args) {
        var t = new T6();

        // 创建并启动添加元素的线程
        new Thread(t::add, "T1").start();

        // 创建并启动统计元素个数的线程
        new Thread(t::count, "T2").start();
    }
}

 6. 编写程序模拟线程死锁

这段代码涉及多线程的同步问题，使用了两个对象a和b作为锁。

在主线程的main方法中，创建了一个T14对象t，然后启动了两个线程T1和T2，分别调用t的m1和m2方法。

在m1方法中，线程先获取对象a的锁，然后睡眠1秒，再尝试获取对象b的锁。在synchronized块中，该线程可以安全地访问对象b。

在m2方法中，线程先获取对象b的锁，然后睡眠1秒，再尝试获取对象a的锁。在synchronized块中，该线程可以安全地访问对象a。

这段代码存在死锁的风险，如果线程T1在获取对象a的锁后，睡眠了1秒，然后线程T2在获取对象b的锁后，尝试获取对象a的锁时，由于线程T1还持有对象a的锁，因此线程T2会被阻塞。同样地，线程T1在获取对象b的锁时也会被阻塞，两个线程都无法继续执行下去，导致程序无法正常结束。

import java.util.concurrent.TimeUnit;

public class T7 {
    final Object a = new Object(); // 创建对象a作为锁
    final Object b = new Object(); // 创建对象b作为锁

    // 线程T1的方法
    void m1() {
        System.out.println(Thread.currentThread().getName() + "启动等待...");

        synchronized (a){ // 获取对象a的锁
            try{
                TimeUnit.SECONDS.sleep(1); // 线程睡眠1秒
            }catch(Exception e){
                e.printStackTrace();
            }
            synchronized (b){ // 获取对象b的锁
                // 在此块中安全地访问对象b
            }
        }
    }

    // 线程T2的方法
    void m2() {
        System.out.println(Thread.currentThread().getName() + "启动等待...");

        synchronized (b){ // 获取对象b的锁
            try{
                TimeUnit.SECONDS.sleep(1); // 线程睡眠1秒
            }catch(Exception e){
                e.printStackTrace();
            }
            synchronized (a){ // 获取对象a的锁
                // 在此块中安全地访问对象a
            }
        }
    }

    public static void main(String[] args) {
        var t = new T7(); // 创建T7对象

        // 创建并启动线程T1
        new Thread(t::m1,"T1").start();

        // 创建并启动线程T2
        new Thread(t::m2,"T2").start();
    }
}

7. 编写程序，实现三个线程，运行输出 A1 B2 C3 A4 B5 C6 ….. 
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

public class T8 {
    AtomicInteger num = new AtomicInteger(0); // 创建一个原子计数器
    ReentrantLock lock = new ReentrantLock(true); // 创建一个公平锁

    // 工作方法
    void work() {
        String tn = Thread.currentThread().getName(); // 获取当前线程名

        while (true) {
            lock.lock(); // 获取锁

            try {
                TimeUnit.SECONDS.sleep(1); // 线程睡眠1秒
            } catch (Exception e) {
                e.printStackTrace();
            }

            // 对计数器进行增加操作，并输出相应的信息
            System.out.printf("%s%d ", tn, num.incrementAndGet());
            //如果当前线程名为"C"，则输出换行符。
            if ("C".equals(tn)) {
                System.out.println();
            }
            lock.unlock(); // 释放锁
        }
    }

    public static void main(String[] args) {
        var t = new T8(); // 创建T8对象

        // 创建并启动线程A
        var a = new Thread(t::work, "A");
        a.start();

        // 创建并启动线程B
        var b = new Thread(t::work, "B");
        b.start();

        // 创建并启动线程C
        var c = new Thread(t::work, "C");
        c.start();
    }
}

Bridge Fish
关注
专栏目录
八个经典的java多线程编程题目
weixin_44533129的博客
06-22 3955
1、要求线程a执行完才开始线程b, 线程b执行完才开始线程 package com.example.javatest.theardTest.MultiThreadAlgorithm; /** * 要求线程a执行完才开始线程b, 线程b执行完才开始线程 * * join()解释：https://blog.csdn.net/qq_18505715/article/details/79795728 * * wait() 和 notify() 解释：https://blog.csdn.net/ch
Java多线程练习题
11-21
这是对Java多线程的一些相关练习题 包括选择 填空 简答 编程等题型
Java 多线程练习2 （抽奖比较Runnable写法）
最新发布
Aishangyuwen的博客
08-14 495
Java 多线程练习2 （抽奖比较Runnable写法）
java基础多线程练习题（1）
08-08
java基础之多线程的练习题，博客访问地址： http://blog.csdn.net/u014028392/article/details/76906801
Java多线程的练习
Seven597的博客
04-04 743
Java的多线程线程类的部分方法有关方法1有关方法而2创建线程第一种创建线程的方式第二种创建线程的方式分析两种线程的创建线程的优先级优先级设置以及获取优先级的方法线程的生命周期图解线程的生命周期（参考尚硅谷视频）线程的同步同步的优缺点优点缺点同步代码块同步方法当使用 继承Thread的线程实现抢票功能时注意问题变量值使用同步代码块或者同步方法的时需要注意使用 ReentrantLock 线程锁解决同步带来的安全性问题线程同步出现死锁问题 线程类的部分方法 有关方法1 void start() : 启动线程
Java多线程练习
weixin_30947043的博客
02-28 102
国际惯例，先贴出代码package jiankong; import java.util.Date; public class jiankong { public static void main(String [] args) { MyThread thread = new MyThread(); thread.start(); ...
Java多线程练习源代码
01-11
本资源“Java多线程练习源代码”提供了一系列的示例，旨在帮助开发者深入理解和熟练掌握Java多线程的运用。 1. **线程的概念与创建** 线程是程序执行的最小单元，一个进程可以有多个线程同时执行任务。在Java中，...
多线程demo/java多线程练习
05-17
本项目"多线程demo/java多线程练习"旨在通过实际操作来深入理解和掌握多线程技术，同时模拟数据库操作，这在现代应用程序开发中至关重要。 1. **线程基础** - **创建线程**：Java提供了两种创建线程的方式，分别是...
java多线程练习demo 基本的线程使用方式 生产者消费者练习 龟兔赛跑练习.zip
11-01
"java多线程练习demo" 提供了一系列实例，帮助开发者理解和掌握如何在Java中创建和管理线程。在这个压缩包中，我们可以找到一个名为 "multithreading-master" 的文件夹，它可能包含了多个关于多线程的示例项目，比如...
JAVA多线程练习题答案。
04-13
JAVA多线程练习题答案详解 在本文中，我们将对 JAVA 多线程练习题的答案进行详细的解释和分析。这些题目涵盖了 JAVA 多线程编程的基本概念和技术，包括线程的生命周期、线程同步、线程状态、线程优先级、线程安全等...
JAVA多线程练习题。
04-12
JAVA多线程练习题。都是一些基本的练习题。对初学者有帮助
java多线程练习题
xwt1130_的博客
11-13 1117
java多线程练习题
JAVA中的多线程——练习
仔鸡的博客
05-07 760
/* * 需求： * 银行有一个金库 * 有两个储户分别存300元，每次存100，存3次 * 该程序是否有安全问题，有的话如何解决 * * 问题： * 哪些代码是多线程运行代码 * 明确共享数据 * 明确多线程运行代码中哪些语句是操作共享数据的 * */ /** * synchronized可以修饰函数， * */ //class Bank { // private ...
java 多线程 练习
qq_29087535的博客
02-12 448
Runnable.java(实现Runnable接口) package com.jhy.www.thread; //通过实现 Runnable 接口来创建线程 public class RunnableDemo implements Runnable { private Thread t; private String threadName; public Runnab...
Java 多线程 经典练习题
Json的知识梦工厂
08-20 825
//练习题 //生产者（Producer） 将产品交给店员(Clerk) 而消费者(Customer)从店员处取走商品 // 店员一次只能持有固定数量的产品（比如20） 如果生产者试图生产更多的产品 // 店员会叫生产者停一停 如果店中有空位 再通知生产者 继续生产 // 如果店中没有了产品 店员会告诉消费者等一下 // 如果店中有了产品 再通知消费者取走产品 // 分析1. 是否是多线程问题 ？ 是 生产者线程 消费者线程 // 2. 是否有共享数据？ 是 店员（或产品） // 3. 如.
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Bridge Fish

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值