CH8-多线程

已于 2024-02-01 07:02:11 修改
阅读量3.4k 收藏 61
点赞数 11
分类专栏： Java基础案例教程第二版(黑马程序员) 文章标签： java
于 2022-04-13 16:57:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46227276/article/details/124152341
版权

【案例8-1】 龟兔赛跑

【案例介绍】

1.任务描述

​ 众所周知的“龟兔赛跑”故事，兔子因为太过自信，比赛中途休息而导致乌龟赢得了比赛.本案例要求编写一个程序模拟龟兔赛跑，乌龟的速度为1米/1500毫秒，兔子的速度为5米/500毫秒，等兔子跑到第700米时选择休息10000毫秒，结果乌龟赢得了比赛。

2.运行结果

运行结果如图8-1所示。

手机屏幕截图 描述已自动生成

【案例目标】

  • 学会分析”龟兔赛跑”任务实现的逻辑思路。

  • 能够独立完成”龟兔赛跑”程序的源代码编写、编译以及运行。

  • 能够在程序中使用多线程完成逻辑思路。

【案例思路】

​ (1) 查看运行结果分析后，首先创建一个Torist（）方法作为乌龟线程的内部类，在Torist（）方法中使用sleep模拟乌龟跑步。

​ (2) 查看运行结果分析后，创建一个Rabbit（）方法作为兔子线程的内部类，在Torist（）方法中使用sleep模拟乌龟跑步。

​ (3) 最后在main方法中调用Torist（）与Rabbit（）方法实现龟兔赛跑。

【案例代码】

龟兔赛跑小程序的代码如文件8-1所示。

文件8-1 race.java

package chapter0401;
public class race
{
    private int toristDistance;//乌龟跑过的距离
    private int rabbitDistance;//兔子跑过的距离
    /**
    * 乌龟线程内部类
    */
    class Torist extends Thread
    {
        @Override
        public void run()
        {
            //分析编程代码
            for(int i = 1; i <= 800; i++)
            {
                //判断兔子是否到达终点
                if(rabbitDistance == 800)
                {
                    //当兔子先800的时候 兔子就已经赢了
                    System.out.println("兔子赢得了比赛，此时乌龟才跑了" + toristDistance + "米");
                    break;
                }
                else
                {
                    //乌龟开始跑
                    toristDistance += 1;
                    //判断距离是否是100的倍数
                    if(toristDistance % 100 == 0)
                    {
                        try
                        {
                            if(rabbitDistance == 700)
                            {
                                System.out.println("乌龟跑了" + toristDistance + "米，此时兔子在睡觉");
                            }
                            else
                            {
                                System.out.println("乌龟跑了" + toristDistance + "米，此时兔子跑过段距离是" + rabbitDistance);
                            }
                            Thread.sleep(1500);
                        }
                        catch (InterruptedException e)
                        {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
    /**
    * 兔子线程内部类
    */
    class Rabbit extends Thread
    {
        @Override
        public void run()
        {
            //分析编程代码
            for(int i = 1; i <= 800 / 5; i++)
            {
                //判断兔子是否到达终点
                if(toristDistance == 800)
                {
                    //当兔子先1000的时候 兔子就已经赢了
                    System.out.println("乌龟赢得了比赛，此时兔子跑了" + rabbitDistance + "米");
                    break;
                }
                else
                {
                    //乌龟开始跑
                    rabbitDistance += 5;
                    //判断距离是否是100的倍数
                    if(rabbitDistance % 100 == 0)
                    {
                        try
                        {
                            System.out.println("兔子跑了" + rabbitDistance + "米，乌龟跑过了"
                                               + toristDistance);
                            if (rabbitDistance == 700)
                            {
                                System.out.println("兔子觉得自己怎么能可以赢得比赛，所以选择睡一会");
                                Thread.sleep(10000);
                            }
                            Thread.sleep(500);
                        }
                        catch (InterruptedException e)
                        {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
    //测试
    public static void main(String[] args)
    {
        //1 外部类实例构建
        race outer = new race();
        //2兔子 乌龟线程实例构建
        Rabbit rabbit = outer.new Rabbit();
        Torist torist = outer.new Torist();
        //3 依次启动
        //在现实中 也不可能两个同时跑 这样也是很公平的
        rabbit.start();
        torist.start();
    }
}

​ 代码第9~38行代码是乌龟线程的内部类，使用for循环嵌套Thread的sleep方法模拟乌龟跑步，代码第42~72行代码是兔子线程的内部类，与乌龟线程的内部类类似，第76~84行代码是启动线程，模拟乌龟兔子赛跑。

【案例8-2】 Svip优先办理服务

【案例介绍】

1.任务描述

​ 在日常工作生活中，无论哪个行业都会设置一些Svip用户，Svip用户具有超级优先权，在办理业务时，Svip用户具有最大的优先级。

​ 本案例要求编写一个模拟Svip优先办理业务的程序，在正常的业务办理中，插入一个Svip用户，优先为Svip用户办理业务。本案例在实现时，可以通过多线程实现。

2.运行结果

运行结果如图8-1所示。

手机屏幕截图 描述已自动生成

【案例目标】

  • 学会分析”Svip优先办理服务”任务实现的逻辑思路。

  • 能够独立完成”Svip优先办理服务”程序的源代码编写、编译以及运行。

  • 能够在程序中使用多线程的”插队”完成逻辑思路。

【案例思路】

​ (1) 查看运行结果分析后，创建一个special()方法模拟Svip办理业务。

​ (2) 查看运行结果分析后，首先创建一个normal()方法模拟正常的窗口排队，当有Svip客户是使用join线程让步，调用special()优先让Svip办理业务。

​ (3) 最后在main方法中调用normal()方法。

【案例代码】

Svip优先办理服务程序的代码实现如文件8-1所示。

文件8-1 svip.java

package chapter0402;
public class svip
{
    public static void main(String[]args) throws InterruptedException
    {
        new Thread(new normal()).start();
    }
}
class specia* extends Thread
{
    public void run()
    {
        System.out.println("svip客户开始办理业务");
        System.out.println("svip客户办理业务的倒计时");
        for(int i = 10; i >= 0; i--)
        {
            System.out.println(i + "秒");
            try
            {
                Thread.sleep(1000);
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        System.out.println("svip客户办理完毕");
    }
}
class norma* extends Thread
{
    public void run()
    {
        System.out.println("业务办理窗口在正常排队中");
        System.out.println("此时来了一位svip客户");
        Thread t = new Thread(new special());
        //各走各的逻辑错误，再加入join先执行完special，再执行normal剩下的
        t.start();
        try
        {
            t.join();
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println("业务办理窗口又恢复正常排队");
    }
}

​ 文件8-1中第8~24行代码是svip客户办理业务，使用for循环10次模拟办理业务第25~39行代码是模拟窗口正常排队，第32~35行代码是normal线程让步special线程。

【案例8-3】 模拟银行存取钱

【案例介绍】

1.任务描述

​ 在银行办理业务时，通常银行会开多个窗口，客户排队等候，窗口办理完业务，会呼叫下一个用户办理业务。本案例要求编写一个程序模拟银行存取钱业务办理。假如有两个用户在存取钱，两个用户分别操作各自的账户，并在控制台打印存取钱的数量以及账户的余额。

2.运行结果

运行结果如图8-1所示。

电脑屏幕的照片 描述已自动生成

【案例目标】

  • 学会分析”模拟银行存取钱功能”任务实现的逻辑思路。

  • 能够独立完成”模拟银行存取钱功能”程序的源代码编写、编译以及运行。

  • 通过存取款线程理解多线程安全问题的发生原因，并掌握如何解决多线程安全问题。

【案例思路】

​ (1) 通过任务描述和运行结果可以看出，该任务需要使用多线程的相关知识来是实现。由于两个用户操作各自的账户，因此我们需要创建两个线程完成每个用户的操作。这里我们使用实现Runnable接口的方法来创建线程。

​ (2) 既然是储户去银行存款，那么可以得出该任务会涉及到三个类，分别是银行类、储户类和测试类。

​ (3) 定义一个实体类作为账务的集合，包括用户名、登录名、登录密码、钱包、取钱时间和存钱时间等字段。

​ (4) 在银行类中需要定义一个账户的实体类、一个存钱的方法、一个取钱的方法、查询余额的方法和获取当前用户的方法。获取等前用户方法需要使用synchronized线程锁判断是是哪一位用户，在存钱和取钱的方法中先调用获取用户方法判断操作者，再进行存取钱操作，需要注意的是在进行取钱操作是，需要判断余额是否大于需要取的钱数。

​ (5) 在测试类中使用for循环调用线程模拟用户存取钱操作。

【案例代码】

（1） 创建用户类

定义一个用户的类，根据用户实现多人同时存取钱功能，如文件8-1所示。

文件8-1 User.java

package chapter0403;
import java.util.Date;
public class User {
    private String u_name;//用户名
    private String u_login_name;//登录名 卡的id
    private String u_login_pwd;//登录密码
    private String u_wallet;//钱包
    private Date  draw_money_time;//取钱时间
    private Date  save_money_time;//存钱时间
    public User(){}
    public User(String u_name, String u_login_name, String u_login_pwd, 
                String u_wallet) {
        this.u_name = u_name;
        this.u_login_name = u_login_name;
        this.u_login_pwd = u_login_pwd;
        this.u_wallet = u_wallet;
    }
    public User(String u_name, String u_login_name, String u_login_pwd, 
                String u_wallet, Date draw_money_time, Date save_money_time) {
        this.u_name = u_name;
        this.u_login_name = u_login_name;
        this.u_login_pwd = u_login_pwd;
        this.u_wallet = u_wallet;
        this.draw_money_time = draw_money_time;
        this.save_money_time = save_money_time;
    }
    public String getU_name() {
        return u_name;
    }
    public void setU_name(String u_name) {
        this.u_name = u_name;
    }
    public String getU_login_name() {
        return u_login_name;
    }
    public void setU_login_name(String u_login_name) {
        this.u_login_name = u_login_name;
    }
    public String getU_login_pwd() {
        return u_login_pwd;
    }
    public void setU_login_pwd(String u_login_pwd) {
        this.u_login_pwd = u_login_pwd;
    }
    public String getU_wallet() {
        return u_wallet;
    }
    public void setU_wallet(String u_wallet) {
        this.u_wallet = u_wallet;
    }
    public Date getDraw_money_time() {
        return draw_money_time;
    }
    public void setDraw_money_time(Date draw_money_time) {
        this.draw_money_time = draw_money_time;
    }
    public Date getSave_money_time() {
        return save_money_time;
    }
    public void setSave_money_time(Date save_money_time) {
        this.save_money_time = save_money_time;
    }
}

（2） 创建银行业务类

定义一个业务类，实现用户的存取钱功能，如文件8-2所示。

文件8-2 Bank.java

package chapter0403;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class Bank
{
    private List<User> userList = new ArrayList<>();
    public  Bank(List<User> userList)
    {
        this.userList = userList;
    }
    public  List<User> getUserList()
    {
        return userList;
    }
    public void setUserList(List<User> userList)
    {
        this.userList = userList;
    }
    //存钱
    public Boolean saveMoney(String card, String pwd, String moneyNum)
    {
        User u = getUserByCard(card);
        synchronized (Bank.class)
        {
            if (u.getU_login_name().equals(card) &&
                    u.getU_login_pwd().equals(pwd))
            {
                BigDecimal oldData = new BigDecimal(u.getU_wallet());
                BigDecimal money = new BigDecimal(moneyNum);
                u.setU_wallet(oldData.add(money).toString());
                u.setSave_money_time(new Date());
                System.out.println(Thread.currentThread().getName() + "存钱---->" + u.getU_name() +
                                   "在" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(u.getSave_money_time()) +
                                   "存[" + moneyNum + "]钱，余额：" + u.getU_wallet());
                return true;
            }
        }
        System.out.println(getUserByCard(card).getU_name() + "存钱失败");
        return false;
    }
    //取钱
    public Boolean getMoney(String card, String pwd, String moneyNum)
    {
        User u = getUserByCard(card);
        synchronized (Bank.class)
        {
            if (u != null && u.getU_login_name().equals(card) &&
                    u.getU_login_pwd().equals(pwd))
            {
                BigDecimal oldData = new BigDecimal(u.getU_wallet());
                BigDecimal money = new BigDecimal(moneyNum);
                if(oldData.compareTo(money) >= 0)
                {
                    u.setU_wallet(oldData.subtract(money).toString());
                    u.setDraw_money_time(new Date());
                    System.out.println(Thread.currentThread().getName() + "取钱---->" + u.getU_name() +
                                       "在" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(u.getDraw_money_time()) +
                                       "取[" + moneyNum + "]钱,余额：" + u.getU_wallet());
                    return true;
                }
                else
                {
                    System.out.println(getUserByCard(card).getU_name() + "要取[" + moneyNum + "]钱,但余额不足");
                    return false;
                }
            }
        }
        System.out.println(card + "取钱失败");
        return false;
    }
    //查询余额
    public String balanceEnquiry(String card, String pwd)
    {
        for(User u : this.userList)
        {
            if(u.getU_login_name().equals(card) &&
                    u.getU_login_pwd().equals(pwd))
            {
                System.out.println(Thread.currentThread().getName() + ":"
                                   + u.getU_name() + "余额：" + u.getU_wallet());
                return u.getU_wallet();
            }
        }
        System.out.println(Thread.currentThread().getName() + ":" + card + "操作失败");
        return null;
    }
    //获取当前用户
    public synchronized User getUserByCard(String card)
    {
        for(User u : this.userList)
        {
            if(u.getU_login_name().equals(card))
            {
                return u;
            }
        }
        return null;
    }
    public void delayTime(Integer nim)
    {
        try
        {
            Thread.sleep(nim);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

（3） 创建测试类

定义测试类，再类中创建客户对象，并创建和开启线程执行存取钱操作，如文件8-3所示。

package chapter0403;
import java.util.ArrayList;
import java.util.List;
public class BankText {
    public static void main(String[] args) throws Exception {
        User u = new User("张三", "132466", "123", "100");
        User uu = new User("李四", "4600882", "123", "0");
        List<User> list = new ArrayList<>();
        list.add(u);
        list.add(uu);
        Bank atm = new Bank(list);//初始化数据 模拟
        Thread t = new Thread() {
            public void run() {

                for (int i = 0; i < 10; i++) {
                    atm.saveMoney("132466", "123", "12");
                    atm.delayTime(250);
                    atm.getMoney("4600882", "123", "14");
                    atm.delayTime(250);
                }

            }
        };
        Thread tt = new Thread() {
            public void run() {

                for (int i = 0; i < 10; i++) {
                    atm.getMoney("132466", "123", "2");
                    atm.delayTime(250);
                    atm.saveMoney("4600882", "123", "12");
                    atm.delayTime(250);
                }
            }
        };
        t.start();
        tt.start();
    }
}

【案例8-4】 工人搬砖

【案例介绍】

1.任务描述

​ 在某个工地，需要把100块砖搬运到二楼，现在有工人张三和李四，张三每次搬运3块砖，每趟需要10分钟，李四每次搬运5块砖，每趟需要12分钟。本案例要求编写程序分别计算两位工人搬完100块砖需要多长时间。本案例要求使用多线程的方式实现。

2.运行结果

img

【案例目标】

  • 学会分析”工人搬砖”任务实现的逻辑思路。

  • 能够独立完成” 工人搬砖”程序的源代码编写、编译以及运行。

  • 能够在程序中使用多线程完成逻辑思路。

【案例思路】

​ (1) 查看运行结果分析后，需要定义一个搬砖用时的全局变量。还需要定义两个方法分别计算张三和李四搬100块砖所用的时间。

​ (2) 重写run()方法，在run()方法中使用if判断调用计算张三搬砖所用时间的方法还是计算李四搬砖所用时间的方法。

​ (3) 在测试类的main方法中创建并开启线程“张三”和“李四”。

【案例代码】

工人搬砖程序的代码实现如文件8-1所示。

文件8-1 MoveBricks.java

package chapter0404;
class Bricks implements Runnable {
    private int time = 0;
    public void run(){
      if (Thread.currentThread().getName().equals("张三")){
          zsmovebrick();    //计算张三搬砖所用时间的方法
      }else if(Thread.currentThread().getName().equals("李四")){
          lsmovebrick();    //计算李四搬砖所用时间的方法
      }
    }
    private synchronized void zsmovebrick(){
        time=(int)Math.ceil((double)100/(double)3)*10;
        System.out.println(Thread.currentThread().getName()+"搬完100块砖需
	   要"+time+"分钟");
    }
    private synchronized void lsmovebrick(){
        time= 100/5*12;
        System.out.println(Thread.currentThread().getName()+"搬完100块砖需
	   要"+time+"分钟");
    }
}
public class MoveBricks{
    public static void main(String[] args){
        Bricks bricks = new Bricks();
        new Thread(bricks,"张三").start();
        new Thread(bricks,"李四").start();
    }
}

​ 文件8-1中第3行代码定义了一个搬砖用时的全局变量；第5~9行代码用于判断调用计算张三搬砖所用时间的方法还是计算李四搬砖所用时间的方法；第11~15行代码是计算张三搬100块砖所用时间的方法；第16~21行代码是计算李四搬100块砖所用时间的方法；第24~26行代码是创建并开启线程“张三”和“李四”。

【案例8-5】 小朋友就餐问题

【案例介绍】

1.任务描述

​ 一圆桌前坐着5位小朋友，两个人中间有一只筷子，桌子中央有面条。小朋友边吃边玩，当饿了的时候拿起左右两只筷子吃饭，必须拿到两只筷子才能吃饭。但是，小朋友在吃饭过程中，可能会发生5个小朋友都拿起自己右手边的筷子，这样每个小朋友都因缺少左手边的筷子而没有办法吃饭。本案例要求编写一个程序解决小朋友就餐问题，使每个小朋友都能成功就餐。

2.运行结果

运行结果如图8-1所示。

手机屏幕截图 描述已自动生成

【案例目标】

  • 学会分析”小朋友就餐问题”任务实现的逻辑思路。

  • 能够独立完成”小朋友就餐问题”程序的源代码编写、编译以及运行。

  • 通过”小朋友就餐问题”程序理解多线程安全问题的方式原因，并掌握如果解决多线程安全问题。

【案例思路】

​ (1) 查看运行结果分析后，每个小朋友相当于一个线程，所以先创建一个Philosopher()方法作为小朋友。

​ (2) 查看运行结果分析后，创建eating()方法作为小朋友吃饭时的线程，创建thinking()方法作为小朋友玩耍是的线程。

​ (3) 查看运行结果分析后，需要在获取筷子的方法Fork中先定义一个boolean类型的数组，代表5根筷子的使用情况；再使用synchronized线程锁来控制只有左右手的筷子都未被使用时，才允许获取筷子，且必须同时获取左右手筷子。

​ (4) 查看运行结果分析后，需要在释放左右手筷子的方法putFork中使用synchronized线程锁来释放筷子。

​ (5) 最后在Test测试类中调用5次以上方法，代表5位小朋友。

【案例代码】

小朋友就餐问题的程序代码实现如文件8-1所示。

文件8-1 Philosopher.java

package chapter04061;
/*每个小朋友相当于一个线程*/
public class Philosopher extends Thread{
    private String name;
    private Fork fork;
    public Philosopher(String name,Fork fork){
        super(name);
        this.name=name;
        this.fork=fork;
    }
    public void run(){
        while(true){
            thinking();
            fork.takeFork();
            eating();
            fork.putFork();
        }
    }
    public void eating(){
        System.out.println("小朋友"+name+"在吃饭");
        try {
            sleep(1000);//模拟吃饭，占用一段时间资源
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public void thinking(){
        System.out.println("小朋友"+name+"在玩游戏");
        try {
            sleep(1000);//模拟思考
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
class Fork{
    /*5只筷子，初始为都未被用*/
    private boolean[] used={false,false,false,false,false,false};
    /*只有当左右手的筷子都未被使用时，才允许获取筷子，且必须同时获取左右手筷子*/
    public synchronized void takeFork(){
        String name = Thread.currentThread().getName();
        int i = Integer.parseInt(name);
        while(used[i]||used[(i+1)%5]){
            try {
                wait();//如果左右手有一只正被使用，等待
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        used[i ]= true;
        used[(i+1)%5]=true;
    }
    /*必须同时释放左右手的筷子*/
    public synchronized void putFork(){
        String name = Thread.currentThread().getName();
        int i = Integer.parseInt(name);
        used[i]= false;
        used[(i+1)%5]=false;
        notifyAll();//唤醒其他线程
    }
}

​ 文件8-1中第3~18行代码封装一个小朋友的方法，第19~27行代码是封装了小朋友吃饭时的方法，第28~37行代码封装了小朋友玩耍时的方法，第28~64行代码封装了筷子使用情况的方法。

测试类的代码如文件8-2所示，调用5次Fork代表5个小朋友。

文件8-2 Test.java

package chapter04061;
public class Test {
	  public static void main(String []args){
	        Fork fork = new Fork();
	        new Philosopher("0",fork).start();
	        new Philosopher("1",fork).start();
	        new Philosopher("2",fork).start();
	        new Philosopher("3",fork).start();
	        new Philosopher("4",fork).start();
	    }
}
绿洲213
关注
  • 11
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
多人赛跑用多线程实现
xtzhiker的博客
10-07 287
【代码】多人赛跑用多线程实现。
CH11-C#进程与线程.md
12-27
1. 理解进程和线程的基本概念 2. C# Process：进程类 3. C# Thread：线程及与线程有关的类 4. C# ThreadStart：创建无参数无返回的线程 ...6. C# Priority：多线程优先级设置 7. C# lock：给线程加锁，保证线程同步
Java多线程——模拟龟兔赛跑的场景
Kluadias的博客
05-10 4128
题目分析 1. 编写龟兔赛跑多线程程序，设赛跑长度为100米，先完成的一方胜利。 2. 兔子要休眠一段时间,但是跑步速度更快,乌龟不休眠,但是速度慢. 3. 编写兔子和乌龟类 RabbitAndTurtle继承Thread.然后编写逻辑. 4. 使用Thread的sleep(long milis)方法使线程休眠来控制兔子休眠时间. 5. 用Math.random()方法或setPrior...
Java多线程案例——龟兔赛跑
最新发布
chenyang_88的博客
05-23 254
1. 首先确定赛道距离，然后要离终点越来越近；2. 判断比赛是否结束；4. 龟兔赛跑比赛开始；6. 最后乌龟赢得比赛。3. 打印出胜利者；5. 模拟兔子睡觉；
Java多线程之赛跑游戏（含生成exe文件）
李章勇的博客
12-11 977
Java多线程之赛跑游戏（含生成exe文件） 在JavaSE中，多线程是一个重要的内容。 我们要了解多线程的概念，就要先了解进程的概念；要了解进程的概念，就离不开操作系统的概念。 在一台正常运行的电脑中，计算机硬件（如CPU、内存、硬盘、网卡、显示器、键盘、鼠标等）提供了基础的硬件环境；在硬件之上，是操作系统，这是系统级的软件程序，用来管理计算机的...
多线程争冠军（多线程赛跑）
qq_45679717的博客
12-17 537
这里设计了一个Champion单例类以及多个线程，每个线程从左到右水平移动一个属于自己的按钮，最先将按钮移动到指定位置的线程为冠军，即该线程将负责创建出Chanpion单例类的唯一实例（冠军），后续将自己的按钮移动到指定位置的其他线程都可以看到冠军的有关信息，即看到Champion单例类的唯一实例的有关属性值。 MoveButton.java import java.awt.*; import javax.swing.*; import java.util.Random; public class Move
Java多线程-模拟接力赛跑
five小点心的博客
11-15 892
Java多线程-模拟接力赛跑：多人参加1000米接力跑。每人跑100米，换下一个选手。要求每跑10米显示信息。
多线程龟兔赛跑
GHYshuai55的博客
11-02 800
package com.zhidi.lianxi; public class Lianxi02 { public static void main(String[] args) { Gui g = new Gui(); g.setName("乌龟"); g.setPriority(5); Tu t = new Tu(); t.setName("兔子"); t.set
ch-se-pr.zip_ch-se-pr
09-14
总结来说，"ch-se-pr.zip_ch-se-pr"是一个包含Java聊天客户端和服务器的项目，涉及网络编程、多线程、GUI设计等多个技术领域，通过解压这个文件，开发者可以查看和运行项目的源代码，进一步了解和学习这些技术。
CH-8.6---PageRank.rar_Java 8
09-24
此外，Java 8的并发特性如`ForkJoinPool`和`CompletableFuture`可以帮助优化多线程处理，提升计算效率。 总的来说，Java 8实现的Hadoop PageRank算法是一种高效、可扩展的解决方案，尤其适合处理大规模的互联网数据...
JavaPD-Ch08mao线程1
08-03
线程同步是解决多线程访问共享资源时可能出现的竞态条件问题。Java提供了多种同步机制，如synchronized关键字（用于锁定代码块或方法），wait()、notify()和notifyAll()方法（用于线程间的通信），以及Lock接口及其...
多线程赛跑小游戏，练手demo
08-09
控制不同的人来跑一段固定的距离，最后通过名次来判断输赢，一个练手的小demo，感兴趣的可以试试。
操作系统课设：多线程实现龟兔赛跑
07-17
基于MFC实现，有简单的图形界面。主要是多线程以及SLEEP的使用。
java多线程编程之InheritableThreadLocal
08-29
Java 多线程编程之 InheritableThreadLocal Java 多线程编程之 InheritableThreadLocal 是一种特殊的 ThreadLocal 类，它允许子线程继承父线程中的值，从而实现了父子线程之间的值传递。 InheritableThreadLocal ...
多线程实现龟兔赛跑
zhourongxiang1的博客
03-19 207
pos从0到100，代表龟兔距离起点的长度。
Java多线程-龟兔赛跑
qq_45874900的博客
04-20 1275
学习java已经过了两个月了，之前一直有想记录学习情况的想法，但是由于太懒，自身语言组织能力差又放弃了，现在java学到线程这块，还是觉得的尝试一下写写博客来提升自我。第一篇博客就从龟兔赛跑这个题目开始记录吧，让我们先来看看题目需求吧。 题目： 实现龟兔赛跑 提示：可以采用Math.random()取得0~1之间的随机数模拟比赛进程， 如总距离为100米，在随机数0~0.3之间代表兔子跑， ...
多线程_03_抢票_龟兔赛跑
Pure_Man_Ben的博客
08-25 264
学过创建线程的二种方法，一是继承Thread类，重写run方法，第二种是实现Runnble接口，推荐使用第二种，这样能够避免单继承的局限性。 接下来用第二种实现Runnble接口写下案例，模拟抢票 package com.cb.thread; /* * 共享资源,并发（线程安全） */ public class Web12306 implements Runnable{ private ...
多线程的实例之龟兔赛跑
李十八的博客
06-06 2319
  龟兔赛跑我们可以看成两个线程并发执行，我们可以通过让其中一个线程 “睡觉” 来实现 “操盘”，下面让我们看一下代码如何实现： public class TestThread implements Runnable{ static String winner; @Override public void run(){ //定义一条“跑道” for (i...
Java 多线程—龟兔赛跑问题
井以及真实的博客
08-28 8398
什么是多线程？在回答这个问题之前先要明白什么是线程，线程是能独立运行的基本单位，要完成程序的运行，最先执行的就是线程，线程的“容器”叫做进程，如原子构成分子，分子构成元素，程序就是元素，进程相当于分子，而线程就相当于原子。随着计算机的发展，程序需要的运行速度需要越来越快，这是单条线程完成进程然后再完成程序的执行远远跟不上人们的需求，所以多线程应运而生。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

绿洲213

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

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

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

打赏作者

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

抵扣说明：

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

余额充值