java多线程的编程实例

java中可有两种方式实现多线程：

一种是继承Thread类；
一种是实现Runnable接口；

Thread类

    是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但限制是一个类只能继承一个父类

package org.thread.demo;  
class MyThread extends Thread{  
    private String name;  
    public MyThread(String name) {  
    super();  
    this.name = name;  
    }  
    public void run(){  
        for(int i=0;i<10;i++){  
            System.out.println("线程开始："+this.name+",i="+i);  
        }  
    }  
}  

package org.thread.demo;  
public class ThreadDemo01 {  
    public static void main(String[] args) {  
        MyThread mt1=new MyThread("线程a");  
        MyThread mt2=new MyThread("线程b");  
        mt1.run();  
        mt2.run();  
    }  
} 

但这种调用是顺序执行的，先执行mt1，然后mt2。没有并行。并行需要调用start()方法，则会通过JVM找到run()方法，在jdk中可以看源码

package org.thread.demo;  
    public class ThreadDemo01 {  
    public static void main(String[] args) {  
    MyThread mt1=new MyThread("线程a");  
    MyThread mt2=new MyThread("线程b");  
    mt1.start();  
    mt2.start();  
    }  
}; 

start()—用于启动线程。
使用了private native void start();其中native关键字表示可以调用操作系统的底层函数，那么这样的技术成为JNI技术（java Native Interface）

但实际开发多线程操作很少用Thread类，而是通过Runnable接口完成。
public interface Runnable{
public void run();
}
例子：

package org.runnable.demo;  
    class MyThread implements Runnable{  
        private String name;  
        public MyThread(String name) {  
            this.name = name;  
        }
        public void run(){  
            for(int i=0;i<100;i++){  
                System.out.println("线程开始："+this.name+",i="+i);  
            }  
        }  
    }; 

上例或者直接，实例化借口，重载run函数：
    package org.runnable.demo;  
    import org.runnable.demo.MyThread;  
    public class ThreadDemo01 {  
        public static void main(String[] args) {  
            MyThread mt1=new MyThread("线程a");  
            MyThread mt2=new MyThread("线程b");  
            new Thread(mt1).start();  
            new Thread(mt2).start();  
        }  
    }
    Runnable run = new Runnable() {
        @Override
        public void run() {
        for(int i = 0; i < 10; i++) {
        System.out.println(i);
        }
        }
    };

调用通过
Thread thread = new Thread(run);
thread.start();

用Runnable定义的子类中没有start()方法。所以需要通过Thread类来启动Runnable实现的多线程，也就是说用start()才能协调系统的资源，
Thread构造方法：public Thread(Runnable targer)。
Runnable接口相比继承Thread类有如下好处：
避免点继承的局限，一个类可以继承多个接口。
适合于资源的共享
而继承Thread不能直接进行多线程工作，你得为你的每一部分工作都定义一个线程。
比如买票实例，使用Thread就没有办法实现多线程共享票务资源，每个Thread类拥有自己独立的占据资源。使用Runnable可以共享资源，一起共享总票务资源，如：

class MyThread implements Runnable{
    private int ticket=10;  
    public void run(){  
        for(int i=0;i<20;i++){  
            if(this.ticket>0)
                System.out.println("卖票：ticket"+this.ticket--);  
        }  
    } 
};
MyThread mt=new MyThread();  
new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一  
new Thread(mt).start();//个实例化对象mt，就会出现异常  
new Thread(mt).start();