实现接口创建线程

一、理论

1.进程与线程

  几乎所有的操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行中的程序就是一个进程。
  当一个程序运行时，内部可能包含了多个顺序执行流，每个顺序执行流就是一个线程。

2. 进程
 
     几乎所有操作系统都支持进程的概念，所有运行中的任务通常对应一条进程（Process）。当一个程序进入内存运行，即变成一个进程。进程是处于运行过程中的程序，并且具有一定独立功能， 进程是系统进行资源分配和调度的一个独立单位。
    一般而言，进程包含如下三个特征：
    <1>独立性：进程是系统中独立存在的实体，它可以拥有自己独立的资源，每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以                            直接 访问其他进程的地址空间。
   <2> 动态性：进程与程序的区别在于：程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念。进程具有自己的生命周期和各                            种不同的状态，这些概念在程序中都是不具备的。
   <3> 并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响。 
 

3.线程：

          多线程则扩展了多进程的概念，使得同一个进行可以同时并发处理多个任务。线程（Thread）也被称作轻量级进程（Ligheweight Process），线程是进程的执行单元。就象进程在操作系统中的地位一样，线程在程序中是独立的、并发的执行流。当进程被初始化后，主线程就被创建了。对于绝大多数的应用程序来说，通常仅要求有一个主线程，但我们也可以在该进程内创建多条顺序执行流，这些顺序执行流就是线程，每条线程也是互相独立的。
         线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量，但不再拥有系统资源，它与父进程的其它线程共享该进程所拥有的全部资源。因为多个线程共享父进程里的全部资源，因此编程更加方便；但必须更加小心，我们必须确保线程不会妨碍同一进程里的其它线程。
            线程可以完成一定的任务，可与其他线程共享父进程中的共享变量及部分环境、相互之间协同来完成进程所要完成的任务。
简而言之：一个程序运行后至少有一个进程，一个进程里可以包含多个线程，但至少包含一个线程。

4.线程的优势：

   <1>进程间不能共享内存，但线程之间共享内存非常容易。
   <2>系统创建进程需要为该进程重新分配系统资源，但创建线程则代价小得多，因此使用多线程来实现多任务并发比多进程的效率高。
   <3>Java语言内置的多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了Java的多线程编程。

5.创建线程的两种方式：

        <1>采用实现Runnable接口方式的多线程：

线程类只是实现了Runnable接口，还可以可以继承其他类。
在这种方式下，可以多个线程共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU，代码和数据分开，形成清晰的模型，较好地         体现了面向对象的思想。

劣势是：编程稍稍复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

         <2>采用继承Thread类方式的多线程：

劣势是：因为线程类已经继承了Thread类，所以不能再继承其他父类。

优势是：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。 

二、实例

下面演示了实现Clallable和Runnable接口创建线程，并使用了接口实现类和Lambda表达式（匿名内部类两种方式）：

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

public class TestThread <span style="font-family: Arial, Helvetica, sans-serif;">{</span>

	public static void main(String[] args) 
	{
		// runThread();
		 callThread();
	}
	public static void runThread()
	{
		//实现Runnable接口
				for(int i=0;i<10;i++)
				{
					new Thread(new RunableThread(),"实现Runnable接口创建的线程 : "+i).start();
					//Lambda表达式创建线程的代码将被大大简化
					new Thread((Runnable)()->{
						for(int j=0;j<10;j++)
						{
							System.out.println(Thread.currentThread().getName()+"------------"+j);
						}
						
					},"实现Runnable接口并使用Lambda表达式创建的线程").start();
				}
	}
	public static void callThread()
	{
		FutureTask<Integer> task=null;
		for(int i=0;i<10;i++)
		{
			task=new FutureTask<Integer>(new CallableThread());
			new Thread(task,"实现Callable接口的线程类").start();
		}
		//Lambda表达式创建线程的代码将被大大简化
		FutureTask<Integer> task2=new FutureTask<Integer>((Callable<Integer>)()->{
			   Integer i=6;
				while(i<900)
				{
					System.out.println(Thread.currentThread().getName()+"******************"+i++);
				}
				return i;
		});
		new Thread(task2,"Lambda表达式实现Callable接口的线程类").start();
	}
}

//实现Callable接口的线程类
class CallableThread implements Callable<Integer>
{
	private int i=0;
	@Override
	public Integer call() throws Exception 
	{
		while(i<50)
		{
			System.out.println(Thread.currentThread().getName()+"----------"+i++);
		}
		return i;
	}
}
//实现Runnable接口的线程类
class RunableThread implements Runnable
{
	private int i=0;
	@Override
	public void run() 
	{
		for(;i<10;i++)
		{
			System.out.println(Thread.currentThread().getName()+"------------"+i);
		}
	}
	
}