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();