多线程的练习

最新推荐文章于 2024-10-17 19:11:48 发布

小林工作室76

最新推荐文章于 2024-10-17 19:11:48 发布

阅读量277

点赞数 4

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_68397667/article/details/141643168

版权

多线程的练习

一

有1000张电影票，可以在两个窗口领取，假设每次领取的时间为3000毫秒,

要求：请用多线程模拟卖票过程并打印剩余电影票的数量

public class FilmThread extends Thread{
    static int tack = 1000;
    static Object lock = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (lock) {
                if (tack == 0){
                    System.out.println("没票了:"+tack);
                    break;
                }
                tack--;
                System.out.println("剩余：" + tack + "张票");
                try {
                    sleep(3000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

            }
        }
    }
}

 public static void main(String[] args) {

        FilmThread filmThread = new FilmThread();
        FilmThread filmThread1 = new FilmThread();

        filmThread.start();
        filmThread1.start();
    }

二

有100份礼品，两人同时发送，当剩下的小礼品小于10份的时候则不在送出。

利用多线程模拟该过程并将线程的名字和剩余的礼品数量打印出来。

public static void main(String[] args) {
        Song s1 = new Song();
        Song s2 = new Song();
        
        s1.start();
        s2.start();
    }

public class Song extends Thread{
    static int lp = 100;
    static Object lock = new Object();

    @Override
    public void run() {

        while(true){
            synchronized (lock){
                if(lp == 10){
                    break;
                }
                lp--;
                System.out.println(getName()+"送出了第"+(100-lp)+"件礼品");
            }
        }
    }
}

三

同时开启两个线程，共同获取1-100之间的所有数字。

要求输出：所有的奇数。

public class JiShu extends Thread{
    static int i = 0;
    static Object lock = new Object();

    @Override
    public void run() {

        while (true){
            synchronized (lock){
                if (i >= 100) break;
                i++;
                if(i%2!=0){
                    System.out.println(i);
                }
            }
        }
    }
}

四

假设：100块，分成了3个包，现在有5个人去抢。其中，红包是共享数据，5个人是5个线程。

打印结果如下：

某某抢到了多少钱

某某没有抢到

public class RedThread extends Thread {
    static double money = 100;
    static final double MIX = 0.01;
    static int count = 3;
    static Object lock = new Object();

    @Override
    public void run() {
        synchronized (lock) {
            if (count == 0){
                System.out.println(getName()+"没有抢到红包");
            }else {
                double price = 0;
                if(count == 1){
                    price = money;
                }else {
                    Random random = new Random();
//                    double bounds = 100 -(count -1)*MIX;
                    price = random.nextDouble()*100;
                    if(money < price){
                        price = MIX;
                    }
                    if (price<MIX){
                        price=MIX;
                    }
                }
                money = money-price;
                count--;
                System.out.println(getName()+"抢到了"+price+"元");
            }
        }
        }

}

public static void main(String[] args) {
        RedThread red1 = new RedThread();
        RedThread red2 = new RedThread();
        RedThread red3 = new RedThread();
        RedThread red4 = new RedThread();
        RedThread red5 = new RedThread();

        red1.start();
        red2.start();
        red3.start();
        red4.start();
        red5.start();

    }

五

有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为{10,5,20,50,100,200,500,800,2,80,300,700};创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”“抽奖箱2”随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
每次抽出一个奖项就打印一个(随机)
抽奖箱1 又产生了一个 10 元大奖
抽奖箱1 又产生了一个 100 元大奖
抽奖箱1 又产生了一个 200 元大奖
抽奖箱1 又产生了一个 800 元大奖
抽奖箱2 又产生了一个 700 元大奖

/**
 * 有一个抽奖池,该抽奖池中存放了奖励的金额,该抽奖池中的奖项为{10,5,20,50,100,200,500,800,2,80,300,700};创建两个抽奖箱(线程)设置线程名称分别为“抽奖箱1”“抽奖箱2”随机从抽奖池中获取奖项元素并打印在控制台上,格式如下:
 *
 * 每次抽出一个奖项就打印一个(随机)
 *
 * 抽奖箱1 又产生了一个 10 元大奖
 *
 * 抽奖箱1 又产生了一个 100 元大奖
 *
 * 抽奖箱1 又产生了一个 200 元大奖
 *
 * 抽奖箱1 又产生了一个 800 元大奖
 *
 * 抽奖箱2 又产生了一个 700 元大奖
 */
public class CjThread extends Thread{
    //准备一个抽奖的数据
    static int[][] arrrys = new int[][]{
            {10,5,20,50,100,200,500,800,2,80,300,700},
            {0,0,0,0,0,0,0,0,0,0,0,0},
    };
    //抽将的次数
    static int count = arrrys[0].length;
    static Random r = new Random();

    private static int f() {
        int v =  r.nextInt(arrrys[0].length);
        return v;
    }

    static Object lock = new Object();
    @Override
    public void run() {
        while (true){
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (lock){
                if(count == 0){
                    break;
                }
                int price = 0;
                int f = f();
                while (arrrys[1][f] == 1){
                    f = f();
                }

                price = arrrys[0][f];
                arrrys[1][f] = 1;
                System.out.println(getName()+" 又产生了一个"+price+"元大奖");
                count--;
            }
        }
    }
}

第二种：


public class CjThread extends Thread{
    ArrayList<Integer> list;
    public CjThread(ArrayList<Integer> list){
        this.list = list;
    }
    static Object lock = new Object();
    @Override
    public void run() {
        while (true){
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (lock){
                if(list.size() == 0){
                    break;
                }
                //利用shuffle进行一个打乱
                Collections.shuffle(list);
                System.out.println(getName() + " 又产生了一个" + list.remove(0) + "元大奖");
            }
        }
    }
}

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
        CjThread c1 = new CjThread(list);
        CjThread c2 = new CjThread(list);

        c1.setName("奖箱1");
        c2.setName("奖箱2");
        c1.start();
        c2.start();
    }

六

在五题基础上继续完成如下需求:
每次抽的过程中，不打印，抽完时一次性打印(随机)在此次抽奖过程中，抽奖箱1总共产生了6个奖项，
分别为:10,20,100,500,2,300最高奖项为300元，总计额为932元在此次抽奖过程中，抽奖箱2总共产生了6个奖项
分别为:5,50,200,800,80,700最高奖项为800元，总计额为1835元

public class CjThread extends Thread{
    ArrayList<Integer> list;
    public CjThread(ArrayList<Integer> list){
        this.list = list;
    }
    static Object lock = new Object();
    @Override
    public void run() {
        ArrayList<Integer> arrayList = new ArrayList<>();
        while (true){
            synchronized (lock){
                if(list.size() == 0){
                    System.out.println(getName()+":"+arrayList.toString());
                    break;
                }
                //利用shuffle进行一个打乱
                Collections.shuffle(list);
                arrayList.add(list.remove(0));
                }
            }
        try {
            sleep(100);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

七

在上一题基础上继续完成如下需求
在此次抽奖过程中，抽奖箱1总共产生了6个奖项，分别为:10,20,100,500,2,300最高奖项为300元，总计额为932元
在此次抽奖过程中，抽奖箱2总共产生了6个奖项，分别为:5,50,200,800,80,700最高奖项为800元，总计额为1835元
在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为800元
以上打印效果只是数据模拟,实际代码运行的效果会有差异

和第七差不多;