【java】【多线程】创建线程的两种常用方式（2）

java虚拟机允许应用程序吧并发的运行多个线程。

Java有三种创建线程的方式，分别是继承Thread类、实现Runable接口和使用线程池。前两种最常用。最后一种后期补充学习。

1、继承Thread类

（1）定义类集成Thread类，并重写父类的run()方法，方法里的内容就是线程所要执行的任务； 
（2）创建子类的实例，即生成线程的实例对象； 

（3）调用现成的start()方法来启动线程，内部会自动调用run方法。

注意：若不使用start()方法开启线程，只调用run方法相当于单纯的调用方法而已并没有开启线程，程序依然会使用main单线程执行。

    start方法有两种含义：

• 启动多线程。
• 调用线程中的run方法（具体怎么调用run方法是由虚拟机执行的，无法通过源码查看）

public class Demo2_Thread {	
        public static void main(String[] args) {
	MyThread mt = new MyThread();			//4,创建自定义类的对象
	mt.start();					//5,开启线程
					
	for(int i = 0; i < 3000; i++) {
		System.out.println("bb");
		}
	}
			
	}
	class MyThread extends Thread {			//1,定义类继承Thread
	    public void run() {				//2,重写run方法
		for(int i = 0; i < 3000; i++) {		//3,将要执行的代码,写在run方法中
			System.out.println("aa");
		}
	}
}

2、实现Runnable接口

（1）定义类实现Runnable接口

（2）实现run方法，这个run（）方法和Thread中的run()方法一样是线程的执行体。把新线程要做的事写在run方法中

    注意：Runnable接口中只有run方法。

（3）创建自定义的Runnable的子类对象

（4）创建Thread对象, 传入Runnable子类对象。因为runnable接口中没有start方法，需借用Thread类的start方法。Thread对象才是真正的线程对象

（5）调用start()开启新线程, 内部会自动调用Runnable的run()方法.

public class Demo3_Runnable {
	public static void main(String[] args) {
		MyRunnable mr = new MyRunnable();		//4,创建自定义类对象
		//Runnable target = new MyRunnable();           
		Thread t = new Thread(mr);			//5,将其当作参数传递给Thread的构造函数
		t.start();					//6,开启线程
					
		for(int i = 0; i < 3000; i++) {
			System.out.println("bb");
			}
		}
	}
	
		class MyRunnable implements Runnable {	        //1,自定义类实现Runnable接口
		        @Override
		        public void run() {											//2,重写run方法
			for(int i = 0; i < 3000; i++) {		//3,将要执行的代码,写在run方法中
				System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaa");
			}
		}
				
	}

实现Runnable的原理  (了解)

* 查看源码

    * 1，看Thread类的构造函数,传递 了Runnable接口的引用

    * 2，通过init()方法找到传递的target给成员变量的target赋值

    * 3，查看run方法,发现run方法中有判断,如果target不为null就会调用Runnable接口子类对象的run方法

3、继承方式与实现方式有什么区别

1、查看源码的区别:

• 继承Thread：由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
• 实现Runnable：构造函数中传入了Runnable的引用, 成员变量记住了它（this）, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法

2、多线程执行代码位置不同：
    继承Thread类：代码存放在Thread类的run方法中

    实现Runnable类：代码存放在Runnable接口的run方法中。

4、继承方式与实现方式的优缺点

1、 继承Thread

    * 好处：可以直接使用Thread类中的方法,代码简单

    * 弊端：如果已经有了父类,就不能用这种方法

2、 实现Runnable接口

    * 好处：即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的，避免了单继承的局限性

    * 弊端：不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

注意：继承方式和实现方式的优缺点是互换的。

5、使用匿名内部类实现线程的两种方式

1）继承Thread类

    new Thread() {				    //1,new 类(){}继承这个类
	public void run() {			    //2,重写run方法
		for(int i = 0; i < 3000; i++) {	    //3,将要执行的代码,写在run方法中
			System.out.println("aa");
			}
		}
	}.start();

2）实现Runnable接口

new Thread(new Runnable(){	                    //1,new 接口(){}实现这个接口
	public void run() {			    //2,重写run方法
		for(int i = 0; i < 3000; i++) {	    //3,将要执行的代码,写在run方法中
			System.out.println("bb");
			}
		}
	}).start();