创建线程的三种基本方式

Java中线程开启需要用到Thread类

线程开启我们需要用到了 java.lang.Thread 类，API中该类中定义了有关线程的一些方法，具体如 下：
构造方法：
1). public Thread() :分配一个新的线程对象。
2). public Thread(String name) :分配一个指定名字的新的线程对象。
3). public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
4). public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定 名字。
常用方法：
1). public String getName() :获取当前线程名称。
2). public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
3). public void run() :此线程要执行的任务在此处定义代码。
4). public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时 停止执行）。
5). public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

创建线程方式一_继承方式

Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线 程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体 来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任 务,因此把run()方法称为线程执行体。
2. 创建Thread子类的实例，即创建了线程对象 。
3. 调用线程对象的start()方法来启动该线程。
   代码如下：
   自定义线程类：

public class MyThread extends Thread {    
//定义指定线程名称的构造方法    
		public MyThread(String name) {        
			//调用父类的String参数的构造方法，指定线程的名称        
			super(name);    
		}    
		public MyThread() {        
		//不指定线程的名字,线程有默认的名字Thread-0    
		}    
		/**     * 重写run方法，完成该线程执行的逻辑     */    
		@Override    
		public void run() {        
			for (int i = 0; i < 200; i++) {            
				System.out.println(getName()+"：正在执行！"+i);        
				}    
			} 
		}
}

测试类：

public class Demo01 {
    public static void main(String[] args) {
            //创建自定义线程对象
            MyThread mt = new MyThread("新的线程！");        
            //开启新线程        
            mt.start();        
            //在主方法中执行for循环        
            for (int i = 0; i < 200; i++) {
                  System.out.println("main线程！"+i);        
            }    
	} 
}

创建线程的方式二_实现Runnable接口方式

采用 java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可。
步骤如下：

1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线 程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对 象才是真正的线程对象。
3. 调用线程对象的start()方法来启动线程。
   代码如下：

自定义线程类：

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

测试类：

public class Demo {
    public static void main(String[] args) {
     	//创建自定义类对象  线程任务对象        
     	MyRunnable mr = new MyRunnable();        
     	//创建线程对象        
     	Thread t = new Thread(mr, "小强");        
     	t.start();        
     	for (int i = 0; i < 20; i++) {
            System.out.println("旺财 " + i);      
     	}    
    } 
}

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所 有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后 调用Thread对象的start()方法来运行多线程代码。 实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是 实现Runnable接口来实现多线程，终还是通过Thread的对象的API来控制线程的，熟悉Thread类的 API是进行多线程编程的基础。

tips:Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线 程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方 法

Thread和Runnable的区别
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源 共享。

实现Runnable接口比继承Thread类所具有的优势：

1. 适合多个相同的程序代码的线程去共享同一个资源。
2. 可以避免java中的单继承的局限性。
3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4. 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

匿名内部类方式

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。
使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：

public class NoNameInnerClassThread {
    public static void main(String[] args) {        
    	//      new Runnable(){ 
    	//          public void run(){ 
    	//              for (int i = 0; i < 20; i++) { 
    	//                  System.out.println("张宇:"+i); 
    	//              } 
    	//          }   
    	//      }; 
    	//---这个整体  相当于new MyRunnable()
        Runnable r = new Runnable(){
            public void run(){
                for (int i = 0; i < 20; i++) {
                    System.out.println("张宇:"+i);                
                }            
            }          
        };        
        new Thread(r).start();
  	    for (int i = 0; i < 20; i++) {
  	        System.out.println("费玉清:"+i);
        }   
    }
}

创建线程的方式三_实现Callable接口方式

1).之前两种实现线程的方式：
A).继承Thread类，重写run()方法；
B).实现Runnable接口，重写run()方法
这两种方式有两个缺点：
1).run()方法不能抛出编译期异常。
2).run()方法不能返回值。
2).从JDK5开始，Java提供了第三种实现线程的方式：实现Callable接口，重写call()
示例代码：
自定义线程类：

public class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        //计算1--100的累加和，并将结果返回给主线程
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum += i;
            Thread.sleep(50);
        }
        return sum;
    }
}

测试类：

public class Demo02 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //注意：启动Callable线程，必须使用线程池

        ExecutorService service = Executors.newFixedThreadPool(2);
        MyCallable myCallable = new MyCallable();
        Future<Integer> submit = service.submit(myCallable);//不阻塞

        //线程在计算，但主线程会继续
        //做一些其它事情
        //获取结果
        System.out.println("已经submit()...一会获取结果");
        Integer result = submit.get();//此方法会阻塞——等待线程中计算结束

        System.out.println("线程计算结果：" + result);

    }
}