进程与多线程实现

进程：进程就是起运一段程序，将这段程序加载进入内存，并为其分配相关资源，是资源分配的最小
单位。
线程：线程是比进程更小一级的单位，一个进程中可以有多个线程同时存在，并执行相关任务，是计
算机最小的调度单元。
线程和进程有何不同？
线程是进程划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，线程可以共享资源，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序。

什么是多线程？
指在同一个间段内程序运行多个子任务，而多个子任务是几乎同时运行（操作者），在计算机层面，是多个任务一直切换，速度很快，导致的结果。

java多线程的实现：
有三种实现方式：
1.继承Thread类创建线程类
2.实现Runnable接口创建线程类
3.使用Callable和Futere创建线程

继承Thread类来创建新线程
package thread_thread;

public class myThread extends Thread{
	
	@Override
	public void run() {
		for (int i = 0; i <20; i++) {
			System.out.println(getName()+i);
		}
	}
}



package thread_thread;
/**
 *  利用继承Thread类创建多线程
 * 1.继承Thread类
 * 2.重写run方法
 * 3.创建Thread子类实例对象
 * 4.调用start()方法开启多线程
 * 注意：调用start()方法而不是调用run方法
 * 调用run方法只是单纯的调用一个方法，还是main线程在单独执行，而不会创建新的线程
 * 调用start()方法会创建新的线程
 * void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法
 * 	start()方法只能执行一次，不能多次调用否则会抛出异常：
 * 	java.lang.IllegalThreadStateException
 * @author DELL
 *
 */
public class myThreadTest{
	public static void main(String[] args) {
		Thread mt=new myThread();
		mt.start();
		for(int i=0;i<20;i++) {
			System.out.println(Thread.currentThread().getName()+i);
		}
		mt.start();
	}
}

提倡这种使用Runnable接口编程——面向接口编程
package thread_runnable;

public class Runnableimpl implements Runnable{

	@Override
	public void run() {
		for(int i=0;i<20;i++) {
			System.out.println(Thread.currentThread().getName()+i);
		}
	}
	
}



package thread_runnable;
/**
 * 实现多线程：第二种方法——实现Runnable接口
 * 1.类实现Runnable接口
 * 2.实现接口中的run()方法
 * 3.创建该类的实例对象
 * 4.创建Thread实例并将Runnable实例当做参数传递进去创建线程
 * 5.调用Thread的start()方法开启线程
 * 注意：提倡使用这种方式开启多线程，因为第一种继承Thread的方法会使子类受限，
 * 而第二种方式面向接口编程，可以使子类摆脱单继承的束缚
 * @author DELL
 *
 */
public class RunnableimplTest {
	public static void main(String[] args) {
		Runnableimpl myrun=new Runnableimpl();
		new Thread(myrun).start();
		for(int i=0;i<20;i++) {
			System.out.println(Thread.currentThread().getName()+i);
		}
	}
}

Callable接口实际和Runnable接口一样，都是用来对于多线程实现的补充，

不一样的地方在于：Callable的call()方法允许抛出异常，并可以有返回值，但是Runnable的run方法不行。

Future的实现类FutureTask不仅实现了Future还实现了Runnable接口，因此可以使用此类将Runnable或者Callable接口的实现类对象包装为一个任务交给线程，

FutureTask(Callable callable)
创建一个 FutureTask，一旦运行就执行给定的 Callable。

FutureTask(Runnable runnable, V result)
创建一个 FutureTask，一旦运行就执行给定的 Runnable，并安排成功完成时 get 返回给定的结果 。

如果Runnable接口实现类没有返回结果：则使用如下方法构造
Future<?> f = new FutureTask(runnable, null)

package thread_callable;

import java.util.concurrent.Callable;

public class callableimpl implements Callable<Integer>{
	private int a=0;
	@Override
	public Integer call() throws Exception {
		for(int i=0;i<20;i++) {
			if(i>=10) {
				return a;
			}
			System.out.println(Thread.currentThread().getName()+i);
		}
		return null;
	}

}



package thread_callable;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
 * 使用Callable接口和FutureTask实现多线程
 * 步骤：
 * 1.创建Callable接口实现类
 * 2.重写接口的call()方法
 * 3.构造实现类的对象
 * 4.利用FutureTask类构造一个线程的任务
 * 5.将线程任务构造进Thread
 * 6.调用start()开启一个线程
 * @author DELL
 *
 */
public class callableTest {
	public static void main(String[] args) {
		callableimpl cab=new callableimpl();
		FutureTask<Integer> fu=new FutureTask<Integer>(cab);
		Thread th=new Thread(fu);
		th.start();
		for(int i=0;i<20;i++) {
			System.out.println(Thread.currentThread().getName()+i);
		}
		try {
			System.out.println("计算结果是："+fu.get());
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}
	}
	
}