java多线程编程实例
这篇文章主要介绍了java多线程编程实例，分享了几则多线程的实例代码，具备必定参考价值，加深多线程编程的理解仍是颇有帮助的，须要的朋友能够参考下。java
1.三个售票窗口同时出售20张票
程序分析：(1)票数要使用同一个静态值
(2)为保证不会出现卖出同一个票数，要java多线程同步锁。
设计思路：
(1)建立一个站台类Station，继承Thread，重写run方法，在run方法里面执行售票操做！售票要使用同步锁：即有一个站台卖这张票时，其余站台要等这张票卖完！
(2)建立主方法调用类
（一）建立一个站台类，继承Thread编程
package com.xykj.threadStation;
public class Station extends Thread {
// 经过构造方法给线程名字赋值
public Station(String name) {
super(name);// 给线程名字赋值
}
// 为了保持票数的一致，票数要静态
static int tick = 20;
// 建立一个静态钥匙
static Object ob = "aa";//值是任意的
// 重写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();
}
}
}
}
（二）建立主方法调用类多线程
package com.xykj.threadStation;
public class MainClass {
/**
* java多线程同步锁的使用
* 示例：三个售票窗口同时出售10张票
* */
public static void main(String[] args) {
//实例化站台对象，并为每个站台取名字
Station station1=new Station("窗口1");
Station station2=new Station("窗口2");
Station station3=new Station("窗口3");
// 让每个站台对象各自开始工做
station1.start();
station2.start();
station3.start();
}
}
程序运行结果：并发
窗口1卖出了第20张票 窗口2卖出了第19张票 窗口3卖出了第18张票 窗口3卖出了第17张票 窗口1卖出了第16张票 窗口2卖出了第15张票 窗口3卖出了第14张票 窗口1卖出了第13张票 窗口2卖出了第12张票 窗口2卖出了第11张票 窗口1卖出了第10张票 窗口3卖出了第9张票 窗口3卖出了第8张票 窗口1卖出了第7张票 窗口2卖出了第6张票 窗口3卖出了第5张票 窗口1卖出了第4张票 窗口2卖出了第3张票 窗口3卖出了第2张票 窗口1卖出了第1张票 票卖完了
能够看到票数是不会有错的！ide
2.两我的AB经过一个帐户A在柜台取钱和B在ATM机取钱！
程序分析：
钱的数量要设置成一个静态的变量，两我的要取的同一个对象值。
（一）建立一个Bank类
（一）建立一个Bank类
package com.thread.demo.demo2;
import java.util.Objects;
public class Bank {
// 假设一个帐户有1000块钱
static double money = 1000;
// 柜台Counter取钱的方法
private void Counter(double money) {
Bank.money -= money;
System.out.println("柜台取钱" + money + "元，还剩" + Bank.money + "元！");
}
// ATM取钱的方法
private void ATM(double money) {
Bank.money -= money;
System.out.println("ATM取钱" + money + "元，还剩" + Bank.money + "元！");
}
//提供一个对外取款途径，防止直接调取方法同时取款时，并发余额显示错误
public synchronized void outMoney(double money, String mode) throws Exception{
if(money > Bank.money){
//校验余额是否充足
throw new Exception("取款金额"+money+",余额只剩"+Bank.money+"，取款失败");
}
if(Objects.equals(mode, "ATM")){
ATM(money);
} else {
Counter(money);
}
}
}
（二）建立一个PersonA类this
package com.thread.demo.demo2;
public class PersonA extends Thread {
Bank bank;
String mode;
public PersonA(Bank bank, String mode) {
this.mode = mode;
this.bank = bank;
}
public void run (){
while(bank.money >= 100){
try {
bank.outMoney(100, mode);
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
（三）建立一个PersonB类spa
package com.thread.demo.demo2;
public class PersonB extends Thread {
Bank bank;
String mode;
public PersonB(Bank bank, String mode) {
this.bank = bank;
this.mode = mode;
}
public void run() {
while (bank.money >= 200) {
try {
bank.outMoney(200, mode);
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
（四）建立主方法的调用类线程
package com.thread.demo.demo2;
/**
* 两我的AB经过一个帐户A在柜台取钱和B在ATM机取钱
* */
public class MainClass {
public static void main(String[] args) {
Bank bank = new Bank();
// 实例化两我的，传入同一个银行的对象
PersonA a = new PersonA(bank, "Counter");
PersonB b = new PersonB(bank, "ATM");
a.start();
b.start();
}
}
运行结果：
能够看到取完就中止运行了。
3.龟兔赛跑问题
龟兔赛跑：2000米要求：
(1)兔子每 0.1 秒 5 米的速度，每跑20米休息1秒;
(2)乌龟每 0.1 秒跑 2 米，不休息；
(3)其中一个跑到终点后另外一个不跑了！
程序设计思路：
(1)建立一个Animal动物类，继承Thread，编写一个running抽象方法，重写run方法，把running方法在run方法里面调用。
(2)建立Rabbit兔子类和Tortoise乌龟类，继承动物类
(3)两个子类重写running方法
(4)本题的第3个要求涉及到线程回调。须要在动物类建立一个回调接口，建立一个回调对象。
（一）建立Animal动物类设计
package com.thread.demo.demo3;
public abstract class Animal extends Thread {
public int length = 2000;// 比赛长度
public abstract void runing();
@Override
public void run() {
super.run();
while (length > 0) {
runing();
}
}
// 在须要回调数据的地方（两个子类须要），声明一个接口
public static interface Calltoback {
public void win();
}
// 2.建立接口对象
public Calltoback calltoback;
}
（二）建立Rabbit兔子类code
package com.thread.demo.demo3;
public class Rabbit extends Animal {
public Rabbit() {
setName("兔子");
}
@Override
public void runing() {
//兔子速度
int dis = 5;
length -= dis;
System.out.println("兔子跑了" + dis + "米，距离终点还有" + length + "米");
if (length <= 0) {
length = 0;
System.out.println("兔子得到了胜利");
// 给回调对象赋值，让乌龟不要再跑了
if (calltoback != null) {
calltoback.win();
}
}
try {
if ((2000 - length) % 20 == 0) { // 每20米休息一次,休息时间是1秒
sleep(1000);
} else { //没0.1秒跑5米
sleep(100);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
（三）建立Tortoise乌龟类
package com.thread.demo.demo3;
public class Tortoise extends Animal {
public Tortoise() {
setName("乌龟");// Thread的方法，给线程赋值名字
}
// 重写running方法，编写乌龟的奔跑操做
@Override
public void runing() {
// 乌龟速度
int dis = 2;
length -= dis;
System.out.println("乌龟跑了" + dis + "米，距离终点还有" + length + "米");
if (length <= 0) {
length = 0;
System.out.println("乌龟得到了胜利");
// 让兔子不要在跑了
if (calltoback != null) {
calltoback.win();
}
}
try {
sleep(100); //没0.1秒跑2米
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
（四）建立一个让动物线程中止的类，这里要实现回调接口
package com.thread.demo.demo3;
import com.thread.demo.demo3.Animal.Calltoback;
public class LetOneStop implements Calltoback {
// 动物对象
Animal an;
// 获取动物对象，能够传入兔子或乌龟的实例
public LetOneStop(Animal an) {
this.an = an;
}
// 让动物的线程中止
@Override
public void win() {
// 线程中止
an.stop();
}
}
（五）建立一个主方法调用类
package com.thread.demo.demo3;
public class MainClass {
/**
* 龟兔赛跑：2000米
*/
public static void main(String[] args) {
// 实例化乌龟和兔子
Tortoise tortoise = new Tortoise();
Rabbit rabbit = new Rabbit();
// 回调方法的使用，谁先调用calltoback方法，另外一个就不跑了
LetOneStop letOneStop1 = new LetOneStop(tortoise);
// 让兔子的回调方法里面存在乌龟对象的值，能够把乌龟stop
rabbit.calltoback = letOneStop1;
LetOneStop letOneStop2 = new LetOneStop(rabbit);
// 让乌龟的回调方法里面存在兔子对象的值，能够把兔子stop
tortoise.calltoback = letOneStop2;
// 开始跑
tortoise.start();
rabbit.start();
}
}
运行结果：
4. 线程示例总结
（1）代码块锁是一个防止数据发生错误的一个重要手段；（2）对象的统一性是很是重要的，这要想到对象的传入问题，要操做的对象只能new一次，其余的操做都是对这个传入的对象进行的，才能保证数据一致性，完整性和正确性。