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类 结果:
待续。。。。