JAVA多线程基础：实现多线程的3种常用方式

• 线程运行速度比进程速度快
• 任何情况下，只要定义了多线程，多线程的启动永远只有一种方案，Thread类中的start()方法
• 多线程开发的本质是在于多个线程可以进行对统一资源的抢占

第一种：实现Thread类

• 内部调用的是strat0()，这是一个JNI实现方法，JVM根据不同的系统实现不同的start0()方法

• Thread类不是抽象类，也不是接口

• 父类接口为Runnable

  import java.util.function.*;
  class MyThread extends Thread{
  	private String title;
  	public MyThread(String title){
  		this.title = title;
  	}
  	@Override
  	public void run(){
  		for(int i= 0;i< 10;i++){
  			System.out.println(this.title + "i = " + i);
  		}
  	}
  }
  public class JavaDemo{
      public static void main(String[] arges){
          MyThread myThread01 = new MyThread("TEST01 ");
  		myThread01.start();
          MyThread myThread02 = new MyThread("TEST02 ");
  		myThread02.start();
          MyThread myThread03 = new MyThread("TEST03 ");
  		myThread03.start();
      }
  }
  

• 缺点：继承了Thread类后，就不能继承其他类了，但是实现Runnable接口就不一样了

  Runnable接口实现多线程

• 1.8之后就变为函数式接口，可以直接实现lambda函数式

• 因为Runnable是接口，所以开发中首要考虑Runnable实现

• 但还是需要借助子类Thread(Runnable target)实现

import java.util.function.*;
class MyThread implements Runnable{
	private String title;
	public MyThread(String title){
		this.title = title;
	}
	@Override
	public void run(){
		for(int i= 0;i< 10;i++){
			System.out.println(this.title + "i = " + i);
		}
	}
}
public class JavaDemo{
    public static void main(String[] arges){
        Thread thread = new Thread(new MyThread("TEST"));
		thread.start();
    }
}

• Lambda函数式(超简洁)

  public class JavaDemo{
      public static void main(String[] arges){
  		Runnable run = ()->{
  			System.out.println("这里在多线程中执行");
  		};
          new Thread(run).start();
      }
  }
  

#更简单的
import java.util.function.*;
public class JavaDemo{
    public static void main(String[] arges){
        new Thread(()->{
			System.out.println("dsfsdf");
		}).start();
    }
}

Thread与Runnable的关系

• Thread类也是实现了Runnable接口的子类
• 由上面了解到，多线程的方法主要都是由Thread实现的，所以操作系统的资源调用也是通过Thread调用的
• Thread为代理类，MyThread或者实现Runnable接口的类为真实类

Callable实现多线程

• Runnable的缺点是，执行完毕后，无法给主线程一个返回值，而Callable可以

• 1.5之后实现的新方法java.util.concurrent.Callable接口，使用泛型返回数据

• 方法流程图

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class MyThread implements Callable<String>{
	@Override
	public String call() throws Exception{
		for(int i=0;i < 1000;i++){
			System.out.println("==========" + i);
		}
		return "=====end========";
	}
}
public class JavaDemo{
    public static void main(String[] arges)throws Exception{
        FutureTask<String> task = new FutureTask<>(new MyThread());
		new Thread(task).start();
		System.out.println(task.get());
    }
}

Runnable与Callable

• Runnable是在JDK1.0的时候提出的多线程的实现接口，而Callable是JDK1.5之后提出来的

• java.lang.Runnable接口之中只提出一个run()方法，并没有返回值

• java.util.concurrent.Callable接口提供有call()方法，可以有返回值;