2019-04-24 java 多线程的创建方式

1.java线程常见的三种创建方式

1.1 通过继承Thread类

package com.demo.noteBook;
public class MyThread1 extends Thread{
      public MyThread1(){
      }
      @Override
    public void run() {
        System.out.println("Mythread1 test!");
    }
     public static void main(String[] args) throws Exception{
      Thread myThread = new MyThread1();
      //1.直接调用myThread.run()方法，这里体现的是并发特性，
      //只有一个线程run方法里面的代码执行完后才能执行别的线程的run方法 
      //myThread.run();
      //2.调用线程的Thread的start()的方法，体现的是并行特性，多个线程的run方法同时执行。
       myThread.start();
  }
}

优点：直接继承Thread类，可以直接调用Thread类里面的方法。
缺点：由于java是单继承模式，导致不能继承其他的类，可拓展性不强。

1.2 实现Runnable接口

package com.demo.noteBook;
public class MyThread2 implements Runnable{
     @Override
     public void run(){
         System.out.println("MyThread2 test");  
   }
     public static void main(String[] args) throws Exception{
       Thread myThread = new Thread(new MyThread2());  
       myThread.start();
     }
    }

也可以直接使用jdk1.8的lamda表达式写匿名函数，更加简洁直接：

package com.demo.noteBook;
public class MyThread3{
      public static void main(String[] args) throws Exception{
        Thread myThread3 = new Thread( () ->{ System.out.println("MyThread3 test");} );
        myThread3.start();
      }
}

优点：java是多实现的，可拓展行强，同时使用这种方法实现多线程的使用。
缺点：无法直接使用Thread里面的方法，代码比较复杂。

1.3 Callable方式

package com.demo.noteBook;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class MyThread4 implements Callable{
      @Override
      //call 方法返回的必须是对象
      public Integer call(){
        int sum = 0;
        for(int i= 1; i <= 100; i++)
          sum += i;
        return sum;
      }

      public static void main(String[] args) throws Exception{
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //调用sumit方法有返回执行结果的future对象，通过get方法获得执行结果
        Future f1 = pool.submit(new MyThread4());
         System.out.println(f1.get());
      }
    }

lamda表达式重写

package com.demo.noteBook;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyThread5 {
     public static void main(String[] args) throws Exception{
      ExecutorService pool = Executors.newSingleThreadExecutor();
    int result =  pool.submit( () -> {  int sum = 0;
           for(int i= 1; i <= 100; i++)
             sum += i;
           return sum; } ) .get();
   System.out.println("future result : " + result);
   }
   }

优点：有返回值，获取结果的get()方法是异步执行的
缺点：需要用到线程池，代码比较复杂

2.并发和并行的区别

并发的关键是有处理多个任务的能力，不一定要同时。
并行的关键是有同时处理多个任务的能力。

参考文章链接 https://blog.csdn.net/hxhaaj/article/details/81004712