多线程的创建方式

Java多线程有两种实现方式：
1.继承Thread类
2.实现Runnable接口
【匿名内部类】
实现Runnable接口的好处：

• 避免了单线程局限性：单继承多实现。
• 增强了程序的扩展性，降低了程序的耦合性（解耦）：实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）。实现类中，重写了run()方法，用来设置线程任务。创建Thread类对象，调用start()方法：用来开启新线程。

1.继承Thread类

实现步骤：
a.创建一个类，继承Therad类。
b.重写run()方法，在方法中设置线程任务。
c.在主方法中创建Thread子类对象。
d.使用该子类对象调用Therad类中的start()方法。【注意：线程开启的位置】

//主类
public class Test{
	public static void main(String... args){
		//注意开启新线程的位置（第一次写在了for循环下面）
		//3.创建子类对象
		Thread1 t1 = new Thread1();
		t1.start();//使用子类对象调用Thread类的start()方法，开启新线程

		for(int i = 0; i < 20; i++){
			System.out.println("main:"+i);
		}
	}
}

//1.创建一个新线程类，继承Thread类
public class Thread1 extends Thread{
	//2.重写run()方法，设置线程任务
	@Override
	public void run(){
		for(int i = 0; i < 20; i++){
			System.out.println("thread1>>>>>>>>>>"+i);
		}
	}
}

执行结果：

2.实现Runnable接口

实现步骤：
1.创建一个类，实现Runnable接口，并重写run()方法，设置线程任务；
2.创建实现类对象；
3.创建Thread类对象，同时将实现类对象传入Thread类的构造方法中；
4.调用Thread类对象的start()方法，开启新线程执行run()方法。

//1.创建一个类，实现Runnable接口
public class ImplementRunnable implements Runnable{
	//并重写run()方法，设置线程任务
	@Override
	public void run(){
		for(int i = 0; i < 20; i++){
			System.out.println(Thread.currentThread().getName()+"--->"+i);
		}
	}
}

public class Test{
	public static void main(String[] args){
		// 2.创建实现类对象
		ImplementRunnable ir = new ImplementRunnable();
		//3.创建Thread类对象，同时将实现类对象传入Thread类的构造方法中；
		Thread t = new Thread(ir);
		//4.调用Thread类对象的start()方法，开启新线程执行run()方法。
		t.start();
		
		for(int i = 0; i < 20; i++){
			System.out.println(Thread.currentThread().getName()+"--->"+i);
		}
	}
}

执行结果：

3.匿名内部类

匿名：没有名字； 内部类：写在其他类内部的类； 作用：简化代码。
       把子类继承父类、重写父类的方法，创建子类对象合成一步完成。
       把实现类、实现类接口、重写接口中的方法、创建实现类对象合成一步完成。

格式：
new 父类/接口(){
           //重写父类或接口中的run方法；
};

public class AnonymousInnerClassThread{
	/*第一次把匿名内部类写成了成员
	在main方法只创建了该类对象，导致编译报错
	(可能是在编译的时候就开始调用start方法原因，
	但是把内部类写在main方法中编译就不会报错)*/
	//第一种：使用Thread类
	//new Thread(){run()}.start();
	public void t(){
		new Thread(){
		@Override
		public void run(){
			for(int i = 0; i < 10; i++){
				System.out.println(Thread.currentThread().getName()+"--->"+i);
			}
		}
	}.start();
	//第二种：使用Runnable接口
	/*
	回想一下实现Runnable接口的步骤：
	1.创建一个类实现Runnable接口，重写接口的run()方法；
	2.创建实现类对象；
	3.创建Thread类对象，同时在该类的构造方法中传入实现类对象；
	4.调用start()方法，执行run()方法。
	
	所以，使用Runnable接口实现匿名内部类的步骤为：
	1.创建Runnable接口对象，重写run()方法；
	2.创建Thread类对象，同时在该类的构造方法中传入Runnable接口对象；
	3.调用Thread类对象的start()方法，执行run()方法。
	*/
	
	//1.创建Runnable接口对象，重写run()方法
	Runnable r = new Runnable(){
		@Override
		public void run(){
			for(int i = 0; i < 10; i++){
				System.out.println(Thread.currentThread().getName()+"--->"+i);
			}
		}
	};
	//2.创建Thread类对象，同时在该类的构造方法中传入Runnable接口对象
	//3.调用start()方法
	new Thread(r).start();

	//使用Runnable接口的简写方法
	//new Thread(new Runnable(){}).start();
	new Thread(new Runnable(){
		@Override
		public void run(){
			for(int i = 0; i < 10; i++){
				System.out.println(Thread.currentThread().getName()+"--->"+i);
			}
		}
	}).start();
	}
}

public class Test{
	public static void main(String... args){
		//Thread1 t1 = new Thread1();
		//t1.start();
		
		//ImplementRunnable ir = new ImplementRunnable();
		//Thread t = new Thread(ir);
		//t.start();
		
		AnonymousInnerClassThread   act = new AnonymousInnerClassThread();
		act.t();
		
		for(int i = 0; i < 20; i++){
			System.out.println(Thread.currentThread().getName()+"--->"+i);
		}
	}
}

执行结果：

多线程详解