package zuoye;
import java.util.Random;

public class zuoye06 {

        /**
         * 6：创建一个Bank银行类,属性有money(初始值为100),生成set/get方法,创建一个Bank银行对象,创建三个线程(分别给线程命名为"用户A","用户B","用户C")(4分)
         *当用户A线程执行时,通过set方法将money的值增加100,在控制台输出 "用户A线程正在执行第X次,增加了100元,目前money的值为X元" (2分)
         *当用户B线程执行时,通过set方法将money值随机增加1-100(不含100),在控制台输出"用户B线程正在执行第X次,增加了X元,目前money的值为X元" (2分)
         *当用户C线程执行时,线程休眠10毫秒,不作任何操作.在控制台输出"用户C线程正在执行第X次,睡眠了10毫秒"(2分)
         *共执行20次,最后打印输出money的值,如 "增加后的money值为:X元"(2分)

         */
        public static void main(String[] args) {
                Thread t = new Thread(new Bank());
                Thread t1 = new Thread(new Bank());
                Thread t2 = new Thread(new Bank());
                t.setName("用户A");
                t1.setName("用户B");
                t2.setName("用户C");
                t.start();
                t1.start();
                t2.start();
        }
}
class Bank implements Runnable{
        private static int money = 100;
        private static int i = 1;
        @Override
        public void run() {
                for (; i < 20; i++) {
                        synchronized (Bank.class) {
                                if ("用户A".equals(Thread.currentThread().getName())) {
                                        setMoney(money+100);
                                        System.out.println("用户A线程正在执行第"+i+"次,增加了100元,目前money的值为"+money+"元");
                                }
                       
                                else if ("用户B".equals(Thread.currentThread().getName())) {
                                        Random r = new Random();
                                        int nextInt = r.nextInt(100);
                                        setMoney(money+nextInt);
                                        System.out.println("用户B线程正在执行第"+i+"次,增加了"+nextInt+"元,目前money的值为"+money+"元");
                                }
                       
                                else if ("用户C".equals(Thread.currentThread().getName())) {
                                        Thread.currentThread();
                                        try {
                                                Thread.sleep(10);
                                        } catch (InterruptedException e) {       
                                                e.printStackTrace();
                                        }
                                        System.out.println("用户C线程正在执行第"+i+"次,睡眠了10毫秒");
                                }
                        }
                        if (i==20) {
                                System.out.println("增加后的money值为:"+money+"元");
                                break;
                        }
                }       
               
                       
        }
        public Bank() {
                super();
               
        }
        public static int getMoney() {
                return money;
        }
        public static void setMoney(int money) {
                Bank.money = money;
        }
       
       
}

谢谢分享，挺有意思的题

要是创建三个线程类做是更好呢还是不好呢

试了试你这个，不妥

厉害了word哥,赶紧mark

mark  还没学

正在学习中....

IceLoveInFire丶 发表于 2016-10-21 13:09
试了试你这个，不妥

??? 那有问题?

读书可以当饭吃 发表于 2016-10-21 01:06
谢谢分享，挺有意思的题

不客气 希望对你有帮助

IceLoveInFire丶 发表于 2016-10-21 09:54
要是创建三个线程类做是更好呢还是不好呢

可以试试啊 ,效果出来了 代码越简洁越好

public class Test6{

    /**
     * 创建一个Bank银行类,属性有money(初始值为100),生成set/get方法,创建一个Bank银行对象,创建三个线程(分别给线程命名为
     * "用户A","用户B","用户C")(4分) 当用户A线程执行时,通过set方法将money的值增加100,在控制台输出
     * "用户A线程正在执行第X次,增加了100元,目前money的值为X元" (2分)
     * 当用户B线程执行时,通过set方法将money值随机增加1-100
     * (不含100),在控制台输出"用户B线程正在执行第X次,增加了X元,目前money的值为X元" (2分)
     * 当用户C线程执行时,线程休眠10毫秒,不作任何操作.在控制台输出"用户C线程正在执行第X次,睡眠了10毫秒"(2分)
     * 共执行20次,最后打印输出money的值,如 "增加后的money值为:X元"(2分)
     *
     * @author purity 2016-10-20下午6:57:32 7:15
     */
    public static void main(String[] args) {
        StoreMoney s = new StoreMoney();
        new Thread(s, "用户A").start();
        new Thread(s, "用户B").start();
        new Thread(s, "用户C").start();
    }
}

class Bank1 {
    private int money;

    public Bank1() {
        this.money = 100;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money += money;
    }
}

class StoreMoney extends Bank1 implements Runnable {

    int times = 0;

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (StoreMoney.class) {
                String name = Thread.currentThread().getName();
                times++;
                if (times > 20) {
                    break;
                }
                if (name.equals("用户A")) {
                    super.setMoney(100);
                    System.out.println(name + "线程正在执行第" + times + "次,增加了100元,目前money的值为" + super.getMoney() + "元");
                } else if (name.equals("用户B")) {
                    int _money = (int) (Math.random() * 100 + 1);
                    super.setMoney(_money);
                    System.out.println(name + "线程正在执行第" + times + "次,增加了" + _money + "元,目前money的值为" + super.getMoney()
                            + "元");
                } else if (name.equals("用户C")) {
                    try {
                        Thread.sleep(10);
                        System.out.println(name + "线程正在执行第" + times + "次,睡眠了10毫秒");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (times == 20) {
                    System.out.println("增加后的money值为:" + super.getMoney() + "元");
                }
            }
        }
    }
}

ouyzm 发表于 2016-10-22 00:01
??? 那有问题?

你多试几次就看出问题了

ouyzm 发表于 2016-10-22 00:32
不客气 希望对你有帮助

不过你的做法有一些安全问题，控制循环次数的变量i++是在锁外面进行的，也就是说有可能3个线程一起执行i++，这样你的i就会一下子跳了3次，如果说执行了18次以后i=18了,每个线程执行了i++以后在判断i<20之前，就停在了那里，这样i一下子就跳到了21，每个线程再去判断循环条件的时候已经不满足了，只能执行18次。