java 奇偶数顺序打印和猜数字游戏

最新推荐文章于 2022-11-15 19:28:04 发布
最新推荐文章于 2022-11-15 19:28:04 发布
阅读量639 收藏 1
点赞数
分类专栏： JAVA多线程 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Michael312917/article/details/105663711
版权

java 奇偶数顺序打印

Lock和Synchronized之间的区别
  1. synchronized 属于关键字
  • 针对同步代码块而言，它的底层是通过moniter对象的moniterenter和moniterexit来实现加锁和解锁；每个对象都有一个监视器monitor，当monitor被占用时就处于加锁状态，线程在执行monitorenter指令时就会尝试去获取monitor的执行权。
     - 如果monitor的进入数为0，则线程进入monitor，然后将进入数置为1，该线程即为monitor的所有者
 - 如果线程已经占有了该monitor，只是重新进入，然后将进入数加1(这也就是被称为可重入锁的原因)
 - 如果其他线程已经占有该monitor，则线程就会进入到阻塞状态，直到monitor的进入数为0，再去重新尝试获取
  • 如果是静态方法或普通方法，则是通过在flags中加 ACC_SYNCHRONIZED标识来实现的
   当方法被调用时，调用指令将会检查方法的ACC_SYNCHRONIZED访问标志是否被设置，如果设置了，执行的线程将会先获取monitor，获取成功之后才能执行方法体，方法执行完成之后将释放monitor。在方法执行期间，其他任何线程将无法获取同一个monitor对象。

javap -v -p -s -sysinfo -constants XXX.class 通过该命令可以查看java生成的对应class文件。
Lock是属于API层面

  1. synchronized 不需要用户手动去释放锁，系统会让线程主动释放对锁的占用；
    lock锁必须显示的去释放锁，否则可能会导致死锁，通常会配合try{lock.lock}catch()finally{lock.unlock}使用

  2. synchronized 是不可中断的，需要程序正常执行完方法体或者抛出异常；
    lock是可以中断的，其获取锁的方式：
    1)tryLock(long timeout,TimeUnit unit)或lock.tryLock()尝试获取锁，如果获取不到，就处于等待
    2)lockInterruptibly()可中断的锁，调用intterput()方法可中断线程的运行

  3. synchronized 非公平锁，ReentrantLock默认是非公平锁，可以通过构造函数参数设置是公平锁或者非公平锁(公平或者非公平：首先申请获取锁的线程是否首先去获取锁)

  4. ReentrantLock可以通过绑定Condition，实现对线程的精确控制去唤醒其等待线程的执行，而synchronized则无法实现精确控制，只有通过notify或者notifyAll去随机唤醒或者唤醒所有等待的线程

案例一 龟兔赛跑

要求：
1 龟兔都是从起点出发，乌龟跑的慢，兔子跑的快
2 当兔子跑到40m，还没看见乌龟时，休眠一段时间(100ms)
3 当兔子跑到80m时，还是没看见乌龟，则暂停一段时间
4 乌龟处于一直跑的状态

public class GameRunnable {
    // 定义乌龟和兔子的起步线
    private int tortoiseNum = 0;
    private int rabbitNum = 0;
   // private ReentrantLock lock = new ReentrantLock();
    //private Condition condition = lock.newCondition();
    // 定义锁
    private Object lock = new Object();
    public void tortoiseRace() {
        //设置线程优先级 低
        Thread.currentThread().setPriority(Thread.NORM_PRIORITY-1);
        try {
           // lock.lock();
            synchronized (lock) {
                while (tortoiseNum < 100) {
                    tortoiseNum++;
                    System.out.println("乌龟跑：" + tortoiseNum);
                    if (tortoiseNum == 100) {
                        System.out.println("乌龟跑完100");
                    }
                }
            }
        }catch (Exception e){}finally {
            //lock.unlock();
        }
    }

    public void rabbitRace() {
        //设置线程优先级 高
        Thread.currentThread().setPriority(Thread.NORM_PRIORITY+1);
       try {
          //lock.lock();
           synchronized (lock) {
               while (rabbitNum < 100) {
                   rabbitNum++;
                   System.out.println("兔子跑完" + rabbitNum);
                   if (rabbitNum == 40 && tortoiseNum != 40) {
                       Thread.sleep(100);
                       System.out.println("兔子休眠100ms结束");
                   }
                   if (rabbitNum == 80 && tortoiseNum != 80) {
                       //condition.await();
                      // lock.wait();
                      //yield()方法只是让该线程暂时让出CPU的执行权，让其他线程执行
                       Thread.yield();
                   }
                   if (rabbitNum == 100) {
                       System.out.println("兔子跑完100");
                   }
               }
           }
       }catch (Exception e){}finally {
          // lock.unlock();
       }
    }
}

测试类如下：

    public static void main(String[] args) {
        GameRunnable runnable = new GameRunnable();

        Thread t1 = new Thread(() -> {
            runnable.rabbitRace();
        });
        Thread t2 = new Thread(() -> {
            runnable.tortoiseRace();
        });
        t1.start();
        t2.start();
    }

备注：Thread.join()代表的是当前线程放弃CPU的执行权，等待某个线程的执行直至结束，这就使得线程之间的并行执行变成了同步执行
Thread.join()方法举例如下：

public class Test1 {
   static class JoinTest implements Runnable{
       @Override
       public void run() {
           for (int i = 1; i <= 100; i++) {
               System.out.println(Thread.currentThread().getName()+":"+i);
           }
       }
   }
    public static void main(String[] args) throws InterruptedException {
       JoinTest joinTest = new JoinTest();
        Thread t1 = new Thread(joinTest, "t1");
        Thread t2 = new Thread(joinTest, "t2");
        t2.start();
        t1.start();
        /**
         * join会使得当前线程放弃执行，并返回对应的线程
         *  main方法中调用了t1线程的join(),则main线程会放弃CPU的执行权，
         *  并返回t1线程继续执行直至t1线程执行结束
         */
        t1.join();
        System.out.println("main线程执行结束");
    }
}

    public final void join() throws InterruptedException {
        join(0);
    }
     // 传入参数millis为0 代表某个线程一直等待调被用线程的执行，直至被调用线程执行结束
     // 传入参数millis如果是大于0的数值，代表某个线程会等待被调用线程millis后，这两个线程再并行执行
     // 其执行原理就是wait()/notifyAll()方法：
     // 调用join()方法处，被调用方法的wait()执行；当被调用线程执行完毕后，会自动调用其notifyAll()唤醒调用线程继续执行
    public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;
        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }
案例二 模拟3位教师下放100份作业的实现
public class MyData {
    private int num = 100;

    public void issueHomeWork() {
        while (true) {
            synchronized (MyData.class) {
                if (num >= 1) {
                    System.out.println(Thread.currentThread().getName() + "下发第" + (num--) + "份作业");
                }else {
                    break;
                }
            }
        }
    }
}
public class TestMyData {
    public static void main(String[] args) {
        MyData myData = new MyData();
        for (int i = 0; i < 3; i++) {
            new Thread(()->{
                myData.issueHomeWork();
            },"第"+i+"位教师").start();
        }
    }
}

测试时结果总是启动1个或者2个线程下发全部的作业，较难见到三个线程同时运行的情况，因此采用多线程Semaphore信号量的方式对共享资源进行控制其并发数。

public class MyData {
    private int num = 100;
    // 创建固定数量的信号量：控制并发线程数
    Semaphore semaphore = new Semaphore(3);
    public void issueHomeWork() {
        while (true) {
            try {
              //在当前信号量中获取一个许可.当前线程会一直阻塞直到有一个可用的许可,或被其他线程中断.
                semaphore.acquire();
                if (num >= 1) {
                    System.out.println(Thread.currentThread().getName() + "下发第" + (num--) + "份作业");
                }else {
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
              // 释放一个许可,让它返回到semaphore信号量中.
                semaphore.release();
            }
        }
    }
}
案例三实现奇偶数的顺序打印
public class OrderPrint {
    private int num = 1;
    private Lock lock;
    // 奇数条件
    private Condition oddLock;
    // 偶数条件
    private Condition evenLock;
    // 最大值
    private int MAX_VALUE = 100;
    //线程停止运行标志位
    private boolean isStop = false;

    public OrderPrint(Lock lock) {
        this.lock = lock;
        oddLock = lock.newCondition();
        evenLock = lock.newCondition();
    }
    // 打印奇数
    public void printOdd() {
        try {
            lock.lock();
            while (num <= MAX_VALUE && !isStop) {
                if (num % 2 != 0) {
                    System.out.println(Thread.currentThread().getName() + "输出：" + num);
                    num++;
                    evenLock.signalAll();
                    oddLock.await();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
     //打印偶数
    public void printEven() {
        try {
            lock.lock();
            while (num <= MAX_VALUE && !isStop) {
                // 如果是偶数
                if (num % 2 == 0) {
                    System.out.println(Thread.currentThread().getName() + "输出：" + num);
                    if (num == MAX_VALUE) {
                        // 到达最大值100，设置线程停止标志位为true
                        isStop = true;
                        // 确保奇数线程唤醒，停止其运行
                        oddLock.signalAll();
                    } else {
                        // num ++ 一定是奇数
                        num++;
                        // 唤醒奇数线程进行消费
                        oddLock.signalAll();
                        // 如果num不是偶数 则进行等待
                        evenLock.await();
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

测试多线程启动查看结果是否顺序打印：

public class OrderPrintTest {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        OrderPrint data= new OrderPrint(lock);
        new Thread(()->{
            data.printOdd();
        },"奇数线程").start();
        new Thread(()->{
            data.printEven();
        },"偶数线程").start();
    }
}

测试结果如下：
顺序打印奇偶数

案例四 猜数字游戏

要求：
1 一个线程随机生成一个(1-100)的数，等待另一个线程输入
2 如果输入的数值小于或者大于随机生成的数值，则生成随机数的线程给出提示小了或者大了，然后再次等待线程的输入数值，再按照上面顺序循环
3只有猜的数字和随机生成的数字一样，给出猜对了提示后，停止运行

public class GuessData {
    private int num = -1;
    private int guessNum = 0;
    private ReentrantLock lock;
    private Condition waitInput;
    private Condition nextInput;
    // 中断标志位
    private boolean isStop = false;

    public GuessData(ReentrantLock lock) {
        this.lock = lock;
        this.waitInput = lock.newCondition();
        this.nextInput = lock.newCondition();
    }

    public void generateNum() {
        num = new Random().nextInt(100) + 1;
        System.out.println("生成得随机数为：" + num);
        try {
            // 获取可中断得锁
            //lock.lockInterruptibly();
            lock.lock();
            // 死循环判断
            while (true && !isStop) {
                // 等待线程2输入所猜测得数据
                waitInput.await();
                if (num > guessNum) {
                    System.out.println("猜的数字小了");
                } else if (num < guessNum) {
                    System.out.println("猜的数字大了");
                } else {
                    //如果输入得数字和随机生成得数字相等，则中断当前线程
                    isStop = true;
                    System.out.println("恭喜你，猜对了");
                }
                //唤醒线程2进行下次输入
                nextInput.signalAll();
            }
        } catch (Exception e) {
             e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void guessNum() {
        Scanner scanner = new Scanner(System.in);
        try {
           // lock.lockInterruptibly();获取可中断得锁
            lock.lock();
            while (true && !isStop) {
                System.out.println("请输入你猜的数字");
                guessNum = Integer.parseInt(scanner.next());
                //唤醒线程1进行判断
                waitInput.signalAll();
                // 线程2进行等待下次输入
                nextInput.await();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

测试

public class Test {
    public static void main(String[] args) {
        GuessData guessData = new GuessData(new ReentrantLock());

        new Thread(() -> {
            guessData.generateNum();
        }, "生成数字线程").start();
        new Thread(() -> {
            guessData.guessNum();
        }, "猜数字线程").start();

    }
}

测试结果如下：
猜数字游戏

Michael312917
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java指定线程数顺序打印数字
qq_40727267的博客
04-04 499
问题 有kCount个线程，从1开始编号，顺序打印1,2,3…，打印到n； eg：kCount = 3; n = 10; 输出： Thread 1 -> 1 Thread 2 -> 2 Thread 3 -> 3 Thread 1 -> 4 Thread 2 -> 5 Thread 3 -> 6 Thread 1 -> 7 Thread 2 -> 8...
java中怎么按顺序打印数字_Java多个线程顺序打印数字
weixin_35642587的博客
03-07 556
要求启动N个线程, 这N个线程要不间断按顺序打印数字1-N. 将问题简化为3个线程无限循环打印1到3方法一: 使用synchronized三个线程无序竞争同步锁, 如果遇上的是自己的数字, 就打印. 这种方式会浪费大量的循环public class TestSequential1 {private volatile int pos = 1;private volatile int count = ...
java编写奇数偶数,java基础奇数偶数判断
weixin_36096321的博客
03-12 815
class="java" name="code">1. 按位与运算 按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0package shenkxiao.test.com;public class ShenkxiaoTestisOdd {/*** @param args* @author She...
java演练 猜奇偶小游戏开发 DB游戏必输的设计
pyhui的技术博客
09-09 437
java演练 猜奇偶小游戏开发 DB游戏必输的设计 阶段一，视频 https://www.ixigua.com/6870390946270446088?logTag=J_BVJOm_LIpQ-hWYYF4eI 阶段一，流程图的绘制 阶段二，视频 https://www.ixigua.com/6870396051078152717?logTag=TjxlSM6IdhE7wHXSuuaud 阶段二，代码编写游戏架构 import java.util.Scanner; public class test {
用java写数字游戏
weixin_47669758的博客
11-15 726
总共分了2个类，方法类作为子类继承父类，然后父类里边直接按照静态类方法的调运方式调运静态方法，在父类里输入您的账号密码进入数字游戏内，输入你想输入的数字【0-100】和随机数值【0-101）比较的代码。
数字筛选，奇偶性归类区分
04-16
本主题“数字筛选，奇偶性归类区分”关注的是如何使用编程语言，如Java，来实现这个功能。我们将深入探讨相关的知识点，包括数据类型的处理、条件判断、数组操作和排序算法。 首先，我们要理解Java中的数字类型，...
利用JAVA，求数字特征值。
07-18
描述提到“奇偶特征是一种简单的特征值”，这暗示了我们可能会探讨如何通过Java计算数字的奇偶性，但这只是特征值的一种基础应用。 特征值通常与线性代数中的矩阵理论相关，其中特征值代表了矩阵变换下向量伸缩和...
数字奇偶判断
11-11
在编程领域，数字奇偶性的判断是一个基础但重要的概念，尤其在算法设计和问题解决中经常用到。本文将深入探讨数字奇偶性及其在编程中的应用，以帮助你理解和运用这一知识点。 首先，我们要理解什么是数字的奇偶性。...
奇偶数交互多线程thread源码java
02-06
并发调试和JDK8新特性.pdf 16:55:20.677 [main] INFO org.malin.allutils.makefile.ReadFileNameUtil - 获取到 文件名称： 11.jetty分析.pdf 16:55:20.677 [main] INFO org.malin.allutils.makefile....
使用顺序表实现奇偶排序
09-25
在`main`函数中，用户可以输入元素个数，然后创建顺序表，执行奇偶排序，并打印排序后的结果。 注意，在`changelist`函数中，根据输入元素个数n是奇数还是偶数，分别处理奇数和偶数的存储。当n为奇数时，`arr1`会...
java生成字母数字组合的随机数示例 java生成随机数
09-04
主要介绍了java生成字母数字组合的随机数的示例，大家参考使用吧
第五章 如何使用java中的线程打印偶数和奇数
we
07-17 1158
你有两个线程。您需要使用一个线程打印奇数，使用另一个线程打印偶数。您需要以自然顺序打印最多MAX。如果MAX为10，则需要打印所以13579将由奇数线程打印246810将由偶数线程打印。
Java多线程交替打印奇数和偶数
optics's blog
02-22 6035
/** * Created by CHG on 2017-02-22 12:27. * 题目:2个多线程交替打印1-100内数字,其中t1线程打印奇数,t2程打印偶数 * 主要考察对多线程创建以及多线程执行顺序的应用,难点是通过对一个对象的加锁,避免多线程随机打印,用一个开关控制打印奇数还是偶数 */ package cn.itchg;
java判断jdialog是否关闭_JAVA语言基础实例讲解：猜数字游戏
weixin_39880479的博客
11-04 281
在前述文章中，我们介绍到了JAVA语言的逻辑结构，分为顺序结构、分支结构、循环结构。顾名思义，顺序结构从上往下依次执行，按步骤一步一步执行即可，相对简单。所以我们没有过多的去讲解顺序结构。重点介绍的分支结构和循环结构。并且在上一篇文章中通过收银台收款系统对if以及if-else语句的使用做了练习。那么今天的文章，我们就结合前述文章对循环结构的介绍，通过编写“猜数字游戏”这一案例，加深一下循环结构知...
【Java多线程手写代码】（一）：启动两个线程交替顺序打印奇偶数
少侠露飞的学习笔记
11-16 1318
两个线程交替打印奇偶数的问题
Java实现猜数字游戏 简明 易懂 完整代码
热门推荐
qq_50916191的博客
01-06 4万+
生成随机数Random() 用户输入Scanner() 实现进入游戏的选择菜单
Java:按顺序打印一个数字的每一位.
yufy0528的博客
03-11 1252
按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4) 使用递归方法 public static void num(int a) { if(a>=9) { num(a/10); } System.out.println(a%10) ; } 只要大于九便开始递归. 完整代码 import java.util.Scanner; public class Te...
java多线程交替打印0-100的奇偶数
IT咸鱼圈
12-14 2533
package thread; public class PrintSD { //定义打印的方法 public synchronized void print(String str){ notify(); System.out.println(str); try { wait(); } catch (InterruptedException e) { //
Java-交替打印偶数和奇数
MARKPAIN的专栏
08-22 859
常见的一道面试题，认真想一想，自己写出来还是对wait()和notify()的理解有好处的，但是还是推荐使用reentrantlock去实现，更灵活吧。 package com.ilovewl.interview.concurrent; /** * 主要就是两个线程占用同一把锁，一个标志位保存当前应该输出偶数还是奇数 * @author liuchangrong */ public cl...
java输入一段数字输出奇偶个数
最新发布
09-08
要实现输入一段数字，然后输出奇偶个数的功能，可以按照以下步骤进行： 1. 首先，需要导入java.util.Scanner类，用于从标准输入读取数字。...通过以上步骤，就可以实现Java输入一段数字，然后输出奇偶个数的功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值