java线程安全&通信练习

一时失言乱红尘 2023-02-26 04:21 3阅读 0赞

# 模拟银行取钱的问题 #

>  *  1.定义一个Account类  
>     1）该Account类封装了账户编号（String）和余额（double）两个属性  
>     2）设置相应属性的getter和setter方法  
>     3）提供无参和有两个参数的构造器  
>     4）系统根据账号判断与用户是否匹配，需提供hashCode()和equals()方法的重写
>  *  2.提供两个取钱的线程类：小明、小明’s wife  
>     1）提供了Account类的account属性和double类的取款额的属性  
>     2）提供带线程名的构造器  
>     3）run()方法中提供取钱的操作  
>     3.在主类中创建线程进行测试。考虑线程安全问题。

package com.oceanstar;
    
    import java.util.Objects;
    
    class Account{
        
        private String  accountId;
        private double  balance;
    
        public Account() {
        
        }
    
        public Account(String accountId, double balance) {
        
            this.accountId = accountId;
            this.balance = balance;
        }
    
        public String getAccountId() {
        
            return accountId;
        }
    
        public void setAccountId(String accountId) {
        
            this.accountId = accountId;
        }
    
        public double getBalance() {
        
            return balance;
        }
    
        public void setBalance(double balance) {
        
            this.balance = balance;
        }
    
        @Override
        public boolean equals(Object o) {
        
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Account account = (Account) o;
            return Double.compare(account.balance, balance) == 0 &&
                    Objects.equals(accountId, account.accountId);
        }
    
        @Override
        public int hashCode() {
        
            return Objects.hash(accountId, balance);
        }
    }
    
    
    class  Client extends Thread{
        
        private Account account;
        private double  quota;
    
        public Client(String name, Account account, double quota) {
        
            super(name);
            this.account = account;
            this.quota = quota;
        }
    
    
    
        @Override
        public void run() {
        
            if (account.getBalance() > quota){
        
    
                try {
        
                    Thread.sleep(10);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
    
                synchronized (account){
        
                    System.out.println(Thread.currentThread().getName() + ":取款成功，取现的金额为：" + quota);
                    account.setBalance(account.getBalance() - quota);
                }
            }else{
        
                System.out.println("取现额度超过账户余额，取款失败");
            }
            System.out.println("当前账户的余额为：" + account.getBalance());
        }
    }
    
    
    
    public class testT{
        
        public static void main(String[] args) {
        
            Account account1 = new Account("小明", 10000);
    
            Client t1 = new Client("小明", account1, 100);
            Client t2 = new Client("小明'wife", account1, 300);
    
            t1.start();
            t2.start();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]

# 生产者&&消费者 #

> 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]

package com.oceanstar;
    
    
    
    class Clert {
        
        private int product; // 属性：产品数量
    
    
        public Clert() {
        
        }
    
        public synchronized void addProduct(){
        
            if (product < 20){
        
                product++;
                System.out.println(Thread.currentThread().getName() + "生产第" + product + "个产品");
                notify(); // 唤醒：已经有产品可以消费啦
            }else{
        
                try {
        
                    wait();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("没地方可以存放啦, 生产者休息");
            }
        }
    
        public synchronized void redProduct(){
        
            if (product > 0){
        
                System.out.println(Thread.currentThread().getName() + "消费第" + product + "个产品");
                product--;
                notify(); // 唤醒：用完一个了哦
            }else{
        
                try {
        
                    wait();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("没有产品了，等待。。。。");
            }
        }
    }
    
    class Productor implements Runnable{
        
        private Clert clert;  //
    
        public Productor(Clert clert) {
        
            this.clert = clert;
        }
    
        @Override
        public void run() {
        
            System.out.println("生产者开始生产产品");
            while (true){
        
                try {
        
                    Thread.sleep(10);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                clert.addProduct();
            }
        }
    }
    class Comsumer implements Runnable{
        
        private Clert clert;  //
    
        public Comsumer(Clert clert) {
        
            this.clert = clert;
        }
    
        @Override
        public void run() {
        
            while (true){
        
                System.out.println("消费者开始消费产品");
                try {
        
                    Thread.sleep(100);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                clert.redProduct();
            }
        }
    }
    
    
    public class testT{
        
        public static void main(String[] args) {
        
            Clert clert = new Clert();
            Productor productor = new Productor(clert);
            Comsumer comsumer = new Comsumer(clert);
    
            new Thread(productor).start();
            new Thread(comsumer).start();
        }
    }

# 银行存钱问题 #

> 银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]

package com.oceanstar;
    
    
    class Account{
        
        private double balance;
    
        public Account(double balance) {
        
            this.balance = balance;
        }
    
        public synchronized void  deposit(double amt){
        
            this.balance += amt;
            System.out.println(Thread.currentThread().getName() + ":存钱成功。余额为：" + balance);
        }
    
    }
    
    
    class Person extends Thread{
        
        private Account account;
    
        public Person(Account account) {
        
            this.account = account;
        }
    
        @Override
        public void run() {
        
            for (int i = 0; i < 3; i++) {
        
                account.deposit(1000);
            }
        }
    }
    
    public class testT {
        
    
        public static void main(String[] args) {
        
            // 两个人共享同一个账户
            Account account = new Account(0);
    
            Person p1 = new Person(account);
            Person p2 = new Person(account);
    
    
            p1.setName("甲");
            p2.setName("乙");
    
    
            p1.start();
            p2.start();
    
    
        }
    
    }

![在这里插入图片描述][20200714094239551.png]

拓展问题：可否实现两个储户交替存钱的操作  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3]

package com.oceanstar;
    
    
    class Account{
        
        private double balance;
    
        public Account(double balance) {
        
            this.balance = balance;
        }
    
        public synchronized void  deposit(double amt){
        
            notify();
    
            this.balance += amt;
            System.out.println(Thread.currentThread().getName() + ":存钱成功。余额为：" + balance);
    
    
            try {
        
                wait();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    
    }
    
    
    class Person extends Thread{
        
        private Account account;
    
        public Person(Account account) {
        
            this.account = account;
        }
    
        @Override
        public void run() {
        
            for (int i = 0; i < 3; i++) {
        
                account.deposit(1000);
            }
        }
    }
    
    public class testT {
        
    
        public static void main(String[] args) {
        
            // 两个人共享同一个账户
            Account account = new Account(0);
    
            Person p1 = new Person(account);
            Person p2 = new Person(account);
    
    
            p1.setName("甲");
            p2.setName("乙");
    
    
            p1.start();
            p2.start();
    
    
        }
    
    }

# 双线程交替数数 #

> 使用两个线程打印 1-100。线程1, 线程2 交替打印  
> ![在这里插入图片描述][20200714100909690.png]

package com.oceanstar;
    
    
    // 因为number需要共享，所以用Runnable更好
    class Number implements Runnable{
        
        private int i = 0;
        @Override
        public void run() {
        
            while (i <= 100){
        
                synchronized (this){
        
                    notify();
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                    i++;
                    try {
        
                        wait();
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
    
    public class testT {
        
    
        public static void main(String[] args) {
        
            // 两个人共享同一个账户
            Number num = new Number();
    
    
            Thread p1 = new Thread(num);
            Thread p2 = new Thread(num);
    
    
            p1.setName("甲");
            p2.setName("乙");
    
    
            p1.start();
            p2.start();
    
        }
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20230209/58163ff00eaf4c05ad41d0147c733a1c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: /images/20230209/952feaa400994b8295c3a1bb556230ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 2]: /images/20230209/2959ea0da54d4b93842e179338cf7237.png
[20200714094239551.png]: /images/20230209/45df8c8ab35b47f2bb2a94637085e5e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 3]: /images/20230209/055b0824b7464b91b1c87eaa5b8a66d1.png
[20200714100909690.png]: /images/20230209/c8b9cddce51c40f0ad71ce81506da559.png