Java 多线程

public class MyThread extends Thread {    //多线程的操作类
    private String name ;
    public MyThread(String name) {
        this.name = name ;
    }
    @Override
    public void run() {    //覆写run方法作为线程的主操作类
            for(int x = 0 ; x <200 ;x++) {
                System.out.println(this.name+"-->"+x);
            }
    }

}


main:
     MyThread mt1 = new MyThread("线程A");
     MyThread mt2 = new MyThread("线程B");
     MyThread mt3 = new MyThread("线程C");
     //启动多线程
     mt1.start();
     mt2.start();
     mt3.start();


为什么多线程启动不是调用run()而必须调用start()?
　　在java的开发里面有一门技术称为Java本地接口（Java Native Interface,JNI）技术。使用Java调用本地操作系统提供的函数。
这个技术不能离开特定的操作系统，如果要执行线程，需要根据操作系统来进行资源的分配。主要是由JVM根据不同的操作系统来实现。
即使用Thread类的start()方法不仅要启动多线程的执行代码，还要根据不同的操作系统进行资源分配

public class MyThread2 implements Runnable {  //实现接口
    private String name ;
    public MyThread2(String name) {
        this.name = name ;
    }
    @Override
    public void run() {　　　　//覆写run()
        for(int x = 0 ; x <200 ;x++) {
            System.out.println(this.name+"-->"+x);
        }
    }
}


main：

/***实现Runnable接口的多线程，,Thread是Runnable接口 的子类（代理），
* 通过Thread类对象包装Runnable接口对象实例，然后利用Thread 类的start()方法启动多线程***/
MyThread2 mt01 = new MyThread2("线程1");
MyThread2 mt02 = new MyThread2("线程2");
MyThread2 mt03 = new MyThread2("线程3");

new Thread(mt01).start();
new Thread(mt02).start();
new Thread(mt03).start();

使用Runnable接口可以有效避免单继承局限问题，所以在实际的开发中对于多线程的实现首选Runnable接口

@FunctionalInterface
public interface Callable<V>{
      public V call() throws Exception;          
}

public class MyThread implements Callable<String> {

    private int ticket = 0 ;
    @Override
    public String call() throws Exception {
        for(int i = 0 ; i <100; i ++) {
            if(this.ticket > 0) {
                System.out.println("卖出,剩余"+this.ticket --);
            }
        }
        return "票卖完了!";   //返回结果
    }
}

如何启动实现Callable接口的多线程？
Thread类没有定义构造方法可以直接接收Callble接口对象实例，并且由于需要接收call()方法返回值的问题。JDK1.5开始，提供了java.util.concurrent.FutureTask<V>类
public class FutureTask<V> extends Object implements RunnableFuture<V>

/***实现了callable 接口的多线程,可以返回结果；
* RunnableFuture接口 实现了Runnable接口和Future接口
* FutureTask 又实现了 RunnableFuture 接口
* ***/
MyThread mt1 = new MyThread();
MyThread mt2 = new MyThread();

FutureTask<String> task1 = new FutureTask<String>(mt1);
FutureTask<String> task2 = new FutureTask<String>(mt2);
//FutureTask是Runnable接口子类，所以可以使用Thread类的构造来接收task对象

new Thread(task1).start();
new Thread(task2).start();

//多线程执行完毕后可以取得内容
System.out.println("A线程的返回结果"+task1.get());
System.out.println("B线程的返回结果"+task2.get());