在java中比较常用的有三种创建多线程的方式。
方式一：继承Thread类，要重写run方法。
在MyThread类
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100 ; i++) {
//获取线程名称
System.out.println(getName()+":"+i);
}
super.run();
}
}
测试类：
public class MyThreadDemo {
public static void main(String[] args) {
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
my1.setName("张飞");
my2.setName("关羽");
my1.setDaemon(true);
//开启线程
my1.start();
my2.start();
//设置主线程名称
Thread.currentThread().setName("刘备");
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
常用方法：
public static void sleep(long millis,int nanos) 在指定的毫秒数内让当前正在执行的线程休眠
这里再提一句：start和run方法有什么区别：run方法就是执行括号里的代码 start方法是首先启动了线程，然后由jvm调用run方法。
方式二：
实现Runnable接口，也要重写run方法。创建Thread对象，将Runnable作为参数传递。
//测试Runnable
public static void testRunnable(){
//创建Runnable对象
Runnable r = new Runnable() { @Override//run()方法没有返回值,只能通过try抛出异常
public void run() {
System.out.println("当前线程的名字是:"+Thread.currentThread().getName());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO: handle exception
}
}
};
//Thread包装Runnable
Thread t = new Thread(r);
t.start();
}
方式三：
实现Callable接口。在展示Demo之前，说一说实现这个接口需要用到的类和接口。
ExecutorService（线程池）：接口，它的超级接口是Executor。
下面这些是返回ExecutorService对象的方法。
* public static ExecutorService newCachedThreadPool() 创建corePoolSize为0，最大线程数为整型的最大数，线程 keepAliveTime为1分钟，缓存任务的队列为SynchronousQueue的线程池。
* public static ExecutorService newFixedThreadPool(int nThread) 创建固定大小的线程池
* public static ExecutorService newSingleThreadExecutor() 创建大小为1的固定线程池
可以执行Runnable对象或者Callable对象代表的线程。
Future<?> submit(Runnable task)
<T> Future<T> submit(Callable<T> task)
Executors(类):提供了用于此包中所提供的执行程序服务的工厂方法。也就是说可以用它来创建线程池。
Future(接口)，API解释：
Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。还提供了其他方法，以确定任务是正常完成还是被取消了。一旦计算完成，就不能再取消计算。如果为了可取消性而使用 Future 但又不提供可用的结果，则可以声明 Future<?> 形式类型、并返回 null 作为底层任务的结果。说白了就是获取Callable返回值的对象。
FutureTask(类):它实现的接口：Runnable Future<V> RunnableFuture<V>。
构造方法：
FutureTask(Callable<V> callable)
创建一个 FutureTask，一旦运行就执行给定的 Callable。
FutureTask(Runnable runnable, V result)
创建一个 FutureTask，一旦运行就执行给定的 Runnable，并安排成功完成时 get 返回给定的结果 。
//测试Callable,可以通过throws抛出异常
public static void testCallable() throws InterruptedException, ExecutionException{
//创建对象
Callable<Student> c = new Callable<Test.Student>() { @Override
//call()方法可以有返回值,并且可以通过throws抛出异常
public Student call() throws Exception {
System.out.println("当前线程的名称是:"+Thread.currentThread().getName());
Thread.sleep(2000);
return new Student("张飞", 30);
}
};
//包装对象 第一种方法
FutureTask<Student> ft = new FutureTask<Student>(c); try {
//执行线程
new Thread(ft).start();
//获取结果
System.out.println(ft.get().getName()+ft.get().getAge());
} catch (Exception e) {
e.printStackTrace();
} //第二种方法
//创建一个使用单个 worker 线程的 Executor，以*队列方式来运行该线程。
ExecutorService es = Executors.newSingleThreadExecutor();
//Executors Executor ExecutorService
Future<Student> f = es.submit(new Callable<Student>() { @Override
public Student call() throws Exception { return new Student("关羽", 33);
}
});
System.out.println(f.get().getName() + f.get().getAge()); }