Java线程 (使用Callable实现多线程)，看完你发现多线程多么简单！（二）

1.Thread 与 Runnable 的关系

    经过一系列的分析之后可以发现，在多线程的实现过程之中已经有了两种做法：Thread类、Runnable接口，如果从代码结构本身来讲，使用Runnable是最方便的，因为其可以避免单继承的局限，同时也可以更好的进行功能的扩充。
    但是从结构上也需要来观察Thread与Runnable的联系，打开Thread类的定义：

public class Thread extends Object implements Runnable{}

    发现现在Thread类也是Runnable接口的子类，那么在之前继承Thread类的时候实际上覆写的还是Runnable接口的run()方法，于是此时来观察一下程序的类结构。

    多线程的设计之中，使用了代理设计模式的结构，用户自定义的线程主体类只是负责项目核心功能的实现，而所有的辅助实现全部交由Thread类来处理。

可以查看一下Thread类里面的信息，来阅读下面：

    在进行Thread启动多线程的时候调用的是start()方法，而后找到的是run()方法，当通过Thread类的构造方法传递了一个Runnable接口对象的时候，那么该接口对象将被Thread类中的target属性所保存，在start()方法执行的时候会调用Thread类中的run()方法，而这个run()方法去调用Runnable接口子类被覆写过得run(）方法。
     多线程开发的本质实质上是在于多个线程可以进行同一资源的抢占，那么Thread主要描述的是线程，而资源的描述是通过Runnable完成的。

案例：利用卖票程序来实现多个线程的资源并发访问：

class MyThread implements Runnable {  //接口实现类必须实现接口的所有方法,如果要实现部分的话,可以用抽象类
	private int ticket = 5;

	@Override
	public void run() {
    	for (int x = 0; x < 100; x++) {
        	if (this.ticket > 0)
            	System.out.println("卖票。ticket = " + this.ticket--);
    	}
	}
}

public class test {
	public static void main(String[] args) {
    	MyThread mt = new MyThread();
    	new Thread(mt).start();
    	new Thread(mt).start();
    	new Thread(mt).start();
	}
}

通过内存分析图来分析本程序的执行结构：

2.Callable实现多线程

    从最传统的开发来讲，如果要进行多线程的实现肯定依靠的就是Runnable，但是Runnable接口有一个缺点：当线程执行完毕之后无法获取一个返回值，所以从JDK1.5之后就提出了一个新的线程实现接口：java.util.comcurrent.Callable接口，首先来观察这个接口的定义：

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

    可以发现Callable定义的时候可以设置一个泛型，此泛型的类型就是返回数据的类型，这样的好处是可以避免向下转型所带来的安全隐患。
看下面的代码时，一定要多看看接口和类的源码(ctrl+鼠标左键)

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class MyThread implements Callable<String> {
	@Override
	public String call() throws Exception {
    	for (int x = 0; x < 10; x++) {
        	System.out.println("**************** 线程执行,x = " + x);
    	}
    	return "线程执行完毕";
	}
}

public class test {
	public static void main(String[] args) throws Exception {
    	FutureTask<String> task = new FutureTask<>(new MyThread());
    	new Thread(task).start();
    	System.out.println("线程返回数据" + task.get());

	}
}

Runnable与Callable的区别？
1.Runnable是在JDK1.0的时候提出的多线程的实现接口，而Callable是在JDK1.5之后提出的；
2.java.lang.Runnable接口之中只提供有一个run()方法，并且没有返回值；
3.java.util.concurrent.Callable接口提供有call()，可以有返回值。

3.线程运行状态

    对于多线程的开发而言，编写程序的过程之中总是按照：定义线程主体类，而后通过Thread类进行线程的启动，但是并不意味着你调用了start()方法，线程就已经开始运行了，因为整体的线程处理有自己的一套运行的状态。

1.任何一个线程的对象都应该使用Thread类进行封装，所以线程的启动使用的是start()，但是启动的时候实际上若干个线程都将进入到一种叫就绪状态，也就是说开始并没有直接执行；
2.进入到就绪状态之后就需要等待进行资源调度，**当某一个线程调度成功之后则进入到运行状态(run()方法)，但是所有的线程不可能一直持续执行下去，产生一些暂停的状态，**例如：某个线程执行一段时间后就需要让出资源，而后这个线程就将进入阻塞状态，随后重新回归到就绪状态。
3.当run()方法执行完毕之后，实际上该线程的主要任务也就结束了，那么此时就可以直接进入到停止状态。