java多线程

java多线程

1.继承Thread类创建线程

   public class MyThread extends Thread {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
} 
   MyThread t = new MyThread();  
   t.start();

2.使用 Runnable 接口

public class ThreadDemo {
    public static void main(String[] args){ 
        System.out.println(Thread.currentThread().getName());
        Thread t1 = new Thread(new MyThread());
        t1.start(); 
    }
}

class MyThread implements Runnable{
    public void run() ｛
        System.out.println(Thread.currentThread().getName()+"-->我是通过实现接口的线程实现方式！");
    }   
}

3.通过Callable和FutureTask包装器 创建线程

a:创建Callable接口的实现类 ，并实现Call方法
b:创建Callable实现类的实现，使用FutureTask类包装Callable对象，该 FutureTask对象封装了Callable对象的Call方法的返回值
c:使用FutureTask对象作为Thread对象的target创建并启动线程
d:调用FutureTask对象的get()来获取子线程执行结束的返回值

public class ThreadDemo03 {

    public static void main(String[] args) {

        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;
    }   
}

4.通过线程池创建线程
使用ExecutorService、Callable、Future实现有返回结果的线程

import java.util.concurrent.*;  
import java.util.Date;  
import java.util.List;  
import java.util.ArrayList;  
  
/** 
* 有返回值的线程 
*/  
@SuppressWarnings("unchecked")  
public class Test {  
public static void main(String[] args) throws ExecutionException,  
    InterruptedException {  
   System.out.println("----程序开始运行----");   
  
   int taskSize = 5;  
   // 创建一个线程池  
   ExecutorService pool = Executors.newFixedThreadPool(taskSize);  
   // 创建多个有返回值的任务  
   List<Future> list = new ArrayList<Future>();  
   for (int i = 0; i < taskSize; i++) {  
    Callable c = new MyCallable(i + " ");  
    // 执行任务并获取Future对象  
    Future f = pool.submit(c);  
    // System.out.println(">>>" + f.get().toString());  
    list.add(f);  
   }  
   // 关闭线程池  
   pool.shutdown();  
  
   // 获取所有并发任务的运行结果  
   for (Future f : list) {  
    // 从Future对象上获取任务的返回值，并输出到控制台  
    System.out.println(">>>" + f.get().toString());  
   }  
  
}  
}  
  
class MyCallable implements Callable<Object> {  
private String taskNum;  
  
MyCallable(String taskNum) {  
   this.taskNum = taskNum;  
}  
  
public Object call() throws Exception {  
   System.out.println(">>>" + taskNum + "任务启动");  
   Thread.sleep(1000);  
   System.out.println(">>>" + taskNum + "任务终止");  
   return taskNum;  
}  
} 

执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了。get方法是阻塞的，即：线程无返回结果，get方法会一直等待。

public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。

submit( )：该方法接收Runnable或Callable对象作为输入参数 ，返回一个Future对象。submit方法提交的任务中的call方法如果返回Integer，那么submit方法就返回Future；如果call方法返回Float，那么submit方法就返回Future；call方法返回的List，那么submit方法就返回Future<List>
对submit方法返回值的使用，上面我们已经知道，实际返回值为List，但是被封装成了Future<List>，我们可以通过get()方法取出里面的List对象。 submit方法其实是伪返回的（回顾：即submit方法一执行，马上会产生Future类型的返回值，刚才提交的任务也许还在线程池的任务队列中排队）。那么这种情况下我们在submit方法返回的Future对象上调用get()方法来取出里面的List时，get()方法所在的线程将会阻塞（Future类的get()方法时阻塞调用的），直到submit提交的任务在池中真正执行并且产生结果。

参考文章：
实现多线程的四种方式
实现多线程的四种方式
submit() 方法