线程的4种实现方式（Java）

Java纯面向对象语言，一切皆对象

Java中与线程相关的类   java.lang.Thread    此类是Java中多线程的核心类

所以要实现多线程，必须与java.lang.Thread类产生联系，调用Thread的对象方法start(),才能成功启动一个线程，线程一旦启动就和创建他的线程没有关系了，他们之间是并行的，无先后关系。

Thread类的所有构造方法：

前两个构造方法：

1、继承Thread类，而后覆写run()方法（线程需要执行的任务）

通过继承Thread有Thread的所有结构

class MyThread extends Thread{
    private String title;
    public MyThread(String title){
        this.title = title;
    }
    @Override
    public void run(){
        for(int i = 0;i<5;i++){
            System.out.println(title+"---"+i);
        }
    }
}
public class ThreadTest {
    public static void main(String[] args){
        MyThread myThread1 = new MyThread("hah1");
        MyThread myThread2 = new MyThread("hah2");
        MyThread myThread3 = new MyThread("hah3");
        myThread1.start();
        myThread2.start();
        myThread3.start();
    }
}
/*运行结果：
hah1---0
hah1---1
hah1---2
hah1---3
hah1---4
hah2---0
hah2---1
hah2---2
hah2---3
hah2---4
hah3---0
hah3---1
hah3---2
hah3---3
hah3---4*/

一个线程的strat()方法只能被调用一次，执行多次会抛出IllegalThreadStateException()异常-非受查异常

2、实现Runnable接口，而后覆写run()方法

通过Thread的构造方法将实现Runnable接口的类传入Thread

public class ThreadTest {
    public static void main(String[] args){
        MyRThread myRThread1= new MyRThread("hah1");
        MyRThread myRThread2 = new MyRThread("hah2");
        MyRThread myRThread3 = new MyRThread("hah3");
        Thread Thread1 = new Thread(myRThread1);
        Thread Thread2 = new Thread(myRThread2);
        Thread Thread3 = new Thread(myRThread3);
        Thread1.start();
        Thread2.start();
        Thread3.start();
    }
}
class MyRThread implements Runnable{
    private String title;
    public MyRThread(String title){
        this.title = title;
    }
    public void run() {
        for(int i = 0;i<5;i++){
            System.out.println(title+"---"+i);
        }
    }
}

无论使用哪种方式创建线程，启动线程一律使用Thread类提供的strat()方法,而不是run()方法，run()不能直接由用户调用,如下所示，用户调用run()只是调用了一个普通的方法，并不能实现多线程。

class MyThread extends Thread{
	private String title;
	public MyThread(String title){
		this.title=title;
	}
	@Override
	public void run(){
		for(int i=0;i<5;i++){
			System.out.println(title+"---"+i);
		}
	}
}

public class ThreadTest{
	public static void main(String[] args){
	MyThread myThread1 = new MyThread("hah1");
	MyThread myThread2 = new MyThread("hah2");
	MyThread myThread3 = new MyThread("hah3");
	myThread1.run();
	myThread2.run();
	myThread3.run();
	}
}
/*运行结果：
hah2---0
hah3---0
hah1---0
hah3---1
hah2---1
hah3---2
hah1---1
hah3---3
hah2---2
hah3---4
hah1---2
hah1---3
hah1---4
hah2---3*/

public class Thread implements Runnable:Thread类本身实现了Runnable接口

class MyRThread implements Runnable：自定义的类

Java中Thread类本身也实现了Runnable接口，与用户自定义的线程类共同组成代理设计模式。

其中Thread类实现辅助操作，包括线程的资源调度等任务，自定义线程完成真实业务。

代理设计模式：一个接口，两个子类，一个时辅助操作，一个实现真实业务。

3、实现Callable接口，而后覆写call<v>方法。

  Callable时JDK1.5之后加入的java.unit.concurrent(JUC包)。import java.util.concurrent.Callable;

V call() throws Exception;线程执行任务后有返回值，而run（）方法没有返回值

那么如何将Callable对象传入Thread中，不能通过构造方法，因为Thread类JDK1.0就有了，而Callable时JDK1.5才有的

Future接口：接受Callable接口的返回值。V get()方法接受Callable的返回值

public class Thread implements Runnable

public class FutureTask<V> implements RunnableFuture<V>

public interface RunnableFuture<V> extends Runnable,Future<V>

public interface Future<V>

public interface Runnable

public interface Callable<V>

class CallableThread implements Callable<String>  ：自己实现的类

FutureTask类public FutureTask(Callable<V> callable)构造方法

public class CallableTest {
    public static void main(String[] args) {
        CallableThread callableThread = new CallableThread();
        FutureTask<String> futureTask = new FutureTask<String>(callableThread);
        Thread thread1 = new Thread(futureTask);
        Thread thread2 = new Thread(futureTask);
        Thread thread3 = new Thread(futureTask);
        thread1.start();
        thread2.start();
        thread3.start();
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class CallableThread implements Callable<String> {
    private int a = 20;
    public String call() throws Exception {
        while(a>0){
            a=a-1;
            System.out.println("还有"+a+"张票");
        }
        return "票卖完了~";
    }
}

4、线程池