多线程问题的一些模型

怼烎@ 2023-08-17 17:22 58阅读 0赞

**1.一个多线程实例：**

描述：某个火车售票系统，有多个窗口，但是票只在同一个系统中存有：

设计思路： 只存在一个系统：

设计细节： 使用单例设计模式确保多窗口公用一个对象，

使用Vector集合框架保证线程的并发的安全性；

多个窗口卖票，使用多线程模拟多个窗口，在run方法中采用组合的方式调用System 类的sellTicket()方法。

代码如下：

//Ticket 实体类
    
    public class Ticket {
        //起始站，终点，价格
        // 只有一些属性，一个对象包含很多属性，增强可读性
        //JavaBean , POJO
        String start;
        String end;
        Float price;  //大写，包装类
    
        public Ticket(String start, String end, Float price) {
            this.start = start;
            this.end = end;
            this.price = price;
        }
    
        public Ticket() {
        }
    
        public String getStart() {
            return start;
        }
    
        public String getEnd() {
            return end;
        }
    
        public Float getPrice() {
            return price;
        }
    
        public void setStart(String start) {
            this.start = start;
        }
    
        public void setEnd(String end) {
            this.end = end;
        }
    
        public void setPrice(Float price) {
            this.price = price;
        }
    
        //重写toString 方法，为了打印对象方便
        public String toString(){
            StringBuilder sb=new StringBuilder();
            sb.append(this.start).append("->").append(this.end).append("   价格").append(this.price);
            return new String(sb);
        }
    }
    
    
    
    //SystemTest类
    
    public class SystemTest {
    
        //只有一个系统： 设计单例模式
        private SystemTest(){
    
        }
    
        private static SystemTest st=new SystemTest();
        //静态： 保证唯一性
    
        public static  SystemTest getInstance(){
            //静态方法：通过类名可以调用
            return st;
        }
    
        //属性 ，集合 ArrayList,Vector -->synchronized,Stack
         private Vector<Ticket> tickets=new Vector<>();
    
        //当前系统创建后给，tickets集合赋值，用块完成
        {
            for (int i = 10; i < 100; i++) {
                tickets.add(new Ticket("北京"+i,"深圳"+i,i%5+5+25F));
            }
        }
    
        //设计一个方法，从集合内拿票
        public Ticket getTicket(){
    
            try {
              return  tickets.remove(0);
            } catch (Exception e) {
               return null;
                   //没有票的情况
            }
    
        }
    }
    
    
    //窗口 Windows类
    
    public class Window extends Thread{
        String windowName;
    
        public Window(String windowName){
            this.windowName=windowName;
        }
    
        @Override
        public void run() {
            //卖票
            sellTicket();
        }
        public void sellTicket(){
            while(true){
                SystemTest st=SystemTest.getInstance();
                //获得单例对象
    
                Ticket t=st.getTicket();
                //从Vector集合中获取票
    
                if(t==null){
                    System.out.println(windowName+"窗口票已卖完");
                    break;
                }
                System.out.println(windowName+"售出： "+t);
            }
        }
    }
    
    
    //TestMain  测试主类
    
    public class TestMain {
        public static void main(String[] args) {
            //有很多个窗口，每个窗口共有一个系统
            Window w1=new Window("北京站");
            Window w2=new Window("西安站");
            Window w3=new Window("重庆站");
    
            w1.start();
            w2.start();
            w3.start();
    
    
        }
    }

**2.轮流打印ABCABCABC.......10次：**

采用synchronized给对象上锁的方式，使得每次访问对象方法的线程不能同时进行，得一个一个来。

具体：synchronized(Object)\{ \}

//Test类 即就是 要执行打印的类
    
    //轮流上锁
    
    //线程类跑起来就是一条线程
    public class Test implements Runnable{
    
        private String name;   // eg: "A"
        private Object pre;    //oa,ob,oc三个对象之间前后循环
        private Object self;   //自己
    
        public Test(String name, Object pre, Object self) {
            this.name = name;
            this.pre = pre;
            this.self = self;
        }
    
    
        //每个线程有每个线程的run方法。
        @Override
        public void run() {
            int count = 10;  //倒计时 打印10次
            while (count > 0) {
                synchronized (pre) {
                    synchronized (self) {
                        System.out.print(name);   //锁的代码块
                        count--;
    
                        self.notify();
                    }
                    try {
                        pre.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
    
            }
        }
    
    
    
    //    @Override
    //    public void run() {
    //        synchronized (pre){
    //            synchronized (self){  //此处锁的是while的循环体
    //                //先写自身逻辑在考虑上锁问题
    //                int count =10;
    //                while(count>0){
    //                    System.out.println(name+count);
    //                    count--;
    //                    self.notify();
    //                }
    //            }
    //            try {
    //                pre.wait();
    //            } catch (InterruptedException e) {
    //                e.printStackTrace();
    //            }
    //        }
    //    }
    }
    
    
    //测试主类：
    
    
    public class Main {
    
    
        public static void main(String[] args) throws InterruptedException {
            Object oa=new Object();
            Object ob=new Object();
            Object oc=new Object();
    
            new Thread(new Test("A",oc,oa)).start();
            Thread.sleep(1000);
    
            new Thread(new Test("B",oa,ob)).start();
            Thread.sleep(1000);
    
            new Thread(new Test("C",ob,oc)).start();
            Thread.sleep(1000);
        }
    
    }

**3.模拟哲学家进食的问题：**

题目描述：有四个哲学家，四支筷子，当他们同时拿起自己左右手边的筷子时，才能开始进食。

//筷子实体类：
    
    public class Chopsticks {
        private int num;//
        public Chopsticks (int num){
            this.num=num;
        }
    
        public int getNum() {
            return num;
        }
    }
    
    
    //哲学家类
    
    //哲学家进餐问题，体现线程死锁
    public class Thinker extends Thread {
        String name;
        Chopsticks left;
        Chopsticks right;
        public Thinker(String name,Chopsticks left,Chopsticks right){
            this.name=name;
            this.left=left;
            this.right=right;
        }
        @Override
        public void run() {
            synchronized (left){   //当前访问left对象的线程，单独享有left对象的访问权
                System.out.println(this.name+"拿起了左手"+left.getNum()+"号筷子！");
                synchronized (right){
                    System.out.println(this.name+"拿起了右手"+right.getNum()+"号筷子！");
                    System.out.println(this.name+"开始吃饭饭啦~~~");
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    }
    
    
    //主测试类
    
    //a:1,2号
    //b:2,3号
    //c:3,4号
    //d:4,1号
    //a,b,c,d 四个哲学家竞争四个筷子
    public class TestMain {
        public static void main(String[] args) {
            //4个筷子
            Chopsticks c1=new Chopsticks(1);
            Chopsticks c2=new Chopsticks(2);
            Chopsticks c3=new Chopsticks(3);
            Chopsticks c4=new Chopsticks(4);
    
            //4个哲学家
            Thinker a=new Thinker("a",c2,c1);
            Thinker b=new Thinker("b",c3,c2);
            Thinker c=new Thinker("c",c4,c3);
            Thinker d=new Thinker("d",c1,c4);
    
            a.start();
            b.start();
            c.start();
            d.start();
    
        }
    }

**4.生产者消费者问题：**

问题描述： 有一个共同的仓库，生产者每次想仓库中放进一个元素，消费者每次从仓库中拿出一个货物。 但是放元素时仓库的容量是有限的，取货物时仓库为空不能取。

代码如下：

//仓库类：
    
    public class House {
    //    //生产者消费者使用同一个仓库-->单例模式 
    //    private House(){
    //                                       可以采用单例的方式使得生产者消费者公用同一个仓库，也可以使用传入参数的方式使得生产者消费者使用同一个参数。
    //    }
    //    private static House h=new House();
    //    public House getH(){
    //        return h;
    //    }
    
    
        //集合，仓库 放东西
        ArrayList<String> list=new ArrayList<>();
    
        //向集合内放东西，生产者
        //synchronized锁的是调用该方法的对象   ，即是仓库对象house
        //Synchronized锁的是调用该方法的对象 即就是每次只能一个线程进行访问该对象的synchronized方法，
       //当该方法是普通方法并且类中有多个synchronized修饰的方法时。每个对象只能有一个线程进入，并访问方法。
                      //生产者线程 或者是消费者线程
        public synchronized void add(){
            if(list.size()<20){
                list.add("a");
            }else{
    //            return;  //让方法执行到这里就结束方法
                try {
                    this.notifyAll();  //唤醒线程
                    this.wait();  //让当前线程等待,不是仓库等待  wait会释放锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
        }
    
        //从集合内拿东西,消费者
        public synchronized void  get(){
            if(list.size()>0){
                list.remove(0);
            }else{
    //            return;
                try {
                    this.notifyAll();
                    this.wait();//访问仓库的线程等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    
    
    //生产者类
    
    public class Producer extends Thread {
        //为了保证生产者消费者使用同一个仓库对象，添加一个属性
        //可以自己传入参数来控制对象的一致性，两个线程构造函数中使用同一个House对象  仓库对象
        private House house;
        public Producer(House house){
            this.house=house;
        }
    
        @Override
        public void run() {
            //方法重写，原则：名字，参数列表必须一致
            //一直向仓库内放元素
            while(true){
                house.add();     //使用house的add方法。  add方法时synchronized修饰的
                System.out.println("生产者存入了一件货物");
    
            }
        }
    }
    
    //消费者类：
    
    public class Consumer extends Thread {
        private House house;
        public Consumer(House house){
            this.house=house;
        }
    
        @Override
        public void run() {
            //一直从仓库拿东西
            while(true){
                house.get();
                System.out.println("消费者拿走了一件东西");
            }
        }
    }
    
    
    //测试主类
    
    public class TestMain {
        public static void main(String[] args) {
            House house=new House();
            Producer producer=new Producer(house);
            //设置线程优先级
            producer.setPriority(10);
            Consumer consumer=new Consumer(house);
            Consumer consumer2=new Consumer(house);
            producer.start();
            consumer.start();
            consumer2.start();
        }
    }

转载于:https://www.cnblogs.com/xbfchder/p/11504073.html