JavaThread 03 Runnable&&初识并发问题

最新推荐文章于 2024-11-01 14:48:20 发布

牟泉禹[Dark Cat]

最新推荐文章于 2024-11-01 14:48:20 发布

阅读量136

点赞数 1

分类专栏：学习笔记文章标签： java thread 多线程

BY-牟泉禹/MuQuanyu

本文链接：https://blog.csdn.net/qq_52606908/article/details/118783402

版权

学习笔记专栏收录该内容

387 篇文章 11 订阅

订阅专栏

1.4 Runnable&&初识并发问题

1.4.1 实现 Runnable 接口

其实 Thread 这个类就是 Runnable 接口的实现，所以我们建议直接用 Runnable 接口，而不是去用二次封装的 Thread 是有道理的。

需要注意的是，Runnable 接口在开启线程之前，需要建立一个 Thread 对象，作为代理，用来开启线程！

package www.muquanyu.lesson01;

public class RunnableDemo implements Runnable {

    @Override
    public void run() {
        for(int i = 0;i<200;++i)
        {
            System.out.println("线程：" + i);
        }
    }

    public static void main(String[] args) {

//需要 建立一个 Thread 对象
        Thread thread = new Thread(new RunnableDemo());
        thread.start();

        for(int i = 0;i<200;++i)
        {
            System.out.println(i);
        }
    }

}

在这里插入图片描述

两者的区别

继承 Thread 类

子类继承 Thread 类具备多线程能力
启动线程：子类对象.start()
不建议使用：避免OOP 单继承的局限性

实现 Runnable 接口

实现接口 Runnable 具有多线程能力
启动线程：传入目标对象 + Thread 对象.start()
推荐使用：避免单继承的局限性，灵活方便，方便同一个对象被多个线程使用

比如说三个线程同时跑一个事务！如果你继承 Thread 是无法实现的。只有实现 Runnable 接口才可以。

1.4.2 初识并发问题

比如我们三个人去抢十张票，那么这三个人就相当于三个线程，并且在做同一个事情，那就是抢票。也就相当于在处理同一个事务下的资源。这种情况，就会出现 “并发” 问题。

package www.muquanyu.lesson01;

import sun.misc.PostVMInitHook;

public class 多线程同时处理一个事务 implements Runnable {

    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true)
        {
            if(ticketNums <= 0)
            {
                break;
            }
            //模拟延迟
            try {
                Thread.sleep(200);
            }catch (Exception e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }

    }

    public static void main(String[] args) {
        多线程同时处理一个事务 test = new 多线程同时处理一个事务();

        new Thread(test,"小明").start();
        new Thread(test,"老师").start();
        new Thread(test,"黄牛党").start();
    }
}

我们可以清晰地看到我们开了三个线程，在处理一个事务。分别是小明、老师、黄牛党，在同一个事务里面，抢去资源（票）。但是票数是有限的，所以肯定会出现乱抢的情况。因为数据量过小，我们就加上了 sleep 延迟，这样就会更加可观的看到结果。在这里插入图片描述

这个时候，我们发现可能会有人抢到 -1 这个票，也可能会有人抢到的票是同一个。这就叫并发问题。

当多个线程对象，操作同一个资源的情况下，线程是不安全的。最明显的现象就是数据紊乱。。。

1.4.3 并发问题（龟兔赛跑）

我们还有一个典型的并发问题。————> 龟兔赛跑-Race
乌龟和兔子同时都在一条跑道上赛跑，肯定要争先抢后的去跑每一步，道路上的地方就那么大。但是他俩确实就有其中一个可能会后抢到道路的那块资源，或先抢到道路上的那块资源，导致最后谁赢（谁先抢到资源，或抢的多，肯定就赢了。）

首先来个赛道距离，然后要离终点越来越近。（可以设定跑了多少米）
判断比赛是否结束（距离为 0 不就结束了吗）
打印出胜利者
龟兔赛跑开始
故事中乌龟赢了，兔子是在睡觉的，所以我们来模拟一下兔子睡觉就行了。
终于，乌龟赢得了比赛。

在这里插入图片描述

package www.muquanyu.lesson01;

//模拟龟兔赛跑
public class Race implements Runnable {
    //只能 有一个 胜利者，所以是 静态的
    private static String winner;
    @Override
    public void run() {

        for(int i = 0;i <= 100;++i)
        {
            if(Thread.currentThread().getName().equals("兔子") && i%10==0)
            {
                try{
                    Thread.sleep(1);
                }catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
            boolean flag = gameOver(i);
            if(flag)
            {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "-->跑了"+i+"米！");
        }
    }

    private boolean gameOvera(int i) {
        return false;
    }

    //判断是否完成比赛
    private boolean gameOver(int steps)
    {
        if(winner != null)
        {
            return true;
        }
        if(steps == 100)
        {
            winner = Thread.currentThread().getName();
            System.out.println("winner is "+ winner);
            return true;
        }
        return false;
    }


    public static void main(String[] args) {
        Race race = new Race();

        Thread 兔子 = new Thread(race, "兔子");
        Thread 乌龟 = new Thread(race, "乌龟");
        兔子.start();
        乌龟.start();
    }
}