如上图所示，我们这里模拟一下去车站买票的情形：这里有3个柜台同时售票，总共是1000张票，这三个柜台同时买票，但是只能一个柜台卖同一张票，也就是说1号票卖了之后我们就只能买2号票，2号票卖了之后我们只能买3号票！依次类推！直到卖完这1000张票，然后再从头开始卖票！如下代码演示：
package com.bawei.multithread;
//这里模拟售票窗口
public class TicketWindow extends Thread {
//柜台名称，表示第几个柜台
private final String name;
//定义一个变量，模拟最多有这1000张票,这里之所以要用static关键字，主要是因
//为不想在线程创建对象的时候，每个线程都有一份自己的实例变量，而是想让我们这里所
//有的线程懂共享同一份数据，也就是只让这个变量初始化一次,所以这里设置为静态变量
private static final int MAX=1000;
//给定一个初始化变量，从第一张票开始卖,static同上
private static int index =1; public TicketWindow(String name) {
this.name = name;
} @Override
public void run() {
while(index <= MAX){
System.out.println("当前柜台是"+name+", 所售号码是"+(index++));
}
} }
上面这个类是Thead的子类，模拟售卖票的窗口，这里面控制着唯一资源票,而且这个票是被几个窗口所共享的，所以这里我们定义成了static的！
package com.bawei.multithread;
public class Station {
public static void main(String[] args) {
//这里我们创建了三个线程，来模拟3个柜台！
TicketWindow ticketWindow1 = new TicketWindow("1号柜台");
ticketWindow1.start();
TicketWindow ticketWindow2 = new TicketWindow("2号柜台");
ticketWindow2.start();
TicketWindow ticketWindow3 = new TicketWindow("3号柜台");
ticketWindow3.start();
}
}
这个类就是车站类，在这个类中我们创建了3个TicketWindow对象，用这三个对象来模拟3个售票窗口同时售票的情形！
注意:这里有一个问题，就是票是static的，是被多个线程对象所共享的，资源是唯一的，但是static修饰变量的生命周期是很长的，因为它不是随着类的消亡而消亡，这个变量一旦被JVM加载到内存中，它是有一个单独的区域来存放这个变量的，它的生命周期比类的生命周期可能还要长！当然这这只是一个粗糙版本的售票系统！我们下面会用代码给大家演示，如何友好的，将线程和业务分离开来的一个方式!也就是将我们的业务数据MAX,index与线程的逻辑(run方法)分离开来！那我们如何将我们的业务数据MAX、index,业务的控制逻辑语句和线程的执行单元[run方法]抽离开来呢?这时候就是Runnable接口起到一个作用，如下代码所示：我们先用线程类将业务数据和业务逻辑都封装在了这个线程类中
package com.bawei.multithread;
//线程类实现了Runnable接口，该线程类将业务数据和业务逻辑都封装在了这个线程类中！
public class TicketWindowRunnable implements Runnable {
//业务数据
private int index = 1;
private final int MAX=1000; @Override
public void run() {
//业务逻辑:操作业务数据的逻辑代码
while(index <= MAX){
System.out.println(Thread.currentThread()+"运行的号码是"+(index++));
try {
Thread.sleep(1L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} }
如下是创建线程，并使用我们的业务数据和业务逻辑！
public class BankVersion2 {
public static void main(String[] args) {
// final类不能被继承，没有子类，final类中的方法默认是final的。
// final方法不能被子类的方法覆盖，但可以被继承。
// final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
// final不能用于修饰构造方法。
// 注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
final TicketWindowRunnable ticketWindow= new TicketWindowRunnable();
/**
*上面的ticketWindow这个业务数据或者 业务逻辑的实例只有一个就是这个ticketWindow,这样就不会像上面的那个
*案例那样只有new了一个Thread类就new了一份自身的业务数据【当然我们通过静态变量的方式解决了这个问题，但是该方案始终不怎么好】，
*而这里通过我们这样的抽取，就将业务数据MAX,index和业务逻辑【run方法中操作MAX和index的代码逻辑】给抽取出来了，
*我们下面无论定义多少个线程，都不再会将业务数据、业务逻辑和线程控制的代码混淆在一起，也就是说业务数据、业务逻辑此时和
*Thread类的代码是在不同的object【对象】中的！
*/
Thread windowThread1 = new Thread(ticketWindow,"1号窗口");
Thread windowThread2 = new Thread(ticketWindow,"2号窗口");
Thread windowThread3 = new Thread(ticketWindow,"3号窗口");
//启动这3个线程！
windowThread1.start();
windowThread2.start();
windowThread3.start();
}
}
提醒: 这里我们既然访问的业务数据是同一份，而且还要去改变它，那这里实际上是有一个线程的安全的问题,！这里我们先不讲解，先不用去管，后面我们会讲！
Runnable的中文解释就是可执行的，也就是说在这个Runnable接口实现类封装可执行单元【业务数据和业务逻辑】，这样就可以将可执行的逻辑单元和线程控制分离开来，这也是面向对象思想的一个很好体现！这与我们多线程设计模式中的哪种模式比较相近呢？答：策略模式！
创建多线程的两种方式我们这里都给大家讲到了，一种是继承Thread类的方式，另一种是实现Runnable接口的方式，实现Runnable接口的这种方式容易将业务数据和业务逻辑与线程类对象分离开来！而继承Thread类的方式却无法实现分离，new一个Thread子类就会出现一个新对象，这个对象的本身即是业务数据和业务逻辑对象同时也是线程对象！
策略模式在Thread和Runnable中的应用分析
程序最开始可以是：
package com.bawei.multithread;
//税务计算器
public class TaxCalculator {
//工资
private final double salary;
//奖金
private final double bonus;
//通过构造方法给这两个属性赋值！
public TaxCalculator(double salary, double bonus) {
super();
this.salary = salary;
this.bonus = bonus;
} //计算税务问题,在这里我们什么也没做，留给子类去实现或者去写适合他自己的代码，这里写税率的逻辑计算！
public double calcTax(){
return 0.0d;
} /**
* 也就是税率的计算我们是交给本类中的calculate()方法，当然在calculate方法内，在return this.calcTax();
* 这段代码的前后我们也可以加一些其它代码！具体的计算逻辑在这个方法中是不管的，我们交给本类的calcTax()方法！而本
* 类的calcTax()方法实际上也是个空实现，也就是什么也没做，那么就要求交给子类来实现自己的业务计算逻辑了,我们在外边
* 用本类的子类覆写本类的calcTax()方法，然后用子类对象调用本类的calculate方法，然后calculate方法帮我们调用
* 子类的calcTax()方法！
*/
public double calculate(){
return this.calcTax();
} public double getSalary() {
return salary;
} public double getBonus() {
return bonus;
} }
然后我们在别的类中调用使用该类的子类对象执行calculate()方法！
package com.bawei.multithread;
public class TaxCalculatorMain {
public static void main(String[] args) {
TaxCalculator taxCalculator = new TaxCalculator(10000d,2000d){
//匿名子类覆写里面的calcTax方法,实现适合自己的业务逻辑【即税务问题】
//这里我们的税务是工资的10%和奖金的15%
//但是假如我这里的计算逻辑比较复杂的话，那么实际上
@Override
public double calcTax() {
return getSalary()*0.1+getBonus()*0.15;
}
};
double tax = taxCalculator.calculate();
System.out.println(tax);
}
}
程序是到这里肯定是没问题的，这样也可以，但是我们这里实际上是将税率的逻辑calTax()和税率的计算calculate()放到一起的，即都是在TaxCalculator类的子类中完成的！如果我们想将税率的计算calculate放到一个专门的接口中，那怎么实现呢？
我们只需要再定义一个接口CalculatorStrategy：
package com.bawei.multithread;
public interface CalculatorStrategy {
double calculate(double salary, double bonus);
}
然后，将我们原来TaxCalculator类修改为：
package com.bawei.multithread;
//税务计算器
public class TaxCalculator {
//工资
private final double salary;
//奖金
private final double bonus;
//计算策略
private CalculatorStrategy calculatorStrategy;
//通过构造方法给这两个属性赋值！
public TaxCalculator(double salary, double bonus) {
super();
this.salary = salary;
this.bonus = bonus;
} //计算税务问题,在这里我们什么也没做，留给子类去实现或者去写适合他自己的代码，这里写税率的逻辑计算！
public double calcTax(){
//这里你怎么计算我不管，我只需要调用这个接口的子类的calculate方法就可以了！
return calculatorStrategy.calculate(salary, bonus);
} public double calculate(){
return this.calcTax();
}
public double getSalary() {
return salary;
} public double getBonus() {
return bonus;
} public CalculatorStrategy getCalculatorStrategy() {
return calculatorStrategy;
}
//提供set方法可以将这个calculatorStrategy对象给注入进来！
public void setCalculatorStrategy(CalculatorStrategy calculatorStrategy) {
this.calculatorStrategy = calculatorStrategy;
} }
然后再定义一个CalculatorStrategy接口的一个子类实现SimpleCalculatorStrategy，如下所示：
package com.bawei.multithread;
//CalculatorStrategy接口的子类实现！
public class SimpleCalculatorStrategy implements CalculatorStrategy {
//常量要么定义成可配置的，要么就抽取出来作为常量处理！
//工资税率
private final static double SALARY_RATE = 0.1;
//奖金税率
private final static double BONUS_RATE = 0.1; //计算
@Override
public double calculate(double salary, double bonus) {
return salary*SALARY_RATE+bonus*BONUS_RATE;
} }
将原来的TaxCalculatorMain类改为：
package com.bawei.multithread;
public class TaxCalculatorMain {
public static void main(String[] args) {
TaxCalculator taxCalculator = new TaxCalculator(10000d,2000d);
CalculatorStrategy strategy = new SimpleCalculatorStrategy();
taxCalculator.setCalculatorStrategy(strategy);
System.out.println(taxCalculator.calculate());
}
}
如果此时我们的税率发生了变化，那么此时我们只需要将这个CalculatorStrategy接口的实现类SimpleCalculatorStrategy给替换掉就可以了！而TaxCalculator类不用变，CalculatorStrategy这个接口也不用变！当然这里我们在TaxCalculator类中是通过set方法将CalculatorStrategy设置进去的，实际上我们也可以不用这个set方法，而是使
用在构造方法中传入该CalculatorStrategy类型的子类对象即可！
实际上我们是借助上面的这个CalculatorStrategy接口给大家说明Runnable接口也是这么分离出来的，而且Thread类也是通过构造器注入的这个Runnable接口的实现类！
其实Runnable准确的说并不算一个线程，它只是Thread中用到的一个可运行单元，它里面有一个run方法，Thread会调用这个run方法，Thread类是在start0()这个c++代码
中调用的Runnable接口的run方法！这里Thread线程类本身实现了Runnable接口， 由源码可以看出，如果我们在创建Thread对象的时候不给对象传递Runnable接口子类对象，那么Thread类就不会调用Runnable接口子类的run方法，如果创建Thread子类对象的时候在构造器中给它传递了Runnable接口子类对象，那么Thread子类就会调用这个Runnable接口子类对象中的run方法！
总结：我们讲了多线程的两种实现方式，继承Thread类，实现Runnable接口，Runnable接口的好处【将业务数据、业务逻辑【可执行单元】和线程分离开来】，以及Runnable接口是一个什么样的设计思想【策略模式】，