java 多线程--概要

  最近在看多线程这一块儿，会对多线程做一个比较详细的介绍吧！之前看了好多大牛的博客，有看懂的，也有看不懂的，在这里做一个总结。

  一、是什么

   多线程是多任务的一种特别的形式，但是多线程使用了更小的资源开销。但是一个线程是不鞥呢独立存在的，他必须是进程的一部分。此外多线程能够满足程序员编写高效率的程序来达到充分利用CPU的目的。

二：生命周期

新建状态：使用new 关键字和Thread类或是其子类建立一个线程对象后，改线程对象就处于一个新建的状态，他保持这个状态知道程序start()这个线程。

就绪状态：当线程对象调用了start()方法之后，该线程就进入就绪状态，就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。

阻塞状态：如果一个线程执行了sleep、suspend等方法，失去所占用资源后，该线程就从运行状态进入阻塞状态，在水面时间已到或是获得设备资源后可以重新进入就绪状态。

死亡状态：一个运行状态的吸纳成完成任务或者其他终止条件发生时，该线程就切换到终止状态。

创建线程：

（1）通过实现Runnable接口

class hello implements Runnable {
        public void run() {
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName());
            }
        }
     
        public static void main(String[] args) {
            hello he = new hello();
            Thread demo = new Thread(he,"线程");
            demo.start();
            for(int i=0;i<50;++i){
                if(i>10){
                    try{
                        demo.join();  //强制执行demo
                    }catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("main 线程执行-->"+i);
            }
        }
    }

（2）通过集成Thread类本身

public class thread extends Thread {
        
    public thread(String threadName){
        super(threadName);
    }
    public void run(){
        System.out.println(getName() + " 线程运行开始!");
        for(int i=0;i<1000;i++){
            System.out.println(i+""+getName());
            try{
                sleep((int) Math.random() * 10);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(getName() + " 线程运行结束!");
        }
    }  

（3）使用线程池，ExecutorService、Callable、Future实现有返回结果的多线程。

public static void main(String[] args) throws ExecutionException,  
    InterruptedException {  
   System.out.println("----程序开始运行----");  
   Date date1 = new Date();  
  
   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());  
   }  
  
   Date date2 = new Date();  
   System.out.println("----程序结束运行----，程序运行时间【"  
     + (date2.getTime() - date1.getTime()) + "毫秒】");  
}  
}  
  
class MyCallable implements Callable<Object> {  
private String taskNum;  
  
MyCallable(String taskNum) {  
   this.taskNum = taskNum;  
}  
  
public Object call() throws Exception {  
   System.out.println(">>>" + taskNum + "任务启动");  
   Date dateTmp1 = new Date();  
   Thread.sleep(1000);  
   Date dateTmp2 = new Date();  
   long time = dateTmp2.getTime() - dateTmp1.getTime();  
   System.out.println(">>>" + taskNum + "任务终止");  
   return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";  
}  

三、继承thread和实现Runnable接口对比：
   1.实现Runnable接口：
         （1）线程类实现了Runnable接口还可以继承其他类；
         （2） 在这种方式下，可以多个线程共享一个target对象，所以适合多个相同的线程来处理同一份资源，从而可以将CPU、代码和数据分开，形成清晰的模型，比较好的体现了面向对象的思想。
         （3） 编程会偏复杂，必须使用Thread.currentThread()方法。
     2.继承Thread实现多线程
         （1）编程简单，如果需要访问当前的线程，只需要使用this就可以获取当前线程。
         （2）因为已经继承了Thread类，不能再继承其他父类。
总结：

关于多线程这里只是总结一些基础的只是，在后面还会分享一些关于多线程的东西。