Runable和Thread
Java多线程
java中有两种实现多线程的方式：
1. 一种是通过继承Thread类，同时重写run()方法。但是java中，只允许单继承，也就是一个类只能继承一个父类，使得该方式具有一定的局限性，等下就知道了。
2. 另一种是实现Runnable类接口的run()方法，再结合Thread类来实现多线程。
两种方式最终都是通过调用start()方法来实现多线程。切记不能直接调用Thread类或Runnable对象的run()方法，因为直接调用run()方法，只会执行同一个线程中的任务，而不会启动新线程。调用start()方法将会创建一个
例1：继承Thread类，调用run()方法
public class MyThread extends Thread {
private String name;
private int ticket = 5;
public MyThread(String name) {
this.name = name;
}
public void run() {
for (int i=0; i<10; i++) {
if (this.ticket>0)
System.out.println("线程开始："+this.name+",卖票：i="+this.ticket--);
}
}
}
//TestThreadRunnable.java：调用run()方法
public class TestThreadRunnable {
public static void main(String [] args) {
Thread t1 = new MyThread("线程a");
Thread t2 = new MyThread("线程b");
**t1.run()**;
**t2.run()**;
/*
Runnable r = new MyRunnable();
Thread t1 = new Thread(r, "线程a");
Thread t2 = new Thread(r, "线程b");
t1.start();
t2.start();
*/
}
}
运行结果
线程开始：线程a,卖票：i=5 线程开始：线程a,卖票：i=4 线程开始：线程a,卖票：i=3 线程开始：线程a,卖票：i=2 线程开始：线程a,卖票：i=1 线程开始：线程b,卖票：i=5 线程开始：线程b,卖票：i=4 线程开始：线程b,卖票：i=3 线程开始：线程b,卖票：i=2 线程开始：线程b,卖票：i=1
一、扩展java.lang.Thread类
public class Main { public static void main(String[] args) { MyThread T1 = new MyThread("A"); MyThread T2 = new MyThread("B"); T1.start(); T2.start(); } } class MyThread extends Thread { private String name; public MyThread(String name) { this.name = name; } @Override public void run() { for (int i = 0; i < 5; i++) { System.out.println(name+":"+i); try { sleep(1000); //休眠1秒，避免太快导致看不到同时执行 } catch (InterruptedException e) { e.printStackTrace(); } } } }
输出：
A:0
B:0
A:1
B:1
B:2
A:2
B:3
A:3
A:4
B:4
程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用MitiSay的两个对象的start方法，另外两个线程也启动了，这样，整个应用就在多线程下运行。
注意：start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。
从程序运行的结果可以发现，多线程程序是乱序执行。因此，只有乱序执行的代码才有必要设计为多线程。
Thread.sleep()方法调用目的是不让当前线程独自霸占该进程所获取的CPU资源，以留出一定时间给其他线程执行的机会。
实际上所有的多线程代码执行顺序都是不确定的，每次执行的结果都是随机的。（要看效果要去除sleep方法，然后加大打印次数）
二、实现java.lang.Runnable接口
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。
public class Main {
public static void main(String[] args) {
//测试Runnable
MyThread1 t1 = new MyThread1();
new Thread(t1).start();//同一个t1，如果在Thread中就不行，会报错
new Thread(t1).start();
new Thread(t1).start();
}
}
class MyThread1 implements Runnable{
private int ticket = 10;
@Override
//记得要资源公共，要在run方法之前加上synchronized关键字，要不然会出现抢资源的情况
public synchronized void run() {
for (int i = 0; i <10; i++) {
if (this.ticket>0) {
System.out.println("卖票：ticket"+this.ticket--);
}
}
}
}
输出：
卖票：ticket10
卖票：ticket9
卖票：ticket8
卖票：ticket7
卖票：ticket6
卖票：ticket5
卖票：ticket4
卖票：ticket3
卖票：ticket2
卖票：ticket1
这里要注意每个线程都是用同一个实例化对象，如果不是同一个，效果就和上面的一样了！
总结：
实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
