Java 多线程实现的方式有四种
- 1. 继承 Thread 类,重写 run 方法
- 2. 实现 Runnable 接口,重写 run 方法,实现 Runnable 接口的实现类的实例对象作为 Thread 构造函数的 target
- 3. 通过 Callable 和 FutureTask 创建线程
- 4. 通过线程池创建线程
前面两种可以归结为一类:无返回值,原因很简单,通过重写 run 方法,run 方式的返回值是 void,所以没有办法返回结果
后面两种可以归结成一类:有返回值,通过 Callable 接口,就要实现 call 方法,这个方法的返回值是 Object,所以返回的结果可以放在 Object 对象中
方式 1:继承 Thread 类的线程实现方式如下:
public class ThreadDemo01 extends Thread{public ThreadDemo01(){// 编写子类的构造方法,可缺省}
public void run(){
// 编写自己的线程代码
System.out.println(Thread.currentThread().getName());
}
public static void main(String[] args){ThreadDemo01 threadDemo01 = new ThreadDemo01();
threadDemo01.setName("我是自定义的线程 1");
threadDemo01.start();
System.out.println(Thread.currentThread().toString());
}
}
程序结果:
Thread[main,5,main]
我是自定义的线程 1
线程实现方式 2:通过实现 Runnable 接口,实现 run 方法,接口的实现类的实例作为 Thread 的 target 作为参数传入带参的 Thread 构造函数,通过调用 start()方法启动线程
public class ThreadDemo02 {public static void main(String[] args){System.out.println(Thread.currentThread().getName());
Thread t1 = new Thread(new MyThread());
t1.start();}
}
class MyThread implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(Thread.currentThread().getName()+"--> 我是通过实现接口的线程实现方式!");
}
}
程序运行结果:
main
Thread-0–> 我是通过实现接口的线程实现方式!
线程实现方式 3:通过 Callable 和 FutureTask 创建线程
a: 创建 Callable 接口的实现类,并实现 Call 方法
b: 创建 Callable 实现类的实现,使用 FutureTask 类包装 Callable 对象,该 FutureTask 对象封装了 Callable 对象的 Call 方法的返回值
c: 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动线程
d: 调用 FutureTask 对象的 get() 来获取子线程执行结束的返回值
public class ThreadDemo03 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Callable<Object> oneCallable = new Tickets<Object>();
FutureTask<Object> oneTask = new FutureTask<Object>(oneCallable);
Thread t = new Thread(oneTask);
System.out.println(Thread.currentThread().getName());
t.start();}
}
class Tickets<Object> implements Callable<Object>{
// 重写 call 方法
@Override
public Object call() throws Exception {
// TODO Auto-generated method stub
System.out.println(Thread.currentThread().getName()+"--> 我是通过实现 Callable 接口通过 FutureTask 包装器来实现的线程");
return null;
}
}
程序运行结果:
main
Thread-0–> 我是通过实现 Callable 接口通过 FutureTask 包装器来实现的线程
线程实现方式 4:通过线程池创建线程
public class ThreadDemo05{
private static int POOL_NUM = 10; // 线程池数量
/**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
// TODO Auto-generated method stub
ExecutorService executorService = Executors.newFixedThreadPool(5);
for(int i = 0; i<POOL_NUM; i++)
{RunnableThread thread = new RunnableThread();
//Thread.sleep(1000);
executorService.execute(thread);
}
// 关闭线程池
executorService.shutdown();}
}
class RunnableThread implements Runnable
{
@Override
public void run()
{System.out.println("通过线程池方式创建的线程:" + Thread.currentThread().getName() + " ");
}
}
程序运行结果:
通过线程池方式创建的线程:pool-1-thread-3
通过线程池方式创建的线程:pool-1-thread-4
通过线程池方式创建的线程:pool-1-thread-1
通过线程池方式创建的线程:pool-1-thread-5
通过线程池方式创建的线程:pool-1-thread-2
通过线程池方式创建的线程:pool-1-thread-5
通过线程池方式创建的线程:pool-1-thread-1
通过线程池方式创建的线程:pool-1-thread-4
通过线程池方式创建的线程:pool-1-thread-3
通过线程池方式创建的线程:pool-1-thread-2
ExecutorService、Callable 都是属于 Executor 框架。返回结果的线程是在 JDK1.5 中引入的新特征,还有 Future 接口也是属于这个框架,有了这种特征得到返回值就很方便了。
通过分析可以知道,他同样也是实现了 Callable 接口,实现了 Call 方法,所以有返回值。这也就是正好符合了前面所说的两种分类
执行 Callable 任务后,可以获取一个 Future 的对象,在该对象上调用 get 就可以获取到 Callable 任务返回的 Object 了。get 方法是阻塞的,即:线程无返回结果,get 方法会一直等待。
再介绍 Executors 类:提供了一系列工厂方法用于创建线程池,返回的线程池都实现了 ExecutorService 接口。
- public static ExecutorService newFixedThreadPool
(int nThreads)创建固定数目线程的线程池。 - public static ExecutorService newCachedThreadPool()
创建一个可缓存的线程池,调用 execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并 添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线 程。 - public static ExecutorService newSingleThreadExecutor()
创建一个单线程化的 Executor。 - public static ScheduledExecutorService newScheduledThreadPool(intcorePoolSize)
创建一个支持定时及周期性的任务执行的线程池,多数情况下可用 来替代 Timer 类。 - ExecutoreService 提供了 submit()方法,传递一个 Callable,或 Runnable,返回 Future。如果 Executor 后台线程池还没有完成 Callable 的计算,这调用返回 Future 对象的 get()方法,会阻塞直到计算完成。