Java中线程的创建方式

一、继承Thread类，重写run方法

public class MyThread{public static void main(String[] args) {Thread threadDome = new ThreadDome();threadDome.start();}
}class ThreadDome extends Thread{@Overridepublic void run() {for (int i = 0; i < 5; i++) {try {Thread.sleep(500);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("i = " + i);}}
}

二、实现Runnable接口,重写run方法

public class MyThread{   public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();new Thread(myRunnable).run();}
}class MyRunnable implements Runnable{@Overridepublic void run() {for (int i = 0; i < 5; i++) {try {Thread.sleep(500);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("i = " + i);}}
}

三、实现Callable接口，重写call方法

public class MyThread{public static void main(String[] args) throws ExecutionException, InterruptedException             {MyCallable myCallable = new MyCallable();FutureTask futureTask = new FutureTask(myCallable);new Thread(futureTask).start();System.out.println(futureTask.get());}
}class MyCallable implements Callable<Integer>{@Overridepublic Integer call() throws Exception {return 10;}
}

callable相较于runnable接口，可以拥有返回值，并且runnable中程序出现异常只能通过try...catch进行捕获然后处理，callable可以将异常抛出。

四、使用线程池

1、线程池的实现：

1、FixedThreadPool（定长线程池）:只有核心线程，线程数量固定，执行完立即回收，任务队列为链表结果的有界队列，控制线程的最大并发数

    @Testpublic void test() throws ExecutionException, InterruptedException {//创建线程池ExecutorService pool = Executors.newFixedThreadPool(5);//使用线程池for (int i = 0; i < 5; i++) {Future<Integer> submit = pool.submit(new Callable<Integer>() {@Overridepublic Integer call() throws Exception {return 10;}});System.out.println(submit.get());}//关闭线程池pool.shutdown();}

2、ScheduledThreadPool（定时线程池）：核心线程数量固定，非核心线程数量无限，执行完闲置10s后回收，任务队列为延时阻塞队列，执行定时或周期性任务

    @Testpublic void test02() throws ExecutionException, InterruptedException {//创建线程池ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);//使用线程池for (int i = 0; i < 5; i++) {ScheduledFuture<Integer> schedule = pool.schedule(new Callable<Integer>() {@Overridepublic Integer call() throws Exception {return 10;}}, 1, TimeUnit.SECONDS);System.out.println(schedule.get());}//销毁线程池pool.shutdown();}

3、CachedThreadPool（可缓存线程池）:无核心线程，非核心线程数量无限，执行完闲置60s回收，任务队列为不存储元素的阻塞队列，执行大量，耗时少的任务

    @Testpublic void test03() throws ExecutionException, InterruptedException {//创建线程池ExecutorService pool = Executors.newCachedThreadPool();//使用线程池for (int i = 0; i < 5; i++) {Future<Integer> submit = pool.submit(new Callable<Integer>() {@Overridepublic Integer call() throws Exception {return 10;}});System.out.println(submit.get());}//关闭线程池pool.shutdown();}

4、SingleThreadExecutor（单线程化线程池）：只有一个核心线程，无非核心线程，执行完立即回收，任务队列为链表结果的有界队列，不适合做并发但可能引起io阻塞及影响ui线程响应的操作，如数据库操作、文件操作等

@Testpublic void test04() throws ExecutionException, InterruptedException {//创建线程池ExecutorService pool = Executors.newSingleThreadExecutor();//使用线程池for (int i = 0; i < 5; i++) {Future<Integer> submit = pool.submit(new Callable<Integer>() {@Overridepublic Integer call() throws Exception {return 10;}});System.out.println(submit.get());}//关闭线程池pool.shutdown();}