java中多线程的实现方法

一、进程与线程

进程：是并发执行的程序在执行过程中分配和管理资源的基本单位，是一个动态概念，竞争计算机系统资源的基本单位。

线程：是进程的一个执行单元，是进程内科调度实体。比进程更小的独立运行的基本单位。线程也被称为轻量级进程。

二、什么是多线程

多线程（英语：multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。

三、java中如何实现多线程

1. 继承Thread类实现多线程，重写run()方法，使用start()方法开启多线程（JDK 1.0 时提出）

   package base.Multithreading;
   
   public class FromThread{
   	public static void main(String[] args) {
       	MyThread a = new MyThread("A");
       	MyThread b = new MyThread("B");
       	MyThread c = new MyThread("C");
   
       	a.start();
       	b.start();
       	c.start();
   	}
   }
   
   class MyThread extends Thread{
   
   	String name;
   
   	MyThread(String name){
       	this.name = name;
   	}
   
   	@Override
   	public void run() {
       	for(int i = 0 ; i < 10 ;i++){
           	System.out.println("Thread " + name + " is running.....");
       	}
   	}
   }
   

   如果一个线程启动了很多次，那么将会抛出java.lang.IllegalThreadStateException异常

2. 实现Runnable接口实现多线程（JDK 1.0 时提出）
   将实现了Runnable的类封装到Thread类中，使用Thread的实例调用start()方法开启线程

   package base.Multithreading;
   
   public class FromRunable {
   	public static void main(String[] args) {
       	Thread a = new Thread(new MyThread1("A"));
       	Thread b = new Thread(new MyThread1("B"));
       	Thread c = new Thread(new MyThread1("C"));
   
       	a.start();
       	b.start();
       	c.start();
   	}
   }
   
   class MyThread1 implements Runnable{
   	String name;
   
   	MyThread1(String name){
       	this.name = name;
   	}
   
   
   	@Override
   	public void run() {
       	for (int i = 0 ; i < 10 ; i++){
           	System.out.println("Thread " + name + " is running...");
       	}
   	}
   }
   

   使用Runnable接口实现多线程的话，我们无法在线程结束的时候获得一个返回值。

3. 实现Callable（java.util.concurrent）接口实现多线程（JDK 1.5 时提出）
   Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。
   
   示例：

   package base.Multithreading;
   
   import java.util.concurrent.Callable;
   import java.util.concurrent.ExecutionException;
   import java.util.concurrent.FutureTask;
   
   public class FromCallable {
   	public static void main(String[] args) throws ExecutionException, InterruptedException {
       	// 使用 FutureTask 的实例包裹线程类对象
       	FutureTask<String> futureTask = new FutureTask<>(new MyThread2("A"));
   
       	// 使用 FutureTask 的实例包裹线程类对象
       	FutureTask<String> futureTask1 = new FutureTask<>(new MyThread2("B"));
   
       	// 使用 FutureTask 的实例包裹线程类对象
       	FutureTask<String> futureTask2 = new FutureTask<>(new MyThread2("C"));
   
   
   
       	// 使用 Thread 的实例包裹 FutureTask 实例，调用 Thread 的 start() 方法
       	new Thread(futureTask).start();
   
       	// 使用 Thread 的实例包裹 FutureTask 实例，调用 Thread 的 start() 方法
       	new Thread(futureTask1).start();
   
       	// 使用 Thread 的实例包裹 FutureTask 实例，调用 Thread 的 start() 方法
       	new Thread(futureTask2).start();
   
   
   
       	// 使用 futureTask.get() 会抛出异常
       	System.out.println(futureTask.get());
   
       	// 使用 futureTask.get() 会抛出异常
       	System.out.println(futureTask1.get());
   
       	// 使用 futureTask.get() 会抛出异常
       	System.out.println(futureTask2.get());
   	}
   }
   
   class MyThread2 implements Callable<String> {
   	String name;
   
   	MyThread2(String name){
       	this.name = name;
   	}
   
   
   	@Override
   	public String call() throws Exception {
       	for(int i = 0; i < 10 ; i++){
           	System.out.println("Thread " + name + " is running...");
       	}
       	return "线程执行结束...";
   	}
   }
   

四、start()方法原理

start()方法调用了JVM提供的start0()方法，而start0()方法是根据不同操作系统提供的方法而生成的不同的方法，所以能够做到无论在哪一个操作系统上运行start()方法，他都能够正常的启动线程。