Java多线程_复习(更新中！！)

java多线程的常见例子

一.相关知识：

Java多线程程序设计到的知识：

（一）对同一个数量进行操作

（二）对同一个对象进行操作

（三）回调方法使用

（四）线程同步，死锁问题

（五）线程通信

等等

二．示例一：三个售票窗口同时出售20张票;

程序分析：1.票数要使用同一个静态值

2.为保证不会出现卖出同一个票数，要java多线程同步锁。

设计思路：1.创建一个站台类Station，继承Thread，重写run方法，在run方法里面执行售票操作！售票要使用同步锁：即有一个站台卖这张票时，其他站台要等这张票卖完！

2.创建主方法调用类

（一）创建一个站台类，继承Thread

package com.com.shundong.thread;

/**
 * @ClassName Station
 * @Description 三个售票窗口同时出售20张票
 * @Author shundong
 * @Date 2018/12/8 12:31 AM
 * @Version 1.0
 **/
public class Station extends Thread {
    // 通过构造方法给线程名字赋值
    public Station(String name) {
        super(name);// 给线程名字赋值
    }

    // 为了保持票数的一致，票数要静态
    static int tick = 20;

    // 创建一个静态钥匙
    static Object ob = "test";//值是任意的

    // 重写run方法，实现买票操作
    @Override
    public void run() {
        while (tick > 0) {
            synchronized (ob) {// 这个很重要，必须使用一个锁，
                // 进去的人会把钥匙拿在手上，出来后才把钥匙拿让出来
                if (tick > 0) {
                    System.out.println(getName() + "卖出了第" + tick-- + "张票");
                    //tick--;
                } else {
                    System.out.println("票卖完了");
                }
            }
            try {
                sleep(1000);//休息一秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    // for test
    public static void main(String[] args) {
        Station station1 = new Station("站台一");
        Station station2 = new Station("站台二");
        Station station3 = new Station("站台仨");
        station1.start();
        station2.start();
        station3.start();
    }
}

程序运行结果：　　

可以看到票数是不会有错的！

三．示例二：两个人AB通过一个账户A在柜台取钱和B在ATM机取钱！

程序分析：钱的数量要设置成一个静态的变量。两个人要取的同一个对象值。 取钱的方法一定要同步

（一）创建一个Bank类

package com.shundong.day1;

/**
 * @ClassName Bank
 * @Description 银行 内置柜台 和 ATM 两张方式取钱
 * @Author shundong
 * @Date 2018/12/8 7:31 PM
 * @Version 1.0
 **/
public class Bank {
    // 假设一个账户有1000块钱
    static int money = 1000;

    // 柜台Counter取钱的方法
    public synchronized void Counter(int money) {// 参数是每次取走的钱
        Bank.money -= money;//取钱后总数减少
        System.out.println("A取走了" + money + "还剩下" + (Bank.money));
    }

    // ATM取钱的方法
    public synchronized void ATM(int money) {// 参数是每次取走的钱
        Bank.money -= money;//取钱后总数减少
        System.out.println("B取走了" + money + "还剩下" + (Bank.money));
    }

}

（二）创建一个PersonA类

package com.shundong.day1;

/**
 * @ClassName PersonA
 * @Description 用户A 在柜台取钱 每次 100
 * @Author shundong
 * @Date 2018/12/8 7:31 PM
 * @Version 1.0
 **/
public class PersonA extends Thread{
    //创建一个银行对象
    Bank bank;

    // 通过构造器传入银行对象，确保两个人进入的是一个银行
    public PersonA(Bank bank) {
        this.bank = bank;
    }

    //重写run方法，在里面实现使用柜台取钱
    @Override
    public void run() {
        while (Bank.money >= 100) {
            bank.Counter(100);// 每次取100块
            try {
                sleep(100);// 取完休息0.1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

（三）创建一个PersonB类

package com.shundong.day1;

/**
 * @ClassName PersonB
 * @Description 用户B 在ATM 取款 每次200
 * @Author shundong
 * @Date 2018/12/8 7:33 PM
 * @Version 1.0
 **/
public class PersonB extends Thread {
    // 创建银行对象
    Bank bank;

    // 通过构造器传入银行对象，确保两个人进入的是一个银行
    public PersonB(Bank bank) {
        this.bank = bank;
    }

    // 重写run方法，在里面实现使用柜台取钱
    @Override
    public void run() {
        while (Bank.money >= 200) {
            bank.ATM(200);// 每次取200块
            try {
                sleep(100);// 取完休息0.1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

}

（四）创建一个MainClass类 测试

package com.shundong.day1;

/**
 * @ClassName MainClass
 * @Description 两个人AB通过一个账户A在柜台取钱和B在ATM机取钱
 * @Author shundong
 * @Date 2018/12/8 7:35 PM
 * @Version 1.0
 **/
public class MainClass {
    //for test
    public static void main(String[] args) {
    Bank bank = new Bank();
    PersonA personA = new PersonA(bank);
    PersonB personB = new PersonB(bank);
    personA.start();
    personB.start();
    }
}

　　运行MainClass类 结果：

四．示例三：龟兔赛跑问题

龟兔赛跑：20米     //只要为了看到效果，所有距离缩短了

要求：

1.兔子每秒0.5米的速度，每跑2米休息10秒，

2.乌龟每秒跑0.1米，不休息

3.其中一个跑到终点后另一个不跑了！

程序设计思路：

1.创建一个Animal动物类，继承Thread，编写一个running抽象方法，重写run方法，把running方法在run方法里面调用。

2.创建Rabbit兔子类和Tortoise乌龟类，继承动物类

3.两个子类重写running方法

4.本题的第3个要求涉及到线程回调。需要在动物类创建一个回调接口，创建一个回调对象

（一）创建Animal动物类

package com.shundong.dya2;

/**
 * @ClassName Animal
 * @Description 抽象类 动物
 * @Author shundong
 * @Date 2018/12/8 7:53 PM
 * @Version 1.0
 **/
public abstract class Animal extends Thread {
    //赛道长度
    public double length = 20.00;

    //抽象的 runing 子类只需要重写 该方法即可
    public abstract void runing();

    //父类重写的 run 只需要调用 runing即可
    @Override
    public void run() {
        super.run();
        while (length > 0) {
            runing();
        }
    }

    //在需要回调数据的地方（两个子类需要），声明一个接口
    public static interface Calltoback {
        public void win();
    }

    //2.创建接口对象
    public Calltoback calltoback;
}

（二）创建Rabbit兔子类

package com.shundong.dya2;

/**
 * @ClassName Rabbit
 * @Description 兔子的类 兔子每秒0.5米的速度，每跑2米休息10秒，
 * @Author shundong
 * @Date 2018/12/8 8:01 PM
 * @Version 1.0
 **/
public class Rabbit extends Animal {
    //构造器为 此线程取名
    public Rabbit() {
        setName("兔子");
    }

    //重写 父类 动物类的 runing的 方法
    @Override
    public void runing() {
        // 跑的距离
        double dis = 0.5;
        length -= dis;//跑完后距离减少
        if (length <= 0) {
            length = 0;
            System.out.println("兔子获得了胜利");
            //给回调对象赋值，让乌龟不要再跑了
            if (calltoback != null) {
                calltoback.win();
            }
        }
        System.out.println("兔子跑了" + dis + "米，距离终点还有" + (int) length + "米");

        if (length % 2 == 0) {// 两米休息一次 时间为 1s  10s太长了 该处为了 方便测试
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

（三）创建Tortoise乌龟类

package com.shundong.dya2;

/**
 * @ClassName Tortoise
 * @Description 乌龟类
 * @Author shundong
 * @Date 2018/12/8 8:05 PM
 * @Version 1.0
 **/
public class Tortoise extends Animal {
    // Thread的方法，给线程赋值名字
    public Tortoise() {
        setName("乌龟");
    }

    // 重写running方法，编写乌龟的奔跑操作
    @Override
    public void runing() {
        // 跑的距离
        double dis = 0.1;
        length -= dis;
        if (length <= 0) {
            length = 0;
            System.out.println("乌龟获得了胜利");
            // 让兔子不要在跑了 回调函数
            if (calltoback != null) {
                calltoback.win();
            }
        }
        System.out.println("乌龟跑了" + dis + "米，距离终点还有" + (int) length + "米");
        try {
            sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

（四）创建一个让动物线程停止的类，这里要实现回调接口

package com.shundong.dya2;

/**
 * @ClassName LetOneStop
 * @Description 处理回调函数
 * @Author shundong
 * @Date 2018/12/8 8:09 PM
 * @Version 1.0
 **/
public class LetOneStop implements Animal.Calltoback {
    //动物对象
    Animal animal;
    //传过来的 参数 不是乌龟就是兔子
    public LetOneStop(Animal animal) {
        this.animal = animal;
    }

    //让线程停止的回调函数
    @Override
    public void win() {
        //停止线程
        animal.stop();
    }
}

（五）创建一个主方法调用类，

package com.shundong.dya2;

/**
 * @ClassName MainClass
 * @Description 龟兔赛跑：20米    测试
 * @Author shundong
 * @Date 2018/12/8 8:12 PM
 * @Version 1.0
 **/
public class MainClass {
    //for test
    public static void main(String[] args) {
        //实例化乌龟和兔子
        Tortoise tortoise = new Tortoise();
        Rabbit rabbit = new Rabbit();
        //回调方法的使用，谁先调用calltoback方法，另一个就不跑了
        LetOneStop letOneStop1 = new LetOneStop(tortoise);
        rabbit.calltoback = letOneStop1;//让兔子的回调方法里面存在乌龟对象的值，可以把乌龟stop
        LetOneStop letOneStop2 = new LetOneStop(rabbit);
        tortoise.calltoback = letOneStop2;//让乌龟的回调方法里面存在兔子对象的值，可以把兔子stop
        //开始跑
        tortoise.start();
        rabbit.start();

    }
}

　　运行MainClass类 结果：

待续。。。。