java实现多线程的两个方法

方法一：

实现多线程只需继承Thread类，然后重写run方法

然后在main方法中创建一个Thread子类对象，调用start方法，启动线程

注意我们不可以直接调用run方法，如果直接调用run无法实现多线程，调用start方法后，会将该线程添加到线程组中，交给CPU进行处理调度，系统会自动调用run方法

举个例子，龟兔赛跑，分别有两个类代表乌龟和兔子，都继承了Thread类，并且重写了run方法

public class Rabbit extends Thread {@Overridepublic void run() {for(int i=0;i<10;i++){System.out.println("rabbit running!"+i);}}}class Tortoise extends Thread{@Overridepublic void run() {for(int i=0;i<10;i++){System.out.println("tortoise running!"+i);}}}

在main方法中创建两个对象，测试多线程

public class RabbitTest {public static void main(String[] args) {Rabbit rabbit=new Rabbit();Tortoise tortoise=new Tortoise();rabbit.start();tortoise.start();}}

每次运行都不相同，因为处理及对于线程的调度不尽相同，这里包含了main，兔子，乌龟，三个线程，抛开gc，和异常异常处理，兔子和乌龟谁先抢占到CPU，谁就先运行

rabbit running!0tortoise running!0rabbit running!1tortoise running!1rabbit running!2tortoise running!2rabbit running!3tortoise running!3rabbit running!4tortoise running!4rabbit running!5rabbit running!6rabbit running!7rabbit running!8rabbit running!9tortoise running!5tortoise running!6tortoise running!7tortoise running!8tortoise running!9

方法二：

由于java是单继承，而使用方法一时，子类不能再继承其他父类，这对于有些必须继承其他父类的类是无法实现多线

程的，所以就有了方法二，通过实现Runnable接口+静态代码实现多线程

在知道如何实现多线程之前，需要了解一下什么是静态代理设计模式

静态代理有两个类，一个是真实的角色，一个是代理角色，其中代理角色需持有真实角色的引用

并且二者需要实现相同的接口

举个例子，比如你要结婚找婚礼策划公司策划婚礼，那么此时你就是真实角色，婚礼策划公司就是代理角色

public class StaticProxy {public static void main(String[] args) {//创建真实角色You you =new You();//创建代理角色+真实角色的引用WeddingCompany wc=new WeddingCompany(you);//结婚wc.marry();}}interface Marry{void marry();}class You implements Marry{@Overridepublic void marry() {System.out.println("you married johnny depp!");}}class WeddingCompany implements Marry{private Marry you;public WeddingCompany() {// TODO Auto-generated constructor stub}public WeddingCompany(Marry you) {this.you = you;}private void before(){System.out.println("get ready for wedding!");}private void after(){System.out.println("get ready for party!");}@Overridepublic void marry() {before();you.marry();after();}}

输出结果为 

get ready for wedding!
you married johnny depp!
get ready for party!

那么这里的You就是你设计的类，weddingCompant就是Thread类，而Marry就是Runnable接口

Thread类已经实现了Runnable接口，所以你设计的类只要实现Runnable接口即可

public class Programer implements Runnable {@Overridepublic void run() {for(int i=0;i<10;i++){System.out.println("watching..."+i);}}}

public class ProgramerTest {public static void main(String[] args) {Programer p=new Programer();Thread thread=new Thread(p);thread.start();for(int i=0;i<10;i++){System.out.println("eating..."+i);}}}

使用Runnable+静态代理的好处：

1.避免单继承的局限性

2.便于共享资源

使用方法二模拟买票机制（两个买票窗口）

public class web12306 implements Runnable{public int num=50;@Overridepublic void run() {while(true){if(num<=0){break;}System.out.println(Thread.currentThread().getName()+"抢到了 "+num--);}}public static void main(String[] args) {//真实角色web12306 web=new web12306();//两个代理Thread t1=new Thread(web);Thread t2=new Thread(web);//启动线程t1.start();t2.start();}}

Thread-1抢到了 10
Thread-0抢到了 9
Thread-1抢到了 8
Thread-0抢到了 7
Thread-1抢到了 6
Thread-1抢到了 4
Thread-1抢到了 3
Thread-1抢到了 2
Thread-0抢到了 5
Thread-1抢到了 1