【Java基础】多线程的创建

Java 提供了三种创建线程的方法：

• 通过实现 Runnable 接口；
• 通过继承 Thread 类本身；
• 通过 Callable 和 Future 创建线程。

继承Thread类

该方法是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。该方法尽管被列为一种多线程实现方式，但是本质上也是实现了 Runnable 接口的一个实例。

1. 在Java中负责实现线程功能的类是java.lang.Thread 类。

2. 可以通过创建 Thread的实例来创建新的线程。

3. 每个线程都是通过某个特定的Thread对象所对应的方法run( )来完成其操作的，方法run( )称为线程体。

4. 通过调用Thread类的start()方法来启动一个线程。

步骤：继承Thread类 、重写run()方法、创建子类对象，调用start()启动线程。

/*
 * 创建线程方式一：
 * 1.创建：继承Thread+重写run
 * 2.启动：创建子类对象+start
 */
public class StartThread extends Thread{
	
	/*
	   * 线程入口点
	 */
	@Override
		public void run() {
			for(int i=0;i<20;i++) {
				System.out.println("一边听歌");
			}
		}

	public static void main(String[] args) {
		//启动线程
		StartThread st =new StartThread(); //创建子类对象
		st.start();//调用start进行启动，不保证立即运行，而是由CPU进行调用
		
		//主线程
		for(int i=0;i<20;i++) {
			System.out.println("一边coding");
		}
	}

}

 此种方式的缺点：如果我们的类已经继承了一个类(如小程序必须继承自 Applet 类)，则无法再继承 Thread 类。 

实现 Runnable 接口 (推荐)

创建一个线程，最简单的方法是创建一个实现 Runnable 接口的类。在开发中，我们应用更多的是通过Runnable接口实现多线程。为了实现 Runnable，一个类只需要执行一个方法调用 run()。

/*
 * 创建线程方式二：
 * 1.创建：实现Runnable+重写run
 * 2.启动：创建实现类对象+Thread类对象+start()
 */

public class StartRun implements Runnable{   //这行有不同
	
	/*
	   * 线程入口点
	 */
	@Override
		public void run() {
			for(int i=0;i<20;i++) {
				System.out.println("一边听歌");
			}
		}

	public static void main(String[] args) {
		//启动线程
		StartRun sr =new StartRun(); //创建实现类对象
		//创建代理类对象
		Thread t = new Thread(sr);       //这行有不同
		t.start();//调用start进行启动       这行有不同
		
		//主线程
		for(int i=0;i<20;i++) {
			System.out.println("一边coding");
		}
	}

}

以上代码运动的效果与继承Thread类的效果是一样的，运行结果：

上面的代码可以进行简化： 

将这部分代码进行替换：

//启动线程
 StartRun sr =new StartRun(); //创建实现类对象
 //创建代理类对象
 Thread t = new Thread(sr);       //这行有不同
  t.start();//调用start进行启动       这行有不同

替换为：

new Thread(new StartRun()).start();

12306例子

对同一个资源进行代理，12306的票是固定的，大家公平竞争，争夺同一份资源。

/*
 * 创建线程方式二：
 * 1.创建：实现Runnable+重写run
 * 2.启动：创建实现类对象+Thread类对象+start()
 */

public class Web12306 implements Runnable{
	
	//票的总数
	private int ticketNum = 99;
	
	/*
	   * 线程入口点
	 */
	@Override
		public void run() {
			while(true) {
				if(ticketNum<0) {
					//没票了
					break;
				}
				System.out.println(Thread.currentThread().getName()+"-->"+ticketNum--);
			}
		}

	public static void main(String[] args) {
		//一份资源
		Web12306 web =new Web12306(); //创建实现类对象
		System.out.println(Thread.currentThread().getName());
		//多个代理
		new Thread(web,"张三").start();//调用start进行启动
		new Thread(web,"李四").start();
		new Thread(web,"王五").start();
				
		}

}

龟兔赛跑例子 

/*
 * 创建线程方式二：
 * 1.创建：实现Runnable+重写run
 * 2.启动：创建实现类对象+Thread类对象+start()
 */

public class Racer implements Runnable{
	private String winner ;

	/*
	   * 线程入口点
	 */
	@Override
		public void run() {
			for(int steps=1;steps<=100;steps++) {
				System.out.println(Thread.currentThread().getName()+"-->"+steps);
				//比赛是否结束
				if(gameover(steps)) {
					break;
				}
			}
		}

	private boolean gameover(int steps) {
		if(winner != null) {//存在胜利者
			return true;
		}else {
			if(steps == 100) {
				winner = Thread.currentThread().getName();
				System.out.println("winner is : "+ winner);
				return false;
			}
		}
		return false;
	}
	
	public static void main(String[] args) {
		//启动线程
		Racer sr =new Racer(); //创建实现类对象
		//创建代理类对象
		new Thread(sr,"乌龟").start();
		new Thread(sr,"兔子").start();
		
	}

}

通过 Callable 和 Future 创建线程

1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。

2. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。

3. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。

4. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

线程的常用方法