创建线程的几种方式

创建线程的几种方式

方式1：继承Thread类实现多线程

• run()为线程类的核心方法，相当于主线程的main方法，是每个线程的入口
• 一个线程调用 两次start()方法将会抛出线程状态异常，也就是的start()只可以被调用一次
• run()方法是由jvm创建完本地操作系统级线程后回调的方法，不可以手动调用（否则就是普通方法）

public class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread1 run()");
    }
}

方式2：实现Runnable接口(推荐！！！)

• 覆写Runnable接口实现多线程可以避免单继承局限
• 当子类实现Runnable接口，此时子类和Thread的代理模式（子类负责真是业务的操作，thread负责资源调度与线程创建辅助真实业务

public class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("MyThread2 run()");
    }
}

public class Test {
    public static void main(String[] args) {
        MyThread2 myThread2 = new MyThread2();
        Thread t1 = new Thread(myThread2,"t1");
        t1.start();
    }
}

Thread和Runnable方式的区别

• 实现Runnable接口避免多继承局限
• 实现Runnable()可以更好的体现共享的概念
• 使得线程的创建和线程实体进行解耦

Runnable接口和Callable接口的区别

方式3：覆写Callable接口实现多线程（JDK1.5）

• 核心方法叫call()方法，有返回值

public class MyThread3 implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "feng";
    }
}

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread3 thread = new MyThread3();
        FutureTask<String> futureTask = new FutureTask<String>(thread);
        Thread t2 = new Thread(futureTask);
        t2.start();
        //返回值即为call()方法的返回值
        String result = futureTask.get();
        System.out.println(result);
    }
}

Runnable和Callable的区别

• Runnable执行方法是run()，Callable执行的是call()方法
• 实现Runnable接口的任务线程无返回值；实现Callable接口的任务线程能返回执行结果
• call方法可以抛出异常，run方法若有异常只能在内部消化

Callable接口需要注意的点：

• Callable接口支持返回执行结果，需要调用**FutureTask.get()**方法实现，此方法会阻塞主线程直到获取结果；当不调用此方法时，主线程不会阻塞！
• 如果线程出现异常，Future.get()会抛出InterruptedException或者ExecutionException；如果线程已经取消，会抛出CancellationException

方式4：通过线程池启动多线程

• 通过Executor 的工具类可以创建三种类型的普通线程池

FixThreadPool(int n)：固定大小的线程池

使用于为了满足资源管理需求而需要限制当前线程数量的场合。使用于负载比较重的服务器。

public class Test {
	public static void main(String[] args) {
        //创建固定大小的线程池
		ExecutorService ex = Executors.newFixedThreadPool(5);
		for(int i = 0;i < 5;i++) {
			ex.submit(new Runnable() {
				@Override
				public void run() {
					for(int j = 0;j < 10;j++) {
						System.out.println(Thread.currentThread().getName() + j);
					}
				}
			});
		}
		ex.shutdown();
	}
}

SingleThreadPoolExecutor : 单线程池

需要保证顺序执行各个任务的场景

public class Test {
	public static void main(String[] args) {
        //创建一个单线程池
		ExecutorService ex = Executors.newSingleThreadExecutor();
		for(int i = 0;i < 5;i++) {
			ex.submit(new Runnable() {
				@Override
				public void run() {
					for(int j = 0;j < 10;j++) {
						System.out.println(Thread.currentThread().getName() + j);
					}
					
				}
			});
		}
		ex.shutdown();
	}	
}

CashedThreadPool()：缓存线程池

当提交任务速度高于线程池中任务处理速度时，缓存线程池会不断的创建线程。适用于提交短期的异步小程序，以及负载较轻的服务器

public class Test {
	public static void main(String[] args) {
        //创建缓存线程池
		ExecutorService ex = Executors.newCachedThreadPool();
		for(int i = 0;i < 5;i++) {
			ex.submit(new Runnable() {	
				@Override
				public void run() {
					for(int j = 0;j < 10;j++) {
						System.out.println(Thread.currentThread().getName() + j);
					}
				}
			});
		}
		ex.shutdown();
	}	
}