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<Integer> 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
